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 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 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);
}
/// <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);
}
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.Max(value1, value2));
}
private int NewMethod(int max, float value)
{
return((int)JryMath.Max(JryMath.Min(max, value), 0));
}
