Recursive Offsetting of Closed Polylines With Holes Until "Complete"

[bVess12]

I'm attempting to recursively offset polygons until they reach "completion." I'm having a hard time wrapping my brain around the specifics of what constitutes "completion" and am wondering if there's some built-in way to achieve this using PolyTrees or orientation or something.

Please note than in all examples below I am aware these need to be divided into sets of polylines with holes. I have only shown the offset results of the groups in each giving me problems.

Example 1 (Problem):
My polyline with holes offsets inward until it eventually results in only one polyline. Continuing to inwardly offset this polygon returns the incorrect result shown below:

Example 1 (Desired Solution):
Here is what I would LIKE to achieve. I got this by stopping recursion after the result of the inflation has fewer polylines than the input paths

Example 2 (Problem):
Unfortunately, this method doesn't work in all situations. As shown below, if I prevent recursion when the number of polylines is reduced, I get this result

Example 2(Desired Solution):
Here is what I would LIKE to achieve.

I'm sure I must be missing something simple. I'm essentially trying to generate the rabbit example shown on your front page! Any and all help is appreciated.

[AngusJohnson]

bird2.svg.zip

#include "clipper2/clipper.h"
#include "../../Utils/clipper.svg.utils.h"
using namespace Clipper2Lib;

void AppendPaths(PathsD& paths, const PathsD& extra)
{
  paths.insert(std::end(paths), extra.cbegin(), extra.cend());
}

int main() {
  double delta = -2.50;
  SvgReader svg_reader;
  svg_reader.LoadFromFile("c:\\temp\\bird2.svg");
  PathsD paths = svg_reader.GetPaths(), solution;
  do 
  {
    AppendPaths(solution, paths);
    paths = InflatePaths(paths, delta, JoinType::Round, EndType::Polygon);
    paths = SimplifyPaths(paths, 0.25);
    if(delta < -1.0) delta += 0.033;
  } while (paths.size());
  std::string filename = "c:\\temp\\bird3.svg";
  SvgWriter svg;
  SvgAddSolution(svg, solution, FillRule::EvenOdd, false);
  SvgSaveToFile(svg, filename, 600, 600);
  return 0;
}

[bVess12]

`

      private const int PRECISION = 1000;
      private static int toPath(double val) => (int)(PRECISION * val);
      static float fromPath(double val) => (float)val / PRECISION;
     public static Polyline3D[]? Offset(this IEnumerable<Polyline3D> origin, double offset, bool recurse = true) {
        var results = new List<Polyline3D>();

        //Add each of the polylines to the path to offset
        var _paths = new Paths64();
        foreach (var p in origin) {
            if (!p.IsClosed)
                throw new Exception("Not implemented, only closed Polylines can be offset");

            var polyPath = new Path64();
            polyPath.AddRange(
                p.GetAllPoints().Select(p =>
                    new Point64(toPath(p.X), toPath(p.Y))));

            _paths.Add(polyPath);
        }

        while (_paths.Any())
        {
            //Offset the paths
            _paths = Clipper.InflatePaths(
                _paths,
                toPath(offset),
                joinType: JoinType.Miter,
                endType: EndType.Polygon);
            if (_paths == null || _paths.Count == 0)
                break;
            _paths = Clipper.SimplifyPaths(_paths, 2.5);
            results.AddRange(
                _paths.Select(p =>
                    new Polyline3D(
                        p.Select(p2 => 
                            new Vector3(fromPath(p2.X), fromPath(p2.Y), 0f)), true)));
            if (!recurse)
                break;
        }

        return results.ToArray();
    }`

Thank you so much for the reply! But I'm getting the above results when I do what I believe is a reasonable translation into c#. Am I doing something wrong? Am I just using the wrong epsilon value?

Also, my main issue is shown in example 1: The outer "ring" has its inflated paths converge from two separate inwardly-moving rings into one polyline. Because I don't know how to recognize that one resulting polyline as the final result of the offset, I keep recursively offsetting until it doubles back on itself and collapses all the way to the center. Is there a way to distinguish when the offsetting is "complete?"