Back to project page Processing-Android-Eclipse-Demos.
The source code is released under:
MIT License
If you think the Android project Processing-Android-Eclipse-Demos listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Portions Copyright (C) 2003-2006 Sun Microsystems, Inc. // ww w. j av a 2 s . c om * All rights reserved. */ /* ** License Applicability. Except to the extent portions of this file are ** made subject to an alternative license as permitted in the SGI Free ** Software License B, Version 2.0 (the "License"), the contents of this ** file are subject only to the provisions of the License. You may not use ** this file except in compliance with the License. You may obtain a copy ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: ** ** http://oss.sgi.com/projects/FreeB ** ** Note that, as provided in the License, the Software is distributed on an ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. ** ** NOTE: The Original Code (as defined below) has been licensed to Sun ** Microsystems, Inc. ("Sun") under the SGI Free Software License B ** (Version 1.1), shown above ("SGI License"). Pursuant to Section ** 3.2(3) of the SGI License, Sun is distributing the Covered Code to ** you under an alternative license ("Alternative License"). This ** Alternative License includes all of the provisions of the SGI License ** except that Section 2.2 and 11 are omitted. Any differences between ** the Alternative License and the SGI License are offered solely by Sun ** and not by SGI. ** ** Original Code. The Original Code is: OpenGL Sample Implementation, ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. ** Copyright in any portions created by third parties is as indicated ** elsewhere herein. All Rights Reserved. ** ** Additional Notice Provisions: The application programming interfaces ** established by SGI in conjunction with the Original Code are The ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X ** Window System(R) (Version 1.3), released October 19, 1998. This software ** was created using the OpenGL(R) version 1.2.1 Sample Implementation ** published by SGI, but has not been independently verified as being ** compliant with the OpenGL(R) version 1.2.1 Specification. ** ** Author: Eric Veach, July 1994 ** Java Port: Pepijn Van Eeckhoudt, July 2003 ** Java Port: Nathan Parker Burg, August 2003 ** Processing integration: Andres Colubri, February 2012 */ package com.processing.opengl.tess; class Sweep { private Sweep() { } // #ifdef FOR_TRITE_TEST_PROGRAM // extern void DebugEvent( GLUtessellator *tess ); // #else private static void DebugEvent(GLUtessellatorImpl tess) { } // #endif /* * Invariants for the Edge Dictionary. * - each pair of adjacent edges e2=Succ(e1) satisfies EdgeLeq(e1,e2) * at any valid location of the sweep event * - if EdgeLeq(e2,e1) as well (at any valid sweep event), then e1 and e2 * share a common endpoint * - for each e, e.Dst has been processed, but not e.Org * - each edge e satisfies VertLeq(e.Dst,event) && VertLeq(event,e.Org) * where "event" is the current sweep line event. * - no edge e has zero length * * Invariants for the Mesh (the processed portion). * - the portion of the mesh left of the sweep line is a planar graph, * ie. there is *some* way to embed it in the plane * - no processed edge has zero length * - no two processed vertices have identical coordinates * - each "inside" region is monotone, ie. can be broken into two chains * of monotonically increasing vertices according to VertLeq(v1,v2) * - a non-invariant: these chains may intersect (very slightly) * * Invariants for the Sweep. * - if none of the edges incident to the event vertex have an activeRegion * (ie. none of these edges are in the edge dictionary), then the vertex * has only right-going edges. * - if an edge is marked "fixUpperEdge" (it is a temporary edge introduced * by ConnectRightVertex), then it is the only right-going edge from * its associated vertex. (This says that these edges exist only * when it is necessary.) */ /* When we merge two edges into one, we need to compute the combined * winding of the new edge. */ private static void AddWinding(GLUhalfEdge eDst, GLUhalfEdge eSrc) { eDst.winding += eSrc.winding; eDst.Sym.winding += eSrc.Sym.winding; } private static ActiveRegion RegionBelow(ActiveRegion r) { return ((ActiveRegion) Dict.dictKey(Dict.dictPred(r.nodeUp))); } private static ActiveRegion RegionAbove(ActiveRegion r) { return ((ActiveRegion) Dict.dictKey(Dict.dictSucc(r.nodeUp))); } static boolean EdgeLeq(GLUtessellatorImpl tess, ActiveRegion reg1, ActiveRegion reg2) /* * Both edges must be directed from right to left (this is the canonical * direction for the upper edge of each region). * * The strategy is to evaluate a "t" value for each edge at the * current sweep line position, given by tess.event. The calculations * are designed to be very stable, but of course they are not perfect. * * Special case: if both edge destinations are at the sweep event, * we sort the edges by slope (they would otherwise compare equally). */ { GLUvertex event = tess.event; GLUhalfEdge e1, e2; double t1, t2; e1 = reg1.eUp; e2 = reg2.eUp; if (e1.Sym.Org == event) { if (e2.Sym.Org == event) { /* Two edges right of the sweep line which meet at the sweep event. * Sort them by slope. */ if (Geom.VertLeq(e1.Org, e2.Org)) { return Geom.EdgeSign(e2.Sym.Org, e1.Org, e2.Org) <= 0; } return Geom.EdgeSign(e1.Sym.Org, e2.Org, e1.Org) >= 0; } return Geom.EdgeSign(e2.Sym.Org, event, e2.Org) <= 0; } if (e2.Sym.Org == event) { return Geom.EdgeSign(e1.Sym.Org, event, e1.Org) >= 0; } /* General case - compute signed distance *from* e1, e2 to event */ t1 = Geom.EdgeEval(e1.Sym.Org, event, e1.Org); t2 = Geom.EdgeEval(e2.Sym.Org, event, e2.Org); return (t1 >= t2); } static void DeleteRegion(GLUtessellatorImpl tess, ActiveRegion reg) { if (reg.fixUpperEdge) { /* It was created with zero winding number, so it better be * deleted with zero winding number (ie. it better not get merged * with a real edge). */ assert (reg.eUp.winding == 0); } reg.eUp.activeRegion = null; Dict.dictDelete(tess.dict, reg.nodeUp); /* __gl_dictListDelete */ } static boolean FixUpperEdge(ActiveRegion reg, GLUhalfEdge newEdge) /* * Replace an upper edge which needs fixing (see ConnectRightVertex). */ { assert (reg.fixUpperEdge); if (!Mesh.__gl_meshDelete(reg.eUp)) return false; reg.fixUpperEdge = false; reg.eUp = newEdge; newEdge.activeRegion = reg; return true; } static ActiveRegion TopLeftRegion(ActiveRegion reg) { GLUvertex org = reg.eUp.Org; GLUhalfEdge e; /* Find the region above the uppermost edge with the same origin */ do { reg = RegionAbove(reg); } while (reg.eUp.Org == org); /* If the edge above was a temporary edge introduced by ConnectRightVertex, * now is the time to fix it. */ if (reg.fixUpperEdge) { e = Mesh.__gl_meshConnect(RegionBelow(reg).eUp.Sym, reg.eUp.Lnext); if (e == null) return null; if (!FixUpperEdge(reg, e)) return null; reg = RegionAbove(reg); } return reg; } static ActiveRegion TopRightRegion(ActiveRegion reg) { GLUvertex dst = reg.eUp.Sym.Org; /* Find the region above the uppermost edge with the same destination */ do { reg = RegionAbove(reg); } while (reg.eUp.Sym.Org == dst); return reg; } static ActiveRegion AddRegionBelow(GLUtessellatorImpl tess, ActiveRegion regAbove, GLUhalfEdge eNewUp) /* * Add a new active region to the sweep line, *somewhere* below "regAbove" * (according to where the new edge belongs in the sweep-line dictionary). * The upper edge of the new region will be "eNewUp". * Winding number and "inside" flag are not updated. */ { ActiveRegion regNew = new ActiveRegion(); if (regNew == null) throw new RuntimeException(); regNew.eUp = eNewUp; /* __gl_dictListInsertBefore */ regNew.nodeUp = Dict.dictInsertBefore(tess.dict, regAbove.nodeUp, regNew); if (regNew.nodeUp == null) throw new RuntimeException(); regNew.fixUpperEdge = false; regNew.sentinel = false; regNew.dirty = false; eNewUp.activeRegion = regNew; return regNew; } static boolean IsWindingInside(GLUtessellatorImpl tess, int n) { switch (tess.windingRule) { case PGLU.GLU_TESS_WINDING_ODD: return (n & 1) != 0; case PGLU.GLU_TESS_WINDING_NONZERO: return (n != 0); case PGLU.GLU_TESS_WINDING_POSITIVE: return (n > 0); case PGLU.GLU_TESS_WINDING_NEGATIVE: return (n < 0); case PGLU.GLU_TESS_WINDING_ABS_GEQ_TWO: return (n >= 2) || (n <= -2); } /*LINTED*/ // assert (false); throw new InternalError(); /*NOTREACHED*/ } static void ComputeWinding(GLUtessellatorImpl tess, ActiveRegion reg) { reg.windingNumber = RegionAbove(reg).windingNumber + reg.eUp.winding; reg.inside = IsWindingInside(tess, reg.windingNumber); } static void FinishRegion(GLUtessellatorImpl tess, ActiveRegion reg) /* * Delete a region from the sweep line. This happens when the upper * and lower chains of a region meet (at a vertex on the sweep line). * The "inside" flag is copied to the appropriate mesh face (we could * not do this before -- since the structure of the mesh is always * changing, this face may not have even existed until now). */ { GLUhalfEdge e = reg.eUp; GLUface f = e.Lface; f.inside = reg.inside; f.anEdge = e; /* optimization for __gl_meshTessellateMonoRegion() */ DeleteRegion(tess, reg); } static GLUhalfEdge FinishLeftRegions(GLUtessellatorImpl tess, ActiveRegion regFirst, ActiveRegion regLast) /* * We are given a vertex with one or more left-going edges. All affected * edges should be in the edge dictionary. Starting at regFirst.eUp, * we walk down deleting all regions where both edges have the same * origin vOrg. At the same time we copy the "inside" flag from the * active region to the face, since at this point each face will belong * to at most one region (this was not necessarily true until this point * in the sweep). The walk stops at the region above regLast; if regLast * is null we walk as far as possible. At the same time we relink the * mesh if necessary, so that the ordering of edges around vOrg is the * same as in the dictionary. */ { ActiveRegion reg, regPrev; GLUhalfEdge e, ePrev; regPrev = regFirst; ePrev = regFirst.eUp; while (regPrev != regLast) { regPrev.fixUpperEdge = false; /* placement was OK */ reg = RegionBelow(regPrev); e = reg.eUp; if (e.Org != ePrev.Org) { if (!reg.fixUpperEdge) { /* Remove the last left-going edge. Even though there are no further * edges in the dictionary with this origin, there may be further * such edges in the mesh (if we are adding left edges to a vertex * that has already been processed). Thus it is important to call * FinishRegion rather than just DeleteRegion. */ FinishRegion(tess, regPrev); break; } /* If the edge below was a temporary edge introduced by * ConnectRightVertex, now is the time to fix it. */ e = Mesh.__gl_meshConnect(ePrev.Onext.Sym, e.Sym); if (e == null) throw new RuntimeException(); if (!FixUpperEdge(reg, e)) throw new RuntimeException(); } /* Relink edges so that ePrev.Onext == e */ if (ePrev.Onext != e) { if (!Mesh.__gl_meshSplice(e.Sym.Lnext, e)) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(ePrev, e)) throw new RuntimeException(); } FinishRegion(tess, regPrev); /* may change reg.eUp */ ePrev = reg.eUp; regPrev = reg; } return ePrev; } static void AddRightEdges(GLUtessellatorImpl tess, ActiveRegion regUp, GLUhalfEdge eFirst, GLUhalfEdge eLast, GLUhalfEdge eTopLeft, boolean cleanUp) /* * Purpose: insert right-going edges into the edge dictionary, and update * winding numbers and mesh connectivity appropriately. All right-going * edges share a common origin vOrg. Edges are inserted CCW starting at * eFirst; the last edge inserted is eLast.Sym.Lnext. If vOrg has any * left-going edges already processed, then eTopLeft must be the edge * such that an imaginary upward vertical segment from vOrg would be * contained between eTopLeft.Sym.Lnext and eTopLeft; otherwise eTopLeft * should be null. */ { ActiveRegion reg, regPrev; GLUhalfEdge e, ePrev; boolean firstTime = true; /* Insert the new right-going edges in the dictionary */ e = eFirst; do { assert (Geom.VertLeq(e.Org, e.Sym.Org)); AddRegionBelow(tess, regUp, e.Sym); e = e.Onext; } while (e != eLast); /* Walk *all* right-going edges from e.Org, in the dictionary order, * updating the winding numbers of each region, and re-linking the mesh * edges to match the dictionary ordering (if necessary). */ if (eTopLeft == null) { eTopLeft = RegionBelow(regUp).eUp.Sym.Onext; } regPrev = regUp; ePrev = eTopLeft; for (; ;) { reg = RegionBelow(regPrev); e = reg.eUp.Sym; if (e.Org != ePrev.Org) break; if (e.Onext != ePrev) { /* Unlink e from its current position, and relink below ePrev */ if (!Mesh.__gl_meshSplice(e.Sym.Lnext, e)) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(ePrev.Sym.Lnext, e)) throw new RuntimeException(); } /* Compute the winding number and "inside" flag for the new regions */ reg.windingNumber = regPrev.windingNumber - e.winding; reg.inside = IsWindingInside(tess, reg.windingNumber); /* Check for two outgoing edges with same slope -- process these * before any intersection tests (see example in __gl_computeInterior). */ regPrev.dirty = true; if (!firstTime && CheckForRightSplice(tess, regPrev)) { AddWinding(e, ePrev); DeleteRegion(tess, regPrev); if (!Mesh.__gl_meshDelete(ePrev)) throw new RuntimeException(); } firstTime = false; regPrev = reg; ePrev = e; } regPrev.dirty = true; assert (regPrev.windingNumber - e.winding == reg.windingNumber); if (cleanUp) { /* Check for intersections between newly adjacent edges. */ WalkDirtyRegions(tess, regPrev); } } static void CallCombine(GLUtessellatorImpl tess, GLUvertex isect, Object[] data, float[] weights, boolean needed) { double[] coords = new double[3]; /* Copy coord data in case the callback changes it. */ coords[0] = isect.coords[0]; coords[1] = isect.coords[1]; coords[2] = isect.coords[2]; Object[] outData = new Object[1]; tess.callCombineOrCombineData(coords, data, weights, outData); isect.data = outData[0]; if (isect.data == null) { if (!needed) { isect.data = data[0]; } else if (!tess.fatalError) { /* The only way fatal error is when two edges are found to intersect, * but the user has not provided the callback necessary to handle * generated intersection points. */ tess.callErrorOrErrorData(PGLU.GLU_TESS_NEED_COMBINE_CALLBACK); tess.fatalError = true; } } } static void SpliceMergeVertices(GLUtessellatorImpl tess, GLUhalfEdge e1, GLUhalfEdge e2) /* * Two vertices with idential coordinates are combined into one. * e1.Org is kept, while e2.Org is discarded. */ { Object[] data = new Object[4]; float[] weights = new float[]{0.5f, 0.5f, 0.0f, 0.0f}; data[0] = e1.Org.data; data[1] = e2.Org.data; CallCombine(tess, e1.Org, data, weights, false); if (!Mesh.__gl_meshSplice(e1, e2)) throw new RuntimeException(); } static void VertexWeights(GLUvertex isect, GLUvertex org, GLUvertex dst, float[] weights) /* * Find some weights which describe how the intersection vertex is * a linear combination of "org" and "dest". Each of the two edges * which generated "isect" is allocated 50% of the weight; each edge * splits the weight between its org and dst according to the * relative distance to "isect". */ { double t1 = Geom.VertL1dist(org, isect); double t2 = Geom.VertL1dist(dst, isect); weights[0] = (float) (0.5 * t2 / (t1 + t2)); weights[1] = (float) (0.5 * t1 / (t1 + t2)); isect.coords[0] += weights[0] * org.coords[0] + weights[1] * dst.coords[0]; isect.coords[1] += weights[0] * org.coords[1] + weights[1] * dst.coords[1]; isect.coords[2] += weights[0] * org.coords[2] + weights[1] * dst.coords[2]; } static void GetIntersectData(GLUtessellatorImpl tess, GLUvertex isect, GLUvertex orgUp, GLUvertex dstUp, GLUvertex orgLo, GLUvertex dstLo) /* * We've computed a new intersection point, now we need a "data" pointer * from the user so that we can refer to this new vertex in the * rendering callbacks. */ { Object[] data = new Object[4]; float[] weights = new float[4]; float[] weights1 = new float[2]; float[] weights2 = new float[2]; data[0] = orgUp.data; data[1] = dstUp.data; data[2] = orgLo.data; data[3] = dstLo.data; isect.coords[0] = isect.coords[1] = isect.coords[2] = 0; VertexWeights(isect, orgUp, dstUp, weights1); VertexWeights(isect, orgLo, dstLo, weights2); System.arraycopy(weights1, 0, weights, 0, 2); System.arraycopy(weights2, 0, weights, 2, 2); CallCombine(tess, isect, data, weights, true); } static boolean CheckForRightSplice(GLUtessellatorImpl tess, ActiveRegion regUp) /* * Check the upper and lower edge of "regUp", to make sure that the * eUp.Org is above eLo, or eLo.Org is below eUp (depending on which * origin is leftmost). * * The main purpose is to splice right-going edges with the same * dest vertex and nearly identical slopes (ie. we can't distinguish * the slopes numerically). However the splicing can also help us * to recover from numerical errors. For example, suppose at one * point we checked eUp and eLo, and decided that eUp.Org is barely * above eLo. Then later, we split eLo into two edges (eg. from * a splice operation like this one). This can change the result of * our test so that now eUp.Org is incident to eLo, or barely below it. * We must correct this condition to maintain the dictionary invariants. * * One possibility is to check these edges for intersection again * (ie. CheckForIntersect). This is what we do if possible. However * CheckForIntersect requires that tess.event lies between eUp and eLo, * so that it has something to fall back on when the intersection * calculation gives us an unusable answer. So, for those cases where * we can't check for intersection, this routine fixes the problem * by just splicing the offending vertex into the other edge. * This is a guaranteed solution, no matter how degenerate things get. * Basically this is a combinatorial solution to a numerical problem. */ { ActiveRegion regLo = RegionBelow(regUp); GLUhalfEdge eUp = regUp.eUp; GLUhalfEdge eLo = regLo.eUp; if (Geom.VertLeq(eUp.Org, eLo.Org)) { if (Geom.EdgeSign(eLo.Sym.Org, eUp.Org, eLo.Org) > 0) return false; /* eUp.Org appears to be below eLo */ if (!Geom.VertEq(eUp.Org, eLo.Org)) { /* Splice eUp.Org into eLo */ if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(eUp, eLo.Sym.Lnext)) throw new RuntimeException(); regUp.dirty = regLo.dirty = true; } else if (eUp.Org != eLo.Org) { /* merge the two vertices, discarding eUp.Org */ tess.pq.pqDelete(eUp.Org.pqHandle); /* __gl_pqSortDelete */ SpliceMergeVertices(tess, eLo.Sym.Lnext, eUp); } } else { if (Geom.EdgeSign(eUp.Sym.Org, eLo.Org, eUp.Org) < 0) return false; /* eLo.Org appears to be above eUp, so splice eLo.Org into eUp */ RegionAbove(regUp).dirty = regUp.dirty = true; if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(eLo.Sym.Lnext, eUp)) throw new RuntimeException(); } return true; } static boolean CheckForLeftSplice(GLUtessellatorImpl tess, ActiveRegion regUp) /* * Check the upper and lower edge of "regUp", to make sure that the * eUp.Sym.Org is above eLo, or eLo.Sym.Org is below eUp (depending on which * destination is rightmost). * * Theoretically, this should always be true. However, splitting an edge * into two pieces can change the results of previous tests. For example, * suppose at one point we checked eUp and eLo, and decided that eUp.Sym.Org * is barely above eLo. Then later, we split eLo into two edges (eg. from * a splice operation like this one). This can change the result of * the test so that now eUp.Sym.Org is incident to eLo, or barely below it. * We must correct this condition to maintain the dictionary invariants * (otherwise new edges might get inserted in the wrong place in the * dictionary, and bad stuff will happen). * * We fix the problem by just splicing the offending vertex into the * other edge. */ { ActiveRegion regLo = RegionBelow(regUp); GLUhalfEdge eUp = regUp.eUp; GLUhalfEdge eLo = regLo.eUp; GLUhalfEdge e; assert (!Geom.VertEq(eUp.Sym.Org, eLo.Sym.Org)); if (Geom.VertLeq(eUp.Sym.Org, eLo.Sym.Org)) { if (Geom.EdgeSign(eUp.Sym.Org, eLo.Sym.Org, eUp.Org) < 0) return false; /* eLo.Sym.Org is above eUp, so splice eLo.Sym.Org into eUp */ RegionAbove(regUp).dirty = regUp.dirty = true; e = Mesh.__gl_meshSplitEdge(eUp); if (e == null) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(eLo.Sym, e)) throw new RuntimeException(); e.Lface.inside = regUp.inside; } else { if (Geom.EdgeSign(eLo.Sym.Org, eUp.Sym.Org, eLo.Org) > 0) return false; /* eUp.Sym.Org is below eLo, so splice eUp.Sym.Org into eLo */ regUp.dirty = regLo.dirty = true; e = Mesh.__gl_meshSplitEdge(eLo); if (e == null) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(eUp.Lnext, eLo.Sym)) throw new RuntimeException(); e.Sym.Lface.inside = regUp.inside; } return true; } static boolean CheckForIntersect(GLUtessellatorImpl tess, ActiveRegion regUp) /* * Check the upper and lower edges of the given region to see if * they intersect. If so, create the intersection and add it * to the data structures. * * Returns true if adding the new intersection resulted in a recursive * call to AddRightEdges(); in this case all "dirty" regions have been * checked for intersections, and possibly regUp has been deleted. */ { ActiveRegion regLo = RegionBelow(regUp); GLUhalfEdge eUp = regUp.eUp; GLUhalfEdge eLo = regLo.eUp; GLUvertex orgUp = eUp.Org; GLUvertex orgLo = eLo.Org; GLUvertex dstUp = eUp.Sym.Org; GLUvertex dstLo = eLo.Sym.Org; double tMinUp, tMaxLo; GLUvertex isect = new GLUvertex(); GLUvertex orgMin; GLUhalfEdge e; assert (!Geom.VertEq(dstLo, dstUp)); assert (Geom.EdgeSign(dstUp, tess.event, orgUp) <= 0); assert (Geom.EdgeSign(dstLo, tess.event, orgLo) >= 0); assert (orgUp != tess.event && orgLo != tess.event); assert (!regUp.fixUpperEdge && !regLo.fixUpperEdge); if (orgUp == orgLo) return false; /* right endpoints are the same */ tMinUp = Math.min(orgUp.t, dstUp.t); tMaxLo = Math.max(orgLo.t, dstLo.t); if (tMinUp > tMaxLo) return false; /* t ranges do not overlap */ if (Geom.VertLeq(orgUp, orgLo)) { if (Geom.EdgeSign(dstLo, orgUp, orgLo) > 0) return false; } else { if (Geom.EdgeSign(dstUp, orgLo, orgUp) < 0) return false; } /* At this point the edges intersect, at least marginally */ DebugEvent(tess); Geom.EdgeIntersect(dstUp, orgUp, dstLo, orgLo, isect); /* The following properties are guaranteed: */ assert (Math.min(orgUp.t, dstUp.t) <= isect.t); assert (isect.t <= Math.max(orgLo.t, dstLo.t)); assert (Math.min(dstLo.s, dstUp.s) <= isect.s); assert (isect.s <= Math.max(orgLo.s, orgUp.s)); if (Geom.VertLeq(isect, tess.event)) { /* The intersection point lies slightly to the left of the sweep line, * so move it until it''s slightly to the right of the sweep line. * (If we had perfect numerical precision, this would never happen * in the first place). The easiest and safest thing to do is * replace the intersection by tess.event. */ isect.s = tess.event.s; isect.t = tess.event.t; } /* Similarly, if the computed intersection lies to the right of the * rightmost origin (which should rarely happen), it can cause * unbelievable inefficiency on sufficiently degenerate inputs. * (If you have the test program, try running test54.d with the * "X zoom" option turned on). */ orgMin = Geom.VertLeq(orgUp, orgLo) ? orgUp : orgLo; if (Geom.VertLeq(orgMin, isect)) { isect.s = orgMin.s; isect.t = orgMin.t; } if (Geom.VertEq(isect, orgUp) || Geom.VertEq(isect, orgLo)) { /* Easy case -- intersection at one of the right endpoints */ CheckForRightSplice(tess, regUp); return false; } if ((!Geom.VertEq(dstUp, tess.event) && Geom.EdgeSign(dstUp, tess.event, isect) >= 0) || (!Geom.VertEq(dstLo, tess.event) && Geom.EdgeSign(dstLo, tess.event, isect) <= 0)) { /* Very unusual -- the new upper or lower edge would pass on the * wrong side of the sweep event, or through it. This can happen * due to very small numerical errors in the intersection calculation. */ if (dstLo == tess.event) { /* Splice dstLo into eUp, and process the new region(s) */ if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(eLo.Sym, eUp)) throw new RuntimeException(); regUp = TopLeftRegion(regUp); if (regUp == null) throw new RuntimeException(); eUp = RegionBelow(regUp).eUp; FinishLeftRegions(tess, RegionBelow(regUp), regLo); AddRightEdges(tess, regUp, eUp.Sym.Lnext, eUp, eUp, true); return true; } if (dstUp == tess.event) { /* Splice dstUp into eLo, and process the new region(s) */ if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(eUp.Lnext, eLo.Sym.Lnext)) throw new RuntimeException(); regLo = regUp; regUp = TopRightRegion(regUp); e = RegionBelow(regUp).eUp.Sym.Onext; regLo.eUp = eLo.Sym.Lnext; eLo = FinishLeftRegions(tess, regLo, null); AddRightEdges(tess, regUp, eLo.Onext, eUp.Sym.Onext, e, true); return true; } /* Special case: called from ConnectRightVertex. If either * edge passes on the wrong side of tess.event, split it * (and wait for ConnectRightVertex to splice it appropriately). */ if (Geom.EdgeSign(dstUp, tess.event, isect) >= 0) { RegionAbove(regUp).dirty = regUp.dirty = true; if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException(); eUp.Org.s = tess.event.s; eUp.Org.t = tess.event.t; } if (Geom.EdgeSign(dstLo, tess.event, isect) <= 0) { regUp.dirty = regLo.dirty = true; if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException(); eLo.Org.s = tess.event.s; eLo.Org.t = tess.event.t; } /* leave the rest for ConnectRightVertex */ return false; } /* General case -- split both edges, splice into new vertex. * When we do the splice operation, the order of the arguments is * arbitrary as far as correctness goes. However, when the operation * creates a new face, the work done is proportional to the size of * the new face. We expect the faces in the processed part of * the mesh (ie. eUp.Lface) to be smaller than the faces in the * unprocessed original contours (which will be eLo.Sym.Lnext.Lface). */ if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException(); if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException(); if (!Mesh.__gl_meshSplice(eLo.Sym.Lnext, eUp)) throw new RuntimeException(); eUp.Org.s = isect.s; eUp.Org.t = isect.t; eUp.Org.pqHandle = tess.pq.pqInsert(eUp.Org); /* __gl_pqSortInsert */ if (eUp.Org.pqHandle == Long.MAX_VALUE) { tess.pq.pqDeletePriorityQ(); /* __gl_pqSortDeletePriorityQ */ tess.pq = null; throw new RuntimeException(); } GetIntersectData(tess, eUp.Org, orgUp, dstUp, orgLo, dstLo); RegionAbove(regUp).dirty = regUp.dirty = regLo.dirty = true; return false; } static void WalkDirtyRegions(GLUtessellatorImpl tess, ActiveRegion regUp) /* * When the upper or lower edge of any region changes, the region is * marked "dirty". This routine walks through all the dirty regions * and makes sure that the dictionary invariants are satisfied * (see the comments at the beginning of this file). Of course * new dirty regions can be created as we make changes to restore * the invariants. */ { ActiveRegion regLo = RegionBelow(regUp); GLUhalfEdge eUp, eLo; for (; ;) { /* Find the lowest dirty region (we walk from the bottom up). */ while (regLo.dirty) { regUp = regLo; regLo = RegionBelow(regLo); } if (!regUp.dirty) { regLo = regUp; regUp = RegionAbove(regUp); if (regUp == null || !regUp.dirty) { /* We've walked all the dirty regions */ return; } } regUp.dirty = false; eUp = regUp.eUp; eLo = regLo.eUp; if (eUp.Sym.Org != eLo.Sym.Org) { /* Check that the edge ordering is obeyed at the Dst vertices. */ if (CheckForLeftSplice(tess, regUp)) { /* If the upper or lower edge was marked fixUpperEdge, then * we no longer need it (since these edges are needed only for * vertices which otherwise have no right-going edges). */ if (regLo.fixUpperEdge) { DeleteRegion(tess, regLo); if (!Mesh.__gl_meshDelete(eLo)) throw new RuntimeException(); regLo = RegionBelow(regUp); eLo = regLo.eUp; } else if (regUp.fixUpperEdge) { DeleteRegion(tess, regUp); if (!Mesh.__gl_meshDelete(eUp)) throw new RuntimeException(); regUp = RegionAbove(regLo); eUp = regUp.eUp; } } } if (eUp.Org != eLo.Org) { if (eUp.Sym.Org != eLo.Sym.Org && !regUp.fixUpperEdge && !regLo.fixUpperEdge && (eUp.Sym.Org == tess.event || eLo.Sym.Org == tess.event)) { /* When all else fails in CheckForIntersect(), it uses tess.event * as the intersection location. To make this possible, it requires * that tess.event lie between the upper and lower edges, and also * that neither of these is marked fixUpperEdge (since in the worst * case it might splice one of these edges into tess.event, and * violate the invariant that fixable edges are the only right-going * edge from their associated vertex). */ if (CheckForIntersect(tess, regUp)) { /* WalkDirtyRegions() was called recursively; we're done */ return; } } else { /* Even though we can't use CheckForIntersect(), the Org vertices * may violate the dictionary edge ordering. Check and correct this. */ CheckForRightSplice(tess, regUp); } } if (eUp.Org == eLo.Org && eUp.Sym.Org == eLo.Sym.Org) { /* A degenerate loop consisting of only two edges -- delete it. */ AddWinding(eLo, eUp); DeleteRegion(tess, regUp); if (!Mesh.__gl_meshDelete(eUp)) throw new RuntimeException(); regUp = RegionAbove(regLo); } } } static void ConnectRightVertex(GLUtessellatorImpl tess, ActiveRegion regUp, GLUhalfEdge eBottomLeft) /* * Purpose: connect a "right" vertex vEvent (one where all edges go left) * to the unprocessed portion of the mesh. Since there are no right-going * edges, two regions (one above vEvent and one below) are being merged * into one. "regUp" is the upper of these two regions. * * There are two reasons for doing this (adding a right-going edge): * - if the two regions being merged are "inside", we must add an edge * to keep them separated (the combined region would not be monotone). * - in any case, we must leave some record of vEvent in the dictionary, * so that we can merge vEvent with features that we have not seen yet. * For example, maybe there is a vertical edge which passes just to * the right of vEvent; we would like to splice vEvent into this edge. * * However, we don't want to connect vEvent to just any vertex. We don''t * want the new edge to cross any other edges; otherwise we will create * intersection vertices even when the input data had no self-intersections. * (This is a bad thing; if the user's input data has no intersections, * we don't want to generate any false intersections ourselves.) * * Our eventual goal is to connect vEvent to the leftmost unprocessed * vertex of the combined region (the union of regUp and regLo). * But because of unseen vertices with all right-going edges, and also * new vertices which may be created by edge intersections, we don''t * know where that leftmost unprocessed vertex is. In the meantime, we * connect vEvent to the closest vertex of either chain, and mark the region * as "fixUpperEdge". This flag says to delete and reconnect this edge * to the next processed vertex on the boundary of the combined region. * Quite possibly the vertex we connected to will turn out to be the * closest one, in which case we won''t need to make any changes. */ { GLUhalfEdge eNew; GLUhalfEdge eTopLeft = eBottomLeft.Onext; ActiveRegion regLo = RegionBelow(regUp); GLUhalfEdge eUp = regUp.eUp; GLUhalfEdge eLo = regLo.eUp; boolean degenerate = false; if (eUp.Sym.Org != eLo.Sym.Org) { CheckForIntersect(tess, regUp); } /* Possible new degeneracies: upper or lower edge of regUp may pass * through vEvent, or may coincide with new intersection vertex */ if (Geom.VertEq(eUp.Org, tess.event)) { if (!Mesh.__gl_meshSplice(eTopLeft.Sym.Lnext, eUp)) throw new RuntimeException(); regUp = TopLeftRegion(regUp); if (regUp == null) throw new RuntimeException(); eTopLeft = RegionBelow(regUp).eUp; FinishLeftRegions(tess, RegionBelow(regUp), regLo); degenerate = true; } if (Geom.VertEq(eLo.Org, tess.event)) { if (!Mesh.__gl_meshSplice(eBottomLeft, eLo.Sym.Lnext)) throw new RuntimeException(); eBottomLeft = FinishLeftRegions(tess, regLo, null); degenerate = true; } if (degenerate) { AddRightEdges(tess, regUp, eBottomLeft.Onext, eTopLeft, eTopLeft, true); return; } /* Non-degenerate situation -- need to add a temporary, fixable edge. * Connect to the closer of eLo.Org, eUp.Org. */ if (Geom.VertLeq(eLo.Org, eUp.Org)) { eNew = eLo.Sym.Lnext; } else { eNew = eUp; } eNew = Mesh.__gl_meshConnect(eBottomLeft.Onext.Sym, eNew); if (eNew == null) throw new RuntimeException(); /* Prevent cleanup, otherwise eNew might disappear before we've even * had a chance to mark it as a temporary edge. */ AddRightEdges(tess, regUp, eNew, eNew.Onext, eNew.Onext, false); eNew.Sym.activeRegion.fixUpperEdge = true; WalkDirtyRegions(tess, regUp); } /* Because vertices at exactly the same location are merged together * before we process the sweep event, some degenerate cases can't occur. * However if someone eventually makes the modifications required to * merge features which are close together, the cases below marked * TOLERANCE_NONZERO will be useful. They were debugged before the * code to merge identical vertices in the main loop was added. */ private static final boolean TOLERANCE_NONZERO = false; static void ConnectLeftDegenerate(GLUtessellatorImpl tess, ActiveRegion regUp, GLUvertex vEvent) /* * The event vertex lies exacty on an already-processed edge or vertex. * Adding the new vertex involves splicing it into the already-processed * part of the mesh. */ { GLUhalfEdge e, eTopLeft, eTopRight, eLast; ActiveRegion reg; e = regUp.eUp; if (Geom.VertEq(e.Org, vEvent)) { /* e.Org is an unprocessed vertex - just combine them, and wait * for e.Org to be pulled from the queue */ assert (TOLERANCE_NONZERO); SpliceMergeVertices(tess, e, vEvent.anEdge); return; } if (!Geom.VertEq(e.Sym.Org, vEvent)) { /* General case -- splice vEvent into edge e which passes through it */ if (Mesh.__gl_meshSplitEdge(e.Sym) == null) throw new RuntimeException(); if (regUp.fixUpperEdge) { /* This edge was fixable -- delete unused portion of original edge */ if (!Mesh.__gl_meshDelete(e.Onext)) throw new RuntimeException(); regUp.fixUpperEdge = false; } if (!Mesh.__gl_meshSplice(vEvent.anEdge, e)) throw new RuntimeException(); SweepEvent(tess, vEvent); /* recurse */ return; } /* vEvent coincides with e.Sym.Org, which has already been processed. * Splice in the additional right-going edges. */ assert (TOLERANCE_NONZERO); regUp = TopRightRegion(regUp); reg = RegionBelow(regUp); eTopRight = reg.eUp.Sym; eTopLeft = eLast = eTopRight.Onext; if (reg.fixUpperEdge) { /* Here e.Sym.Org has only a single fixable edge going right. * We can delete it since now we have some real right-going edges. */ assert (eTopLeft != eTopRight); /* there are some left edges too */ DeleteRegion(tess, reg); if (!Mesh.__gl_meshDelete(eTopRight)) throw new RuntimeException(); eTopRight = eTopLeft.Sym.Lnext; } if (!Mesh.__gl_meshSplice(vEvent.anEdge, eTopRight)) throw new RuntimeException(); if (!Geom.EdgeGoesLeft(eTopLeft)) { /* e.Sym.Org had no left-going edges -- indicate this to AddRightEdges() */ eTopLeft = null; } AddRightEdges(tess, regUp, eTopRight.Onext, eLast, eTopLeft, true); } static void ConnectLeftVertex(GLUtessellatorImpl tess, GLUvertex vEvent) /* * Purpose: connect a "left" vertex (one where both edges go right) * to the processed portion of the mesh. Let R be the active region * containing vEvent, and let U and L be the upper and lower edge * chains of R. There are two possibilities: * * - the normal case: split R into two regions, by connecting vEvent to * the rightmost vertex of U or L lying to the left of the sweep line * * - the degenerate case: if vEvent is close enough to U or L, we * merge vEvent into that edge chain. The subcases are: * - merging with the rightmost vertex of U or L * - merging with the active edge of U or L * - merging with an already-processed portion of U or L */ { ActiveRegion regUp, regLo, reg; GLUhalfEdge eUp, eLo, eNew; ActiveRegion tmp = new ActiveRegion(); /* assert ( vEvent.anEdge.Onext.Onext == vEvent.anEdge ); */ /* Get a pointer to the active region containing vEvent */ tmp.eUp = vEvent.anEdge.Sym; /* __GL_DICTLISTKEY */ /* __gl_dictListSearch */ regUp = (ActiveRegion) Dict.dictKey(Dict.dictSearch(tess.dict, tmp)); regLo = RegionBelow(regUp); eUp = regUp.eUp; eLo = regLo.eUp; /* Try merging with U or L first */ if (Geom.EdgeSign(eUp.Sym.Org, vEvent, eUp.Org) == 0) { ConnectLeftDegenerate(tess, regUp, vEvent); return; } /* Connect vEvent to rightmost processed vertex of either chain. * e.Sym.Org is the vertex that we will connect to vEvent. */ reg = Geom.VertLeq(eLo.Sym.Org, eUp.Sym.Org) ? regUp : regLo; if (regUp.inside || reg.fixUpperEdge) { if (reg == regUp) { eNew = Mesh.__gl_meshConnect(vEvent.anEdge.Sym, eUp.Lnext); if (eNew == null) throw new RuntimeException(); } else { GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(eLo.Sym.Onext.Sym, vEvent.anEdge); if (tempHalfEdge == null) throw new RuntimeException(); eNew = tempHalfEdge.Sym; } if (reg.fixUpperEdge) { if (!FixUpperEdge(reg, eNew)) throw new RuntimeException(); } else { ComputeWinding(tess, AddRegionBelow(tess, regUp, eNew)); } SweepEvent(tess, vEvent); } else { /* The new vertex is in a region which does not belong to the polygon. * We don''t need to connect this vertex to the rest of the mesh. */ AddRightEdges(tess, regUp, vEvent.anEdge, vEvent.anEdge, null, true); } } static void SweepEvent(GLUtessellatorImpl tess, GLUvertex vEvent) /* * Does everything necessary when the sweep line crosses a vertex. * Updates the mesh and the edge dictionary. */ { ActiveRegion regUp, reg; GLUhalfEdge e, eTopLeft, eBottomLeft; tess.event = vEvent; /* for access in EdgeLeq() */ DebugEvent(tess); /* Check if this vertex is the right endpoint of an edge that is * already in the dictionary. In this case we don't need to waste * time searching for the location to insert new edges. */ e = vEvent.anEdge; while (e.activeRegion == null) { e = e.Onext; if (e == vEvent.anEdge) { /* All edges go right -- not incident to any processed edges */ ConnectLeftVertex(tess, vEvent); return; } } /* Processing consists of two phases: first we "finish" all the * active regions where both the upper and lower edges terminate * at vEvent (ie. vEvent is closing off these regions). * We mark these faces "inside" or "outside" the polygon according * to their winding number, and delete the edges from the dictionary. * This takes care of all the left-going edges from vEvent. */ regUp = TopLeftRegion(e.activeRegion); if (regUp == null) throw new RuntimeException(); reg = RegionBelow(regUp); eTopLeft = reg.eUp; eBottomLeft = FinishLeftRegions(tess, reg, null); /* Next we process all the right-going edges from vEvent. This * involves adding the edges to the dictionary, and creating the * associated "active regions" which record information about the * regions between adjacent dictionary edges. */ if (eBottomLeft.Onext == eTopLeft) { /* No right-going edges -- add a temporary "fixable" edge */ ConnectRightVertex(tess, regUp, eBottomLeft); } else { AddRightEdges(tess, regUp, eBottomLeft.Onext, eTopLeft, eTopLeft, true); } } /* Make the sentinel coordinates big enough that they will never be * merged with real input features. (Even with the largest possible * input contour and the maximum tolerance of 1.0, no merging will be * done with coordinates larger than 3 * GLU_TESS_MAX_COORD). */ private static final double SENTINEL_COORD = (4.0 * PGLU.GLU_TESS_MAX_COORD); static void AddSentinel(GLUtessellatorImpl tess, double t) /* * We add two sentinel edges above and below all other edges, * to avoid special cases at the top and bottom. */ { GLUhalfEdge e; ActiveRegion reg = new ActiveRegion(); if (reg == null) throw new RuntimeException(); e = Mesh.__gl_meshMakeEdge(tess.mesh); if (e == null) throw new RuntimeException(); e.Org.s = SENTINEL_COORD; e.Org.t = t; e.Sym.Org.s = -SENTINEL_COORD; e.Sym.Org.t = t; tess.event = e.Sym.Org; /* initialize it */ reg.eUp = e; reg.windingNumber = 0; reg.inside = false; reg.fixUpperEdge = false; reg.sentinel = true; reg.dirty = false; reg.nodeUp = Dict.dictInsert(tess.dict, reg); /* __gl_dictListInsertBefore */ if (reg.nodeUp == null) throw new RuntimeException(); } static void InitEdgeDict(final GLUtessellatorImpl tess) /* * We maintain an ordering of edge intersections with the sweep line. * This order is maintained in a dynamic dictionary. */ { /* __gl_dictListNewDict */ tess.dict = Dict.dictNewDict(tess, new Dict.DictLeq() { public boolean leq(Object frame, Object key1, Object key2) { return EdgeLeq(tess, (ActiveRegion) key1, (ActiveRegion) key2); } }); if (tess.dict == null) throw new RuntimeException(); AddSentinel(tess, -SENTINEL_COORD); AddSentinel(tess, SENTINEL_COORD); } static void DoneEdgeDict(GLUtessellatorImpl tess) { ActiveRegion reg; int fixedEdges = 0; /* __GL_DICTLISTKEY */ /* __GL_DICTLISTMIN */ while ((reg = (ActiveRegion) Dict.dictKey(Dict.dictMin(tess.dict))) != null) { /* * At the end of all processing, the dictionary should contain * only the two sentinel edges, plus at most one "fixable" edge * created by ConnectRightVertex(). */ if (!reg.sentinel) { assert (reg.fixUpperEdge); assert (++fixedEdges == 1); } assert (reg.windingNumber == 0); DeleteRegion(tess, reg); /* __gl_meshDelete( reg.eUp );*/ } Dict.dictDeleteDict(tess.dict); /* __gl_dictListDeleteDict */ } static void RemoveDegenerateEdges(GLUtessellatorImpl tess) /* * Remove zero-length edges, and contours with fewer than 3 vertices. */ { GLUhalfEdge e, eNext, eLnext; GLUhalfEdge eHead = tess.mesh.eHead; /*LINTED*/ for (e = eHead.next; e != eHead; e = eNext) { eNext = e.next; eLnext = e.Lnext; if (Geom.VertEq(e.Org, e.Sym.Org) && e.Lnext.Lnext != e) { /* Zero-length edge, contour has at least 3 edges */ SpliceMergeVertices(tess, eLnext, e); /* deletes e.Org */ if (!Mesh.__gl_meshDelete(e)) throw new RuntimeException(); /* e is a self-loop */ e = eLnext; eLnext = e.Lnext; } if (eLnext.Lnext == e) { /* Degenerate contour (one or two edges) */ if (eLnext != e) { if (eLnext == eNext || eLnext == eNext.Sym) { eNext = eNext.next; } if (!Mesh.__gl_meshDelete(eLnext)) throw new RuntimeException(); } if (e == eNext || e == eNext.Sym) { eNext = eNext.next; } if (!Mesh.__gl_meshDelete(e)) throw new RuntimeException(); } } } static boolean InitPriorityQ(GLUtessellatorImpl tess) /* * Insert all vertices into the priority queue which determines the * order in which vertices cross the sweep line. */ { PriorityQ pq; GLUvertex v, vHead; /* __gl_pqSortNewPriorityQ */ pq = tess.pq = PriorityQ.pqNewPriorityQ(new PriorityQ.Leq() { public boolean leq(Object key1, Object key2) { return Geom.VertLeq(((GLUvertex) key1), (GLUvertex) key2); } }); if (pq == null) return false; vHead = tess.mesh.vHead; for (v = vHead.next; v != vHead; v = v.next) { v.pqHandle = pq.pqInsert(v); /* __gl_pqSortInsert */ if (v.pqHandle == Long.MAX_VALUE) break; } if (v != vHead || !pq.pqInit()) { /* __gl_pqSortInit */ tess.pq.pqDeletePriorityQ(); /* __gl_pqSortDeletePriorityQ */ tess.pq = null; return false; } return true; } static void DonePriorityQ(GLUtessellatorImpl tess) { tess.pq.pqDeletePriorityQ(); /* __gl_pqSortDeletePriorityQ */ } static boolean RemoveDegenerateFaces(GLUmesh mesh) /* * Delete any degenerate faces with only two edges. WalkDirtyRegions() * will catch almost all of these, but it won't catch degenerate faces * produced by splice operations on already-processed edges. * The two places this can happen are in FinishLeftRegions(), when * we splice in a "temporary" edge produced by ConnectRightVertex(), * and in CheckForLeftSplice(), where we splice already-processed * edges to ensure that our dictionary invariants are not violated * by numerical errors. * * In both these cases it is *very* dangerous to delete the offending * edge at the time, since one of the routines further up the stack * will sometimes be keeping a pointer to that edge. */ { GLUface f, fNext; GLUhalfEdge e; /*LINTED*/ for (f = mesh.fHead.next; f != mesh.fHead; f = fNext) { fNext = f.next; e = f.anEdge; assert (e.Lnext != e); if (e.Lnext.Lnext == e) { /* A face with only two edges */ AddWinding(e.Onext, e); if (!Mesh.__gl_meshDelete(e)) return false; } } return true; } public static boolean __gl_computeInterior(GLUtessellatorImpl tess) /* * __gl_computeInterior( tess ) computes the planar arrangement specified * by the given contours, and further subdivides this arrangement * into regions. Each region is marked "inside" if it belongs * to the polygon, according to the rule given by tess.windingRule. * Each interior region is guaranteed be monotone. */ { GLUvertex v, vNext; tess.fatalError = false; /* Each vertex defines an event for our sweep line. Start by inserting * all the vertices in a priority queue. Events are processed in * lexicographic order, ie. * * e1 < e2 iff e1.x < e2.x || (e1.x == e2.x && e1.y < e2.y) */ RemoveDegenerateEdges(tess); if (!InitPriorityQ(tess)) return false; /* if error */ InitEdgeDict(tess); /* __gl_pqSortExtractMin */ while ((v = (GLUvertex) tess.pq.pqExtractMin()) != null) { for (; ;) { vNext = (GLUvertex) tess.pq.pqMinimum(); /* __gl_pqSortMinimum */ if (vNext == null || !Geom.VertEq(vNext, v)) break; /* Merge together all vertices at exactly the same location. * This is more efficient than processing them one at a time, * simplifies the code (see ConnectLeftDegenerate), and is also * important for correct handling of certain degenerate cases. * For example, suppose there are two identical edges A and B * that belong to different contours (so without this code they would * be processed by separate sweep events). Suppose another edge C * crosses A and B from above. When A is processed, we split it * at its intersection point with C. However this also splits C, * so when we insert B we may compute a slightly different * intersection point. This might leave two edges with a small * gap between them. This kind of error is especially obvious * when using boundary extraction (GLU_TESS_BOUNDARY_ONLY). */ vNext = (GLUvertex) tess.pq.pqExtractMin(); /* __gl_pqSortExtractMin*/ SpliceMergeVertices(tess, v.anEdge, vNext.anEdge); } SweepEvent(tess, v); } /* Set tess.event for debugging purposes */ /* __GL_DICTLISTKEY */ /* __GL_DICTLISTMIN */ tess.event = ((ActiveRegion) Dict.dictKey(Dict.dictMin(tess.dict))).eUp.Org; DebugEvent(tess); DoneEdgeDict(tess); DonePriorityQ(tess); if (!RemoveDegenerateFaces(tess.mesh)) return false; Mesh.__gl_meshCheckMesh(tess.mesh); return true; } }