ZCallback

This property is only exposed when the pre-processor directive USINGZ has been defined. If this is the case, an Int64 Z member will be included in the definitions of both the Point64 and PointD classes. (This Z member is for user defined data and has nothing to do with 3D clipping.)

While most vertices in clipping solutions will correspond to input (subject and clip) vertices, there will also be new vertices wherever these edges intersect. This callback facilitates assigning Z values at these intersections. To aid the user in determining appropriate Z values, the function receives four vertices that will be the bottoms and tops of these intersecting edges. (Subject vertices will always be the first two parameters in the callback unless the intersection is between two clip paths.)

In the following examples, use the Z callback to flag intersections (Z = 1) and differentiate them from non-intersection vertices (default Z = 0).

C++ Example:

  using namespace Clipper2Lib;
  
  // option1 - static callback function
  static void myZCB(const Point64& e1bot, const Point64& e1top,
    const Point64& e2bot, const Point64& e2top, Point64& pt)
  {
    pt.z = 1;
  }
    
  // option2 - class member callback function
  class MyClass {
  public:
    void myZCB(const Point64& e1bot, const Point64& e1top,
      const Point64& e2bot, const Point64& e2top, Point64& pt)
    {
      pt.z = 1;
    }
  };
  
  
  int main()
  {
    PathsD subject, clip, solution;
    //fill subject and clip paths here
    subject.push_back(MakePath(
      {100, 50, 10, 79, 65, 2, 65, 98, 10, 21}));
    
    //option 1: static function assignment
    Clipper64 c = Clipper64;
    c.SetZCallback(myZCB);
    
    /* 
    // option 2: class member function assignment
    MyClass mc;    
    Clipper64 c = Clipper64;
    c.SetZCallback(
      std::bind(&MyClass::myZCB, mc, std::placeholders::_1,
        std::placeholders::_2, std::placeholders::_3,
        std::placeholders::_4, std::placeholders::_5));
    */
        
    c.Execute(ClipType::Union, FillRule::NonZero, solution);
    
    // display result
    SvgWriter svg;
    SvgAddSubject(svg, subject, FillRule::NonZero);
    SvgAddSolution(svg, solution, FillRule::NonZero, true);
    // draw a red circle around any intersections
    for (const auto& sol_path : solution)
    {
      if (sol_path.empty()) continue;
      PathsD ellipses;
      const double r = 3.0;
      for (const Point64& pt : sol_path)
        if (pt.z) ellipses.push_back(
          Ellipse(RectD(pt.x - r, pt.y - r, pt.x + r, pt.y + r), 11));
      svg.AddPaths(ellipses, false, 
        FillRule::NonZero, 0x20FF0000, 0xFFFF0000, 1, false);
    }
    SvgSaveToFile(svg, "usingz_64.svg", 600, 600, 20);        
  }

C# Example:

    using Clipper2Lib;

    public class Application
    {
      public class MyCallbacks
      {
        public void MyCallback64(Point64 bot1, Point64 top1,
          Point64 bot2, Point64 top2, ref Point64 intersectPt)
        {
          intersectPt.Z = 1;
        }
      }

      public static void Main()
      {
        Paths64 solution = new Paths64();
        Paths64 subject = new Paths64();
        subject.Add(Clipper.MakePath(
          new int[] { 100, 50, 10, 79, 65, 2, 65, 98, 10, 21 }));

        Clipper64 c64 = new Clipper64();
        MyCallbacks cb = new MyCallbacks();
        c64.ZCallback = cb.MyCallback64;
        c64.AddSubject(subject);
        c64.Execute(ClipType.Union, FillRule.NonZero, solution);

        SvgWriter svg= new SvgWriter();
        SvgUtils.AddSubject(svg, subject);
        SvgUtils.AddSolution(svg, solution, false);
        // draw a red circle around any intersections
        for (int i = 0; i < solution[0].Count; i++)
        {
          if (solution[0][i].Z == 1)
            svg.DrawCircle(solution[0][i].X, solution[0][i].Y, 
              4, 1, 0x20FF0000, 0xFFFF0000);
        }
        svg.SaveToFile("usingz.svg", 400, 400);
      }

Clipper64.ZCallback

See Also