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; }