Example #1
0
        /// <summary>
        /// sort sites on y, then x, coord also change each site's _siteIndex to
        /// match its new position in the list so the _siteIndex can be used to
        /// identify the site for nearest-neighbor queries
        /// </summary>
        /// <param name="s1"></param>
        /// <param name="s2"></param>
        /// <returns></returns>
        private static double Compare(Site s1, Site s2)
        {
            int returnValue = FortunesAlgorithm.CompareByYThenX(s1, s2);

            // swap _siteIndex values if necessary to match new ordering:
            int tempIndex;

            if (returnValue == -1)
            {
                if (s1._siteIndex > s2._siteIndex)
                {
                    tempIndex     = s1._siteIndex;
                    s1._siteIndex = s2._siteIndex;
                    s2._siteIndex = tempIndex;
                }
            }
            else if (returnValue == 1)
            {
                if (s2._siteIndex > s1._siteIndex)
                {
                    tempIndex     = s2._siteIndex;
                    s2._siteIndex = s1._siteIndex;
                    s1._siteIndex = tempIndex;
                }
            }

            return(returnValue);
        }
Example #2
0
        /// <summary>
        /// This is the only way to make a Vertex
        /// </summary>
        /// <param name="halfedge0"></param>
        /// <param name="halfedge1"></param>
        /// <returns></returns>
        public static Vertex Intersect(Halfedge halfedge0, Halfedge halfedge1)
        {
            Edge     edge0, edge1, edge;
            Halfedge halfedge;
            double   determinant, intersectionX, intersectionY;
            bool     rightOfSite;

            edge0 = halfedge0.edge;
            edge1 = halfedge1.edge;
            if (edge0 == null || edge1 == null)
            {
                return(null);
            }
            if (edge0.RightSite == edge1.RightSite)
            {
                return(null);
            }

            determinant = edge0.a * edge1.b - edge0.b * edge1.a;
            if (-1.0e-10 < determinant && determinant < 1.0e-10)
            {
                // the edges are parallel
                return(null);
            }

            intersectionX = (edge0.c * edge1.b - edge1.c * edge0.b) / determinant;
            intersectionY = (edge1.c * edge0.a - edge0.c * edge1.a) / determinant;

            if (FortunesAlgorithm.CompareByYThenX(edge0.RightSite, edge1.RightSite) < 0)
            {
                halfedge = halfedge0;
                edge     = edge0;
            }
            else
            {
                halfedge = halfedge1;
                edge     = edge1;
            }
            rightOfSite = intersectionX >= edge.RightSite.X;
            if ((rightOfSite && halfedge.leftRight == LR.Left) ||
                (!rightOfSite && halfedge.leftRight == LR.Right))
            {
                return(null);
            }

            return(Vertex.Create(intersectionX, intersectionY));
        }