clipper2-sys 1.0.0

Polygon Clipping and Offsetting (Clipper2 wrapper)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

/*******************************************************************************
* Author    :  Angus Johnson                                                   *
* Date      :  11 February 2023                                                *
* Website   :  https://www.angusj.com                                          *
* Copyright :  Angus Johnson 2010-2023                                         *
* License   :  https://www.boost.org/LICENSE_1_0.txt                           *
*******************************************************************************/

using System;
using System.IO;
using System.Reflection.Metadata.Ecma335;
using Clipper2Lib;

namespace ClipperDemo1
{
  public class Application
  {
    ////////////////////
    public const int edgeCount      = 19;
    public const int displayWidth   = 500;
    public const int displayHeight  = 500;
    public const int rectInsetDist  = 200;
    ////////////////////
    public static void Main()
    {
      // although RectClip isn't really designed for 
      // complex  self-intersecting polygons, it still 
      // handles them pretty well.      
      DoRandomPoly(/* true == repeat last random */);
    }

    public static bool SaveBackup(string filename, Paths64 sub, Paths64 clp)
    {
      StreamWriter writer;
      try
      { writer = new StreamWriter(filename, false); }
      catch { return false; }

      foreach (Point64 pt in sub[0])
        writer.Write("{0},{1} ", pt.X, pt.Y);
      writer.Write("\r\n");
      foreach (Point64 pt in clp[0])
        writer.Write("{0},{1} ", pt.X, pt.Y);
      writer.Write("\r\n");
      writer.Close();
      return true; 
    }

    public static bool RestoreBackup(string filename, out Paths64 sub, out Paths64 clp)
    {
      sub = null;
      clp = null;
      if (!File.Exists(filename)) return false;
      try
      {
        StreamReader reader = new StreamReader(filename);
        string s = reader.ReadLine();
        sub = ClipperFileIO.PathFromStr(s);
        s = reader.ReadLine();
        clp = ClipperFileIO.PathFromStr(s);
      }
      catch { return false; }
      return true;
    }

    public static uint RandomColor(Random rc)
    {
      return (uint) (rc.Next() | 0xBF000000);
    }

    public static void DoRandomPoly(bool loadPrevious = false)
    {
      Random rand = new();
      Paths64 sub = new Paths64(), clp = new Paths64(), sol;
      Rect64 rec = new(rectInsetDist, rectInsetDist,
        displayWidth - rectInsetDist, displayHeight - rectInsetDist);

      if (loadPrevious)
      {
        if (!RestoreBackup(".\\backup.txt", out sub, out clp)) return;
        rec = Clipper.GetBounds(clp);
      }
      else      
      {
        clp.Add(rec.AsPath());
        sub.Add(MakeRandomPath(displayWidth, displayHeight, edgeCount, rand));
        if (!SaveBackup(".\\backup.txt", sub, clp)) return;
      }

      /////////////////////////////////////////////////
      sol = Clipper.RectClip(rec, sub);
      /////////////////////////////////////////////////

      SvgWriter svg = new (FillRule.NonZero);
      SvgUtils.AddSubject(svg, sub);
      SvgUtils.AddClip(svg, clp);

      //SvgUtils.AddSolution(svg, sol, false);
      if (sol.Count > 0)
      {
        double frac = 1.0 / sol.Count;
        double cumFrac = frac;
        foreach (Path64 path in sol)
        {
          uint c = RandomColor(rand); 
          cumFrac += frac;
          uint c2 = (c & 0xFFFFFF) | 0x20000000;
          svg.AddClosedPath(path, c2, c, 1.2);
        }
      }
      svg.SaveToFile("../../../rectclip.svg", 800, 600, 20);
      ClipperFileIO.OpenFileWithDefaultApp("../../../rectclip.svg");
    }

    private static Point64 MakeRandomPt(int maxWidth, int maxHeight, Random rand)
    {
      long x = rand.Next(maxWidth);
      long y = rand.Next(maxHeight);
      return new Point64(x, y);
    }

    public static Path64 MakeRandomPath(int width, int height, int count, Random rand)
    {
      Path64 result = new(count);
      for (int i = 0; i < count; ++i)
        result.Add(MakeRandomPt(width, height, rand));
      return result;
    }

  } //end Application

} //namespace