Hi, in the 'Illustrations' part in the README.MD file there are many examples. I think this examples are obtained using the library. Why not expand the examples library with the code used to get the images shown? I think this could be very useful for the people approaching the library,

when working with offsets for CNC paths generation, I feel greatly limited with two existing methods: PGS_Contour.offsetCurvesInwards and PGS_Contour.offsetCurvesOutwards. First one generates uncontrollable number of offsets, and it's impossible to know if any subsequent offset consists of multiple children or not (I just get outlines for subsequent steps, together with their children in one set, unable to differentiate them).
The other method provides control on number of curves to offset, so I can potentially generate them one by one, but works only outside :-) no way to cheat it, since it only accepts positive offset distances.
The only way to control it fully would be to use underlying (invisible) method PGS_Contour.offsetCurves(...) but it is currently private - please either expose it, or add another method that gives more control.

Hi

Lovely library! Seems to work great when using it the default Processing way in draw().

However in my setup I maintan a stage where I can manage all the PShapes in the scene and draw them with their shape.draw(PGraphics) method (I'm passing the PApplet.g PGraphics to it).

This works great when I create shapes with createShape(), but when using methods from PGS I can't get the shapes to show at all.

I suspect - although it's really just a guess - it's since PGS creates new shapes with new PShape() and not createShape() - the latter sets the internal protected PGraphics g in the PShape - the constructor of PShape does not.

Or perhaps I'm way off.

Any thoughts on how I could investigate this further - or perhaps even a way to overcome it?

All the best, Thomas

Hello,

Your library is (almost) a life savior for me, thanks!

I have an issue with a shape that I want to create. I want so subtract several rectangles from a circle, like so:

import micycle.pgs.*;

void setup() {
  background(255);
  size(800, 600);
  smooth();
}

void draw() {
  fill(#505050);
  noStroke();
  translate(400, 300);
 
  // create a donut
  var outer = createShape(ELLIPSE, 0, 0, 200, 200);
  var inner = createShape(ELLIPSE, 0, 0, 100, 100);
  outer = PGS_ShapeBoolean.subtract(outer, inner);
  
  // display on left side
  shape(outer, -250, 0);
  
  // make a first hole
  var hole1 = createShape(RECT, 0, -20, 200, 40);
  outer = PGS_ShapeBoolean.subtract(outer,hole1);
  
  // display in the center
  shape(outer);

  // make a second hole
  var hole2 = createShape(RECT, 0, -20, 200, 40);
  hole2.rotate(PI/3);
  outer = PGS_ShapeBoolean.subtract(outer,hole2);
  
  // display on right side
  shape(outer, 250, 0);
}

I would expect the result to be the same as the second shape + one more hole, but it loses its color.
Is there a limitation in subtractions, or did I discover a bug?

Thank you!

Not sure if this is an issue, but I ran into a nullpointer exception when I was trying to slice a custom PShape using the P2D renderer.
PShapes created in this renderer are for some reason of the type PShapeOpenGL which I think PGS can't handle, right?. Leaving the renderer option blank results in no errors.

Hi @micycle1, I'm using PGS to do hidden line removal for my old Roland plotter. The idea is that because the plotter has no concept of .fill(), I'm progressively subtracting / merging shapes from each other.

It seems to work for the most part, but I intermittently get an illegal arg exception - Invalid number of points in LinearRing (found 2 - must be 0 or >= 4) when calling PGS_ShapeBoolean.subtract()

I've tried to mock this up in the below code - it will stop at the offending PShape and draw in pink. All the 'valid' PShapes above that one will be drawn in black.

Hoping for some pointers please, maybe I'm misusing the subtract / shape group ? Apologies in advance, I'm new to both Java & Processing!

import micycle.pgs.*;

void setup() 
{
  size(3000, 1800);
}

void draw()
{  
  noLoop();
  ArrayList<RandomPoly> polys = new ArrayList<RandomPoly>();
  int max = 20;

  //create objects, randomly placed over each other
  for (int i = 0; i < max; i++)
  {
    boolean intersectsPrevious = false;
    while (!intersectsPrevious)
    {
      RandomPoly p = new RandomPoly();

      if (i == 0)
        intersectsPrevious = true;
      else 
      intersectsPrevious = PGS_ShapePredicates.intersect(polys.get(i - 1).shape, p.shape);

      if (intersectsPrevious)
      {
        polys.add(p);
      }
    }
  }

  //now plot them in reverse order
  PShape group = polys.get(polys.size() - 1).shape;
  for (int i = polys.size() - 2; i >= 0; i--)
  {
    RandomPoly background = polys.get(i);
    PShape merged = mergeShapes(background.shape, group);

    if (merged == null)
    {
      shape(background.shape); //draw invalid shape in pink and stop
      break;
    } else
    {
      group = merged;
    }
  }

  PGS_Conversion.setAllStrokeColor(group, color(0), 1);
  shape(group);
}

//Here we are taking a background and foreground shape, and making a group of out of 
// 1 - the foreground shape, and 
// 2 - the subtraction of foreground from background
//This allows us to send to a plotter that has no concept of fill() 
PShape mergeShapes(PShape backgroundShape, PShape foregroundShape)
{
  PShape g = createShape(GROUP);

  g.addChild(foregroundShape);
  try
  {
    g.addChild(PGS_ShapeBoolean.subtract(backgroundShape, foregroundShape));
  }
  catch(Exception e) //java.lang.IllegalArgumentException: Invalid number of points in LinearRing (found 2 - must be 0 or >= 4)
  {
    print(e);
    return null;
  }

  return g;
}

class RandomPoly
{
  PShape shape;
  PVector pos;

  RandomPoly()
  {
    float xStart = randomGaussian() * 200 + width / 2;
    float yStart = randomGaussian() * 200 + height / 2;

    pos = new PVector(xStart, yStart);
    shape = PGS_Transformation.translate(
      PGS_Construction.createRandomPolygon(4, width / 4, height / 4), 
      pos.x, 
      pos.y);
  }
}

In converting from PShapes to Geometries, it was assumed until now that in shapes having multiple contours, every contour beyond the first must represent a hole.

Here's one counter-example to this assumption, where each band of the letter is not a child shape, but a contour:

To convert such shapes properly the code must check the winding of each contour: if it winds in the opposing (usually counter-clockwise) direction to the first contour, it represents a hole; if it winds in the same direction as the first contour, it represents another shape feature and should be preserved.

Hi! Amazing collection of algorithms!! :)

An idea: I was thinking that it would be very nice if when clicking on one of the gifs or pngs it would jump to the source code of the program that created it (instead of linking to the original image file).

Otherwise one may see something they would like to play with, but how to find the related code?

Cheers!

When I used with P2D mode. I've got always a NullPointerException that block the script.

Look at JTS' new OffsetCurve class and determine whether it should replace PGS' current offset curves solution (based on repeated buffering).
locationtech/jts#810

Hi,

i have an array of many PShapes created from tiling an initial square repeatedly using PGS_Processing.slice(). Within that array i pick two neigbouring shapes for unision via the PGS_ShapeBoolean.union(PShape,PShape) function. This works like a charm most of the time and returns a PShape that combines the areas of the two input shapes. Sometimes it doesen't want to do so and instead just returns a PShape that is identical to the second input argument of union(PShape,PShape).

What's confusing is that i cannot tell the difference between cases where it works and where it doesnt. The input shapes look valid to me in both cases...

Not shure if this is a bug or if you can point me towards common issues with unision that i should look into...

Thx for a reply and thanks for sharing this awesome library!

Hi Micycle,

This seems like a great library thanks! I was testing the boolean functionality with two simples shapes an ellipse and a rectangle but it didn't gave me the result I was expecting. It seems the PShapes change positions when united with each other? The expected behaviour would be a unified shape at the same position I'd say. Thought?

import micycle.pgs.*;

void setup() {
 size(595, 842, P2D);
}

void draw() {
  background(0);

  PShape shapeOne = createShape(ELLIPSE, 100, 100, width * 0.4, width * 0.4);
  shapeOne.setFill(#ffff00);

  PShape shapeTwo = createShape(RECT, 150, 150, width * 0.5, width * 0.5);
  shapeTwo.setFill(#00ff00);

  shape(shapeOne);
  shape(shapeTwo);

  PShape union = PGS_ShapeBoolean.union(shapeOne, shapeTwo);
  union.setFill(#ff0000);
  translate(0, 300);
  shape(union);

}

In yellow and green the source shapes. In red the unified shape, slightly translated on the y-axis.

hi, thanks again for this library
two examples show errors:
voronoiCutOut line 68: The function shapeIntersections(PShape, PShape) does not exist.
intersectionsBoids line 32: The function lineSegmentIntersections(List) does not exist.

all others works well here (macos big sur -M1)

i think i will spend a lot of time with this (;
i let you know if see something else
thanks