Suggestion: Make intersection callback delegate available if not using z

[SebastianDirks]

I'm using clipper2 in C#. I understand that the reason for using conditional compilation for usingZ is the performance drawback of having structs with 3 longs instead of 2 for the points.

The use cases I currently require usingZ for are:

1. Identify intersection points created by clipper during boolean operations
2. Identfiy which source polygons were clipped to form an output polygon

Both use cases could also be easily solved using only the intersection callback delegte with X/Y points, using it to fill custom data structures. UsingZ might still be valid for some use cases were additional data needs to be referenced on point to point basis.

So my proposal is to make the z callback delegate available as well in the normal X/Y compilation, maybe calling it IntersectionDelegate? With it defaulting to null and doing nothing. The performance impact of the null check for the delegate should be minimal.

[AngusJohnson]

I'm not sure what you're suggesting.
Could you be more explicit (with code 😁).
Cheers.

[SebastianDirks]

I will try, here are some snippets in C#:
For the delegate:

#if USINGZ
    public delegate void ZCallback64(Point64 bot1, Point64 top1,
        Point64 bot2, Point64 top2, ref Point64 intersectPt);

    public long DefaultZ { get; set; }
    protected ZCallback64? _zCallback;
#else
    public delegate void IntersectionCallback64(Point64 bot1, Point64 top1,
        Point64 bot2, Point64 top2, ref Point64 intersectPt);
    protected IntersectionCallback64? _intersectionCallback;
#endif

for the code calling the delegate:

#if USINGZ
    private bool XYCoordsEqual(Point64 pt1, Point64 pt2)
    {
      return (pt1.X == pt2.X && pt1.Y == pt2.Y);
    }
    
    private void SetZ(Active e1, Active e2, ref Point64 intersectPt)
    {
      if (_zCallback == null) return;

      // prioritize subject vertices over clip vertices
      // and pass the subject vertices before clip vertices in the callback
      if (GetPolyType(e1) == PathType.Subject)
      {
        if (XYCoordsEqual(intersectPt, e1.bot))
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, e1.bot.Z);
        else if (XYCoordsEqual(intersectPt, e1.top))
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, e1.top.Z);
        else if (XYCoordsEqual(intersectPt, e2.bot))
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, e2.bot.Z);
        else if (XYCoordsEqual(intersectPt, e2.top))
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, e2.top.Z);
        else
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, DefaultZ);
        _zCallback(e1.bot, e1.top, e2.bot, e2.top, ref intersectPt);
      }
      else
      {
        if (XYCoordsEqual(intersectPt, e2.bot))
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, e2.bot.Z);
        else if (XYCoordsEqual(intersectPt, e2.top))
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, e2.top.Z);
        else if (XYCoordsEqual(intersectPt, e1.bot))
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, e1.bot.Z);
        else if (XYCoordsEqual(intersectPt, e1.top))
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, e1.top.Z);
        else
          intersectPt = new Point64(intersectPt.X, intersectPt.Y, DefaultZ);
        _zCallback(e2.bot, e2.top, e1.bot, e1.top, ref intersectPt);
      }
    }
#else
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void IntersectCallback(Active e1, Active e2, ref Point64 intersectPt)
    {
      if (_intersectionCallback == null) return;
      // prioritize subject vertices over clip vertices
      // and pass the subject vertices before clip vertices in the callback
      var pointOut = intersectPt;//copy point
      if (GetPolyType(e1) == PathType.Subject)
      {
        _intersectionCallback(e1.bot, e1.top, e2.bot, e2.top, ref pointOut);
      }
      else
      {
        _intersectionCallback(e2.bot, e2.top, e1.bot, e1.top, ref pointOut);
      }
    }
#endif

for calls where intersections are created:

#if USINGZ
          SetZ(ae1, ae2, ref resultOp.pt);
#else
          IntersectCallback(ae1, ae2, ref resultOp.pt);
#endif

I'm not sure if I know enough to do all the other places where intersections are created.

[SebastianDirks]

I might actually be easier to simply remove the conditional compilation and always call SetZ (rename it?), and just have the different method implementations for calling the delegate, one with z and one without.

[AngusJohnson]

I'm not (yet) persuaded that there's more general interest in using this callback without requiring the Z compilation.
(Why you don't simply use the Z compilation?)
Finally, since this is a suggestion and not an Issue I've moved this thread to Discussion.