Actionscript 3 从一个范围转换到另一个范围

我有两组范围，我需要从一个转换到另一个

第一个范围是

-100↔ 100

，默认值为

0

第二个范围是

0.0↔ 10.0

，默认为

1

我在AS3中使用第一个范围，第二个范围是python类，我需要这些数字来排列

我正在用滑块实时调整视频的亮度。视频过滤器接受

-100之间的值↔ 100

。然后我需要获取该值并将其传递给python脚本，但它只接受

0.0中的值↔ 10.0

我尝试了我在网上找到的这个函数，但是在这个特殊情况下它不能正确地转换值

private function convertRange(originalStart:Number,originalEnd:Number,newStart:Number,newEnd:Number,value:Number):Number
{
    var originalRange:Number = originalEnd - originalStart;
    var newRange:Number = newEnd - newStart;
    var ratio:Number = newRange / originalRange;
    var newValue:Number = value * ratio;
    var finalValue:Number = newValue + newStart;
    return finalValue;
}       

这可能吗？希望我的问题很清楚，如果需要澄清，请告诉我

---

这就是我所指的python类：它使用第二个范围，而AS3使用第一个范围。

为什么不尝试这样的方法：

function from_AS_to_PY(as_value:Number): Number     // as_value : -100 ----- 0 ----- 100
{   
    var py_value:Number = (as_value / 100);
        py_value = (py_value <= 0 ? py_value : py_value * 9) + 1;
    return py_value;
}
function from_PY_to_AS(py_value:Number): Number     // py_value : 0 - 1 --------- 10
{   
    var as_value:Number = (py_value <= 1 ? py_value - 1 : ((py_value - 1) / 9)) * 100;
    return as_value;
}


trace(from_AS_to_PY(-100));     // gives : 0
trace(from_AS_to_PY(-99));      // gives : 0.01
trace(from_AS_to_PY(-1));       // gives : 0.99

trace(from_AS_to_PY(0));        // gives : 1

trace(from_AS_to_PY(1));        // gives : 1.09
trace(from_AS_to_PY(99));       // gives : 9.91
trace(from_AS_to_PY(100));      // gives : 10

//---------------------------------------------------

trace(from_PY_to_AS(0));        // gives : -100
trace(from_PY_to_AS(0.01));     // gives : -99
trace(from_PY_to_AS(0.99));     // gives : -1

trace(from_PY_to_AS(1));        // gives : 0

trace(from_PY_to_AS(1.09));     // gives : 1
trace(from_PY_to_AS(9.91));     // gives : 99
trace(from_PY_to_AS(10));       // gives : 100

从\u AS\u到\u PY的函数（AS\u值：Number）：Number//AS\u值：-100---0---100
{   
变量py_值：数字=（作为_值/100）；
py_值=（py_值为什么不试试这样的东西：

function from_AS_to_PY(as_value:Number): Number     // as_value : -100 ----- 0 ----- 100
{   
    var py_value:Number = (as_value / 100);
        py_value = (py_value <= 0 ? py_value : py_value * 9) + 1;
    return py_value;
}
function from_PY_to_AS(py_value:Number): Number     // py_value : 0 - 1 --------- 10
{   
    var as_value:Number = (py_value <= 1 ? py_value - 1 : ((py_value - 1) / 9)) * 100;
    return as_value;
}


trace(from_AS_to_PY(-100));     // gives : 0
trace(from_AS_to_PY(-99));      // gives : 0.01
trace(from_AS_to_PY(-1));       // gives : 0.99

trace(from_AS_to_PY(0));        // gives : 1

trace(from_AS_to_PY(1));        // gives : 1.09
trace(from_AS_to_PY(99));       // gives : 9.91
trace(from_AS_to_PY(100));      // gives : 10

//---------------------------------------------------

trace(from_PY_to_AS(0));        // gives : -100
trace(from_PY_to_AS(0.01));     // gives : -99
trace(from_PY_to_AS(0.99));     // gives : -1

trace(from_PY_to_AS(1));        // gives : 0

trace(from_PY_to_AS(1.09));     // gives : 1
trace(from_PY_to_AS(9.91));     // gives : 99
trace(from_PY_to_AS(10));       // gives : 100

从\u AS\u到\u PY的函数（AS\u值：Number）：Number//AS\u值：-100---0---100
{   
变量py_值：数字=（作为_值/100）；
py_值=（py_值为什么不试试这样的东西：

function from_AS_to_PY(as_value:Number): Number     // as_value : -100 ----- 0 ----- 100
{   
    var py_value:Number = (as_value / 100);
        py_value = (py_value <= 0 ? py_value : py_value * 9) + 1;
    return py_value;
}
function from_PY_to_AS(py_value:Number): Number     // py_value : 0 - 1 --------- 10
{   
    var as_value:Number = (py_value <= 1 ? py_value - 1 : ((py_value - 1) / 9)) * 100;
    return as_value;
}


trace(from_AS_to_PY(-100));     // gives : 0
trace(from_AS_to_PY(-99));      // gives : 0.01
trace(from_AS_to_PY(-1));       // gives : 0.99

trace(from_AS_to_PY(0));        // gives : 1

trace(from_AS_to_PY(1));        // gives : 1.09
trace(from_AS_to_PY(99));       // gives : 9.91
trace(from_AS_to_PY(100));      // gives : 10

//---------------------------------------------------

trace(from_PY_to_AS(0));        // gives : -100
trace(from_PY_to_AS(0.01));     // gives : -99
trace(from_PY_to_AS(0.99));     // gives : -1

trace(from_PY_to_AS(1));        // gives : 0

trace(from_PY_to_AS(1.09));     // gives : 1
trace(from_PY_to_AS(9.91));     // gives : 99
trace(from_PY_to_AS(10));       // gives : 100

从\u AS\u到\u PY的函数（AS\u值：Number）：Number//AS\u值：-100---0---100
{   
变量py_值：数字=（作为_值/100）；
py_值=（py_值为什么不试试这样的东西：

function from_AS_to_PY(as_value:Number): Number     // as_value : -100 ----- 0 ----- 100
{   
    var py_value:Number = (as_value / 100);
        py_value = (py_value <= 0 ? py_value : py_value * 9) + 1;
    return py_value;
}
function from_PY_to_AS(py_value:Number): Number     // py_value : 0 - 1 --------- 10
{   
    var as_value:Number = (py_value <= 1 ? py_value - 1 : ((py_value - 1) / 9)) * 100;
    return as_value;
}


trace(from_AS_to_PY(-100));     // gives : 0
trace(from_AS_to_PY(-99));      // gives : 0.01
trace(from_AS_to_PY(-1));       // gives : 0.99

trace(from_AS_to_PY(0));        // gives : 1

trace(from_AS_to_PY(1));        // gives : 1.09
trace(from_AS_to_PY(99));       // gives : 9.91
trace(from_AS_to_PY(100));      // gives : 10

//---------------------------------------------------

trace(from_PY_to_AS(0));        // gives : -100
trace(from_PY_to_AS(0.01));     // gives : -99
trace(from_PY_to_AS(0.99));     // gives : -1

trace(from_PY_to_AS(1));        // gives : 0

trace(from_PY_to_AS(1.09));     // gives : 1
trace(from_PY_to_AS(9.91));     // gives : 99
trace(from_PY_to_AS(10));       // gives : 100

从\u AS\u到\u PY的函数（AS\u值：Number）：Number//AS\u值：-100---0---100
{   
变量py_值：数字=（作为_值/100）；
py_值=（py_值这个问题有一个根本性的困难。您正试图将一个范围的三个点拟合到另一个范围。如果您只想匹配两个端点，这将很容易，您可以使用线性插值
y=10*（x+100）/200
或简单地
y=（x+100）/20
或等效的
y=x/20+5
。问题是这与默认值不匹配，x=0->5

这可能是您想要的解决方案。但是，如果默认值匹配很重要，则您需要使用非线性解决方案。有许多可能的解决方案。您可以使用分段线性解决方案，如akmozo解决方案，它需要if语句。
if x此问题存在根本性的困难。您正在尝试拟合t一个范围的三个点到另一个范围。如果您只想匹配两个端点，这将很容易。您可以使用线性插值
y=10*（x+100）/200
或简单地
y=（x+100）/20
或等效地
y=x/20+5
。问题是这与默认值和x=0->5不匹配

这可能是您想要的解决方案。但是，如果默认值匹配很重要，则您需要使用非线性解决方案。有许多可能的解决方案。您可以使用分段线性解决方案，如akmozo解决方案，它需要if语句。
if x此问题存在根本性的困难。您正在尝试拟合t一个范围的三个点到另一个范围。如果您只想匹配两个端点，这将很容易。您可以使用线性插值
y=10*（x+100）/200
或简单地
y=（x+100）/20
或等效地
y=x/20+5
。问题是这与默认值和x=0->5不匹配

这可能是您想要的解决方案。但是，如果默认值匹配很重要，则您需要使用非线性解决方案。有许多可能的解决方案。您可以使用分段线性解决方案，如akmozo解决方案，它需要if语句。
if x此问题存在根本性的困难。您正在尝试拟合t一个范围的三个点到另一个范围。如果您只想匹配两个端点，这将很容易。您可以使用线性插值
y=10*（x+100）/200
或简单地
y=（x+100）/20
或等效地
y=x/20+5
。问题是这与默认值和x=0->5不匹配

这可能是您想要的解决方案。但是，如果默认值匹配很重要，则需要使用非线性解决方案。有许多可能的解决方案。您可以使用分段线性解决方案，如akmozo解决方案，它需要if语句。
if xadd 100，然后除以20。（尽管您可能需要检查除法之前的值不是0）例如：
pythonVal=（as3Val+100）/20；
@badfeelingabout这就是我上面函数的工作方式。假设我将滑块设置为0，pythonVal将显示5，它应该显示1。我想知道如果滑块设置为
0
（指定的-100和100之间的中间点），我是否可以修改python脚本以接受与3相同的值，它在python中应该是
5
（0和10之间的中点）而不是
1
-除非您在后处理过程中犯了错误，否则听起来您希望python的数字介于0（在AS3中相当于-100）和2（在AS3中相当于100）之间。python中的0当然相当于-100，但是10（python）在AS3中等于100，而不是2。我从来都不擅长数字，lol原谅我加上100，然后除以20。（尽管你可能需要在除法之前检查值不是0）例如：
pythonVal=（as3Val+100）/20；
@badfeelingabout这就是我上面的函数的工作方式。假设我将滑块设置为0，pythonVal将显示5，它应该显示1。我想知道如果滑块设置为
0
，我是否可以修改python脚本以接受与3相同的值