コード例 #1
0
ファイル: Clipper.cs プロジェクト: philazzi44/DnDCS
 public DoublePoint(DoublePoint dp)
 {
     this.X = dp.X; this.Y = dp.Y;
 }
コード例 #2
0
ファイル: clipper.cs プロジェクト: CharlesTaylor95/clipper
 public IntPoint(DoublePoint dp)
 {
   this.X = (cInt)dp.X; this.Y = (cInt)dp.Y; this.Z = 0;
 }
コード例 #3
0
ファイル: clipper.cs プロジェクト: CharlesTaylor95/clipper
          //------------------------------------------------------------------------------

          public PolyOffsetBuilder(Paths pts, out Paths solution, double delta,
              JoinType jointype, EndType endtype, double limit = 0)
          {
              //precondition: solution != pts
              solution = new Paths();
              if (ClipperBase.near_zero(delta)) {solution = pts; return; }
              m_p = pts;
              if (endtype != EndType.etClosed && delta < 0) delta = -delta;
              m_delta = delta;

              if (jointype == JoinType.jtMiter)
              {
                  //m_miterVal: see offset_triginometry.svg in the documentation folder ...
                  if (limit > 2) m_miterLim = 2 / (limit * limit);
                  else m_miterLim = 0.5;
                  if (endtype == EndType.etRound) limit = 0.25;
              }
              if (jointype == JoinType.jtRound || endtype == EndType.etRound)
              {
              if (limit <= 0) limit = 0.25;
              else if (limit > Math.Abs(delta)*0.25) limit = Math.Abs(delta)*0.25;
              //m_roundVal: see offset_triginometry2.svg in the documentation folder ...
              m_Steps360 = Math.PI / Math.Acos(1 - limit / Math.Abs(delta));
              m_sin = Math.Sin(2 * Math.PI / m_Steps360);
              m_cos = Math.Cos(2 * Math.PI / m_Steps360);
              m_Steps360 /= Math.PI * 2;
              if (delta < 0) m_sin = -m_sin;
              }

              double deltaSq = delta * delta;
              solution.Capacity = pts.Count;
              for (m_i = 0; m_i < pts.Count; m_i++)
              {
                  int len = pts[m_i].Count;
                  if (len == 0 || (len < 3 && delta <= 0)) continue;
                    
                  if (len == 1)
                  {
                      if (jointype == JoinType.jtRound)
                      {
                          double X = 1.0, Y = 0.0;
                          for (cInt j = 1; j <= Round(m_Steps360 * 2 * Math.PI); j++)
                          {
                              AddPoint(new IntPoint(
                                Round(m_p[m_i][0].X + X * delta),
                                Round(m_p[m_i][0].Y + Y * delta)));
                              double X2 = X;
                              X = X * m_cos - m_sin * Y;
                              Y = X2 * m_sin + Y * m_cos;
                          }
                      }
                      else
                      {
                          double X = -1.0, Y = -1.0;
                          for (int j = 0; j < 4; ++j)
                          {
                              AddPoint(new IntPoint(Round(m_p[m_i][0].X + X * delta),
                                Round(m_p[m_i][0].Y + Y * delta)));
                              if (X < 0) X = 1;
                              else if (Y < 0) Y = 1;
                              else X = -1;
                          }
                      }
                      continue;
                  }
                    
                  //build normals ...
                  normals.Clear();
                  normals.Capacity = len;
                  for (int j = 0; j < len -1; ++j)
                      normals.Add(GetUnitNormal(pts[m_i][j], pts[m_i][j+1]));
                  if (endtype == EndType.etClosed)
                      normals.Add(GetUnitNormal(pts[m_i][len - 1], pts[m_i][0]));
                  else
                      normals.Add(new DoublePoint(normals[len - 2]));

                  currentPoly = new Path();
                  if (endtype == EndType.etClosed)
                  {
                      m_k = len - 1;
                      for (m_j = 0; m_j < len; ++m_j)
                          OffsetPoint(jointype);
                      solution.Add(currentPoly); 
                  }
                  else
                  {
                      m_k = 0;
                      for (m_j = 1; m_j < len - 1; ++m_j)
                          OffsetPoint(jointype);

                      IntPoint pt1;
                      if (endtype == EndType.etButt)
                      {
                          m_j = len - 1;
                          pt1 = new IntPoint((cInt)Round(pts[m_i][m_j].X + normals[m_j].X *
                            delta), (cInt)Round(pts[m_i][m_j].Y + normals[m_j].Y * delta));
                          AddPoint(pt1);
                          pt1 = new IntPoint((cInt)Round(pts[m_i][m_j].X - normals[m_j].X *
                            delta), (cInt)Round(pts[m_i][m_j].Y - normals[m_j].Y * delta));
                          AddPoint(pt1);
                      }
                      else
                      {
                          m_j = len - 1;
                          m_k = len - 2;
                          m_sinA = 0;
                          normals[m_j] = new DoublePoint(-normals[m_j].X, -normals[m_j].Y);
                          if (endtype == EndType.etSquare)
                            DoSquare();
                          else
                            DoRound();
                      }

                      //re-build Normals ...
                      for (int j = len - 1; j > 0; j--)
                        normals[j] = new DoublePoint(-normals[j - 1].X, -normals[j - 1].Y);
                      
                      normals[0] = new DoublePoint(-normals[1].X, -normals[1].Y);

                      m_k = len - 1;
                      for (m_j = m_k - 1; m_j > 0; --m_j)
                          OffsetPoint(jointype);

                      if (endtype == EndType.etButt)
                      {
                          pt1 = new IntPoint((cInt)Round(pts[m_i][0].X - normals[0].X * delta),
                            (cInt)Round(pts[m_i][0].Y - normals[0].Y * delta));
                          AddPoint(pt1);
                          pt1 = new IntPoint((cInt)Round(pts[m_i][0].X + normals[0].X * delta),
                            (cInt)Round(pts[m_i][0].Y + normals[0].Y * delta));
                          AddPoint(pt1);
                      }
                      else
                      {
                          m_k = 1;
                          m_sinA = 0;
                          if (endtype == EndType.etSquare) 
                            DoSquare();
                          else
                            DoRound();
                      }
                      solution.Add(currentPoly);
                  }
              }

              //finally, clean up untidy corners ...
              Clipper clpr = new Clipper();
              clpr.AddPaths(solution, PolyType.ptSubject, true);
              if (delta > 0)
              {
                  clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftPositive, PolyFillType.pftPositive);
              }
              else
              {
                  IntRect r = clpr.GetBounds();
                  Path outer = new Path(4);

                  outer.Add(new IntPoint(r.left - 10, r.bottom + 10));
                  outer.Add(new IntPoint(r.right + 10, r.bottom + 10));
                  outer.Add(new IntPoint(r.right + 10, r.top - 10));
                  outer.Add(new IntPoint(r.left - 10, r.top - 10));

                  clpr.AddPath(outer, PolyType.ptSubject, true);
                  clpr.ReverseSolution = true;
                  clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftNegative, PolyFillType.pftNegative);
                  if (solution.Count > 0) solution.RemoveAt(0);
              }
          }
コード例 #4
0
        //------------------------------------------------------------------------------
        private void DoOffset(double delta)
        {
            m_destPolys = new List<List<IntPoint>>();
            m_delta = delta;

            //if Zero offset, just copy any CLOSED polygons to m_p and return ...
            if (ClipperBase.near_zero(delta))
            {
                m_destPolys.Capacity = m_polyNodes.ChildCount;
                for (int i = 0; i < m_polyNodes.ChildCount; i++)
                {
                    PolyNode node = m_polyNodes.Childs[i];
                    if (node.m_endtype == EndType.etClosedPolygon)
                        m_destPolys.Add(node.m_polygon);
                }
                return;
            }

            //see offset_triginometry3.svg in the documentation folder ...
            if (MiterLimit > 2) m_miterLim = 2 / (MiterLimit * MiterLimit);
            else m_miterLim = 0.5;

            double y;
            if (ArcTolerance <= 0.0)
                y = def_arc_tolerance;
            else if (ArcTolerance > Math.Abs(delta) * def_arc_tolerance)
                y = Math.Abs(delta) * def_arc_tolerance;
            else
                y = ArcTolerance;
            //see offset_triginometry2.svg in the documentation folder ...
            double steps = Math.PI / Math.Acos(1 - y / Math.Abs(delta));
            m_sin = Math.Sin(two_pi / steps);
            m_cos = Math.Cos(two_pi / steps);
            m_StepsPerRad = steps / two_pi;
            if (delta < 0.0) m_sin = -m_sin;

            m_destPolys.Capacity = m_polyNodes.ChildCount * 2;
            for (int i = 0; i < m_polyNodes.ChildCount; i++)
            {
                PolyNode node = m_polyNodes.Childs[i];
                m_srcPoly = node.m_polygon;

                int len = m_srcPoly.Count;

                if (len == 0 || (delta <= 0 && (len < 3 ||
                  node.m_endtype != EndType.etClosedPolygon)))
                    continue;

                m_destPoly = new List<IntPoint>();

                if (len == 1)
                {
                    if (node.m_jointype == JoinType.jtRound)
                    {
                        double X = 1.0, Y = 0.0;
                        for (int j = 1; j <= steps; j++)
                        {
                            m_destPoly.Add(new IntPoint(
                              Round(m_srcPoly[0].X + X * delta),
                              Round(m_srcPoly[0].Y + Y * delta)));
                            double X2 = X;
                            X = X * m_cos - m_sin * Y;
                            Y = X2 * m_sin + Y * m_cos;
                        }
                    }
                    else
                    {
                        double X = -1.0, Y = -1.0;
                        for (int j = 0; j < 4; ++j)
                        {
                            m_destPoly.Add(new IntPoint(
                              Round(m_srcPoly[0].X + X * delta),
                              Round(m_srcPoly[0].Y + Y * delta)));
                            if (X < 0) X = 1;
                            else if (Y < 0) Y = 1;
                            else X = -1;
                        }
                    }
                    m_destPolys.Add(m_destPoly);
                    continue;
                }

                //build m_normals ...
                m_normals.Clear();
                m_normals.Capacity = len;
                for (int j = 0; j < len - 1; j++)
                    m_normals.Add(GetUnitNormal(m_srcPoly[j], m_srcPoly[j + 1]));
                if (node.m_endtype == EndType.etClosedLine ||
                  node.m_endtype == EndType.etClosedPolygon)
                    m_normals.Add(GetUnitNormal(m_srcPoly[len - 1], m_srcPoly[0]));
                else
                    m_normals.Add(new DoublePoint(m_normals[len - 2]));

                if (node.m_endtype == EndType.etClosedPolygon)
                {
                    int k = len - 1;
                    for (int j = 0; j < len; j++)
                        OffsetPoint(j, ref k, node.m_jointype);
                    m_destPolys.Add(m_destPoly);
                }
                else if (node.m_endtype == EndType.etClosedLine)
                {
                    int k = len - 1;
                    for (int j = 0; j < len; j++)
                        OffsetPoint(j, ref k, node.m_jointype);
                    m_destPolys.Add(m_destPoly);
                    m_destPoly = new List<IntPoint>();
                    //re-build m_normals ...
                    DoublePoint n = m_normals[len - 1];
                    for (int j = len - 1; j > 0; j--)
                        m_normals[j] = new DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y);
                    m_normals[0] = new DoublePoint(-n.X, -n.Y);
                    k = 0;
                    for (int j = len - 1; j >= 0; j--)
                        OffsetPoint(j, ref k, node.m_jointype);
                    m_destPolys.Add(m_destPoly);
                }
                else
                {
                    int k = 0;
                    for (int j = 1; j < len - 1; ++j)
                        OffsetPoint(j, ref k, node.m_jointype);

                    IntPoint pt1;
                    if (node.m_endtype == EndType.etOpenButt)
                    {
                        int j = len - 1;
                        pt1 = new IntPoint((int)Round(m_srcPoly[j].X + m_normals[j].X *
                          delta), (int)Round(m_srcPoly[j].Y + m_normals[j].Y * delta));
                        m_destPoly.Add(pt1);
                        pt1 = new IntPoint((int)Round(m_srcPoly[j].X - m_normals[j].X *
                          delta), (int)Round(m_srcPoly[j].Y - m_normals[j].Y * delta));
                        m_destPoly.Add(pt1);
                    }
                    else
                    {
                        int j = len - 1;
                        k = len - 2;
                        m_sinA = 0;
                        m_normals[j] = new DoublePoint(-m_normals[j].X, -m_normals[j].Y);
                        if (node.m_endtype == EndType.etOpenSquare)
                            DoSquare(j, k);
                        else
                            DoRound(j, k);
                    }

                    //re-build m_normals ...
                    for (int j = len - 1; j > 0; j--)
                        m_normals[j] = new DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y);

                    m_normals[0] = new DoublePoint(-m_normals[1].X, -m_normals[1].Y);

                    k = len - 1;
                    for (int j = k - 1; j > 0; --j)
                        OffsetPoint(j, ref k, node.m_jointype);

                    if (node.m_endtype == EndType.etOpenButt)
                    {
                        pt1 = new IntPoint((int)Round(m_srcPoly[0].X - m_normals[0].X * delta),
                          (int)Round(m_srcPoly[0].Y - m_normals[0].Y * delta));
                        m_destPoly.Add(pt1);
                        pt1 = new IntPoint((int)Round(m_srcPoly[0].X + m_normals[0].X * delta),
                          (int)Round(m_srcPoly[0].Y + m_normals[0].Y * delta));
                        m_destPoly.Add(pt1);
                    }
                    else
                    {
                        k = 1;
                        m_sinA = 0;
                        if (node.m_endtype == EndType.etOpenSquare)
                            DoSquare(0, 1);
                        else
                            DoRound(0, 1);
                    }
                    m_destPolys.Add(m_destPoly);
                }
            }
        }
コード例 #5
0
        private void OffsetPoint(int j, ref int k, JoinType jointype)
        {
            DoublePoint doublePoint  = m_normals[k];
            double      x            = doublePoint.X;
            DoublePoint doublePoint2 = m_normals[j];
            double      num          = x * doublePoint2.Y;
            DoublePoint doublePoint3 = m_normals[j];
            double      x2           = doublePoint3.X;
            DoublePoint doublePoint4 = m_normals[k];

            m_sinA = num - x2 * doublePoint4.Y;
            if (Math.Abs(m_sinA * m_delta) < 1.0)
            {
                DoublePoint doublePoint5 = m_normals[k];
                double      x3           = doublePoint5.X;
                DoublePoint doublePoint6 = m_normals[j];
                double      num2         = x3 * doublePoint6.X;
                DoublePoint doublePoint7 = m_normals[j];
                double      y            = doublePoint7.Y;
                DoublePoint doublePoint8 = m_normals[k];
                double      num3         = num2 + y * doublePoint8.Y;
                if (num3 > 0.0)
                {
                    List <IntPoint> destPoly      = m_destPoly;
                    IntPoint        intPoint      = m_srcPoly[j];
                    double          num4          = (double)intPoint.X;
                    DoublePoint     doublePoint9  = m_normals[k];
                    long            x4            = Round(num4 + doublePoint9.X * m_delta);
                    IntPoint        intPoint2     = m_srcPoly[j];
                    double          num5          = (double)intPoint2.Y;
                    DoublePoint     doublePoint10 = m_normals[k];
                    destPoly.Add(new IntPoint(x4, Round(num5 + doublePoint10.Y * m_delta)));
                    return;
                }
            }
            else if (m_sinA > 1.0)
            {
                m_sinA = 1.0;
            }
            else if (m_sinA < -1.0)
            {
                m_sinA = -1.0;
            }
            if (!(m_sinA * m_delta < 0.0))
            {
                switch (jointype)
                {
                case JoinType.jtMiter:
                {
                    DoublePoint doublePoint11 = m_normals[j];
                    double      x5            = doublePoint11.X;
                    DoublePoint doublePoint12 = m_normals[k];
                    double      num6          = x5 * doublePoint12.X;
                    DoublePoint doublePoint13 = m_normals[j];
                    double      y2            = doublePoint13.Y;
                    DoublePoint doublePoint14 = m_normals[k];
                    double      num7          = 1.0 + (num6 + y2 * doublePoint14.Y);
                    if (num7 >= m_miterLim)
                    {
                        DoMiter(j, k, num7);
                    }
                    else
                    {
                        DoSquare(j, k);
                    }
                    break;
                }

                case JoinType.jtSquare:
                    DoSquare(j, k);
                    break;

                case JoinType.jtRound:
                    DoRound(j, k);
                    break;
                }
            }
            else
            {
                List <IntPoint> destPoly2     = m_destPoly;
                IntPoint        intPoint3     = m_srcPoly[j];
                double          num8          = (double)intPoint3.X;
                DoublePoint     doublePoint15 = m_normals[k];
                long            x6            = Round(num8 + doublePoint15.X * m_delta);
                IntPoint        intPoint4     = m_srcPoly[j];
                double          num9          = (double)intPoint4.Y;
                DoublePoint     doublePoint16 = m_normals[k];
                destPoly2.Add(new IntPoint(x6, Round(num9 + doublePoint16.Y * m_delta)));
                m_destPoly.Add(m_srcPoly[j]);
                List <IntPoint> destPoly3     = m_destPoly;
                IntPoint        intPoint5     = m_srcPoly[j];
                double          num10         = (double)intPoint5.X;
                DoublePoint     doublePoint17 = m_normals[j];
                long            x7            = Round(num10 + doublePoint17.X * m_delta);
                IntPoint        intPoint6     = m_srcPoly[j];
                double          num11         = (double)intPoint6.Y;
                DoublePoint     doublePoint18 = m_normals[j];
                destPoly3.Add(new IntPoint(x7, Round(num11 + doublePoint18.Y * m_delta)));
            }
            k = j;
        }
コード例 #6
0
 private void DoOffset(double delta)
 {
     m_destPolys = new List <List <IntPoint> >();
     m_delta     = delta;
     if (ClipperBase.near_zero(delta))
     {
         m_destPolys.Capacity = m_polyNodes.ChildCount;
         for (int i = 0; i < m_polyNodes.ChildCount; i++)
         {
             PolyNode polyNode = m_polyNodes.Childs[i];
             if (polyNode.m_endtype == EndType.etClosedPolygon)
             {
                 m_destPolys.Add(polyNode.m_polygon);
             }
         }
     }
     else
     {
         if (MiterLimit > 2.0)
         {
             m_miterLim = 2.0 / (MiterLimit * MiterLimit);
         }
         else
         {
             m_miterLim = 0.5;
         }
         double num  = (ArcTolerance <= 0.0) ? 0.25 : ((!(ArcTolerance > Math.Abs(delta) * 0.25)) ? ArcTolerance : (Math.Abs(delta) * 0.25));
         double num2 = 3.1415926535897931 / Math.Acos(1.0 - num / Math.Abs(delta));
         m_sin         = Math.Sin(6.2831853071795862 / num2);
         m_cos         = Math.Cos(6.2831853071795862 / num2);
         m_StepsPerRad = num2 / 6.2831853071795862;
         if (delta < 0.0)
         {
             m_sin = 0.0 - m_sin;
         }
         m_destPolys.Capacity = m_polyNodes.ChildCount * 2;
         for (int j = 0; j < m_polyNodes.ChildCount; j++)
         {
             PolyNode polyNode2 = m_polyNodes.Childs[j];
             m_srcPoly = polyNode2.m_polygon;
             int count = m_srcPoly.Count;
             if (count != 0 && (!(delta <= 0.0) || (count >= 3 && polyNode2.m_endtype == EndType.etClosedPolygon)))
             {
                 m_destPoly = new List <IntPoint>();
                 if (count == 1)
                 {
                     if (polyNode2.m_jointype == JoinType.jtRound)
                     {
                         double num3 = 1.0;
                         double num4 = 0.0;
                         for (int k = 1; (double)k <= num2; k++)
                         {
                             List <IntPoint> destPoly  = m_destPoly;
                             IntPoint        intPoint  = m_srcPoly[0];
                             long            x         = Round((double)intPoint.X + num3 * delta);
                             IntPoint        intPoint2 = m_srcPoly[0];
                             destPoly.Add(new IntPoint(x, Round((double)intPoint2.Y + num4 * delta)));
                             double num5 = num3;
                             num3 = num3 * m_cos - m_sin * num4;
                             num4 = num5 * m_sin + num4 * m_cos;
                         }
                     }
                     else
                     {
                         double num6 = -1.0;
                         double num7 = -1.0;
                         for (int l = 0; l < 4; l++)
                         {
                             List <IntPoint> destPoly2 = m_destPoly;
                             IntPoint        intPoint3 = m_srcPoly[0];
                             long            x2        = Round((double)intPoint3.X + num6 * delta);
                             IntPoint        intPoint4 = m_srcPoly[0];
                             destPoly2.Add(new IntPoint(x2, Round((double)intPoint4.Y + num7 * delta)));
                             if (num6 < 0.0)
                             {
                                 num6 = 1.0;
                             }
                             else if (num7 < 0.0)
                             {
                                 num7 = 1.0;
                             }
                             else
                             {
                                 num6 = -1.0;
                             }
                         }
                     }
                     m_destPolys.Add(m_destPoly);
                 }
                 else
                 {
                     m_normals.Clear();
                     m_normals.Capacity = count;
                     for (int m = 0; m < count - 1; m++)
                     {
                         m_normals.Add(GetUnitNormal(m_srcPoly[m], m_srcPoly[m + 1]));
                     }
                     if (polyNode2.m_endtype == EndType.etClosedLine || polyNode2.m_endtype == EndType.etClosedPolygon)
                     {
                         m_normals.Add(GetUnitNormal(m_srcPoly[count - 1], m_srcPoly[0]));
                     }
                     else
                     {
                         m_normals.Add(new DoublePoint(m_normals[count - 2]));
                     }
                     if (polyNode2.m_endtype == EndType.etClosedPolygon)
                     {
                         int k2 = count - 1;
                         for (int n = 0; n < count; n++)
                         {
                             OffsetPoint(n, ref k2, polyNode2.m_jointype);
                         }
                         m_destPolys.Add(m_destPoly);
                     }
                     else if (polyNode2.m_endtype == EndType.etClosedLine)
                     {
                         int k3 = count - 1;
                         for (int num8 = 0; num8 < count; num8++)
                         {
                             OffsetPoint(num8, ref k3, polyNode2.m_jointype);
                         }
                         m_destPolys.Add(m_destPoly);
                         m_destPoly = new List <IntPoint>();
                         DoublePoint doublePoint = m_normals[count - 1];
                         for (int num9 = count - 1; num9 > 0; num9--)
                         {
                             List <DoublePoint> normals = m_normals;
                             int         index          = num9;
                             DoublePoint doublePoint2   = m_normals[num9 - 1];
                             double      x3             = 0.0 - doublePoint2.X;
                             DoublePoint doublePoint3   = m_normals[num9 - 1];
                             normals[index] = new DoublePoint(x3, 0.0 - doublePoint3.Y);
                         }
                         m_normals[0] = new DoublePoint(0.0 - doublePoint.X, 0.0 - doublePoint.Y);
                         k3           = 0;
                         for (int num10 = count - 1; num10 >= 0; num10--)
                         {
                             OffsetPoint(num10, ref k3, polyNode2.m_jointype);
                         }
                         m_destPolys.Add(m_destPoly);
                     }
                     else
                     {
                         int k4 = 0;
                         for (int num11 = 1; num11 < count - 1; num11++)
                         {
                             OffsetPoint(num11, ref k4, polyNode2.m_jointype);
                         }
                         IntPoint item = default(IntPoint);
                         if (polyNode2.m_endtype == EndType.etOpenButt)
                         {
                             int         index2       = count - 1;
                             IntPoint    intPoint5    = m_srcPoly[index2];
                             double      num12        = (double)intPoint5.X;
                             DoublePoint doublePoint4 = m_normals[index2];
                             long        x4           = Round(num12 + doublePoint4.X * delta);
                             IntPoint    intPoint6    = m_srcPoly[index2];
                             double      num13        = (double)intPoint6.Y;
                             DoublePoint doublePoint5 = m_normals[index2];
                             item = new IntPoint(x4, Round(num13 + doublePoint5.Y * delta));
                             m_destPoly.Add(item);
                             IntPoint    intPoint7    = m_srcPoly[index2];
                             double      num14        = (double)intPoint7.X;
                             DoublePoint doublePoint6 = m_normals[index2];
                             long        x5           = Round(num14 - doublePoint6.X * delta);
                             IntPoint    intPoint8    = m_srcPoly[index2];
                             double      num15        = (double)intPoint8.Y;
                             DoublePoint doublePoint7 = m_normals[index2];
                             item = new IntPoint(x5, Round(num15 - doublePoint7.Y * delta));
                             m_destPoly.Add(item);
                         }
                         else
                         {
                             int num16 = count - 1;
                             k4     = count - 2;
                             m_sinA = 0.0;
                             List <DoublePoint> normals2 = m_normals;
                             int         index3          = num16;
                             DoublePoint doublePoint8    = m_normals[num16];
                             double      x6           = 0.0 - doublePoint8.X;
                             DoublePoint doublePoint9 = m_normals[num16];
                             normals2[index3] = new DoublePoint(x6, 0.0 - doublePoint9.Y);
                             if (polyNode2.m_endtype == EndType.etOpenSquare)
                             {
                                 DoSquare(num16, k4);
                             }
                             else
                             {
                                 DoRound(num16, k4);
                             }
                         }
                         for (int num17 = count - 1; num17 > 0; num17--)
                         {
                             List <DoublePoint> normals3 = m_normals;
                             int         index4          = num17;
                             DoublePoint doublePoint10   = m_normals[num17 - 1];
                             double      x7            = 0.0 - doublePoint10.X;
                             DoublePoint doublePoint11 = m_normals[num17 - 1];
                             normals3[index4] = new DoublePoint(x7, 0.0 - doublePoint11.Y);
                         }
                         List <DoublePoint> normals4      = m_normals;
                         DoublePoint        doublePoint12 = m_normals[1];
                         double             x8            = 0.0 - doublePoint12.X;
                         DoublePoint        doublePoint13 = m_normals[1];
                         normals4[0] = new DoublePoint(x8, 0.0 - doublePoint13.Y);
                         k4          = count - 1;
                         for (int num18 = k4 - 1; num18 > 0; num18--)
                         {
                             OffsetPoint(num18, ref k4, polyNode2.m_jointype);
                         }
                         if (polyNode2.m_endtype == EndType.etOpenButt)
                         {
                             IntPoint    intPoint9     = m_srcPoly[0];
                             double      num19         = (double)intPoint9.X;
                             DoublePoint doublePoint14 = m_normals[0];
                             long        x9            = Round(num19 - doublePoint14.X * delta);
                             IntPoint    intPoint10    = m_srcPoly[0];
                             double      num20         = (double)intPoint10.Y;
                             DoublePoint doublePoint15 = m_normals[0];
                             item = new IntPoint(x9, Round(num20 - doublePoint15.Y * delta));
                             m_destPoly.Add(item);
                             IntPoint    intPoint11    = m_srcPoly[0];
                             double      num21         = (double)intPoint11.X;
                             DoublePoint doublePoint16 = m_normals[0];
                             long        x10           = Round(num21 + doublePoint16.X * delta);
                             IntPoint    intPoint12    = m_srcPoly[0];
                             double      num22         = (double)intPoint12.Y;
                             DoublePoint doublePoint17 = m_normals[0];
                             item = new IntPoint(x10, Round(num22 + doublePoint17.Y * delta));
                             m_destPoly.Add(item);
                         }
                         else
                         {
                             k4     = 1;
                             m_sinA = 0.0;
                             if (polyNode2.m_endtype == EndType.etOpenSquare)
                             {
                                 DoSquare(0, 1);
                             }
                             else
                             {
                                 DoRound(0, 1);
                             }
                         }
                         m_destPolys.Add(m_destPoly);
                     }
                 }
             }
         }
     }
 }