private float getClipped(Layer2DObject layer, int xph, int v)
{
int x = xph;
int y = v;
if (xph < layer.Resolution.X)
{
x = JryMath.Abs(xph);
}
if (v < layer.Resolution.Y)
{
y = JryMath.Abs(v);
}
if (xph >= layer.Resolution.X)
{
x = 2 * layer.Resolution.X - xph - 2;
}
if (v >= layer.Resolution.Y)
{
y = 2 * layer.Resolution.Y - v - 2;
}
return(layer[x, y].Value);
}
private void ds(Layer2DObject layer, int sizePow2, float ba, INoiseParameters np, IRandom2 rand)
{
int size = sizePow2 - 1;
int log = (int)JryMath.Log(size, 2);
// HACK
var x = np as DsNoiseParameters;
for (int l = 0; l < log; l++)
{
if (l == 0 && x != null)
{
hackeddiamond(layer, ba, x.HillProbability);
}
else
{
diamond(layer, size, ba, l, rand);
}
square(layer, size, ba, l, rand);
ba *= np.Amplitude;
if (l >= np.ToDepth)
{
ba *= np.Amplitude;
}
}
}
public ILayerMasked Do(INoiseParameters param, Vector2 size)
{
var dt = DateTime.Now.Millisecond;
System.Diagnostics.Debug.Print(dt + "Rand" + _rand.NextD(1, 2));
var pow = (int)JryMath.Max(JryMath.Ceil(JryMath.Log(size.X, 2)), JryMath.Ceil(JryMath.Log(size.Y, 2)));
int sizePow2 = (int)JryMath.Pow(2, pow) + 1;
Layer2DObject layer = new Layer2DObject(sizePow2, sizePow2);
setupBaseDS(sizePow2, layer, _rand);
var par = param.BaseAmplitude * param.Amplitude;
ds(layer, sizePow2, par, param, _rand);
var croped = new Layer2DObject(size);
for (int y = 0; y < size.Y; y++)
{
for (int x = 0; x < size.X; x++)
{
croped[x, y] = layer[x, y];
}
}
return(croped);
}
public ILayerMasked Do(Vector2 size)
{
//int maxDim = (int)JryMath.Max(size.X, size.Y);
//CONSTANT - There is a problem with values that are not 2^n wher n is element of N
var maxDim = 256;
int gradSize = 8;
IInterpolation interpolation = new LinearClipped();
Layer2DObject map = new Layer2DObject(size);
int hgrid = (int)size.X;
int vgrid = (int)size.Y;
float gain = _noiseParameters.Amplitude;
float lacunarity = _noiseParameters.Lacunarity;
var gradients = setupGradient(gradSize);
//set up the random numbers table
int[] permutations = getPermutaions(maxDim);
int maxDimMinOne = maxDim - 1;
int gradSizeMinOne = gradSize - 1;
for (int i = 0; i < vgrid; i++)
{
for (int j = 0; j < hgrid; j++)
{
float pixel_value = 0.0f;
float amplitude = 1.0f;
float frequency = 1.0f / maxDim;
for (int k = _noiseParameters.FromDepth; k < _noiseParameters.ToDepth; k++)
{
int x = JryMath.Floor(j * frequency);
int y = JryMath.Floor(i * frequency);
float fracX = j * frequency - x;
float fracY = i * frequency - y;
// following two lines solved the bug.
x += k;
y += k;
IntVector4 v = getIndices(permutations, maxDimMinOne, gradSizeMinOne, x, y);
Vector2[] grads = getGrads(gradients, v);
float interpolatedxy = biInterpolate(interpolation, grads, fracX, fracY);
pixel_value += interpolatedxy * amplitude;
amplitude *= gain;
frequency *= lacunarity;
}
//put it in the map
map[j, i] = pixel_value;
}
}
return(map);
}
private void diamond(ILayer layer, int size, float ap, int l, IRandom2 rand)
{
int squareSize = (int)(size * JryMath.Pow(.5f, l));
int squareHalfSize = (int)(squareSize / 2);
for (int iy = 0; iy < JryMath.Pow(2, l); iy++)
{
for (int ix = 0; ix < JryMath.Pow(2, l); ix++)
{
var xCorL = ix * squareSize;
var xCorR = (ix + 1) * squareSize;
var yCorT = iy * squareSize;
var yCorB = (iy + 1) * squareSize;
var tl = layer[xCorL, yCorT].Value;
var bl = layer[xCorL, yCorB].Value;
var tr = layer[xCorR, yCorT].Value;
var br = layer[xCorR, yCorB].Value;
int xph = xCorL + squareHalfSize;
int yph = yCorT + squareHalfSize;
var c = (tl + tr + br + bl) / 4 + rnd(rand, xph, yph) * ap;
layer[xph, yph] = c;
}
}
}
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));
}
private void square(Layer2DObject layer, int size, float ap, int depth, IRandom2 rand)
{
int squareSize = (int)(size * JryMath.Pow(.5f, depth));
int squareHalfSize = (int)(squareSize / 2);
for (int iy = 0; iy < JryMath.Pow(2, depth); iy++)
{
for (int ix = 0; ix < JryMath.Pow(2, depth); ix++)
{
var xCorL = ix * squareSize;
var xCorR = (ix + 1) * squareSize;
var yCorT = iy * squareSize;
var yCorB = (iy + 1) * squareSize;
var tl = layer[xCorL, yCorT].Value;
var bl = layer[xCorL, yCorB].Value;
var tr = layer[xCorR, yCorT].Value;
var br = layer[xCorR, yCorB].Value;
int xph = xCorL + squareHalfSize;
int yph = yCorT + squareHalfSize;
var c = (tl + tr + br + bl) / 4 + rnd(rand, xph, yph) * ap;
var b = (br + bl + c + getClipped(layer, xph, yph + squareSize)) / 4 + rnd(rand, xph, yph + squareSize) * ap;
var t = (tr + tl + c + getClipped(layer, xph, yph - squareSize)) / 4 + rnd(rand, xph, yph - squareSize) * ap;
var r = (tr + br + c + getClipped(layer, xph + squareSize, yph)) / 4 + rnd(rand, xph + squareSize, yph) * ap;
var l = (tl + bl + c + getClipped(layer, xph - squareSize, yph)) / 4 + rnd(rand, xph - squareSize, yph) * ap;
layer[xph, yCorT] = t;
layer[xph, yCorB] = b;
layer[xCorL, yph] = l;
layer[xCorR, yph] = r;
}
}
}
public override Task <ILayerMasked> GenerateLayer()
{
var pts = _layerLocalParameters.Polygon.Points.ToList();
var bounds = new GeometryUtils().GetBoundsForPoints(pts);
var mask = obtainBluredMask(pts,
_layerLocalParameters.BlurSize,
_layerLocalParameters.ExtendSize);
var size = mask.Resolution;
int count = (int)JryMath.Max(size.X, size.Y) / 100 + 1;
var areas = _voronoiAreGenerator.GenerateAreas(size, bounds.GetSize(), count);
_areaLoggerWithFill.LogAreas(size, areas, "loggedAreasFilled");
var layer = new Layer2DObject(new Vector2(size.X + _layerLocalParameters.ExtendSize, size.Y + _layerLocalParameters.ExtendSize));
var layerSize = layer.Resolution;
var deltaX = (layerSize.X - size.X) / 2;
var deltaY = (layerSize.Y - size.Y) / 2;
var translateVector = new Vector2(deltaX, deltaY);
_voronoiAreaDrawer.PrintToLayer(layer, areas, translateVector);
layer.Mask = mask;
_logger.Log(layer, "mountain");
applyOffset(_layerLocalParameters.ExtendSize, _layerLocalParameters.Polygon.Points.ToList(), layer);
_layUtils.Normalize(layer);
layer.Mask = mask;
return(Task.FromResult((ILayerMasked)layer));
}
public void Update(Vector2 location)
{
if (performCalled)
{
return;
}
if (!firstSet)
{
firstLocation = location;
firstSet = true;
}
var dot = Vector2.Dot(firstLocation.Normalize(), location.Normalize());
var angle = JryMath.Acos(dot);
var a = (updated - center).Normalize();
var b = (location - center).Normalize();
angle = (float)(Math.Atan2(a.Y, a.X) -
Math.Atan2(b.Y, b.X));
if (!float.IsNaN(angle))
{
updatablePolygon.RotateSelected(angle, center);
}
updated = location;
}
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);
}
public IMask GetQuarterFadedCircle(int radius, float fade, IInterpolation interpolation)
{
if (radius < 0 || fade > 1 || fade < 0)
{
throw new ArgumentException();
}
int fadeBegin = (int)(radius * (1 - fade));
var brushmask = new Mask(new Vector2(radius, radius));
for (int y = 0; y < radius; y++)
{
var li = (int)JryMath.Sqrt(radius * radius - (radius - y) * (radius - y));
for (int x = 0; x < li; x++)
{
var yCor = radius - y;
float val = 1;
var dis = JryMath.Sqrt(x * x + yCor * yCor);
if (dis > fadeBegin)
{
val = interpolation.Interpolate(1, 0, (dis - fadeBegin) / (radius - fadeBegin));
}
brushmask[x, yCor - 1] = val;
}
}
return(brushmask);
}
private void solveDegenerateCase(Vector2 point)
{
var newL = new Parabola(point);
Parabola newP = root;
var npl = root.GetLeftNode();
while (npl != null)
{
newP = npl;
npl = newP.GetLeftNode();
}
//newP is a root right now.
var rr = newP;
newP = new Parabola(newP.Site);
var p = new Vector2(newL.Site.X +
JryMath.Abs(newL.Site.X - newP.Site.X) / 2, _maxSize);
var seg = new Segment(p, newP.Site, newL.Site);
segs.Add(seg);
rr.SetRightParabola(newP, seg);
rr.SetLeftParabola(newL);
}
/// <summary>
/// Genereates using user input
/// </summary>
/// <param name="size"></param>
/// <param name="input"></param>
/// <returns></returns>
public IList <IArea> Generate(IntVector2 size, IList <Vector2> input)
{
var f = new Fortune();
//Points = input ;
var segs = f.GetSegments(input, minSize: 0, maxSize: JryMath.Max(size.X, size.Y));
return(_converter.ConvertSegmentToAreas(segs, size));
//return segs;
}
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 NextD(int seedX, int seedY, int seedZ)
{
seedX += _seed;
seedY += 5 * _seed;
seedZ += 13 * _seed;
var n = seedX + seedY * 57 + seedZ * 271;
n = (n << 13) ^ n;
var ra = (float)JryMath.Abs((1.0 - ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0));
var intra = (long)ra;
return(ra - intra);
}
private static Vector2[] setupGradient(int gradSize)
{
Vector2[] gradients = new Vector2[gradSize];
for (int i = 0; i < gradients.Length; ++i)
{
Vector2 v = new Vector2(JryMath.Sin(0.785398163f * i)
, JryMath.Cos(0.785398163f * i));
gradients[i] = v;
}
return(gradients);
}
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)));
}
public virtual float NextD(int seedX, int seedY)
{
seedX += 3 * _seed;
seedY += 5 * _seed;
var n = seedX + seedY * 57;
n = (n << 13) ^ n;
// it must fit into 0-1
var ra = (float)JryMath.Abs((1.0 - ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0));
var intra = (long)ra;
return(ra - intra);
}
public float Interpolate(float a, float b, float progress)
{
if (progress < 0)
{
return(a);
}
if (progress > 1)
{
return(b);
}
float tm = (1 - JryMath.Cos(progress * JryMath.Pi)) / 2;
return(a * (1 - tm) + b * tm);
}
private float decideAngle(float x, float y)
{
if (x >= 0 && y >= 0)
{
return(JryMath.Acos(x));
}
else if (x >= 0)
{
return(JryMath.Pi * 2 - JryMath.Acos(x));
}
else if (y >= 0)
{
return(JryMath.Acos(x));
}
else
{
return(JryMath.Pi * 2 - JryMath.Acos(x));
}
}
private IEnumerable <IntVector2> getLocalMaximaRecord(ILayer layer, int amount)
{
var someSprings = new List <IntVector2>();
var x = new HeapWrapper();
_layerUtility.IterateValues(layer, (cor, val) => x.Add(-val.Value, cor));
var upper10Percent = layer.Resolution.X * layer.Resolution.Y / 5;
var takeEveryNth = (int)JryMath.Ceil(upper10Percent / (float)amount);
for (int i = 0; i < upper10Percent; i++)
{
var item = x.Get();
if (i % takeEveryNth == 0)
{
someSprings.Add(item);
}
}
return(someSprings);
}
public void RotateSelected(float factor, Vector2 center)
{
if (!HasSelectedPoints)
{
return;
}
for (int i = 0; i < _points.Count; i++)
{
var pt = _points[i];
var index = _selectedPoints.IndexOf(pt);
if (index != -1)
{
pt = pt - center;
var p = new Vector2(JryMath.Cos(factor) * pt.X - JryMath.Sin(factor) * pt.Y,
JryMath.Sin(factor) * pt.X + JryMath.Cos(factor) * pt.Y);
_points[i] = p + center;
_selectedPoints[index] = _points[i];
}
}
recalcEdges();
}
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
}
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));
}
