Using toJava2D() with group shapes

[istinnstudio]

Hi..
I am trying to figure how to implement PGS calculations in native Path2D in pure Java, not processing. Not having seen any relative examples I have made a simple method to triangulate a path2D just to see how things work but I get an error in casting, it seems that there is an other internal conversion taking place using JTS library. The question is how to implement the intermediate conversion as I guess the "Shape interface" and Path2D needs casting. The example is random, it would be nice if have some basic examples for other geometric calculations also. The code is as simple as it can get:

    public Path2D performDelaunayTriangulationUsingPGS(Path2D path) {
       PShape pshape = new PShape();  // or PShape.GEOMETRY it seems like the constructor is dependent on JTS
       pshape = fromJava2D(path); // Convert Path2D to PShape
        // Perform Delaunay Triangulation using the PGS library or other implementation
       pshape = delaunayTriangulation(pshape);
        // Convert the triangulated PShape back to Path2D
        Path2D triangulatedPath =  (Path2D) toJava2D(pshape); // casting with error
        return triangulatedPath;
    }
}

SEVERE: null
java.lang.ClassCastException: class org.locationtech.jts.awt.GeometryCollectionShape cannot be cast to class java.awt.geom.Path2D (org.locationtech.jts.awt.GeometryCollectionShape is in unnamed module of loader 'app'; java.awt.geom.Path2D is in module java.desktop of loader 'bootstrap')

[micycle1]

The output of the triangulation is a group-type PShape, which consists of multiple child shapes, each representing a triangle in the triangulated geometry.

The toJava2D() method converts group shapes (multipolygons) to a JTS GeometryCollectionShape type, which implements java.awt.shape. However, since the original shape contains multiple paths, it cannot be directly converted to a Path2D.

To work with the triangulation, you have two options:

1. Cast the output of toJava2D() to a (GeometryCollectionShape) instead, and then use its getPathIterator() method...
2. Iterate over the child PShapes of the triangulation. For each child, you can call toJava2D() that should return a Path2D representing the individual triangle. By iterating over all the child shapes, you can obtain separate Path2D objects for each triangle and work with them individually.

[istinnstudio]

thanks! for the reply, it is clear now, it seems a bit more complicated than I initially have thought, but I will give it a try, probably by creating lists of path2D objects through GeometryCollectionShape. If I will figure out a solution I will post it here.

[istinnstudio]

A simple example in native java using Path2D and PGS 1.4.0, it seems for simple polygons it can be used without using jts GeometryCollectionShape, but it also renders fine with jts, I do not know if jts is necessary for more complex polygon structures. I provide the code for reference and review:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.geom.Path2D;
import java.awt.geom.PathIterator;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;
import static micycle.pgs.PGS_Conversion.toJava2D;
import processing.core.PShape;
import processing.core.PVector;

public class PShapeGroupToPath2DExample extends JPanel {
    private final List<Path2D> pathList = new ArrayList<>();

    public PShapeGroupToPath2DExample() {
        // Create a PShape group
        PShape groupShape = new PShape(PShape.GROUP);

        // Add a child rectangle
        PShape rectangle = new PShape(PShape.PATH);
        rectangle.beginShape();
        rectangle.vertex(50, 50);
        rectangle.vertex(150, 50);
        rectangle.vertex(150, 100);
        rectangle.vertex(50, 100);
        rectangle.endShape(PShape.CLOSE);
        groupShape.addChild(rectangle);

        // Add a child triangle
        PShape triangle = new PShape(PShape.PATH);
        triangle.beginShape();
        triangle.vertex(200, 150);
        triangle.vertex(250, 50);
        triangle.vertex(300, 150);
        triangle.endShape(PShape.CLOSE);
        groupShape.addChild(triangle);

        
                       // Example list of PVectors
        List<PVector> points = List.of(
            new PVector(100, 100),
            new PVector(300, 100),
            new PVector(300, 300),
            new PVector(100, 300),
            new PVector(100, 100)
        );

        // Create the PShape
        PShape shapeFromPVectorsList = createPShapeFromPVectors(points, true); 
        groupShape.addChild(shapeFromPVectorsList);
   
        boolean usePGSFunctions = true;
        if (usePGSFunctions) {
             processing.core.PShape pShapeNGon = micycle.pgs.PGS_Construction.createRandomPolygon(5,shapeFromPVectorsList.getWidth(), shapeFromPVectorsList.getHeight(), 1000);
       groupShape.addChild(pShapeNGon); 
        //    processing.core.PShape pShapeNGon = micycle.pgs.PGS_Construction.createRandomPolygon(5,1d,1d); 
  processing.core.PShape pShapeSnowFlake = micycle.pgs.PGS_Construction.createKochSnowflake(shapeFromPVectorsList.getWidth(), shapeFromPVectorsList.getHeight(), 6);
groupShape.addChild(pShapeSnowFlake);
       }
   
        // Iterate over children and convert each to Path2D
        for (int i = 0; i < groupShape.getChildCount(); i++) {
            PShape child = groupShape.getChild(i);

            // Convert child PShape to Java2D Shape
            Shape java2DShape = toJava2D(child);
            if (java2DShape != null) {
                // Convert Shape to Path2D and add to the list
                Path2D path = ShapeToPath2D.convertShapeToPath2D(java2DShape);
                pathList.add(path);
            }
        }
    }
    
    
    // Method to create a PShape from a list of PVectors
    public static PShape createPShapeFromPVectors(List<PVector> points, boolean closeShape) {
        if (points == null || points.isEmpty()) {
            throw new IllegalArgumentException("Points list cannot be null or empty.");
        }

        PShape shape = new PShape(); // Initialize a PShape instance
        shape.setFamily(PShape.PATH); // Define it as a PATH
        shape.beginShape();

        // No need for fill and stroke here

        // Add vertices from the PVector list
        for (PVector point : points) {
            shape.vertex(point.x, point.y);
        }

        if (closeShape) {
            shape.endShape(PShape.CLOSE);
        } else {
            shape.endShape();
        }

        return shape;
    }

    

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;

        // Set rendering hints for better quality
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);


        for (Path2D path : pathList) {
                   // Draw all paths

             g2d.setColor(new Color(50,0,0,64));
             g2d.fill(path);
             g2d.setColor(Color.RED);
            g2d.draw(path);
        }

        // Add some text for clarity
        g2d.setColor(Color.BLACK);
        g2d.drawString("Rendering child shapes of the PShape group", 50, 400);
    }

    public static void main(String[] args) {
        // Create a JFrame to display the JPanel
        JFrame frame = new JFrame("PShape Group to Path2D Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(500, 500);
        frame.setContentPane(new PShapeGroupToPath2DExample());
        frame.setVisible(true);
    }

    // Helper class to convert Shape to Path2D
    public static class ShapeToPath2D {
        public static Path2D convertShapeToPath2D(Shape shape) {
            Path2D path = new Path2D.Double();
            PathIterator iterator = shape.getPathIterator(null);

            double[] coords = new double[6];
            while (!iterator.isDone()) {
                int segmentType = iterator.currentSegment(coords);
                switch (segmentType) {
                    case PathIterator.SEG_MOVETO:
                        path.moveTo(coords[0], coords[1]);
                        break;
                    case PathIterator.SEG_LINETO:
                        path.lineTo(coords[0], coords[1]);
                        break;
                    case PathIterator.SEG_QUADTO:
                        path.quadTo(coords[0], coords[1], coords[2], coords[3]);
                        break;
                    case PathIterator.SEG_CUBICTO:
                        path.curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]);
                        break;
                    case PathIterator.SEG_CLOSE:
                        path.closePath();
                        break;
                    default:
                        throw new IllegalStateException("Unexpected value: " + segmentType);
                }
                iterator.next();
            }
            return path;
        }
    }
}

.. using JTS:

...

  // Create GeometryCollectionShape and add individual geometries
        GeometryCollectionShape geometryCollectionShape = new GeometryCollectionShape();
        geometryCollectionShape.add((Shape) PGS_Conversion.toJava2D(groupShape)); // Add geometry to the collection

        // Use getPathIterator to convert the geometry into Path2D
        PathIterator pathIterator = geometryCollectionShape.getPathIterator(null);
        Path2D path = new Path2D.Double();

        while (!pathIterator.isDone()) {
            float[] coords = new float[6];
            int type = pathIterator.currentSegment(coords);

            switch (type) {
                case PathIterator.SEG_MOVETO:
                    path.moveTo(coords[0], coords[1]);
                    break;
                case PathIterator.SEG_LINETO:
                    path.lineTo(coords[0], coords[1]);
                    break;
                case PathIterator.SEG_CLOSE:
                    path.closePath();
                    break;
            }

            pathIterator.next();
        }

        pathList.add(path); // Store the resulting Path2D for rendering

...