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
133

#include <cstdlib>
#include <string>
#include <chrono> 
 
#include "clipper2/clipper.h"
#include "../../Utils/clipper.svg.utils.h"
#include "../../Utils/ClipFileLoad.h"
#include "../../Utils/ClipFileSave.h"
#include "../../Utils/Timer.h"

using namespace Clipper2Lib;

const int display_width = 800, display_height = 600;

void RecheckLastBenchmark(bool use_polytree);
void DoBenchmark(int edge_cnt_start, int edge_cnt_end, 
  int increment, bool test_polytree = false);
Path64 MakeRandomPoly(int width, int height, unsigned vertCnt);
void System(const std::string &filename);

int main()
{  
  bool test_polytree = false;//true;// 
  srand((unsigned)time(0));
  DoBenchmark(1000, 7000, 1000, test_polytree);
  //RecheckLastBenchmark(test_polytree);

  std::cout << std::endl;
//#ifdef _DEBUG
  std::string s;
  std::cout << "Press Enter to continue" << std::endl;
  std::getline(std::cin, s);
//#endif
  return 0;
}

void RecheckLastBenchmark(bool use_polytree)
{
  ClipType ct;
  FillRule fr;

  Paths64 subject, subj_open, clip, solution;
  int64_t area, count;
  PolyTree64 polytree;

  std::ifstream test("benchmark_test.txt");
  if (!test.good())
  {
    std::cout << "Unable to find or open test file." << std::endl;
    return;
  }

  bool success = false;
  std::cout << "Checking last benchmark ..." << std::endl;
  LoadTestNum(test, 1, subject, subj_open, clip, area, count, ct, fr);
  if (use_polytree)
  {
    BooleanOp(ct, fr, subject, clip, polytree);
    success = polytree.Count();
  }
  else
  {
    solution = BooleanOp(ct, fr, subject, clip);
    success = solution.size();
  }
  if (success)
    std::cout << "It's OK." << std::endl;
  else
    std::cout << "It failed (again)." << std::endl;
}

inline Path64 MakeRandomPoly(int width, int height, unsigned vertCnt)
{
  Path64 result;
  result.reserve(vertCnt);
  for (unsigned i = 0; i < vertCnt; ++i)
    result.push_back(Point64(rand() % width, rand() % height));
  return result;
}

void DoBenchmark(int edge_cnt_start, int edge_cnt_end, 
  int increment, bool test_polytree)
{
  ClipType ct = ClipType::Intersection;
  FillRule fr = FillRule::NonZero;//EvenOdd;//Positive;//

  Paths64 subject, clip, solution;
  PolyTree64 polytree;
  std::cout << std::endl << "Complex Polygons Benchmark:  " << std::endl;
  for (int i = edge_cnt_start; i <= edge_cnt_end; i += increment)
  {
    subject.clear();
    clip.clear();
    subject.push_back(MakeRandomPoly(800, 600, i));
    clip.push_back(MakeRandomPoly(800, 600, i));
    SaveTest( "benchmark_test.txt", false, &subject, nullptr, &clip, 0, 0, ct, fr);

    std::cout << "Edge Count: " << i << " = ";
    {
      if (test_polytree)
      {
        polytree.Clear();
        Timer t;
        BooleanOp(ct, fr, subject, clip, polytree);
        if (!polytree.Count()) break;
      }
      else
      {
        Timer t;
        solution = BooleanOp(ct, fr, subject, clip);
        if (solution.empty()) break;
      }
    }
  }

  if (test_polytree) solution = PolyTreeToPaths64(polytree);
    
  SvgWriter svg;
  SvgAddSubject(svg, subject, fr);
  SvgAddClip(svg, clip, fr);
  SvgAddSolution(svg, solution, fr, false);
  SvgSaveToFile(svg, "solution3.svg", display_width, display_height, 20);
  System("solution3.svg");
}

void System(const std::string &filename)
{
#ifdef _WIN32
  system(filename.c_str());
#else
  system(("firefox " + filename).c_str());
#endif
}