diff options
5 files changed, 77 insertions, 45 deletions
diff --git a/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java b/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java index 805db522b..3e85ff3dc 100644 --- a/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java +++ b/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java @@ -61,15 +61,16 @@ import com.jogamp.math.geom.plane.Winding; * <a name="windingrules"> * Outline shape general {@link Winding} rules * <ul> - * <li>Outer boundary shapes are required as {@link Winding#CCW}, if unsure + * <li>Outer boundary-shapes are required as {@link Winding#CCW}</li> + * <li>Inner hole-shapes should be {@link Winding#CW}</li> + * <li>If unsure * <ul> - * <li>You may check {@link Winding} via {@link #getWindingOfLastOutline()} or {@link Outline#getWinding()} (optional)</li> + * <li>You may check {@link Winding} via {@link #getWindingOfLastOutline()} or {@link Outline#getWinding()} (optional, might be incorrect)</li> * <li>Use {@link #setWindingOfLastOutline(Winding)} before {@link #closeLastOutline(boolean)} or {@link #closePath()} } to enforce {@link Winding#CCW}, or</li> * <li>use {@link Outline#setWinding(Winding)} on a specific {@link Outline} to enforce {@link Winding#CCW}.</li> * <li>If e.g. the {@link Winding} has changed for an {@link Outline} by above operations, its vertices have been reversed.</li> * </ul></li> - * <li>Inner shapes or holes are adjusted to be {@link Winding#CW}, no user consideration is required here.</li> - * <li>Safe path: Simply create all shapes with {@link Winding#CCW} or apply {@link Outline#setWinding(Winding)}.</li> + * <li>Safe path: Simply create all outer boundary-shapes with {@link Winding#CCW} and inner hole-shapes with {@link Winding#CW}.</li> * </ul> * </p> * Example to creating an Outline Shape: @@ -238,7 +239,7 @@ public final class OutlineShape implements Comparable<OutlineShape> { } /** - * Compute the {@link Winding} of the {@link #getLastOutline()} using the {@link #area(ArrayList)} function over all of its vertices. + * Compute the {@link Winding} of the {@link #getLastOutline()} using the {@link VectorUtil#area2d(ArrayList)} function over all of its vertices. * @return {@link Winding#CCW} or {@link Winding#CW} */ public final Winding getWindingOfLastOutline() { diff --git a/src/jogl/classes/com/jogamp/graph/geom/Outline.java b/src/jogl/classes/com/jogamp/graph/geom/Outline.java index 522919cc6..a9ebd0346 100644 --- a/src/jogl/classes/com/jogamp/graph/geom/Outline.java +++ b/src/jogl/classes/com/jogamp/graph/geom/Outline.java @@ -78,8 +78,8 @@ public class Outline implements Comparable<Outline> { public Outline(final Outline src) { final int count = src.vertices.size(); vertices = new ArrayList<Vertex>(count); - winding = src.getWinding(); - dirtyWinding = false; + winding = Winding.CCW; + dirtyWinding = true; for(int i=0; i<count; i++) { vertices.add( src.vertices.get(i).copy() ); } @@ -138,7 +138,7 @@ public class Outline implements Comparable<Outline> { } /** - * Compute the winding of the {@link #getLastOutline()} using the {@link #area(ArrayList)} function over all of its vertices. + * Compute the winding of the {@link #getLastOutline()} using the {@link VectorUtil#area2d(ArrayList)} function over all of its vertices. * @return {@link Winding#CCW} or {@link Winding#CW} */ public final Winding getWinding() { @@ -149,7 +149,7 @@ public class Outline implements Comparable<Outline> { if( 3 > count ) { winding = Winding.CCW; } else { - winding = VectorUtil.getWinding( getVertices() ); + winding = VectorUtil.getWinding2d( getVertices() ); } dirtyWinding = false; return winding; diff --git a/src/jogl/classes/com/jogamp/math/VectorUtil.java b/src/jogl/classes/com/jogamp/math/VectorUtil.java index 716b63e47..7e66f0b4f 100644 --- a/src/jogl/classes/com/jogamp/math/VectorUtil.java +++ b/src/jogl/classes/com/jogamp/math/VectorUtil.java @@ -537,7 +537,7 @@ public final class VectorUtil { /** * Check if points are in ccw order * <p> - * Consider using {@link #getWinding(ArrayList)} using the {@link #area(ArrayList)} function over all points + * Consider using {@link #getWinding2f(ArrayList)} using the {@link #area2f(ArrayList)} function over all points * on complex shapes for a reliable result! * </p> * @param a first vertex @@ -552,29 +552,29 @@ public final class VectorUtil { /** * Compute the winding of the 3 given points * <p> - * Consider using {@link #getWinding(ArrayList)} using the {@link #area(ArrayList)} function over all points + * Consider using {@link #getWinding2f(ArrayList)} using the {@link #area2f(ArrayList)} function over all points * on complex shapes for a reliable result! * </p> * @param a first vertex * @param b second vertex * @param c third vertex * @return {@link Winding#CCW} or {@link Winding#CW} - * @see #getWinding(ArrayList) + * @see #getWinding2f(ArrayList) */ public static Winding getWinding(final Vert2fImmutable a, final Vert2fImmutable b, final Vert2fImmutable c) { return triAreaVec2d(a,b,c) > InCircleDThreshold ? Winding.CCW : Winding.CW ; } /** - * Computes the area of a list of vertices. + * Computes the area of a list of vertices via shoelace formula. * <p> * This method is utilized e.g. to reliably compute the {@link Winding} of complex shapes. * </p> * @param vertices * @return positive area if ccw else negative area value - * @see #getWinding(ArrayList) + * @see #getWinding2f(ArrayList) */ - public static float area(final ArrayList<? extends Vert2fImmutable> vertices) { + public static float area2f(final ArrayList<? extends Vert2fImmutable> vertices) { final int n = vertices.size(); float area = 0.0f; for (int p = n - 1, q = 0; q < n; p = q++) { @@ -586,17 +586,51 @@ public final class VectorUtil { } /** - * Compute the winding using the {@link #area(ArrayList)} function over all vertices for complex shapes. + * Compute the winding using the {@link #area2f(ArrayList)} function over all vertices for complex shapes. * <p> - * Uses the {@link #area(ArrayList)} function over all points + * Uses the {@link #area2f(ArrayList)} function over all points * on complex shapes for a reliable result! * </p> * @param vertices array of Vertices * @return {@link Winding#CCW} or {@link Winding#CW} - * @see #area(ArrayList) + * @see #area2f(ArrayList) */ - public static Winding getWinding(final ArrayList<? extends Vert2fImmutable> vertices) { - return area(vertices) >= 0 ? Winding.CCW : Winding.CW ; + public static Winding getWinding2f(final ArrayList<? extends Vert2fImmutable> vertices) { + return area2f(vertices) >= 0 ? Winding.CCW : Winding.CW ; + } + + /** + * Computes the area of a list of vertices via shoelace formula. + * <p> + * This method is utilized e.g. to reliably compute the {@link Winding} of complex shapes. + * </p> + * @param vertices + * @return positive area if ccw else negative area value + * @see #getWinding2d(ArrayList) + */ + public static double area2d(final ArrayList<? extends Vert2fImmutable> vertices) { + final int n = vertices.size(); + double area = 0.0; + for (int p = n - 1, q = 0; q < n; p = q++) { + final Vert2fImmutable pCoord = vertices.get(p); + final Vert2fImmutable qCoord = vertices.get(q); + area += (double)pCoord.x() * (double)qCoord.y() - (double)qCoord.x() * (double)pCoord.y(); + } + return area; + } + + /** + * Compute the winding using the {@link #area2f(ArrayList)} function over all vertices for complex shapes. + * <p> + * Uses the {@link #area2f(ArrayList)} function over all points + * on complex shapes for a reliable result! + * </p> + * @param vertices array of Vertices + * @return {@link Winding#CCW} or {@link Winding#CW} + * @see #area2d(ArrayList) + */ + public static Winding getWinding2d(final ArrayList<? extends Vert2fImmutable> vertices) { + return area2d(vertices) >= 0 ? Winding.CCW : Winding.CW ; } /** diff --git a/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2D.java b/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2D.java index d27b7a584..1c2f0b323 100644 --- a/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2D.java +++ b/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2D.java @@ -79,31 +79,24 @@ public class CDTriangulator2D implements Triangulator { } + /* pp */ static final boolean FixedWindingRule = true; + @Override public final void addCurve(final List<Triangle> sink, final Outline polyline, final float sharpness) { Loop loop = getContainerLoop(polyline); - final Winding winding = polyline.getWinding(); if( null == loop ) { // HEdge.BOUNDARY -> Winding.CCW - int edgeType; - boolean hole; - if( Winding.CCW != winding ) { - System.err.println("CDT2.add.xx.BOUNDARY: !CCW but "+winding); - // polyline.print(System.err); - if( false ) { - edgeType = HEdge.HOLE; - hole = true; - } else { - edgeType = HEdge.BOUNDARY; - hole = false; - polyline.setWinding(Winding.CCW); + final int edgeType = HEdge.BOUNDARY; + final boolean hole = false; + if( !FixedWindingRule ) { + final Winding winding = polyline.getWinding(); + if( Winding.CCW != winding ) { + System.err.println("CDT2.add.xx.BOUNDARY: !CCW but "+winding); + // polyline.print(System.err); + polyline.setWinding(Winding.CCW); // FIXME: Too late? } - } else { - edgeType = HEdge.BOUNDARY; - hole = false; } - // Too late: polyline.setWinding(winding); final GraphOutline outline = new GraphOutline(polyline); final GraphOutline innerPoly = extractBoundaryTriangles(sink, outline, hole, sharpness); // vertices.addAll(polyline.getVertices()); @@ -140,12 +133,14 @@ public class CDTriangulator2D implements Triangulator { Thread.dumpStack(); } } else { + final int edgeType = HEdge.HOLE; + final boolean hole = true; // HEdge.HOLE -> Winding.CW, but Winding.CCW is also accepted! // Winding.CW not required, handled in Loop.initFromPolyline(): polyline.setWinding(winding); final GraphOutline outline = new GraphOutline(polyline); - final GraphOutline innerPoly = extractBoundaryTriangles(sink, outline, true, sharpness); + final GraphOutline innerPoly = extractBoundaryTriangles(sink, outline, hole, sharpness); // vertices.addAll(innerPoly.getVertices()); - loop.addConstraintCurve(innerPoly); + loop.addConstraintCurve(innerPoly, edgeType); } } diff --git a/src/jogl/classes/jogamp/graph/curve/tess/Loop.java b/src/jogl/classes/jogamp/graph/curve/tess/Loop.java index d94ab775d..4961ce895 100644 --- a/src/jogl/classes/jogamp/graph/curve/tess/Loop.java +++ b/src/jogl/classes/jogamp/graph/curve/tess/Loop.java @@ -122,8 +122,8 @@ public class Loop { } return null; } - final Winding winding = outline.getOutline().getWinding(); final Winding edgeWinding = HEdge.BOUNDARY == edgeType ? Winding.CCW : Winding.CW; + final Winding winding = CDTriangulator2D.FixedWindingRule ? edgeWinding : outline.getOutline().getWinding(); if( HEdge.BOUNDARY == edgeType && Winding.CCW != winding ) { // XXXX @@ -135,7 +135,7 @@ public class Loop { HEdge lastEdge = null; if( winding == edgeWinding || HEdge.BOUNDARY == edgeType ) { - // Correct Winding or skipped CW -> CCW (no inversion possible here, too late ??) + // Correct Winding or skipped CW -> CCW (no inversion possible here, too late) final int max = vertices.size() - 1; for(int index = 0; index <= max; ++index) { final GraphVertex v1 = vertices.get(index); @@ -156,7 +156,7 @@ public class Loop { } lastEdge = edge; } - } else { // if( hasWinding == Winding.CW ) { + } else { // if( winding == Winding.CW ) { // CCW <-> CW for(int index = vertices.size() - 1; index >= 0; --index) { final GraphVertex v1 = vertices.get(index); @@ -182,13 +182,15 @@ public class Loop { return firstEdge; } - public void addConstraintCurve(final GraphOutline polyline) { + public void addConstraintCurve(final GraphOutline polyline, final int edgeType) { // GraphOutline outline = new GraphOutline(polyline); /**needed to generate vertex references.*/ - if( null == initFromPolyline(polyline, HEdge.HOLE) ) { + if( null == initFromPolyline(polyline, edgeType) ) { // 'usually' HEdge.HOLE return; } - addConstraintCurveImpl(polyline); + if( HEdge.HOLE == edgeType ) { + addConstraintCurveImpl(polyline); + } } private void addConstraintCurveImpl(final GraphOutline polyline) { final GraphVertex v3 = locateClosestVertex(polyline); |