public override Value Visit(Subtract node)
{
Value left = node.Left().Accept(this);
Value right = node.Right().Accept(this);
return(left.Substract((dynamic)right));
}
public Instruction handleInstruction(Token token)
{
Instruction insn = null;
List <Operand> opList = getOperands();
switch (token.strval)
{
case "ADD":
insn = new Add(opList[0], opList[1], false);
break;
case "SUB":
insn = new Subtract(opList[0], opList[1], false);
break;
case "MOV":
insn = new Move(opList[0], opList[1]);
break;
case "POP":
insn = new Pop(opList[0]);
break;
case "PUSH":
insn = new Push(opList[0]);
break;
case "RET":
insn = new Return(false);
break;
}
return(insn);
}
public static Bitmap FastGuidedFilterEnchacement(Bitmap bmp)
{
var fastGuidedFilter = new FastGuidedFilter
{
KernelSize = 16,
Epsilon = 0.16f,
SubSamplingRatio = 0.25f,
OverlayImage = (Bitmap)bmp.Clone()
};
var guidedImage = fastGuidedFilter.Apply(bmp);
var subtracted = new Subtract(guidedImage).Apply(fastGuidedFilter.OverlayImage);
guidedImage.Dispose();
//var mul = 100;
//var Multiply = FastGuidedFilter.GetFilledImage(
// subtracted.Width, subtracted.Height,
// subtracted.PixelFormat, Color.FromArgb(mul, mul, mul));
//new Multiply(Multiply).ApplyInPlace(subtracted);
//Multiply.Dispose();
new Add(subtracted).ApplyInPlace(fastGuidedFilter.OverlayImage);
subtracted.Dispose();
return(AForge.Imaging.Image.Convert16bppTo8bpp(fastGuidedFilter.OverlayImage));
}
public override void Visit(Subtract node)
{
ulong left = thread.Pop().Read().GetAsInt().Value;
ulong right = thread.Pop().Read().GetAsInt().Value;
PushInteger(left - right);
}
public void SubtractTest()
{
Assert.Equal(
$"{OP_0} - {OP_1} - {OP_2}",
Subtract.Do(op0, op1, op2).ToString()
);
}
public object Visit(Subtract expression)
{
object leftValue = expression.Left.Accept <object>(this);
object rightValue = expression.Right.Accept <object>(this);
return((int)leftValue - (int)rightValue);
}
static void Main(string[] args)
{
IResult result = new EmptyResult();
var input = Console.ReadLine();
while (input != "Q")
{
var inputs = input.Split(' ');
switch (inputs.First())
{
case "add":
result = new Add(result, new ParsedResult(inputs.ElementAt(1)));
break;
case "subtract":
result = new Subtract(result, new ParsedResult(inputs.ElementAt(1)));
break;
case "multiply":
result = new Multiply(result, new ParsedResult(inputs.ElementAt(1)));
break;
case "divide":
result = new Divide(result, new ParsedResult(inputs.ElementAt(1)));
break;
}
Console.WriteLine(result.result());
input = Console.ReadLine();
}
}
private IExpression ParseAddSubtract()
{
var res = ParseMultiplyDivide();
while (true)
{
switch (_tokenizer.GetCurToken())
{
case Token.Add:
res = new Add(res, ParseMultiplyDivide());
break;
case Token.Subtract:
res = new Subtract(res, ParseMultiplyDivide());
break;
case Token.Error:
_tokenizer.GetNextToken();
break;
default:
return(res);
}
}
}
public void CalculateTest(double firstArgument, double secondArgument, double result)
{
var calculator = new Subtract();
double testResult = calculator.Calculate(firstArgument, secondArgument);
Assert.AreEqual(testResult, result);
}
// - , resultPrev , new number
public static double Calculate(string operation, double resultValue, double number)
{
IArthimaticOperation arthimatic;
switch (operation)
{
case "-":
arthimatic = new Subtract();
break;
case "+":
arthimatic = new Add();
break;
case "*":
arthimatic = new Multiply();
break;
case "/":
arthimatic = new Divide();
break;
default:
return(0);
}
// result , number
return(arthimatic.DoOperation(resultValue, number));
}
private void CalculateAndPrintResult(double firstNumber, string @operator, double secondNumber)
{
ICalculator calculator = null;
switch (@operator)
{
case "+":
calculator = new Add(firstNumber, secondNumber);
break;
case "-":
calculator = new Subtract(firstNumber, secondNumber);
break;
case "*":
calculator = new Multiply(firstNumber, secondNumber);
break;
case "/":
calculator = new Divide(firstNumber, secondNumber);
break;
}
writer.Write($"The result is: {calculator.Calculate():F2}");
}
public Value Visit(Subtract node)
{
Value left = node.Left().Accept(this);
Value right = node.Right().Accept(this);
return(left.Substract(right));
}
//===================method=========================
public void Get_Plate()
{
image_input = IMAGE;
backgroundFrame = new Bitmap(Application.StartupPath + "\\anh\\nen.jpg");
hor_coe = 0.6; //0.5
ver_coe = 0.4; //0.4
number_coe = 13; //13
min_freq = 100;
plate_ratio = 14; //14;
IFilter filt = new GrayscaleY();
backgroundFrame = filt.Apply(backgroundFrame);
image_input = filt.Apply(image_input);
//IFilter f = new Threshold(180);
//image_input = f.Apply(image_input);
p = image_input;
Subtract sub_img = new Subtract();
sub_img.OverlayImage = backgroundFrame;
Bitmap temp_img = sub_img.Apply(image_input);
image_input = get_object(image_input, temp_img);
image_input = fft(image_input);
PLATE = image_input;
}
public void Subtraction(decimal x, decimal y, decimal result)
{
var calculation = new Subtract(x, y);
var actual = calculation.Calculate();
Assert.Equal <decimal>(result, actual);
}
public static string GetMinusOperand(Subtract expression, VHDLCompilerInterface compiler)
{
string left = GetOperand(expression.Left, compiler);
string right = GetOperand(expression.Right, compiler);
FunctionCallTemplate template = new FunctionCallTemplate(left, "Minus", right);
return(template.TransformText());
}
public void Subtracting()
{
Subtract subtract = new Subtract {
Description = "", Value1 = 10, Value2 = 7
};
Assert.Equal(3, subtract.Eval());
}
public void WhenXMaxValueYMinValue_ShouldArgumentException(
[Values(double.MaxValue)] double x,
[Values(double.MinValue)] double y)
{
var operation = new Subtract(x, y);
Assert.Throws <ArgumentException>(() => { var result = operation.Operate(); });
}
public void WhenXandYMaxValue_ShouldThrowArgumentOutOfRange(
[Values(double.MaxValue)] double x,
[Values(double.MaxValue)] double y)
{
var operation = new Subtract(x, y);
Assert.AreEqual(0, operation.Operate());
}
public static Subtract operator -(float a, Generator b)
{
var sub = new Subtract();
sub.SetLHS(a);
sub.SetRHS(b);
return(sub);
}
public void Visit(Subtract bin)
{
var left = bin.Left;
var right = bin.Right;
PrepareBinaryOperation(left, right);
EmitStackDown("sub");
}
public Bitmap Subtract(Bitmap leftOperand, Bitmap rightOperand)
{
ResizeBilinear resize = new ResizeBilinear(leftOperand.Width, leftOperand.Height);
rightOperand = resize.Apply(rightOperand);
Subtract filter = new Subtract(rightOperand);
return(filter.Apply(leftOperand));
}
public void SubtractXYPositive(
[Values(2, 3)] double x,
[Values(4, 5)] double y
)
{
var operation = new Subtract(x, y);
Assert.AreEqual(x - y, operation.Operate());
}
public void SubtractXYNegative(
[Values(-2, -3)] double x,
[Values(-4, -5)] double y
)
{
var operation = new Subtract(x, y);
Assert.AreEqual(x - y, operation.Operate());
}
/// <summary>
/// Subtracts two objects
/// </summary>
/// <param name="leftHandSide">Left hand side</param>
/// <param name="rightHandSide">Right hand side</param>
/// <returns>The resulting variable</returns>
public virtual VariableBase Subtract(object leftHandSide, object rightHandSide)
{
SetCurrentMethod();
var tempCommand = new Subtract(leftHandSide, rightHandSide);
tempCommand.Setup();
Commands.Add(tempCommand);
++ObjectCounter;
return(tempCommand.Result);
}
public void SubtractOperateGivesExpectedOutputWithValidInput()
{
Subtract test = new Subtract();
Assert.AreEqual("0", test.Operate(2, 2));
Assert.AreEqual("6", test.Operate(8, 2));
Assert.AreEqual("195", test.Operate(200, 5));
Assert.AreEqual("-5", test.Operate(-2, 3));
Assert.AreEqual("0", test.Operate(0, 0));
}
public static void SetEnvironment(Environment e)
{
add = new Add(e);
subtract = new Subtract(e);
multiply = new Multiply(e);
divide = new Divide(e);
print = new Print(e);
getVar = new GetVar(e);
setVar = new SetVar(e);
}
private void timer4_Tick(object sender, EventArgs e)
{
pictureBox3.Image = (Bitmap)pictureBox2.Image.Clone(); // Pozisyon görüntüsü oluşturulur.
p_1 = (Bitmap)pictureBox3.Image;
islem = new Subtract(p_3).Apply(p_1); // Ana görüntüden pozisyon görüntüsü çıkartılır.Sadece pozisyon bilgisi elde edilir.
islem = new FillHoles().Apply(islem); // Görüntüyü netleştirebilmek adına küçük boşluklar doldurulmuştur. Ve ardından opening işlemi yapılmıştır.
islem = new Opening().Apply(islem);
pictureBox5.Image = islem;
timer3.Start();
}
public static void Main()
{
Program sum = new Sum();
Console.WriteLine(sum.calculate(5, 2));
Program sub = new Subtract();
Console.WriteLine(sub.calculate(5, 2));
}
/// <summary>
/// Subtracts two objects
/// </summary>
/// <param name="LeftHandSide">Left hand side</param>
/// <param name="RightHandSide">Right hand side</param>
/// <returns>The resulting variable</returns>
public virtual VariableBase Subtract(object LeftHandSide, object RightHandSide)
{
SetCurrentMethod();
Subtract TempCommand = new Subtract(LeftHandSide, RightHandSide);
TempCommand.Setup();
Commands.Add(TempCommand);
++ObjectCounter;
return(TempCommand.Result);
}
public void Subtract_WithString3StringA_ThrowsRuntimeBinderException()
{
var variables = MakeVariables();
var left = new Constant("3");
var right = new Constant("A");
var expression = new Subtract(left, right);
var actual = expression.GetExpression(variables)
.Calculate();
}
public void CheckIfBothDenominatorsAredifferent_ReturnsSubtractedReducedFraction()
{
int[] firstFraction = { 2, 4 }; // 18 / 36
int[] secondFraction = { 5, 9 }; // 20 / 36 == -2 / 36 == -1 / 18
int[] result = { -1, 18 };
var expected = result;
var actual = Subtract.SubtractFractions(firstFraction, secondFraction);
Assert.AreEqual(expected, actual);
}
public Context(string flag)
{
switch (flag)
{
case "+":
oper=new Add();
break;
case "-":
oper=new Subtract();
break;
}
}
public void Evaluate_Substract_Positive_Test()
{
Expression left = CreateIntLiteral(2);
Expression right = CreateIntLiteral(1);
Expression substract = new Subtract(left, right, pos);
Values.Int value = ((Values.Int)substract.Accept(evaluator));
Assert.IsTrue(value.GetValue() == 1);
}
/// <summary>
/// Creates an Subtract command if one has not been allocated.
/// </summary>
/// <returns>
/// Returns an allocated Subtract command.
/// </returns>
public override Subtract createSubtractCommand()
{
if (subtract == null)
{
subtract = new Subtract();
}// end if
return subtract;
}
// Create Tree from file.
private TreeElement CreateTreeFromFile
(System.IO.StreamReader file, TreeElement treeElement)
{
int value = 0;
TreeElement left = null;
TreeElement right = null;
if (file.EndOfStream)
return treeElement;
int ch = file.Read(); // '(' или цифра или ' '
if (ch == ' ')
ch = file.Read(); // '(' или цифра
if (ch == '(')
{
ch = file.Read(); // ' '
if (ch != ' ')
throw new ExceptionTree("Waiting ' '.");
ch = file.Read(); // sign
if (ch != '+' && ch != '-' && ch != '*' && ch != '/')
throw new ExceptionTree("Waiting sign.");
value = ch;
ch = file.Read(); // ' '
if (ch != ' ')
throw new ExceptionTree("Waiting ' '.");
left = CreateTreeFromFile(file, left);
right = CreateTreeFromFile(file, right);
if (value == '+')
treeElement = new Add(value, left, right);
if (value == '-')
treeElement = new Subtract(value, left, right);
if (value == '*')
treeElement = new Multiply(value, left, right);
if (value == '/')
treeElement = new Divide(value, left, right);
ch = file.Read(); // ')' или ' '
if (ch == ' ')
ch = file.Read(); // ')'
if (ch != ')')
throw new ExceptionTree("Waiting ).");
/* ch = file.Read(); // ' '
if (ch != ' ')
throw new ExceptionTree("Waiting ' '."); */
}
else if (ch <= '9' && ch >= '0')
{
int number = 0;
while (ch <= '9' && ch >= '0')
{
number = number * 10 + ch - '0';
ch = file.Read();
}
if (ch != ' ')
throw new ExceptionTree("Waiting ' '.");
value = number;
treeElement = new Value(value);
}
else
throw new ExceptionTree("Waiting '(' or number.");
return treeElement;
}
/// <summary>
/// Initializes a new instance of the <see cref="DifferenceOfGaussians"/> class.
/// </summary>
///
public DifferenceOfGaussians()
{
formatTranslations = new Dictionary<PixelFormat, PixelFormat>();
formatTranslations[PixelFormat.Format8bppIndexed] = PixelFormat.Format8bppIndexed;
formatTranslations[PixelFormat.Format16bppGrayScale] = PixelFormat.Format16bppGrayScale;
formatTranslations[PixelFormat.Format24bppRgb] = PixelFormat.Format24bppRgb;
formatTranslations[PixelFormat.Format32bppRgb] = PixelFormat.Format32bppRgb;
formatTranslations[PixelFormat.Format32bppArgb] = PixelFormat.Format32bppArgb;
formatTranslations[PixelFormat.Format48bppRgb] = PixelFormat.Format48bppRgb;
formatTranslations[PixelFormat.Format64bppArgb] = PixelFormat.Format64bppArgb;
this.first = new GaussianBlur()
{
Size = 3,
Sigma = 0.4
};
this.second = new GaussianBlur()
{
Size = 5,
Sigma = 0.4
};
this.subtract = new Subtract();
}
public object CalculateParam(ParleyEnviromentInfo info)
{
if (paramaters==null || paramaters.Length==0){
return null;
}
if (paramaters.Length==1 && paramaters[0].StartsWith("\"")){
return paramaters[0].Substring(1,paramaters[0].Length-2);
}
Stack<float> values=new Stack<float>();
Stack<Operator> operators=new Stack<Operator>();
bool lastWasTerm=false;
bool nextTermFlip=false;
foreach (string p in paramaters){
bool term="+-*/".IndexOf(p)==-1;
if (term){
float v=0;
if ("0123456789".IndexOf(p.Substring(0,1))!=-1){
v=float.Parse(p);
}else{
object o=info.GetEnviromentInfo(p);
if (o==null){
Debug.LogWarning("Parley could not find the term <"+term+"> from the Enviroment. Substituting 0");
v=0;
}else{
v=float.Parse(o.ToString());
}
}
if (nextTermFlip){
values.Push(-v);
}else{
values.Push(v);
}
nextTermFlip=false;
lastWasTerm=true;
}else{
if (lastWasTerm){
Operator o=null;
if ("+".Equals(p)){
o=new Add();
} else if ("-".Equals(p)){
o=new Subtract();
} else if ("*".Equals(p)){
o=new Multiply();
} else if ("/".Equals(p)){
o=new Divide();
}
while (operators.Count>0 && o.weight>operators.Peek().weight){
operators.Pop().Execute(values);
}
operators.Push(o);
}else{
// Change sign on next term
if ("-".Equals(p)){
nextTermFlip=true;
}
}
lastWasTerm=false;
}
}
while (operators.Count>0){
operators.Pop().Execute(values);
}
return values.Pop();
}
public virtual void loadFunctions(Rete engine)
{
Abs abs = new Abs();
engine.declareFunction(abs);
funcs.Add(abs);
Acos acos = new Acos();
engine.declareFunction(acos);
funcs.Add(acos);
Add add = new Add();
engine.declareFunction(add);
funcs.Add(add);
Asin asin = new Asin();
engine.declareFunction(asin);
funcs.Add(asin);
Atan atan = new Atan();
engine.declareFunction(atan);
funcs.Add(atan);
Ceil ceil = new Ceil();
engine.declareFunction(ceil);
funcs.Add(ceil);
Const cnst = new Const();
engine.declareFunction(cnst);
funcs.Add(cnst);
Cos cos = new Cos();
engine.declareFunction(cos);
funcs.Add(cos);
Degrees degrees = new Degrees();
engine.declareFunction(degrees);
funcs.Add(degrees);
Divide div = new Divide();
engine.declareFunction(div);
funcs.Add(div);
EqFunction eqf = new EqFunction();
engine.declareFunction(eqf);
funcs.Add(eqf);
Evenp evenp = new Evenp();
engine.declareFunction(evenp);
funcs.Add(evenp);
Exp exp = new Exp();
engine.declareFunction(exp);
funcs.Add(exp);
Floor floor = new Floor();
engine.declareFunction(floor);
funcs.Add(floor);
Greater gr = new Greater();
engine.declareFunction(gr);
funcs.Add(gr);
GreaterOrEqual gre = new GreaterOrEqual();
engine.declareFunction(gre);
funcs.Add(gre);
Less le = new Less();
engine.declareFunction(le);
funcs.Add(le);
LessOrEqual leoe = new LessOrEqual();
engine.declareFunction(leoe);
funcs.Add(leoe);
Log log = new Log();
engine.declareFunction(log);
funcs.Add(log);
Max max = new Max();
engine.declareFunction(max);
funcs.Add(max);
Min min = new Min();
engine.declareFunction(min);
funcs.Add(min);
Multiply mul = new Multiply();
engine.declareFunction(mul);
funcs.Add(mul);
NeqFunction neq = new NeqFunction();
engine.declareFunction(neq);
funcs.Add(neq);
Oddp oddp = new Oddp();
engine.declareFunction(oddp);
funcs.Add(oddp);
Pow pow = new Pow();
engine.declareFunction(pow);
funcs.Add(pow);
Radians radians = new Radians();
engine.declareFunction(radians);
funcs.Add(radians);
Random random = new Random();
engine.declareFunction(random);
funcs.Add(random);
Rint rint = new Rint();
engine.declareFunction(rint);
funcs.Add(rint);
Round round = new Round();
engine.declareFunction(round);
funcs.Add(round);
Sin sin = new Sin();
engine.declareFunction(sin);
funcs.Add(sin);
Sqrt sqrt = new Sqrt();
engine.declareFunction(sqrt);
funcs.Add(sqrt);
Subtract sub = new Subtract();
engine.declareFunction(sub);
funcs.Add(sub);
Tan tan = new Tan();
engine.declareFunction(tan);
funcs.Add(tan);
// now we Add the functions under alias
engine.declareFunction("+", add);
engine.declareFunction("-", sub);
engine.declareFunction("*", mul);
engine.declareFunction("/", div);
engine.declareFunction("**", pow);
engine.declareFunction(">", gr);
engine.declareFunction(">=", gre);
engine.declareFunction("<", le);
engine.declareFunction("<=", leoe);
}
public static void genNoise(int channelId)
{
moduleBase[channelId] = new Perlin();
if (teNoiseChanTypeIndex[channelId] == 1)
{
int tIdx = teNoiseTypeIndex[channelId];
if (tIdx == 0) { moduleBase[channelId] = new Perlin(frequency[channelId], lacunarity[channelId], persistance[channelId], octaves[channelId], seed[channelId], QualityMode.High); }
if (tIdx == 1) { moduleBase[channelId] = new Billow(frequency[channelId], lacunarity[channelId], persistance[channelId], octaves[channelId], seed[channelId], QualityMode.High); }
if (tIdx == 2) { moduleBase[channelId] = new RidgedMultifractal(frequency[channelId], lacunarity[channelId], octaves[channelId], seed[channelId], QualityMode.High); }
if (tIdx == 3) { moduleBase[channelId] = new Voronoi(frequency[channelId], displacement[channelId], seed[channelId], distance[channelId]); }
if (tIdx == 4) { moduleBase[channelId] = new BrownianMotion(frequency[channelId], lacunarity[channelId], octaves[channelId], seed[channelId], QualityMode.High); }
if (tIdx == 5) { moduleBase[channelId] = new HeterogeneousMultiFractal(frequency[channelId], lacunarity[channelId], octaves[channelId], persistance[channelId], seed[channelId], offset[channelId], QualityMode.High); }
if (tIdx == 6) { moduleBase[channelId] = new HybridMulti(frequency[channelId], lacunarity[channelId], octaves[channelId], persistance[channelId], seed[channelId], offset[channelId], gain[channelId], QualityMode.High); }
if (tIdx == 7) { moduleBase[channelId] = new LinearGradientNoise(frequency[channelId]); }
}
if (teNoiseChanTypeIndex[channelId] == 2)
{
int fIdx = teFunctionTypeIndex[channelId];
if (fIdx == 0) { moduleBase[channelId] = new Add(moduleBase[srcChannel1Id[channelId]], moduleBase[srcChannel2Id[channelId]]); }
if (fIdx == 1) { moduleBase[channelId] = new Subtract(moduleBase[srcChannel1Id[channelId]], moduleBase[srcChannel2Id[channelId]]); }
if (fIdx == 2) { moduleBase[channelId] = new Multiply(moduleBase[srcChannel1Id[channelId]], moduleBase[srcChannel2Id[channelId]]); }
if (fIdx == 3) { moduleBase[channelId] = new Min(moduleBase[srcChannel1Id[channelId]], moduleBase[srcChannel2Id[channelId]]); }
if (fIdx == 4) { moduleBase[channelId] = new Max(moduleBase[srcChannel1Id[channelId]], moduleBase[srcChannel2Id[channelId]]); }
if (fIdx == 5) { moduleBase[channelId] = new Blend(moduleBase[srcChannel1Id[channelId]], moduleBase[srcChannel2Id[channelId]], moduleBase[srcChannel3Id[channelId]]); }
if (fIdx == 6) { moduleBase[channelId] = new Clamp((double)noiseFuncMin[channelId], (double)noiseFuncMax[channelId], moduleBase[srcChannel1Id[channelId]]); }
if (fIdx == 7) { moduleBase[channelId] = new Power(moduleBase[srcChannel1Id[channelId]],moduleBase[srcChannel2Id[channelId]]);}
if (fIdx == 8) { Curve tmpCurve = new Curve(moduleBase[srcChannel1Id[channelId]]);
double adjust = double.Parse((controlpointcount[channelId]-1).ToString())*0.5;
for(int i=0;i<controlpointcount[channelId];i++){
tmpCurve.Add(double.Parse(i.ToString())-adjust,(double)cpval[channelId,i]);
moduleBase[channelId] = tmpCurve;
}
}
if(fIdx==9){Terrace tmpTerrace = new Terrace(invertTerrace[channelId],moduleBase[srcChannel1Id[channelId]]);
for(int i=0;i<controlpointcount[channelId];i++){
tmpTerrace.Add((double)cpval[channelId,i]-0.5);
moduleBase[channelId] = tmpTerrace;
}
}
if (fIdx == 18) { moduleBase[channelId] = new Mask(moduleBase[srcChannel1Id[channelId]], (double)noiseFuncMin[channelId], (double)noiseFuncMax[channelId]); }
if (fIdx == 17) { moduleBase[channelId] = new WindexWarp(moduleBase[srcChannel1Id[channelId]]); }
if (fIdx == 16) { moduleBase[channelId] = new TEWarp(moduleBase[srcChannel1Id[channelId]]); }
if (fIdx == 15) { moduleBase[channelId] = new Select((double)noiseFuncMin[channelId], (double)noiseFuncMax[channelId], falloff[channelId], moduleBase[srcChannel1Id[channelId]], moduleBase[srcChannel2Id[channelId]], moduleBase[srcChannel3Id[channelId]]); }
if (fIdx == 14) { moduleBase[channelId] = new Turbulence(power[channelId],moduleBase[srcChannel1Id[channelId]]); }
if (fIdx == 13) { moduleBase[channelId] = new ScaleBias(scale[channelId],bias[channelId],moduleBase[srcChannel1Id[channelId]]); }
if (fIdx == 12) { moduleBase[channelId] = new Invert(moduleBase[srcChannel1Id[channelId]]);}
if (fIdx == 11) { moduleBase[channelId] = new Exponent(exponent[channelId],moduleBase[srcChannel1Id[channelId]]); }
if (fIdx == 10) { moduleBase[channelId] = new Abs(moduleBase[srcChannel1Id[channelId]]);}
}
int resolution = 64;
int xoffset = 0; int yoffset = 0;
m_noiseMap[channelId] = new Noise2D(resolution, resolution, moduleBase[channelId]);
float x1 = xoffset * zoom[channelId];
float x2 = (xoffset * zoom[channelId]) + ((zoom[channelId] / resolution) * (resolution + 1));
float y1 = -yoffset * zoom[channelId];
float y2 = (-yoffset * zoom[channelId]) + ((zoom[channelId] / resolution) * (resolution + 1));
m_noiseMap[channelId].GeneratePlanar(x1, x2, y1, y2);
m_textures[channelId] = m_noiseMap[channelId].GetTexture();
m_textures[channelId].Apply();
}
