Remappage de valeur

De traitement a une grande fonction que j'utilise tout le temps:

map(value, low1, high1, low2, high2)

http://processing.org/reference/map_.html

Il reconfigure value (qui a une plage de low1 à high1) dans une fourchette cible de low2 à high2).

Je veux comprendre les mathématiques derrière elle pour que je puisse l'utiliser dans d'autres langues.
Quelqu'un veut me jeter un os et m'aider à désosser? Je comprends que c'est un lerp qui a été re-mise à l'échelle et re-décalage... sentiment de mort cérébrale ce matin.

source d'informationauteur ack

  1. 27

    À partir de votre description, il devrait le faire, non?

    low2 + (value - low1) * (high2 - low2) /(high1 - low1)

    Trouver dans quelle mesure vous êtes dans la première plage, à l'échelle de distance par le rapport des tailles des plages, et à ce jour, vous devriez être dans la deuxième plage.

  2. 1

    Je voudrais ajouter que c'est parfois utile pour trouver le facteur entre les low1 et high1 de sorte que vous pouvez moduler avec une courbe avant d'utiliser le facteur de LERP t.

    Donc, t = (valeur low1)/(high1-low1) pour obtenir la position relative de la valeur dans la ligne low1 à high1.

    Ensuite, vous pouvez moduler t avec certains de la courbe de filtre par exemple, gamma, les préjugés, gain, etc, Comme aussi de serrage de la t entre 0 et 1 si vous restreindre les valeurs qui vont au-dessus de l'ensemble les hauts et les bas.

    Et ensuite utiliser le t pour la LERP entre low2 et de hauteur2 comme: finalvalue = low2*(1-t) + hauteur2*t

  3. 1

    Traitement est open-source. Vous pouvez afficher les map() fonction ici.

    static public final float map(float value,
                                float start1, float stop1,
                                float start2, float stop2) {
    float outgoing =
      start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
    String badness = null;
    if (outgoing != outgoing) {
      badness = "NaN (not a number)";

    } else if (outgoing == Float.NEGATIVE_INFINITY ||
               outgoing == Float.POSITIVE_INFINITY) {
      badness = "infinity";
    }
    if (badness != null) {
      final String msg =
        String.format("map(%s, %s, %s, %s, %s) called, which returns %s",
                      nf(value), nf(start1), nf(stop1),
                      nf(start2), nf(stop2), badness);
      PGraphics.showWarning(msg);
    }
    return outgoing;
  }

    Plus précisément, vous êtes à la recherche pour cette ligne de code:

    float outgoing =
      start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
  4. 0

    En plus des autres réponses que vous pouvez utiliser 

    (end2-start2) * value / (end1-start1)

    que si vous savez que la gamme d'origine et la cible ont une des formes suivantes

    a) [-a, a] to [-b, b]
b) [-a, 0] to [-b, 0]
c) [0, a] to [0, b]

    où a, b, c et d représentent un nombre != 0
    j'.e

    a) [-15, 15] to [-1, 1]
b) [-2, 0] to [-120, 0]
c) [0, 1] to [0, 340]

    et ne fonctionnent pas pour les autres cas comme

    d) [a, b] to [c, d] 
e) [-a, -b] to [-c, -d]
f) [-a, b] to [c, d]
g) [a, b] to [-c, d]
h) [0, a] to [-b, c]

    etc.