/// <summary>
        /// Create the inner polygon of the doughnut.
        /// </summary>
        /// <param name="_value">double</param>
        /// <param name="_sumDegree">double</param>
        /// <param name="_color">Color</param>
        /// <param name="_degree">double</param>
        private void CreateInnerSection(double _value, ref double _sumDegree, Color _color, out double _degree)
        {
            SVGPoint  p1 = null, p2 = null;
            Polygon   pol    = null;
            ArrayList points = null;

            _degree = this.Relation * _value;

            if (_sumDegree >= 270 || _sumDegree <= 90 || _degree + _sumDegree >= 270 || _degree + _sumDegree <= 90)
            {
                pol       = new Polygon();
                pol.Color = _color;
                points    = new ArrayList();

                double k = _sumDegree;
                while (k < _degree + _sumDegree)
                {
                    p1 = this.GetPoint(k, this.a2, this.b2);
                    pol.AddPoint(p1);
                    p2    = p1;
                    p2.Y += THICKNESS;
                    points.Insert(0, p2);
                    k += 0.2;
                }

                foreach (SVGPoint point in points)
                {
                    pol.AddPoint(point);
                }
                this.Doc.SvgObjects.Add(pol);
            }

            _sumDegree += _degree;
        }
Esempio n. 2
0
        /// <summary>
        /// Creates new point and adds it into collection
        /// </summary>
        /// <param name="x">The x.</param>
        /// <param name="y">The y.</param>
        /// <returns></returns>
        public SVGPoint Add(Int32 x, Int32 y)
        {
            SVGPoint p = new SVGPoint(x, y);

            points.Add(p);
            return(p);
        }
Esempio n. 3
0
 //--------------------------------------------------------------------------------
 //Methods: ArcTo
 //--------------------------------------------------------------------------------
 public void ArcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, SVGPoint p)
 {
     if((this.isUseWidth) && ((int)this._width > 1))
       ArcTo(r1, r2, angle, largeArcFlag, sweepFlag, p, this._width);
     else
       this._basicDraw.ArcTo(r1, r2, angle, largeArcFlag, sweepFlag, p);
 }
Esempio n. 4
0
 //-----
 public void Circle(SVGPoint p, float r, SVGColor? strokeColor)
 {
     if(strokeColor != null) {
       SetColor(strokeColor.Value.color);
     }
     Circle(p, r);
 }
Esempio n. 5
0
 public SVGGEllipse(SVGPoint p, float r1, float r2, float angle)
 {
     _p = p;
     _r1 = r1;
     _r2 = r2;
     _angle = angle;
 }
Esempio n. 6
0
 /*-------------------------------------------------------------------------------
   //Method: Arc4Path
   /-------------------------------------------------------------------------------*/
 public void ArcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, SVGPoint p)
 {
     SVGPoint[] points = new SVGPoint[1];
     points[0] = p;
     ExpandBounds(points, (r1 > r2) ? 2 * (int)r1 + 2 : 2 * (int)r2 + 2, (r1 > r2) ? 2 * (int)r1 + 2 : 2 * (int)r2 + 2);
     //---------------
     this._basicDraw.ArcTo(r1, r2, angle, largeArcFlag, sweepFlag, p);
 }
Esempio n. 7
0
        /// <summary>
        /// Returns a point in the area depending of the angle's degree and the height.
        /// </summary>
        /// <param name="_degree">double</param>
        /// <param name="_height">double</param>
        /// <returns>SVGPoint</returns>
        protected virtual SVGPoint GetPoint(double _degree, double _height)
        {
            SVGPoint p   = new SVGPoint();
            double   rad = this.GetRadians(_degree);

            p.X = Math.Sin(rad) * _height + this.CenterPos.X;
            p.Y = this.CenterPos.Y - Math.Cos(rad) * _height;
            return(p);
        }
Esempio n. 8
0
        /// <summary>
        /// Creates a line with two points of the collection
        /// </summary>
        /// <param name="_source">SVGPoint</param>
        /// <param name="_target">SVGPoint</param>
        protected void CreateLine(SVGPoint _source, SVGPoint _target)
        {
            Line line = new Line(_source, _target);

            line.Width  = (decimal)0.5;
            line.Color  = System.Drawing.Color.Black;
            line.Dashed = false;
            this.Doc.SvgObjects.Add(line);
        }
Esempio n. 9
0
 //================================================================================
 public SVGGArcAbs(float r1, float r2, float angle,
           bool largeArcFlag, bool sweepFlag, SVGPoint p)
 {
     this._r1 = r1;
     this._r2 = r2;
     this._angle = angle;
     this._largeArcFlag = largeArcFlag;
     this._sweepFlag = sweepFlag;
     this._p = p;
 }
Esempio n. 10
0
 public SVGGraphicsPath()
 {
     beginPoint = new SVGPoint(0f, 0f);
     endPoint = new SVGPoint(0f, 0f);
     needSetFirstPoint = true;
     boundUL = new SVGPoint(+10000f, +10000f);
     boundBR = new SVGPoint(-10000f, -10000f);
     transformList = new SVGTransformList();
     listObject = new ArrayList();
     listType = new ArrayList();
 }
Esempio n. 11
0
    //--------------------------------------------------------------------------------
    //AngleBetween2Vector
    //--------------------------------------------------------------------------------
    //Tinh goc giua 2 vector (p1,p2) (p3,p4);
    public float AngleBetween2Vector(SVGPoint p1, SVGPoint p2, SVGPoint p3, SVGPoint p4)
    {
        SVGPoint vt1, vt2;
        vt1 = new SVGPoint(p2.x - p1.x, p2.y - p1.y);
        vt2 = new SVGPoint(p4.x - p3.x, p4.y - p3.y);
        float t1 = vt1.x*vt2.x + vt1.y*vt2.y;
        float gtvt1 = (float)Math.Sqrt(vt1.x * vt1.x + vt1.y*vt1.y);
        float gtvt2 = (float)Math.Sqrt(vt2.x * vt2.x + vt2.y*vt2.y);
        float t2 = gtvt1 * gtvt2;
        float cosAngle = t1/t2;

        return((float)Math.Acos(cosAngle));
    }
Esempio n. 12
0
        /// <summary>
        /// Get a value's point
        /// </summary>
        /// <param name="_value">double</param>
        /// <param name="_xStartPosition">double</param>
        /// <param name="_yStartPosition">double</param>
        /// <returns>SVGPoint</returns>
        private SVGPoint GeneratePoint(double _value, double _xStartPosition, double _yStartPosition)
        {
            double pixelValue = _value - this.minFillFactor;

            pixelValue = pixelValue / (this.maxFillFactor - this.minFillFactor);
            pixelValue = pixelValue * 100 * this.tpcmaxFillFactor;

            SVGPoint p1 = new SVGPoint();

            p1.X = _xStartPosition + (this.colWidth / 2);
            p1.Y = _yStartPosition + pixelValue;
            return(p1);
        }
Esempio n. 13
0
    public void BeginSubBuffer()
    {
        this._boundTopLeft = new SVGPoint(+10000f, +10000f);
        this._boundBottomRight = new SVGPoint(-10000f, -10000f);

        this._subW = this._width;
        this._subH = this._height;
        this._inZoneL = 0;
        this._inZoneT = 0;
        this._translateX = 0;
        this._translateY = 0;

        this._flagStep = 0;
        for(int i = 0; i < this._subW; i++)
          for(int j = 0; j < this._subH; j++)
        this._flag[i, j] = 0;
        this._flagStep = 1;
    }
        /// <summary>
        /// Gets the point from string.
        /// </summary>
        /// <param name="input">The input.</param>
        /// <returns></returns>
        public static SVGPoint GetPointFromString(this String input)
        {
            foreach (Match m in REGEX_POINT_PAIR.Matches(input))
            {
                if (m.Success)
                {
                    if (m.Groups.Count > 2)
                    {
                        SVGPoint p = new SVGPoint();

                        p.X = Convert.ToDouble(m.Groups[2]);
                        p.Y = Convert.ToDouble(m.Groups[3]);
                        return(p);
                    }
                }
            }
            throw new ArgumentException("input string is not in required format", "input");
            return(null);
        }
Esempio n. 15
0
        /// <summary>
        /// Creates the polygon's value.
        /// </summary>
        /// <param name="_value">double</param>
        /// <param name="_sumDegree">double</param>
        /// <param name="_color">Color</param>
        /// <param name="_degree">double</param>
        protected override void CreateCheese(double _value, ref double _sumDegree, Color _color, out double _degree)
        {
            Polygon pol = new Polygon();

            pol.Color = _color;
            _degree   = this.Relation * _value;

            //1st Segment
            SVGPoint p1   = this.GetPoint(_sumDegree);
            SVGPoint p1_2 = this.GetPoint(_sumDegree, this.secRadio);

            pol.AddPoint(p1_2);
            pol.AddPoint(p1);

            //Curve
            double k = _sumDegree;

            while (k < _degree + _sumDegree)
            {
                pol.AddPoint(this.GetPoint(k));
                k += 0.2;
            }

            //2th Segment
            _sumDegree += _degree;
            SVGPoint p2   = this.GetPoint(_sumDegree);
            SVGPoint p2_2 = this.GetPoint(_sumDegree, this.secRadio);

            pol.AddPoint(p2_2);
            pol.AddPoint(p2);

            //Curve
            k = _sumDegree;
            while (k > _sumDegree - _degree)
            {
                pol.AddPoint(this.GetPoint(k, this.secRadio));
                k -= 0.2;
            }

            this.Doc.SvgObjects.Add(pol);
        }
        /// <summary>
        /// Gets points from string: x1,y1 x2,y2 x3,y3 .... where xn,yn are coordinates of point n
        /// </summary>
        /// <param name="input">The input.</param>
        /// <returns></returns>
        public static List <SVGPoint> GetPointsFromString(this String input)
        {
            List <SVGPoint> output = new List <SVGPoint>();

            foreach (Match m in REGEX_POINT_PAIR.Matches(input))
            {
                if (m.Success)
                {
                    if (m.Groups.Count > 2)
                    {
                        SVGPoint p = new SVGPoint();

                        p.X = Convert.ToDouble(m.Groups[2]);
                        p.Y = Convert.ToDouble(m.Groups[3]);
                        output.Add(p);
                    }
                }
            }

            return(output);
        }
Esempio n. 17
0
 private void ExpandBounds(SVGPoint point, float deltax, float deltay)
 {
     ExpandBounds(point.x, point.y, deltax, deltay);
 }
Esempio n. 18
0
 public void Reset()
 {
     beginPoint = new SVGPoint(0f, 0f);
     endPoint = new SVGPoint(0f, 0f);
     needSetFirstPoint = true;
     boundUL = new SVGPoint(+10000f, +10000f);
     boundBR = new SVGPoint(-10000f, -10000f);
     _fillRule = SVGFillRule.NoneZero;
     transformList.Clear();
     listObject.Clear();
     listType.Clear();
 }
Esempio n. 19
0
 private void ExpandBounds(SVGPoint point)
 {
     ExpandBounds(point.x, point.y);
 }
Esempio n. 20
0
 //-----
 public void Circle(SVGPoint p, float r, SVGColor fillColor, SVGColor? strokeColor)
 {
     SetColor(fillColor.color);
     PreCircle(p, r);
     EndSubBuffer();
 }
Esempio n. 21
0
 public void AddQuadraticCurveTo(SVGPoint p1, SVGPoint p)
 {
     SetLastPoint(p);
     SVGGQuadraticAbs svgGQuadraticAbs = new SVGGQuadraticAbs(p1, p);
     listType.Add(SVGPathElementType.QuadraticCurveTo);
     listObject.Add(svgGQuadraticAbs);
 }
Esempio n. 22
0
 /// <summary>
 /// Add the value's point
 /// </summary>
 /// <param name="_point">SVGObject.point</param>
 public void AddPoint(SVGPoint _point)
 {
     Array.Resize(ref this.points, this.points.Length + 1);
     this.points[this.points.Length - 1] = _point;
 }
Esempio n. 23
0
    private void RenderPolylineElement(SVGPolylineElement polylineElement, ISVGPathDraw pathDraw)
    {
        int length = polylineElement.listPoints.Count;
        SVGPoint[] points = new SVGPoint[length];

        for(int i = 0; i < length; i++)
          points[i] = polylineElement.listPoints[i].MatrixTransform(matrixTransform);
        pathDraw.Polyline(points);
    }
Esempio n. 24
0
 public void AddCircleTo(SVGPoint p, float r)
 {
     SVGGCircle gCircle = new SVGGCircle(p, r);
     listType.Add(SVGPathElementType.CircleTo);
     listObject.Add(gCircle);
 }
Esempio n. 25
0
 public void AddCubicCurveTo(SVGPoint p1, SVGPoint p2, SVGPoint p)
 {
     SetLastPoint(p);
     SVGGCubicAbs svgGCubicAbs = new SVGGCubicAbs(p1, p2, p);
     listType.Add(SVGPathElementType.CubicCurveTo);
     listObject.Add(svgGCubicAbs);
 }
Esempio n. 26
0
    public void Add(SVGEllipseElement ellipseElement)
    {
        SVGPoint p = new SVGPoint(ellipseElement.cx.value, ellipseElement.cy.value);
        SetFirstPoint(p);
        SetLastPoint(p);

        listType.Add(SVGPathElementType.Ellipse);
        listObject.Add(ellipseElement);
    }
Esempio n. 27
0
 public void AddArcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, SVGPoint p)
 {
     SetLastPoint(p);
     SVGGArcAbs svgGArcAbs = new SVGGArcAbs(r1, r2, angle, largeArcFlag, sweepFlag, p);
     listType.Add(SVGPathElementType.ArcTo);
     listObject.Add(svgGArcAbs);
 }
Esempio n. 28
0
 public svgLine(Int32 x1, Int32 y1, Int32 x2, Int32 y2)
 {
     start = new SVGPoint(x1, y1);
     end   = new SVGPoint(x2, y2);
 }
Esempio n. 29
0
 private void SetFirstPoint(SVGPoint p)
 {
     if(needSetFirstPoint) {
       beginPoint.SetValue(p);
       needSetFirstPoint = false;
     }
 }
Esempio n. 30
0
 //-----
 public void Circle(SVGPoint p, float r)
 {
     PreCircle(p, r);
     EndSubBuffer();
 }
Esempio n. 31
0
 private void RenderCircleElement(SVGCircleElement elem, ISVGPathDraw pathDraw)
 {
     SVGPoint p = new SVGPoint(elem.cx.value, elem.cy.value).MatrixTransform(matrixTransform);
     pathDraw.Circle(p, elem.r.value);
 }
Esempio n. 32
0
 public void AddEllipseTo(SVGPoint p, float r1, float r2, float angle)
 {
     SVGGEllipse gEllipse = new SVGGEllipse(p, r1, r2, angle);
     listType.Add(SVGPathElementType.EllipseTo);
     listObject.Add(gEllipse);
 }
Esempio n. 33
0
 private void RenderEllipseElement(SVGEllipseElement elem, ISVGPathDraw pathDraw)
 {
     SVGPoint p = new SVGPoint(elem.cx.value, elem.cy.value).MatrixTransform(matrixTransform);
     pathDraw.Ellipse(p, elem.rx.value, elem.ry.value, transformAngle);
 }
Esempio n. 34
0
 public void AddLineTo(SVGPoint p)
 {
     listType.Add(SVGPathElementType.LineTo);
     listObject.Add(p);
 }
Esempio n. 35
0
 private void RenderMoveTo(SVGPoint p, ISVGPathDraw pathDraw)
 {
     pathDraw.MoveTo(p.MatrixTransform(matrixTransform));
 }
Esempio n. 36
0
    public void AddMoveTo(SVGPoint p)
    {
        SetFirstPoint(p);
        SetLastPoint(p);

        listType.Add(SVGPathElementType.MoveTo);
        listObject.Add(p);
    }
Esempio n. 37
0
    private void RenderRectElement(SVGRectElement rectElement, ISVGPathDraw pathDraw)
    {
        SVGPoint p1, p2, p3, p4;
        float tx = rectElement.x.value;
        float ty = rectElement.y.value;
        float tw = rectElement.width.value;
        float th = rectElement.height.value;
        p1 = new SVGPoint(tx, ty);
        p2 = new SVGPoint(tx + tw, ty);
        p3 = new SVGPoint(tx + tw, ty + th);
        p4 = new SVGPoint(tx, ty + th);

        if(rectElement.rx.value == 0.0f && rectElement.ry.value == 0.0f) {
          p1 = p1.MatrixTransform(matrixTransform);
          p2 = p2.MatrixTransform(matrixTransform);
          p3 = p3.MatrixTransform(matrixTransform);
          p4 = p4.MatrixTransform(matrixTransform);

          pathDraw.Rect(p1, p2, p3, p4);
        } else {
          float t_rx = rectElement.rx.value;
          float t_ry = rectElement.ry.value;
          t_rx = (t_rx == 0.0f) ? t_ry : t_rx;
          t_ry = (t_ry == 0.0f) ? t_rx : t_ry;

          t_rx = (t_rx > (tw * 0.5f - 2f)) ? (tw * 0.5f - 2f) : t_rx;
          t_ry = (t_ry > (th * 0.5f - 2f)) ? (th * 0.5f - 2f) : t_ry;

          float angle = transformAngle;

          SVGPoint t_p1 = new SVGPoint(p1.x + t_rx, p1.y).MatrixTransform(matrixTransform);
          SVGPoint t_p2 = new SVGPoint(p2.x - t_rx, p2.y).MatrixTransform(matrixTransform);
          SVGPoint t_p3 = new SVGPoint(p2.x, p2.y + t_ry).MatrixTransform(matrixTransform);
          SVGPoint t_p4 = new SVGPoint(p3.x, p3.y - t_ry).MatrixTransform(matrixTransform);

          SVGPoint t_p5 = new SVGPoint(p3.x - t_rx, p3.y).MatrixTransform(matrixTransform);
          SVGPoint t_p6 = new SVGPoint(p4.x + t_rx, p4.y).MatrixTransform(matrixTransform);
          SVGPoint t_p7 = new SVGPoint(p4.x, p4.y - t_ry).MatrixTransform(matrixTransform);
          SVGPoint t_p8 = new SVGPoint(p1.x, p1.y + t_ry).MatrixTransform(matrixTransform);

          pathDraw.RoundedRect(t_p1, t_p2, t_p3, t_p4, t_p5, t_p6, t_p7, t_p8, t_rx, t_ry,
          angle);
        }
    }
Esempio n. 38
0
 //-----
 public void Circle(SVGPoint p, float r, SVGColor? strokeColor)
 {
     PreCircle(p, r);
     EndSubBuffer(strokeColor);
 }
Esempio n. 39
0
 private void SetLastPoint(SVGPoint p)
 {
     endPoint.SetValue(p);
 }
Esempio n. 40
0
    public void Add(SVGCircleElement circleElement)
    {
        SVGPoint p = new SVGPoint(circleElement.cx.value, circleElement.cy.value);
        SetFirstPoint(p);
        SetLastPoint(p);

        listType.Add(SVGPathElementType.Circle);
        listObject.Add(circleElement);
    }