public CalculatedFractalPart CalculatePart(
ICalculationSpecification specification,
IFractalSettings settings,
CancellationToken cancellationToken)
{
var rectangleToCalculate = ((PointBasedCalculationSpecification)specification).RectangleToCalculate;
var algorithm = (IPointBasedFractal)settings.Algorithm;
var points = new Collection <FractalPath>();
for (var x = rectangleToCalculate.Left; x <= rectangleToCalculate.Right; x++)
{
for (var y = rectangleToCalculate.Top; y <= rectangleToCalculate.Bottom; y++)
{
var value = algorithm.CalculateSinglePoint(x, y, settings);
points.Add(new FractalPath(x - rectangleToCalculate.Left, y - rectangleToCalculate.Top, value));
}
if (cancellationToken.IsCancellationRequested)
{
break;
}
}
return(this.CreateResult(specification, rectangleToCalculate, points));
}
public IEnumerable <FractalPath> CalculatePaths(FractalPath initialPath, IFractalSettings settings, CancellationToken cancellationToken)
{
var paths = new List <FractalPath>();
this.CalculatePaths(initialPath, paths, settings, cancellationToken);
return(paths);
}
public override double CalculateSinglePoint(int x, int y, IFractalSettings settings)
{
var scaledX = this.ScaleX(x, settings);
var scaledY = this.ScaleY(y, settings);
var iteration = RunMandelbrotLoop(scaledX, scaledY, settings.MaxIterations);
return(iteration);
}
protected override double ScaleX(double x, IFractalSettings settings)
{
var scaleFactor = 1 / (settings.FractalRect.Right - settings.FractalRect.Left);
x = x.ScaleXToFractal(this.DefaultScale, settings.ScreenWidth);
x = scaleFactor * (x - settings.FractalRect.Left) * settings.ScreenWidth;
return(x);
}
private IJob CreateJob(IFractalSettings settings, IShader shader)
{
if (this.LastJobResult != null && !this.LastJobResult.Cancelled && this.LastJobResult.Job.Settings.Equals(settings))
{
return(this.jobFactory.CreateFromResult(this.LastJobResult, settings, shader, this.GetNumberOfSectors()));
}
return(this.jobFactory.Create(settings, shader, this.GetNumberOfSectors()));
}
protected override double ScaleY(double y, IFractalSettings settings)
{
var scaleFactor = 1 / (settings.FractalRect.Bottom - settings.FractalRect.Top);
y = y.ScaleYToFractal(this.DefaultScale, settings.ScreenHeight);
y = scaleFactor * (y - settings.FractalRect.Top) * settings.ScreenHeight;
return(y);
}
public override IEnumerable <ICalculationSpecification> GetCalculatableParts(IFractalSettings settings, int numberOfParts)
{
var initialLine = this.GetInitialLine(settings);
var parts = new List <FractalPath>();
this.AddBranches(parts, initialLine.Item1, initialLine.Item2, 0, 2, new CancellationToken());
return(CreateCalculationSpecifications(parts, true));
}
public IJob Create(IFractalSettings settings, IShader shader, int numberOfSectors)
{
var parts = settings.Algorithm.GetCalculatableParts(settings, numberOfSectors);
var stages = this.SplitAndGroupIntoStages(parts);
var renderSpecs = stages.Select(s => s.Select(part => this.renderSpecificationFactory.CreateDefault(part, settings, shader))).ToArray();
return(new Job(settings, renderSpecs));
}
private Tuple <Point <double>, Point <double> > GetInitialLine(IFractalSettings settings)
{
var xPos1 = this.ScaleX(settings.ScreenWidth / 2d, settings);
var xPos2 = xPos1;
var yPos1 = this.ScaleY(settings.ScreenHeight * 0.9d, settings);
var yPos2 = this.ScaleY(settings.ScreenHeight * 0.6d, settings);
return(Tuple.Create(new Point <double>(xPos1, yPos1), new Point <double>(xPos2, yPos2)));
}
public IEnumerable <ICalculationSpecification> GetCalculatableParts(IFractalSettings settings, int numberOfParts)
{
var sizePerSector = settings.ScreenWidth / numberOfParts;
for (var sector = 0; sector < numberOfParts; sector++)
{
var left = sizePerSector * sector;
var right = sector == numberOfParts - 1 ? settings.ScreenWidth - 1 : left + sizePerSector - 1;
var fractionBounds = new Rectangle <int>(left, 0, right, settings.ScreenHeight - 1);
yield return(new PointBasedCalculationSpecification(fractionBounds, 0));
}
}
public CalculatedFractalPart CalculatePart(
ICalculationSpecification specification,
IFractalSettings settings,
CancellationToken cancellationToken)
{
var pathBasedSpec = ((PathBasedCalculationSpecification)specification);
var algorithm = (IPathBasedFractal)settings.Algorithm;
var lines = algorithm.CalculatePaths(pathBasedSpec.InitialPath, settings, cancellationToken);
lines = lines.Union(pathBasedSpec.AdditionalOutput);
return(new CalculatedFractalPart(new Rectangle <int>(0, 0, settings.ScreenWidth - 1, settings.ScreenHeight - 1), lines));
}
public override IEnumerable <ICalculationSpecification> GetCalculatableParts(IFractalSettings settings, int numberOfParts)
{
var radius = Math.Min(settings.ScreenWidth, settings.ScreenHeight) / 3;
var centerPoint = new Point <double>((double)settings.ScreenWidth / 2, (double)settings.ScreenHeight / 2);
var a = this.ScalePoint(Geometry.GetPointFromAngle(centerPoint, radius, this.initialAngle), settings);
var b = this.ScalePoint(Geometry.GetPointFromAngle(centerPoint, radius, this.initialAngle + 120), settings);
var c = this.ScalePoint(Geometry.GetPointFromAngle(centerPoint, radius, this.initialAngle + 240), settings);
var parts = new List <FractalPath>();
this.AddTriangles(parts, a, b, c, 0, 2, new CancellationToken());
return(CreateCalculationSpecifications(parts, true));
}
protected override void CalculatePaths(
FractalPath initialPath,
IList <FractalPath> paths,
IFractalSettings settings,
CancellationToken cancellationToken)
{
this.AddBranches(
paths,
initialPath.GetFirstPoint(),
initialPath.GetSecondPoint(),
(int)initialPath.Value,
settings.MaxIterations,
cancellationToken);
}
protected override void CalculatePaths(
FractalPath initialPath,
IList <FractalPath> paths,
IFractalSettings settings,
CancellationToken cancellationToken)
{
this.AddTriangles(
paths,
initialPath.Points[0],
initialPath.Points[1],
initialPath.Points[2],
(int)initialPath.Value,
settings.MaxIterations,
cancellationToken);
}
public FastBitmap CreateBitmap(CalculatedFractalPart calculatedFractalPart, IFractalSettings settings, IShader shader)
{
var fastBitmap = new FastBitmap(
calculatedFractalPart.ScreenPosition.Right - calculatedFractalPart.ScreenPosition.Left + 1,
calculatedFractalPart.ScreenPosition.Bottom - calculatedFractalPart.ScreenPosition.Top + 1);
using (var lazyGraphics = new LazyGraphics(fastBitmap.Bitmap))
{
using (var pens = new PenCache())
{
foreach (var path in calculatedFractalPart.Paths)
{
var color = shader.GetColor(path.Value, settings.MaxIterations);
DrawPath(path, color, fastBitmap, pens, lazyGraphics);
}
}
}
return(fastBitmap);
}
public IJob CreateFromResult(IJobResult result, IFractalSettings settings, IShader shader, int numberOfSectors)
{
// TODO: this should use the same grouping logic as the algorithm
var allParts = result.RenderResults.Select(r => r.CalculatedFractalPart).OrderBy(r => r.ScreenPosition.Left).ToArray();
var sizePerSector = settings.ScreenWidth / numberOfSectors;
var combinedParts = new List <CalculatedFractalPart>();
for (var sector = 0; sector < numberOfSectors; sector++)
{
var left = sizePerSector * sector;
var right = sector == numberOfSectors - 1 ? settings.ScreenWidth - 1 : left + sizePerSector - 1;
var relevantParts = allParts.Where(part => part.ScreenPosition.Left >= left && part.ScreenPosition.Right <= right);
var paths = relevantParts.SelectMany(part => part.Paths.Select(path => path.Adjust(part.ScreenPosition.Left - left, 0)));
combinedParts.Add(new CalculatedFractalPart(new Rectangle <int>(left, 0, right, settings.ScreenHeight - 1), paths));
}
var renderSpecs = combinedParts.Select(part => this.renderSpecificationFactory.CreateFromCalculatedPart(part, settings, shader));
return(new Job(settings, renderSpecs.ToArray()));
}
public Job(IFractalSettings settings, params IEnumerable <IRenderSpecification>[] stages)
{
this.Settings = settings;
this.Stages = stages;
}
public abstract double CalculateSinglePoint(int x, int y, IFractalSettings settings);
protected abstract void CalculatePaths(
FractalPath initialPath,
IList <FractalPath> paths,
IFractalSettings settings,
CancellationToken cancellationToken);
public IRenderSpecification CreateFromCalculatedPart(CalculatedFractalPart part, IFractalSettings settings, IShader shader)
{
return(new ShadingOnlyRenderSpecification(part, settings, shader));
}
public abstract IEnumerable <ICalculationSpecification> GetCalculatableParts(IFractalSettings settings, int numberOfParts);
protected virtual double ScaleX(double x, IFractalSettings settings)
{
return(x.ScaleXToFractal(settings));
}
protected virtual double ScaleY(double y, IFractalSettings settings)
{
return(y.ScaleYToFractal(settings));
}
public static double ScaleXToFractal(this double screenX, IFractalSettings settings)
{
return(screenX.ScaleXToFractal(settings.FractalRect, settings.ScreenWidth));
}
public ShadingOnlyRenderSpecification(CalculatedFractalPart calculatedFractalPart, IFractalSettings settings, IShader shader)
: base(settings, shader)
{
this.CalculatedFractalPart = calculatedFractalPart;
}
public CalculatingRenderSpecification(ICalculationSpecification calculationSpecification, IFractalSettings settings, IShader shader)
: base(settings, shader)
{
this.CalculationSpecification = calculationSpecification;
}
public IRenderSpecification CreateDefault(ICalculationSpecification calculationSpecification, IFractalSettings settings, IShader shader)
{
return(new CalculatingRenderSpecification(calculationSpecification, settings, shader));
}
protected virtual Point <double> ScalePoint(Point <double> point, IFractalSettings settings)
{
return(new Point <double>(this.ScaleX(point.X, settings), this.ScaleY(point.Y, settings)));
}
public static double ScaleYToFractal(this double screenY, IFractalSettings settings)
{
return(screenY.ScaleYToFractal(settings.FractalRect, settings.ScreenHeight));
}
protected RenderSpecificationBase(IFractalSettings settings, IShader shader)
{
this.Settings = settings;
this.Shader = shader;
}
