Example #1
0
 public StrokeGenerator()
 {
     m_stroker = new StrokeMath();
     vertexDistanceList = new VertexDistanceList();
     m_out_vertices = new VertexStore();
     m_status = StrokeMath.Status.Init;
 }
 public ContourGenerator()
 {
     m_stroker = new StrokeMath();
     m_width = 1;
     vertexDistanceList = new VertexDistanceList();
     m_out_vertices = new VertexStore();
     m_status = StrokeMath.Status.Init;
     m_src_vertex = 0;
     m_closed = false;
     m_orientation = 0;
     m_auto_detect = false;
 }
 // Generator interface
 public void RemoveAll()
 {
     vertexDistanceList.Clear();
     m_closed = false;
     m_status = StrokeMath.Status.Init;
 }
        public VertexCmd GetNextVertex(ref double x, ref double y)
        {
            VertexCmd cmd = VertexCmd.LineTo;

            while (!VertexHelper.IsEmpty(cmd))
            {
                switch (m_status)
                {
                case StrokeMath.Status.Init:
                    this.RewindZero();
                    goto case StrokeMath.Status.Ready;

                case StrokeMath.Status.Ready:

                    if (vertexDistanceList.Count < 2 + (m_closed ? 1 : 0))
                    {
                        cmd = VertexCmd.NoMore;
                        break;
                    }
                    m_status     = StrokeMath.Status.Outline1;
                    cmd          = VertexCmd.MoveTo;
                    m_src_vertex = 0;
                    m_out_vertex = 0;
                    goto case StrokeMath.Status.Outline1;

                case StrokeMath.Status.Outline1:
                    if (m_src_vertex >= vertexDistanceList.Count)
                    {
                        m_status = StrokeMath.Status.EndPoly1;
                        break;
                    }
                    m_stroker.CreateJoin(m_out_vertices,
                                         vertexDistanceList.prev(m_src_vertex),
                                         vertexDistanceList.curr(m_src_vertex),
                                         vertexDistanceList.next(m_src_vertex),
                                         vertexDistanceList.prev(m_src_vertex).dist,
                                         vertexDistanceList.curr(m_src_vertex).dist);
                    ++m_src_vertex;
                    m_status     = StrokeMath.Status.OutVertices;
                    m_out_vertex = 0;
                    goto case StrokeMath.Status.OutVertices;

                case StrokeMath.Status.OutVertices:
                    if (m_out_vertex >= m_out_vertices.Count)
                    {
                        m_status = StrokeMath.Status.Outline1;
                    }
                    else
                    {
                        m_out_vertices.GetVertex(m_out_vertex++, out x, out y);
                        return(cmd);
                    }
                    break;

                case StrokeMath.Status.EndPoly1:

                    if (!m_closed)
                    {
                        return(VertexCmd.NoMore);
                    }
                    m_status = StrokeMath.Status.Stop;
                    x        = (int)EndVertexOrientation.CCW;
                    return(VertexCmd.Close);

                case StrokeMath.Status.Stop:
                    return(VertexCmd.NoMore);
                }
            }
            return(cmd);
        }
Example #5
0
        VertexCmd GetNextVertex(ref double x, ref double y)
        {
            VertexCmd cmd = VertexCmd.LineTo;

            while (!VertexHelper.IsEmpty(cmd))
            {
                switch (m_status)
                {
                case StrokeMath.Status.Init:
                    this.Rewind();
                    goto case StrokeMath.Status.Ready;

                case StrokeMath.Status.Ready:

                    if (vertexDistanceList.Count < 2 + (m_closed ? 1 : 0))
                    {
                        cmd = VertexCmd.Stop;
                        break;
                    }
                    m_status     = m_closed ? StrokeMath.Status.Outline1 : StrokeMath.Status.Cap1;
                    cmd          = VertexCmd.MoveTo;
                    m_src_vertex = 0;
                    m_out_vertex = 0;
                    break;

                case StrokeMath.Status.Cap1:
                    m_stroker.CreateCap(
                        m_out_vertices,
                        vertexDistanceList[0],
                        vertexDistanceList[1],
                        vertexDistanceList[0].dist);

                    m_src_vertex  = 1;
                    m_prev_status = StrokeMath.Status.Outline1;
                    m_status      = StrokeMath.Status.OutVertices;
                    m_out_vertex  = 0;
                    break;

                case StrokeMath.Status.Cap2:
                    m_stroker.CreateCap(m_out_vertices,
                                        vertexDistanceList[vertexDistanceList.Count - 1],
                                        vertexDistanceList[vertexDistanceList.Count - 2],
                                        vertexDistanceList[vertexDistanceList.Count - 2].dist);
                    m_prev_status = StrokeMath.Status.Outline2;
                    m_status      = StrokeMath.Status.OutVertices;
                    m_out_vertex  = 0;
                    break;

                case StrokeMath.Status.Outline1:
                    if (m_closed)
                    {
                        if (m_src_vertex >= vertexDistanceList.Count)
                        {
                            m_prev_status = StrokeMath.Status.CloseFirst;
                            m_status      = StrokeMath.Status.EndPoly1;
                            break;
                        }
                    }
                    else
                    {
                        if (m_src_vertex >= vertexDistanceList.Count - 1)
                        {
                            m_status = StrokeMath.Status.Cap2;
                            break;
                        }
                    }

                    m_stroker.CreateJoin(m_out_vertices,
                                         vertexDistanceList.prev(m_src_vertex),
                                         vertexDistanceList.curr(m_src_vertex),
                                         vertexDistanceList.next(m_src_vertex),
                                         vertexDistanceList.prev(m_src_vertex).dist,
                                         vertexDistanceList.curr(m_src_vertex).dist);
                    ++m_src_vertex;
                    m_prev_status = m_status;
                    m_status      = StrokeMath.Status.OutVertices;
                    m_out_vertex  = 0;
                    break;

                case StrokeMath.Status.CloseFirst:
                    m_status = StrokeMath.Status.Outline2;
                    cmd      = VertexCmd.MoveTo;
                    goto case StrokeMath.Status.Outline2;

                case StrokeMath.Status.Outline2:

                    if (m_src_vertex <= (!m_closed ? 1 : 0))
                    {
                        m_status      = StrokeMath.Status.EndPoly2;
                        m_prev_status = StrokeMath.Status.Stop;
                        break;
                    }

                    --m_src_vertex;
                    m_stroker.CreateJoin(m_out_vertices,
                                         vertexDistanceList.next(m_src_vertex),
                                         vertexDistanceList.curr(m_src_vertex),
                                         vertexDistanceList.prev(m_src_vertex),
                                         vertexDistanceList.curr(m_src_vertex).dist,
                                         vertexDistanceList.prev(m_src_vertex).dist);

                    m_prev_status = m_status;
                    m_status      = StrokeMath.Status.OutVertices;
                    m_out_vertex  = 0;
                    break;

                case StrokeMath.Status.OutVertices:
                    if (m_out_vertex >= m_out_vertices.Count)
                    {
                        m_status = m_prev_status;
                    }
                    else
                    {
                        m_out_vertices.GetVertex(m_out_vertex++, out x, out y);
                        //Vector2 c = m_out_vertices[(int)m_out_vertex++];
                        //x = c.x;
                        //y = c.y;
                        return(cmd);
                    }
                    break;

                case StrokeMath.Status.EndPoly1:
                    m_status = m_prev_status;
                    x        = (int)EndVertexOrientation.CCW;
                    return(VertexCmd.EndAndCloseFigure);

                case StrokeMath.Status.EndPoly2:
                    m_status = m_prev_status;
                    x        = (int)EndVertexOrientation.CW;
                    return(VertexCmd.EndAndCloseFigure);


                case StrokeMath.Status.Stop:
                    cmd = VertexCmd.Stop;
                    break;
                }
            }
            return(cmd);
        }
Example #6
0
 // Vertex Generator Interface
 public void RemoveAll()
 {
     vertexDistanceList.Clear();
     m_closed = false;
     m_status = StrokeMath.Status.Init;
 }
Example #7
0
        VertexCmd GetNextVertex(ref double x, ref double y)
        {
            VertexCmd cmd = VertexCmd.LineTo;
            while (!VertexHelper.IsEmpty(cmd))
            {
                switch (m_status)
                {
                    case StrokeMath.Status.Init:
                        this.Rewind();
                        goto case StrokeMath.Status.Ready;
                    case StrokeMath.Status.Ready:

                        if (vertexDistanceList.Count < 2 + (m_closed ? 1 : 0))
                        {
                            cmd = VertexCmd.Stop;
                            break;
                        }
                        m_status = m_closed ? StrokeMath.Status.Outline1 : StrokeMath.Status.Cap1;
                        cmd = VertexCmd.MoveTo;
                        m_src_vertex = 0;
                        m_out_vertex = 0;
                        break;
                    case StrokeMath.Status.Cap1:
                        m_stroker.CreateCap(
                            m_out_vertices,
                            vertexDistanceList[0],
                            vertexDistanceList[1],
                            vertexDistanceList[0].dist);
                        m_src_vertex = 1;
                        m_prev_status = StrokeMath.Status.Outline1;
                        m_status = StrokeMath.Status.OutVertices;
                        m_out_vertex = 0;
                        break;
                    case StrokeMath.Status.Cap2:
                        m_stroker.CreateCap(m_out_vertices,
                            vertexDistanceList[vertexDistanceList.Count - 1],
                            vertexDistanceList[vertexDistanceList.Count - 2],
                            vertexDistanceList[vertexDistanceList.Count - 2].dist);
                        m_prev_status = StrokeMath.Status.Outline2;
                        m_status = StrokeMath.Status.OutVertices;
                        m_out_vertex = 0;
                        break;
                    case StrokeMath.Status.Outline1:
                        if (m_closed)
                        {
                            if (m_src_vertex >= vertexDistanceList.Count)
                            {
                                m_prev_status = StrokeMath.Status.CloseFirst;
                                m_status = StrokeMath.Status.EndPoly1;
                                break;
                            }
                        }
                        else
                        {
                            if (m_src_vertex >= vertexDistanceList.Count - 1)
                            {
                                m_status = StrokeMath.Status.Cap2;
                                break;
                            }
                        }

                        m_stroker.CreateJoin(m_out_vertices,
                            vertexDistanceList.prev(m_src_vertex),
                            vertexDistanceList.curr(m_src_vertex),
                            vertexDistanceList.next(m_src_vertex),
                            vertexDistanceList.prev(m_src_vertex).dist,
                            vertexDistanceList.curr(m_src_vertex).dist);
                        ++m_src_vertex;
                        m_prev_status = m_status;
                        m_status = StrokeMath.Status.OutVertices;
                        m_out_vertex = 0;
                        break;
                    case StrokeMath.Status.CloseFirst:
                        m_status = StrokeMath.Status.Outline2;
                        cmd = VertexCmd.MoveTo;
                        goto case StrokeMath.Status.Outline2;
                    case StrokeMath.Status.Outline2:

                        if (m_src_vertex <= (!m_closed ? 1 : 0))
                        {
                            m_status = StrokeMath.Status.EndPoly2;
                            m_prev_status = StrokeMath.Status.Stop;
                            break;
                        }

                        --m_src_vertex;
                        m_stroker.CreateJoin(m_out_vertices,
                            vertexDistanceList.next(m_src_vertex),
                            vertexDistanceList.curr(m_src_vertex),
                            vertexDistanceList.prev(m_src_vertex),
                            vertexDistanceList.curr(m_src_vertex).dist,
                            vertexDistanceList.prev(m_src_vertex).dist);
                        m_prev_status = m_status;
                        m_status = StrokeMath.Status.OutVertices;
                        m_out_vertex = 0;
                        break;
                    case StrokeMath.Status.OutVertices:
                        if (m_out_vertex >= m_out_vertices.Count)
                        {
                            m_status = m_prev_status;
                        }
                        else
                        {
                            m_out_vertices.GetVertex(m_out_vertex++, out x, out y);
                            //Vector2 c = m_out_vertices[(int)m_out_vertex++];
                            //x = c.x;
                            //y = c.y;
                            return cmd;
                        }
                        break;
                    case StrokeMath.Status.EndPoly1:
                        m_status = m_prev_status;
                        x = (int)EndVertexOrientation.CCW;
                        return VertexCmd.CloseAndEndFigure;
                    case StrokeMath.Status.EndPoly2:
                        m_status = m_prev_status;
                        x = (int)EndVertexOrientation.CW;
                        return VertexCmd.CloseAndEndFigure;
                    case StrokeMath.Status.Stop:
                        cmd = VertexCmd.Stop;
                        break;
                }
            }
            return cmd;
        }
Example #8
0
 void Rewind()
 {
     if (m_status == StrokeMath.Status.Init)
     {
         vertexDistanceList.Close(m_closed);
         VertexHelper.ShortenPath(vertexDistanceList, m_shorten, m_closed);
         if (vertexDistanceList.Count < 3) { m_closed = false; }
     }
     m_status = StrokeMath.Status.Ready;
     m_src_vertex = 0;
     m_out_vertex = 0;
 }
Example #9
0
 public void AddVertex(double x, double y, VertexCmd cmd)
 {
     m_status = StrokeMath.Status.Init;
     switch (cmd)
     {
         case VertexCmd.MoveTo:
             vertexDistanceList.ReplaceLast(new VertexDistance(x, y));
             break;
         case VertexCmd.CloseAndEndFigure:
             m_closed = true;
             break;
         case VertexCmd.EndFigure:
             m_closed = false;
             break;
         default:
             vertexDistanceList.AddVertex(new VertexDistance(x, y));
             break;
     }
 }
Example #10
0
        public void AddVertex(double x, double y, VertexCmd cmd)
        {
            m_status = StrokeMath.Status.Init;
            switch (cmd)
            {
                case VertexCmd.MoveTo:
                    vertexDistanceList.ReplaceLast(new VertexDistance(x, y));
                    break;
                case VertexCmd.CloseAndEndFigure:
                    {
                        //end and close
                        m_closed = true;
                        if (m_orientation == EndVertexOrientation.Unknown)
                        {
                            switch ((int)x)
                            {
                                case 1:
                                case 2:
                                    {
                                        m_orientation = (EndVertexOrientation)x;
                                    }
                                    break;
                            }
                        }
                    }
                    break;
                case VertexCmd.EndFigure:

                    //end not close 
                    if (m_orientation == EndVertexOrientation.Unknown)
                    {
                        switch ((int)x)
                        {
                            case 1:
                            case 2:
                                {
                                    m_orientation = (EndVertexOrientation)x;
                                }
                                break;
                        }
                    }
                    break;
                default:

                    vertexDistanceList.AddVertex(new VertexDistance(x, y));
                    break;
            }
        }
Example #11
0
        public VertexCmd GetNextVertex(ref double x, ref double y)
        {
            VertexCmd cmd = VertexCmd.LineTo;
            while (!VertexHelper.IsEmpty(cmd))
            {
                switch (m_status)
                {
                    case StrokeMath.Status.Init:
                        this.RewindZero();
                        goto case StrokeMath.Status.Ready;
                    case StrokeMath.Status.Ready:

                        if (vertexDistanceList.Count < 2 + (m_closed ? 1 : 0))
                        {
                            cmd = VertexCmd.Stop;
                            break;
                        }
                        m_status = StrokeMath.Status.Outline1;
                        cmd = VertexCmd.MoveTo;
                        m_src_vertex = 0;
                        m_out_vertex = 0;
                        goto case StrokeMath.Status.Outline1;
                    case StrokeMath.Status.Outline1:
                        if (m_src_vertex >= vertexDistanceList.Count)
                        {
                            m_status = StrokeMath.Status.EndPoly1;
                            break;
                        }
                        m_stroker.CreateJoin(m_out_vertices,
                                            vertexDistanceList.prev(m_src_vertex),
                                            vertexDistanceList.curr(m_src_vertex),
                                            vertexDistanceList.next(m_src_vertex),
                                            vertexDistanceList.prev(m_src_vertex).dist,
                                            vertexDistanceList.curr(m_src_vertex).dist);
                        ++m_src_vertex;
                        m_status = StrokeMath.Status.OutVertices;
                        m_out_vertex = 0;
                        goto case StrokeMath.Status.OutVertices;
                    case StrokeMath.Status.OutVertices:
                        if (m_out_vertex >= m_out_vertices.Count)
                        {
                            m_status = StrokeMath.Status.Outline1;
                        }
                        else
                        {
                            m_out_vertices.GetVertex(m_out_vertex++, out x, out y);
                            return cmd;
                        }
                        break;
                    case StrokeMath.Status.EndPoly1:

                        if (!m_closed) return VertexCmd.Stop;
                        m_status = StrokeMath.Status.Stop;
                        x = (int)EndVertexOrientation.CCW;
                        return VertexCmd.CloseAndEndFigure;
                    case StrokeMath.Status.Stop:
                        return VertexCmd.Stop;
                }
            }
            return cmd;
        }
Example #12
0
 // Vertex Source Interface
 void RewindZero()
 {
     if (m_status == StrokeMath.Status.Init)
     {
         vertexDistanceList.Close(true);
         if (m_auto_detect)
         {
             if (m_orientation == EndVertexOrientation.Unknown)
             {
                 m_orientation = (AggMath.CalculatePolygonArea(vertexDistanceList) > 0.0) ?
                                 EndVertexOrientation.CCW :
                                 EndVertexOrientation.CW;
             }
         }
         switch (m_orientation)
         {
             case EndVertexOrientation.CCW:
                 {
                     m_stroker.Width = m_width;
                 }
                 break;
             case EndVertexOrientation.CW:
                 {
                     m_stroker.Width = -m_width;
                 }
                 break;
         }
     }
     m_status = StrokeMath.Status.Ready;
     m_src_vertex = 0;
 }