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 }