Ejemplo n.º 1
0
        private void linkMenuItem_Click_1(object sender, System.EventArgs e)
        {
            Polygon2DLinkMaker polygonLink = new Polygon2DLinkMaker(this.FirstPolygon, 0, 4);
            polygonLink.Divide();
            polygonLink.BuildPath();
            polygonLinkAdorner = new PolygonLinkAdorner(polygonLink);

            this.Invalidate();
        }
Ejemplo n.º 2
0
 public PolygonLinkAdorner(Polygon2DLinkMaker link)
 {
     polygonLink = link;
 }
        private void InitLinkDistance()
        {
            int Count = this.FirstPolygons.Parent.VertexCount;

            Polygon2D firstPolygon = FirstPolygons.Parent;
            Polygon2D secondPolygon = SecondPolygons.Parent;

            for (int i = 0; i < Count; i++)
            {

                for (int j = i + 2; j < Count; j++)
                {
                    if (i == j || Math.Abs(i - j) == 1 || Math.Abs(i - j) == Count - 1)
                    {
                        continue;
                    }

                    LineSegment2D testLine = new LineSegment2D(firstPolygon.GetPoint(i), firstPolygon.GetPoint(j));
                    if (firstPolygon.InflectsEdge(testLine))
                    {
                        continue;
                    }

                    testLine = new LineSegment2D(secondPolygon.GetPoint(i), secondPolygon.GetPoint(j));

                    if (secondPolygon.InflectsEdge(testLine))
                    {
                        continue;
                    }

                    FirstTarget = new Polygon2DLinkMaker(firstPolygon, i, j);
                    SecondTarget = new Polygon2DLinkMaker(secondPolygon, i, j);
                    FirstTarget.Divide();
                    SecondTarget.Divide();

                    int linkDistance = Math.Max(FirstTarget.LinkDistance, SecondTarget.LinkDistance);

                    if (this.linkDistance == null)
                    {
                        this.linkDistance = new LinkDistance(i, j, 0, linkDistance);
                    }
                    else
                    {
                        this.linkDistance.Add(new LinkDistance(i, j, 0, linkDistance));
                    }
                }
            }
        }
        public void FastTriangluation()
        {
            int from = 0;
            int to = 2;
            Polygon2DEditor polygonEditor = new Polygon2DEditor(this.FirstPolygons.Parent);

            polygonEditor.Clear();
            polygonEditor = new Polygon2DEditor(this.SecondPolygons.Parent);
            polygonEditor.Clear();

            this.InitLinkDistance();

            for (int i = 0; i < FirstPolygons.SubDivision.Count; i++)
            {
                int vertexCount = FirstPolygons.SubDivision[i].VertexCount;
                Polygon2D firstPolygon = FirstPolygons.SubDivision[i];
                Polygon2D secondPolygon = SecondPolygons.SubDivision[i];

                if (vertexCount <= 3)
                {
                    continue;
                }

                int dist = MAX_DIST;

                for (int j = 0; j < vertexCount; j++)
                {
                    for (int k = j + 2; k < vertexCount; k++)
                    {
                        if (j == k || Math.Abs(j - k) == 1 || Math.Abs(j - k) == vertexCount - 1)
                        {
                            continue;
                        }

                        LineSegment2D testLine = new LineSegment2D(firstPolygon.GetPoint(j), firstPolygon.GetPoint(k));

                        if (firstPolygon.InflectsEdge(testLine))
                        {
                            continue;
                        }

                        testLine = new LineSegment2D(secondPolygon.GetPoint(j), secondPolygon.GetPoint(k));
                        if (secondPolygon.InflectsEdge(testLine))
                        {
                            continue;
                        }

                        LinkDistance link = this.linkDistance.Contains(this.FirstPolygons.GetParentIndex(j, i), this.FirstPolygons.GetParentIndex(k, i), 0);

                        int d;

                        if (link != null)
                        {
                            d = link.linkDistance;
                        }

                        else
                        {
                            FirstTarget = new Polygon2DLinkMaker(firstPolygon, j, k);
                            SecondTarget = new Polygon2DLinkMaker(secondPolygon, j, k);
                            FirstTarget.Divide();
                            SecondTarget.Divide();

                            d = Math.Max(FirstTarget.LinkDistance, SecondTarget.LinkDistance);

                            link = new LinkDistance(this.FirstPolygons.GetParentIndex(j, i), this.FirstPolygons.GetParentIndex(k, i), 0, d);
                        }

                        if (dist > d)
                        {
                            dist = d;
                            from = j;
                            to = k;
                        }
                        else if (dist == d)
                        {
                            if (Math.Abs(vertexCount / 2 - Math.Abs(j - k)) > Math.Abs(vertexCount / 2 - Math.Abs(from - to)))
                            {
                                from = j;
                                to = k;
                            }
                        }
                    }
                }

                FirstTarget = new Polygon2DLinkMaker(firstPolygon, from, to);
                SecondTarget = new Polygon2DLinkMaker(secondPolygon, from, to);
                FirstTarget.Divide();
                FirstTarget.BuildPath();
                SecondTarget.Divide();
                SecondTarget.BuildPath();

                if (dist != Math.Max(FirstTarget.LinkDistance, SecondTarget.LinkDistance))
                {
                    dist = Math.Max(FirstTarget.LinkDistance, SecondTarget.LinkDistance);
                    this.linkDistance.Set(this.FirstPolygons.GetParentIndex(from, i), this.FirstPolygons.GetParentIndex(to, i), 0, dist);
                }

                int Extra = dist - FirstTarget.LinkDistance;

                if (Extra > 0)
                {
                    FirstTarget.LinkDivisers.Extend(Extra);
                }

                Extra = dist - SecondTarget.LinkDistance;
                if (Extra > 0)
                {
                    SecondTarget.LinkDivisers.Extend(Extra);
                }

                FirstPolygons.DividedBy(FirstTarget.LinkDivisers, firstPolygon);
                SecondPolygons.DividedBy(SecondTarget.LinkDivisers, secondPolygon);
            }

            GetResult();
            BuildGhostTriangle();
        }
Ejemplo n.º 5
0
        public void Divide()
        {
            UpdateStatus(this, "Dividing...");
            targetDiviser.UpdateStatus += new Microsoft.VS.Akira.Triangulations.TargetDiviser.ShowStatus(UpdateStatus);
            targetDiviser.Divide();
            Polygon2D poly = this.firstPolygon;
            this.firstPolygonCollection.Add(this.firstPolygon);
            this.secondPolygonCollection.Add(this.secondPolygon);
            UpdateStatus(this, "Mapping...");
            for (int i = 0; i < targetDiviser.Divisers.Count; i++)
            {
                int first_index = this.secondPolygon.GetPointIndex(targetDiviser.Divisers[i].FirstPoint);
                int second_index = this.secondPolygon.GetPointIndex(targetDiviser.Divisers[i].LastPoint);

                LineSegment2D line = new LineSegment2D(this.firstPolygon.GetPoint(first_index), this.firstPolygon.GetPoint(second_index));

                for (int j = 0; j < this.firstPolygonCollection.Count; j++)
                {
                    if (this.firstPolygonCollection[j].HasVertex(line.FirstPoint) != Polygon2D.NoSuchPoint
                        &&this.firstPolygonCollection[j].HasVertex(line.LastPoint) != Polygon2D.NoSuchPoint)
                    {
                        poly = this.firstPolygonCollection[j];
                        this.firstPolygonCollection.Remove(j);
                        break;
                    }
                }
                int from = 0;
                int to = 0;

                from = poly.GetPointIndex(line.FirstPoint);
                to = poly.GetPointIndex(line.LastPoint);

                linkMaker = new Polygon2DLinkMaker(poly, from, to);

                linkMaker.Divide();
                int extraPoints = linkMaker.LinkDistance - 1;
                linkMaker.BuildPath();
                Polygon2DDiviser pd = new Polygon2DDiviser(poly);
                pd.DividedBy(linkMaker.LinkDivisers, poly);
                this.firstPolygonCollection.Add(pd.SubDivision[1]);
                this.firstPolygonCollection.Add(pd.SubDivision[2]);

                //divide target polygon
                line = targetDiviser.Divisers[i];

                for (int j = 0; j < this.secondPolygonCollection.Count; j++)
                {
                    if (this.secondPolygonCollection[j].HasVertex(line.FirstPoint) != Polygon2D.NoSuchPoint
                        &&this.secondPolygonCollection[j].HasVertex(line.LastPoint) != Polygon2D.NoSuchPoint)
                    {
                        poly = this.secondPolygonCollection[j];
                        this.secondPolygonCollection.Remove(j);
                        break;
                    }
                }

                from = poly.GetPointIndex(line.FirstPoint);
                to = poly.GetPointIndex(line.LastPoint);

                Point2DCollection path = line.ToPath(extraPoints);

                pd = new Polygon2DDiviser(poly);
                pd.DividedBy(path, poly);

                this.secondPolygonCollection.Add(pd.SubDivision[1]);
                this.secondPolygonCollection.Add(pd.SubDivision[2]);
            }
        }