价值重新映射

发布于 2024-09-13 08:39:23 字数 485 浏览 11 评论 0原文

处理有一个很棒的功能，我一直使用：

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

http://processing.org/reference/map_.html< /a>

它将 value（预期范围为 low1 到 high1）重新映射到 low2 目标范围> 到high2）。

我想了解它背后的数学原理，这样我就可以在其他语言中使用它。有人想给我一点建议并帮我进行逆向工程吗？我知道这是一个被重新调整和重新抵消的麻疯病……今天早上感觉脑死亡。

原文

Processing has a great function I use all the time:

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

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

It remaps value (that has an expected range of low1 to high1) into a target range of low2 to high2).

I want to understand the math behind it so I can use it in other languages.
Anyone want to throw me a bone and help me reverse engineer it? I understand that it's a lerp that's been re-scaled and re-offset... feeling brain dead this morning.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

幸福还没到 2024-09-20 08:39:23

从你的描述来看，应该是这样的吧？

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

找出您进入第一个范围的距离，按范围大小的比率缩放该距离，这就是您应该进入第二个范围的距离。

From your description, it ought to be doing this, right?

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

Find how far you are into the first range, scale that distance by the ratio of sizes of the ranges, and that's how far you should be into the second range.

回复收藏 0 原文

野侃 2024-09-20 08:39:23

处理是开源的。您可以查看map()函数此处。

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;
  }

具体来说，您正在寻找这行代码：

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

Processing is open-source. You can view the map() function here.

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;
  }

Specifically, you're looking for this line of code:

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

回复收藏 0 原文

苏璃陌 2024-09-20 08:39:23

我想补充一点，有时查找 low1 和 high1 之间的因子很有用，以便您可以在将该因子用作 LERP 的 t 之前用曲线对其进行调制。

因此，t = (value-low1)/(high1-low1) 即可获得 value 在 low1 到 high1 行中的相对位置。

然后，您可以使用一些曲线滤波器（例如伽马、偏置、增益等）来调制 t。如果您要限制超出设定低点和高点的值，也可以将 t 限制在 0 和 1 之间。

然后使用 t 表示 low2 和 high2 之间的 LERP，例如：finalvalue = low2*(1-t) + high2*t

回复收藏 0 原文

初见终念 2024-09-20 08:39:23

任何人想知道是否有一个无浮点版本可以保持尽可能高的精度，我做了这个：

int remap(int value, int input_min, int input_max, int output_min, int output_max)
{
    const long long factor = 1000000000;

    long long output_spread = output_max - output_min;
    long long input_spread = input_max - input_min;

    long long l_value = value;

    long long zero_value = value - input_min;
    zero_value *= factor;
    long long percentage = zero_value / input_spread;

    long long zero_output = percentage * output_spread / factor;

    long long result = output_min + zero_output;

    return (int)result;
}

似乎对我有用，但没有经过广泛测试（例如 max 小于 min 未测试）。

背后的想法是通过使用更大的类型来放大原始值，以便除法产生更大的数字 - 从而获得更高的精度。

Anyone wondering if there's a float-less version that keeps as much precision as possible, I made this:

int remap(int value, int input_min, int input_max, int output_min, int output_max)
{
    const long long factor = 1000000000;

    long long output_spread = output_max - output_min;
    long long input_spread = input_max - input_min;

    long long l_value = value;

    long long zero_value = value - input_min;
    zero_value *= factor;
    long long percentage = zero_value / input_spread;

    long long zero_output = percentage * output_spread / factor;

    long long result = output_min + zero_output;

    return (int)result;
}

Seems to work for me, not extensively tested (e.g. max is smaller than min is not tested).

The idea behind is it to enlarge the original value by using a bigger type so that divisions yield bigger numbers - which results in more precision.

回复收藏 0 原文