public Vector2 cropBySize(Vector2 v, IntVector2 size)
{
var x = JryMath.Max(JryMath.Min(v.X, size.X), 0);
var y = JryMath.Max(JryMath.Min(v.Y, size.Y), 0);
return(new Vector2(x, y));
}
public float ApplyMatrix(ILayer source, Vector2 loc, MatrixNxN kernel, int div)
{
var halfSize = (int)(kernel.N / 2);
float acc = 0;
for (int j = 0; j < kernel.N; j++)
{
for (int i = 0; i < kernel.N; i++)
{
int x = -halfSize + (int)loc.X + (int)i;
int y = -halfSize + (int)loc.Y + (int)j;
if (isOk(x, source.Resolution.X) && isOk(y, source.Resolution.Y))
{
var sourceVal = source[x, y];
if (sourceVal.HasValue)
{
acc += sourceVal.Value * kernel[(uint)i, (uint)j];
}
}
}
}
var previous = source[(int)loc.X, (int)loc.Y];
var future = acc / div;
if (previous.HasValue)
{
return(previous.Value + JryMath.Min(future - previous.Value, .1f));
}
return(future);
}
private ILayerMasked merge(IBlendModeAlpha ablend, ILayerMasked baseLayer, IList <DescribedLayer> pars)
{
onMergeStarted();
if (pars == null || pars.Count == 0)
{
throw new ArgumentException();
}
var final = baseLayer;
foreach (var describ in pars)
{
var current = describ.Layer;
var blendMode = describ.GlobalParameters.BlendMode;
var offset = describ.GlobalParameters.Offset - .5f;
var minY = JryMath.Max(0, -current.Offset.Y);
var minX = JryMath.Max(0, -current.Offset.X);
var maxY = JryMath.Min(current.Resolution.Y, final.Resolution.Y - current.Offset.Y);
var maxX = JryMath.Min(current.Resolution.X, final.Resolution.X - current.Offset.X);
for (int y = minY; y < maxY; y++)
{
for (int x = minX; x < maxX; x++)
{
int ix = x + current.Offset.X;
int iy = y + current.Offset.Y;
var curVal = current[x, y];
if (!curVal.HasValue || !final[ix, iy].HasValue || !current.HasMask)
{
continue;
}
var maskValue = current.Mask[x, y];
if (!maskValue.HasValue)
{
continue;
}
var currentLayerValue = curVal.Value + offset;
var currentLayerMaskValue = maskValue.Value;
//currentLayerMaskValue = 1;
var upToThisPointGeneratedLayerValue = final[ix, iy].Value;
var blended = blendMode.Blend(upToThisPointGeneratedLayerValue, currentLayerValue * currentLayerMaskValue);
final[ix, iy] = ablend.Blend(upToThisPointGeneratedLayerValue, blended, currentLayerMaskValue);
if (final[ix, iy] > 0.05f)
{
}
}
}
}
return(baseLayer);
}
private byte obtainColor(float?fVal)
{
if (fVal.HasValue)
{
return((byte)(JryMath.Max(0, JryMath.Min(fVal.Value * 255, 255))));
}
return(0);
}
public float DistanceFromPointToSegmentSquare(ref Vector2 coor, ref LineSegment seg)
{
var perpendicular = new LineSegment(coor, coor + seg.PerpendicularNotNormalized);
Vector2 intersection;
if (LineHasIntersectionWithSegment(ref perpendicular, ref seg, out intersection))
{
return((intersection - coor).LengthSquared());
}
return(JryMath.Min(
Vector2.DistanceSquared(coor, seg.Point1),
Vector2.DistanceSquared(coor, seg.Point2)));
}
private static float crop(float min, float max, float p)
{
return(JryMath.Min(JryMath.Max(p, min), max));
}
public Vector2 getParabalaeIntersection(Parabola left, Parabola right, double directixY)
{
if (left == null || right == null || left.Site == right.Site)
{
throw new Exception("NoIntersectoinFound");
}
double denominator1 = 2.0f * (left.Site.Y - directixY);
//#warning quickfix
if (denominator1 == 0)
{
denominator1 = 0.000001;
}
double a1 = 1.0f / denominator1;
double b1 = -2.0f * left.Site.X / denominator1;
double c1 = ((left.Site.X * left.Site.X) + (left.Site.Y * left.Site.Y) - (directixY * directixY))
/ denominator1;
//y + dp / 4 + px * px / dp
double denominator2 = 2.0f * (right.Site.Y - directixY);
//#warning quickfix
if (denominator2 == 0)
{
denominator2 = 0.000001;
}
double a2 = 1.0f / denominator2;
double b2 = -2.0f * right.Site.X / denominator2;
double c2 = ((right.Site.X * right.Site.X) + (right.Site.Y * right.Site.Y) - (directixY * directixY))
/ denominator2;
double a = a1 - a2;
double b = b1 - b2;
double c = c1 - c2;
double x1 = 0, x2 = 0;
if (a == 0)// 0 = bx +c
{
x1 = -c / b;
x2 = x1;
}
else //0 = ax^2 + bx + c
{
double disc = b * b - 4 * a * c;
if (disc < 0)// when everything is ok. this case become imposible
{
throw new InvalidOperationException("Negative discriminant root not found in real domain");
}
x1 = (-b + JryMath.Sqrt(disc)) / (2 * a);
x2 = (-b - JryMath.Sqrt(disc)) / (2 * a);
}
double x;
if (left.Site.Y < right.Site.Y)
{
x = JryMath.Max(x1, x2);
}
else
{
x = JryMath.Min(x1, x2);
}
double y;
// i have chosen to use left parabola to get Y coor;
y = a1 * x * x + b1 * x + c1;
return(new Vector2((float)x, (float)y));
}
public float Blend(float value1, float value2)
{
return(JryMath.Min(value1, value2));
}
private int NewMethod(int max, float value)
{
return((int)JryMath.Max(JryMath.Min(max, value), 0));
}
private void performStep(ILayer layer, int x, int y)
{
Vector2 lowest = _layerUtility.GetLowestNeighbour(layer, x, y);
var lowestX = (int)lowest.X;
var lowestY = (int)lowest.Y;
if (lowestX == x && lowestY == y)
{
return;
}
//erosion
var lowestWater = _water[lowestX, lowestY];
var lowHeight = layer[lowestX, lowestY];
var currentWater = _water[x, y];
var currentHeight = layer[x, y];
// sure it exists
// ReSharper disable once PossibleInvalidOperationException
float lowestLevel = lowestWater.Value
// sure it exists
// ReSharper disable once PossibleInvalidOperationException
+ lowHeight.Value;
// sure it exists
// ReSharper disable once PossibleInvalidOperationException
float currentLevel = currentWater.Value
// sure it exists
// ReSharper disable once PossibleInvalidOperationException
+ currentHeight.Value;
if (lowestLevel + currentWater < currentHeight.Value)
{
// case 3
//transfer water completely
_waterDiff[lowestX, lowestY] += _water[x, y];
_waterDiff[x, y] -= _water[x, y];
//transfer sediment
var sediment = _water[x, y] * solubility;
//transfer from
_sediment[x, y] -= sediment;
//transfer to
_sediment[lowest] += sediment;
}
else if (lowestLevel < currentLevel)
{
// case 2
//transfer water completely
var transferedWater = JryMath.Min(currentLevel - lowestLevel, currentWater.Value) / 2;
_waterDiff[lowestX, lowestY] += transferedWater;
_waterDiff[x, y] -= transferedWater;
//transfer sediment
var factor = transferedWater / currentWater;
var scaledSolubility = _water[x, y] * solubility * factor;
var solub = scaledSolubility;
//transfer from
_sediment[x, y] -= solub;
//transfer to
_sediment[lowest] += solub;
}
//else lowest one is not lower than current one
#if ImmediateApply
// test codee
_water[x, y] += _waterDiff[x, y];
//transfer sediment
layer[x, y] += _sediment[x, y];
_waterDiff[x, y] = 0;
_sediment[x, y] = 0;
//evaporation
_water[x, y] *= 1 - evaporation;
#endif
}
