private void Initialize(RGProcessor processor)
        {
            if (_initialized)
            {
                return;
            }

            var leftRG = new RGPoint(2, 0);
            var leftC  = leftRG.C(CProjection.C1C2);

            _leftC2Limit = leftC.C2;

            var rightRG = new RGPoint(-1000, (-1000 + 1) / (-1000 - processor.B0) * Math.Pow(-1000 + 1, 2));
            var rightC  = rightRG.C(CProjection.C1C2);

            _rightC2Limit = rightC.C2;

            _criticalPoint         = processor.Alpha >= 1 ? new CPoint(0, 0, 1) : new CPoint(1, 0, 0);
            _criticalPointOpposite = _criticalPoint.Opposite;

            _iterationsLimit = 1000;
            _distanceLimit   = 0.000001;
            _initialized     = true;

            _markupVPoints.Clear();
            _markupHPoints.Clear();

            /*
             * for (var i = 0; i <= 50; i++)
             * {
             *  _markupVPoints.Add(new List<CPoint>());
             *  _markupHPoints.Add(new List<CPoint>());
             * }
             *
             * for (var y = -1f; y <= 1f; y += 0.00001f)
             * {
             *  var c = CPoint.New(new PointF(0, y), CProjection.C1C2);
             *  _markupVPoints[0].Add(c);
             *  for (var i = 1; i <= 50; i++)
             *  {
             *      c = DirectIterated(c, CProjection.C1C2, processor);
             *      _markupVPoints[i].Add(c);
             *  }
             * }
             *
             * for (var x = -1f; x <= 1f; x += 0.00001f)
             * {
             *  var c = CPoint.New(new PointF(x, 0), CProjection.C1C2);
             *  _markupHPoints[0].Add(c);
             *  for (var i = 1; i <= 50; i++)
             *  {
             *      c = DirectIterated(c, CProjection.C1C2, processor);
             *      _markupHPoints[i].Add(c);
             *  }
             * }
             */
        }
        protected override Color GetC1C2Color(CPoint cpt, RGPoint rg, RGScene scene, RGProcessor processor)
        {
            Initialize(processor);

            var   i = 0;
            Color res;
            var   start   = cpt;
            var   current = start;


            while (i < _iterationsLimit)
            {
                current = DirectIterated(current, CProjection.C1C2, processor);
                if (processor.Alpha > 1 && rg.G > 0)
                {
                    if (current.C1 < 0 && current.C2 > _leftC2Limit)
                    {
                        break;
                    }
                    if (current.C1 > 0 && current.C2 > _rightC2Limit)
                    {
                        break;
                    }
                }
                else
                {
                    var d1 = current.DistanceTo(_criticalPoint);
                    var d2 = current.DistanceTo(_criticalPointOpposite);
                    if (d1 < _distanceLimit || d2 < _distanceLimit)
                    {
                        break;
                    }
                }
                i++;
            }
            if (i == _iterationsLimit)
            {
                res = RGScene.UndefinedColor;
            }
            else
            {
                res = rg.G >= 0
                    ?
                      (current.C1 < 0 ? RGScene.PositiveDynamicsLeftColor : RGScene.PositiveDynamicsRightColor)
                    :
                      (current.C1 < 0 ? RGScene.NegativeDynamicsLeftColor : RGScene.NegativeDynamicsRightColor)
                      //RGScene.NegativeDynamicsLeftColor
                ;
            }

            return(res);
        }
        public override Color GetPixelColor(PointF ptF, RGScene scene, RGProcessor processor)
        {
            var cpt = CPoint.New(ptF, CProjection.C1C2);

            if (!cpt.IsNormal)
            {
                return(RGScene.BackgroundColr);
            }

            var rg  = cpt.RG(CProjection.C1C2);
            var clr = GetC1C2Color(cpt, rg, scene, processor);

            return(clr);
        }
        private CPoint ReverseIterated(CPoint source, CProjection projection, RGProcessor processor)
        {
            var c0MinusLambdaMinus1C1      = source.C0 - processor.LambdaMinus1 * source.C1;
            var c1MinusLambdaMinus1C2      = source.C1 - processor.LambdaMinus1 * source.C2;
            var c0C2MinusC1Sq              = source.C0 * source.C2 - source.C1 * source.C1;
            var nLambdaMinus2C0C2MinusC1Sq = processor.NLambdaMinus2 * c0C2MinusC1Sq;

            var c0 = c0MinusLambdaMinus1C1 * c0MinusLambdaMinus1C1 + nLambdaMinus2C0C2MinusC1Sq;
            var c1 = processor.LambdaMinus1 * c0MinusLambdaMinus1C1 * c1MinusLambdaMinus1C2 + nLambdaMinus2C0C2MinusC1Sq;
            var c2 = processor.LambdaMinus2 * c1MinusLambdaMinus1C2 * c1MinusLambdaMinus1C2 + nLambdaMinus2C0C2MinusC1Sq;

            var res = new CPoint(c0, c1, c2);

            res.Project(projection);
            return(res);
        }
        public CPoint DirectIterated(CPoint source, CProjection projection, RGProcessor processor)
        {
            var c1MinusC0     = source.C1 - source.C0;
            var c2MunusC1     = source.C2 - source.C1;
            var c0C2MinusC1Sq = source.C0 * source.C2 - source.C1 * source.C1;
            var n1            = processor.OneDivN;

            var c0 = c1MinusC0 * c1MinusC0 + n1 * c0C2MinusC1Sq;
            var c1 = processor.Lambda * (c1MinusC0 * c2MunusC1 + n1 * c0C2MinusC1Sq);
            var c2 = processor.Lambda2 * (c2MunusC1 * c2MunusC1 + n1 * c0C2MinusC1Sq);

            var res = new CPoint(c0, c1, c2);

            res.Project(projection);
            return(res);
        }
Ejemplo n.º 6
0
 public void ApplyTransformation(RGSceneTransform transform, RGProcessor processor)
 {
     lock (OriginalImage)
     {
         var tImage = new Bitmap(OriginalImage);
         using (var layer = transform.GetLayer(_rgFrame, _uiFrame, this, processor))
         {
             for (var i = 0; i < tImage.Width; i++)
             {
                 for (var j = 0; j < tImage.Height; j++)
                 {
                     var clr = layer.GetPixel(i, j);
                     if (clr != BackgroundColr)
                     {
                         tImage.SetPixel(i, j, clr);
                     }
                 }
             }
             OriginalImage = tImage;
             ResultedImage = new Bitmap(OriginalImage);
         }
     }
 }
        protected override void ApplyMarkup(Bitmap bmp, Graphics gr, RGScene scene, RGProcessor processor)
        {
            base.ApplyMarkup(bmp, gr, scene, processor);
            var markupPen = new Pen(RGScene.MarkupColor);

            //for (var x = -1d; x <= 1d; x += 0.01)
            //{
            //    var eq1 = 1 - x*x - LeftC2Limit*LeftC2Limit;
            //    if (eq1 > 0)
            //    {
            //        var c = new CPoint(eq1, x, LeftC2Limit);
            //        if (c.RG(CProjection.C1C2).G > 0 && x < 0)
            //        {
            //            var pt = new PointF((float) x, (float) LeftC2Limit);
            //            var pt1 = new PointF((float) x + 0.001f, (float) LeftC2Limit);
            //            var p1 = scene.MapToUIFrame(pt);
            //            var p2 = scene.MapToUIFrame(pt1);
            //            gr.DrawLine(markupPen, p1, p2);
            //        }
            //    }
            //}

            //for (var x = -1d; x <= 1d; x += 0.01)
            //{
            //    var eq1 = 1 - x * x - RightC2Limit * RightC2Limit;
            //    if (eq1 > 0)
            //    {
            //        var c = new CPoint(eq1, x, RightC2Limit);
            //        var pt = new PointF((float)x, (float)RightC2Limit);
            //        var pt1 = new PointF((float)x + 0.001f, (float)RightC2Limit);
            //        var p1 = scene.MapToUIFrame(pt);
            //        var p2 = scene.MapToUIFrame(pt1);
            //        gr.DrawLine(markupPen, p1, p2);
            //    }
            //}
        }
Ejemplo n.º 8
0
 public abstract Color GetPixelColor(PointF ptF, RGScene scene, RGProcessor processor);
        public override void ApplyBoundaryPointDynamics(int step, Bitmap bmp, Graphics gr, Tuple <Color, PointF, CPoint> left, Tuple <Color, PointF, CPoint> right, RGScene scene, RGProcessor processor)
        {
            var cptLeft = left.Item3;
            var clrLeft =
                left.Item1 == RGScene.PositiveDynamicsRightColor ||
                left.Item1 == RGScene.NegativeDynamicsLeftColor
                    ? RGScene.Line2Color
                    : RGScene.Line1Color;
            var penLeft  = new Pen(clrLeft);
            var cptRight = right.Item3;
            var clrRight =
                right.Item1 == RGScene.PositiveDynamicsRightColor ||
                right.Item1 == RGScene.NegativeDynamicsLeftColor
                    ? RGScene.Line2Color
                    : RGScene.Line1Color;
            var penRight = new Pen(clrRight);

            var trans = this as DirectRGTransformationC1C2;

            if (trans == null)
            {
                return;
            }

            var resLeft  = cptLeft;
            var resRight = cptRight;

            for (var i = 0; i < step; i++)
            {
                resLeft  = trans.DirectIterated(resLeft, CProjection.C1C2, processor);
                resRight = trans.DirectIterated(resRight, CProjection.C1C2, processor);
            }

            var coordsLeft = scene.MapToUIFrame(new PointF((float)resLeft.C1, (float)resLeft.C2));

            gr.DrawEllipse(penLeft, coordsLeft.X, coordsLeft.Y, 1, 1);
            gr.DrawEllipse(penLeft, coordsLeft.X - 3, coordsLeft.Y - 3, 6, 6);

            var coordsRight = scene.MapToUIFrame(new PointF((float)resRight.C1, (float)resRight.C2));

            gr.DrawEllipse(penRight, coordsRight.X, coordsRight.Y, 1, 1);
            gr.DrawEllipse(penRight, coordsRight.X - 3, coordsRight.Y - 3, 6, 6);
        }
        public override void ApplyMarkupDynamics(int step, Bitmap bmp, Graphics gr, RGScene scene, RGProcessor processor)
        {
            var vline = _markupVPoints[step];
            var vPen  = new Pen(RGScene.MarkupVColor);

            foreach (var cpt1 in vline)
            {
                var p1 = scene.MapToUIFrame(new PointF((float)cpt1.C1, (float)cpt1.C2));
                gr.DrawEllipse(vPen, p1.X, p1.Y, 1, 1);
            }
            var hline = _markupHPoints[step];
            var hPen  = new Pen(RGScene.MarkupHColor);

            foreach (var cpt1 in hline)
            {
                var p1 = scene.MapToUIFrame(new PointF((float)cpt1.C1, (float)cpt1.C2));
                gr.DrawEllipse(hPen, p1.X, p1.Y, 1, 1);
            }
        }
Ejemplo n.º 11
0
 protected abstract void ApplyMarkup(Bitmap bmp, Graphics gr, RGScene scene, RGProcessor processor);
Ejemplo n.º 12
0
        public override Bitmap GetLayer(RectangleF rect, Size frameRect, RGScene scene, RGProcessor processor)
        {
            var bmp    = scene.CreateBackgroundBitmap(frameRect);
            var colors = new Color[bmp.Width, bmp.Height];

            for (var i1 = 0; i1 < bmp.Width; i1++)
            {
                var i = i1;
                Parallel.For(0, bmp.Height, j =>
                {
                    var pt  = scene.MapToRGFrame(new Point(i, j));
                    var clr = GetPixelColor(pt, scene, processor);
                    if (clr != RGScene.BackgroundColr)
                    {
                        //bmp.SetPixel(i, j, clr);
                        colors[i, j] = clr;
                    }
                });

                /*
                 * for (var j = 0; j < bmp.Height; j++)
                 * {
                 *
                 *
                 * }*/
            }
            for (var i = 0; i < bmp.Width; i++)
            {
                for (var j = 0; j < bmp.Height; j++)
                {
                    bmp.SetPixel(i, j, colors[i, j]);
                }
            }
            var gr = Graphics.FromImage(bmp);

            ApplyMarkup(bmp, gr, scene, processor);
            gr.Save();
            return(bmp);
        }
Ejemplo n.º 13
0
 public abstract void ApplyMarkupDynamics(int step, Bitmap bmp, Graphics gr, RGScene scene, RGProcessor processor);
Ejemplo n.º 14
0
 public abstract Bitmap GetLayer(RectangleF rect, Size frameRect, RGScene scene, RGProcessor processor);
        protected override void ApplyMarkup(Bitmap bmp, Graphics gr, RGScene scene, RGProcessor processor)
        {
            var opt           = true;
            var drawParabolas = false;

            var markupPen          = new Pen(RGScene.MarkupColor);
            var labelsBrush        = new SolidBrush(RGScene.LabelsColor);
            var labelsBrushEx      = new SolidBrush(RGScene.MarkupColor);
            var labelsFont         = new Font(FontFamily.GenericSansSerif, 12);
            var line1Pen           = new Pen(RGScene.Line1Color);
            var line2Pen           = new Pen(RGScene.Line2Color);
            var parabolaPen        = new Pen(RGScene.ParabolaColor);
            var reverseParabolaPen = new Pen(RGScene.ReverseParabolaColor);

            var zeroFixedPoint         = new PointF(0, 0);
            var zeroFixedPointUiCoords = scene.MapToUIFrame(zeroFixedPoint);

            gr.DrawEllipse(markupPen, zeroFixedPointUiCoords.X - 4, zeroFixedPointUiCoords.Y - 4, 8, 8);
            gr.DrawString("0", labelsFont, labelsBrushEx, zeroFixedPointUiCoords.X, zeroFixedPointUiCoords.Y);

            var infinityFixedPoint         = new PointF(0, 1);
            var infinityFixedPointUiCoords = scene.MapToUIFrame(infinityFixedPoint);

            gr.DrawEllipse(markupPen, infinityFixedPointUiCoords.X - 4, infinityFixedPointUiCoords.Y - 4, 8, 8);
            gr.DrawString("δ", labelsFont, labelsBrushEx, infinityFixedPointUiCoords.X, infinityFixedPointUiCoords.Y);

            var x0Pt  = new PointF(-1.1f, 0);
            var x1Pt  = new PointF(1.1f, 0);
            var sx0Pt = scene.MapToUIFrame(x0Pt);
            var sx1Pt = scene.MapToUIFrame(x1Pt);

            gr.DrawLine(markupPen, sx0Pt, sx1Pt);
            var xlabelPt  = new PointF(1.0f, -0.02f);
            var sxLabelPt = scene.MapToUIFrame(xlabelPt);

            gr.DrawString("C1", labelsFont, labelsBrushEx, sxLabelPt);

            var y0Pt  = new PointF(0, -1.1f);
            var y1Pt  = new PointF(0, 1.1f);
            var sy0Pt = scene.MapToUIFrame(y0Pt);
            var sy1Pt = scene.MapToUIFrame(y1Pt);

            gr.DrawLine(markupPen, sy0Pt, sy1Pt);
            var ylabelPt  = new PointF(0.07f, 1.07f);
            var syLabelPt = scene.MapToUIFrame(ylabelPt);

            gr.DrawString("C2", labelsFont, labelsBrushEx, syLabelPt);

            var singularPoint        = new CPoint(1, 1, 1);
            var frameSingularPoint   = new PointF((float)singularPoint.C1, (float)singularPoint.C2);
            var singularPoinUiCoords = scene.MapToUIFrame(frameSingularPoint);

            gr.DrawEllipse(markupPen, singularPoinUiCoords.X - 4, singularPoinUiCoords.Y - 4, 8, 8);
            if (opt)
            {
                gr.DrawLine(markupPen, singularPoinUiCoords.X - 4, singularPoinUiCoords.Y - 4, singularPoinUiCoords.X + 4, singularPoinUiCoords.Y + 4);
                gr.DrawLine(markupPen, singularPoinUiCoords.X - 4, singularPoinUiCoords.Y + 4, singularPoinUiCoords.X + 4, singularPoinUiCoords.Y - 4);
            }
            else
            {
                gr.DrawString("3", labelsFont, labelsBrushEx, singularPoinUiCoords.X - 16, singularPoinUiCoords.Y - 4);
            }

            var fixedPointX1 = Math.Sqrt((1 - processor.Lambda * processor.NSqrt) / (processor.NSqrt - processor.Lambda));
            var fixedPointY1 = Math.Sqrt((processor.NSqrt - processor.Lambda) / (1 - processor.Lambda * processor.NSqrt));

            if (!double.IsNaN(fixedPointX1) && !double.IsNaN(fixedPointY1))
            {
                var fixedPointR1        = (processor.NSqrt + fixedPointX1 * fixedPointY1) / (fixedPointX1 * fixedPointX1 - processor.NSqrt);
                var fixedPointG1        = processor.NSqrt * Math.Pow((fixedPointX1 + fixedPointY1) / (fixedPointX1 * fixedPointX1 - processor.NSqrt), 2);
                var fixedPointRG1       = new RGPoint(fixedPointR1, fixedPointG1);
                var fixedPoint1         = fixedPointRG1.C(CProjection.C1C2);
                var fixedPointFrame1    = new PointF((float)fixedPoint1.C1, (float)fixedPoint1.C2);
                var fixedPointUICoords1 = scene.MapToUIFrame(fixedPointFrame1);
                gr.DrawEllipse(markupPen, fixedPointUICoords1.X - 4, fixedPointUICoords1.Y - 4, 8, 8);
                if (opt)
                {
                    gr.DrawLine(markupPen, fixedPointUICoords1.X - 4, fixedPointUICoords1.Y, fixedPointUICoords1.X + 4, fixedPointUICoords1.Y);
                    gr.DrawLine(markupPen, fixedPointUICoords1.X, fixedPointUICoords1.Y - 4, fixedPointUICoords1.X, fixedPointUICoords1.Y + 4);
                }
                else
                {
                    gr.DrawString("1", labelsFont, labelsBrushEx, fixedPointUICoords1.X + 2, fixedPointUICoords1.Y - 3);
                }
            }

            var fixedPointX2 = Math.Sqrt((1 + processor.Lambda * processor.NSqrt) / (processor.NSqrt + processor.Lambda));
            var fixedPointY2 = -Math.Sqrt((processor.NSqrt + processor.Lambda) / (1 + processor.Lambda * processor.NSqrt));

            if (!double.IsNaN(fixedPointX2) && !double.IsNaN(fixedPointY2))
            {
                var fixedPointR2        = (processor.NSqrt + fixedPointX2 * fixedPointY2) / (fixedPointX2 * fixedPointX2 - processor.NSqrt);
                var fixedPointG2        = processor.NSqrt * Math.Pow((fixedPointX2 + fixedPointY2) / (fixedPointX2 * fixedPointX2 - processor.NSqrt), 2);
                var fixedPointRG2       = new RGPoint(fixedPointR2, fixedPointG2);
                var fixedPointC2        = fixedPointRG2.C(CProjection.C1C2);
                var fixedPointFrame2    = new PointF((float)fixedPointC2.C1, (float)fixedPointC2.C2);
                var fixedPointUICoords2 = scene.MapToUIFrame(fixedPointFrame2);
                gr.DrawEllipse(markupPen, fixedPointUICoords2.X - 4, fixedPointUICoords2.Y - 4, 8, 8);
                if (opt)
                {
                    gr.DrawLine(markupPen, fixedPointUICoords2.X - 4, fixedPointUICoords2.Y, fixedPointUICoords2.X + 4,
                                fixedPointUICoords2.Y);
                }
                else
                {
                    gr.DrawString("2", labelsFont, labelsBrushEx, fixedPointUICoords2.X + 2, fixedPointUICoords2.Y - 3);
                }
            }

            /*
             * var fixPart1 = Math.Sqrt(processor.Lambda) / (1 + processor.Lambda);
             * var fixPart2 = (1 + processor.Lambda * processor.Lambda * processor.N) / (processor.Lambda * Math.Sqrt(processor.N));
             * var fixPart3 = (processor.N + 1) / Math.Sqrt(processor.N);
             * var fixPart4 = Math.Sqrt((1 + processor.Lambda * processor.Lambda * processor.N) / (processor.N + processor.Lambda * processor.Lambda));
             */
            /*
             * var cycleX1 = fixPart1 * Math.Sqrt(fixPart2 - fixPart3 * fixPart4);
             * var cycleY1 = Math.Sqrt((processor.N + processor.Lambda * processor.Lambda) / (1 + processor.Lambda * processor.Lambda * processor.N)) * cycleX1;
             * var cycleR1 = (processor.NSqrt + cycleX1 * cycleY1) / (cycleX1 * cycleX1 - processor.NSqrt);
             * var cycleG1 = processor.NSqrt * Math.Pow((cycleX1 + cycleY1) / (cycleX1 * cycleX1 - processor.NSqrt), 2);
             * var cycleRG1 = new RGPoint(cycleR1, cycleG1);
             * var cycleC1 = cycleRG1.C(CProjection.C1C2);
             * var cycleCoords1 = scene.MapToUIFrame(new PointF((float)cycleC1.C1, (float)cycleC1.C2));
             * gr.DrawEllipse(markupPen, cycleCoords1.X - 4, cycleCoords1.Y - 4, 8, 8);
             * if (opt)
             * {
             *  gr.DrawEllipse(markupPen, cycleCoords1.X - 3, cycleCoords1.Y - 3, 6, 6);
             *  gr.DrawEllipse(markupPen, cycleCoords1.X - 5, cycleCoords1.Y - 5, 10, 10);
             * }
             * else
             * {
             *  gr.DrawString("4", labelsFont, labelsBrushEx, cycleCoords1.X + 2, cycleCoords1.Y - 3);
             * }*/
            /*
             * var cycleX2 = fixPart1 * Math.Sqrt(fixPart2 + fixPart3 * fixPart4);
             * var cycleY2 = -Math.Sqrt((processor.N + processor.Lambda * processor.Lambda) / (1 + processor.Lambda * processor.Lambda * processor.N)) * cycleX2;
             * var cycleR2 = (processor.NSqrt + cycleX2 * cycleY2) / (cycleX2 * cycleX2 - processor.NSqrt);
             * var cycleG2 = processor.NSqrt * Math.Pow((cycleX2 + cycleY2) / (cycleX2 * cycleX2 - processor.NSqrt), 2);
             * var cycleRG2 = new RGPoint(cycleR2, cycleG2);
             * var cycleC2 = cycleRG2.C(CProjection.C1C2);
             * var cycleCoords2 = scene.MapToUIFrame(new PointF((float)cycleC2.C1, (float)cycleC2.C2));
             * gr.DrawEllipse(markupPen, cycleCoords2.X - 4, cycleCoords2.Y - 4, 8, 8);
             * if (opt)
             * {
             *  gr.DrawEllipse(markupPen, cycleCoords2.X - 3, cycleCoords2.Y - 3, 6, 6);
             *  gr.DrawEllipse(markupPen, cycleCoords2.X - 5, cycleCoords2.Y - 5, 10, 10);
             * }
             * else
             * {
             *  gr.DrawString("5", labelsFont, labelsBrushEx, cycleCoords2.X + 2, cycleCoords2.Y - 3);
             * }
             */
            /*
             * if (drawParabolas)
             * {
             *  for (var r = -100.0; r < 100.0; r += 0.01)
             *  {
             *      var cpt1 = new CPoint(1, -r, -2 * r - 1);
             *      var pt1 = scene.MapToUIFrame(new PointF((float)cpt1.C1, (float)cpt1.C2));
             *      var r1 = r + 0.01;
             *      var cpt2 = new CPoint(1, -r1, -2 * r1 - 1);
             *      var pt2 = scene.MapToUIFrame(new PointF((float)cpt2.C1, (float)cpt2.C2));
             *      gr.DrawLine(parabolaPen, pt1, pt2);
             *
             *      var cpt1Rev = ReverseIterated(cpt1, CProjection.C1C2, processor);
             *      var pt1Rev = scene.MapToUIFrame(new PointF((float)cpt1Rev.C1, (float)cpt1Rev.C2));
             *      var cpt2Rev = ReverseIterated(cpt2, CProjection.C1C2, processor);
             *      var pt2Rev = scene.MapToUIFrame(new PointF((float)cpt2Rev.C1, (float)cpt2Rev.C2));
             *      if (cpt1Rev.DistanceTo(cpt2Rev) < 0.1)
             *      {
             *          gr.DrawLine(reverseParabolaPen, pt1Rev, pt2Rev);
             *      }
             *  }
             * }*/
        }
Ejemplo n.º 16
0
 public abstract void ApplyTrackPointDynamics(int stem, Bitmap bmp, Graphics gr, Tuple <Color, PointF, CPoint> point, RGScene scene, RGProcessor processor);
Ejemplo n.º 17
0
 public abstract void ApplyBoundaryPointDynamics(int step, Bitmap bmp, Graphics gr, Tuple <Color, PointF, CPoint> left, Tuple <Color, PointF, CPoint> right, RGScene scene, RGProcessor processor);
Ejemplo n.º 18
0
 protected override Color GetC1C2Color(CPoint cpt, RGPoint rg, RGScene scene, RGProcessor processor)
 {
     return(rg.G > 0 ? RGScene.PositiveColor : RGScene.NegativeColor);
 }
Ejemplo n.º 19
0
 public override void ApplyMarkupDynamics(int step, Bitmap bmp, Graphics gr, RGScene scene, RGProcessor processor)
 {
 }
 protected abstract Color GetC1C2Color(CPoint cpt, RGPoint rg, RGScene scene, RGProcessor processor);