Code-Eli  0.3.6
piecewise_polygon_creator_test_suite.hpp
Go to the documentation of this file.
1 /*********************************************************************************
2 * Copyright (c) 2013 David D. Marshall <ddmarsha@calpoly.edu>
3 *
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *
9 * Contributors:
10 * David D. Marshall - initial code and implementation
11 ********************************************************************************/
12 
13 #ifndef piecewise_polygon_creator_test_suite_hpp
14 #define piecewise_polygon_creator_test_suite_hpp
15 
16 #include <cmath> // std::pow, std::exp
17 
18 #include <typeinfo> // typeid
19 #include <string> // std::string
20 #include <sstream> // std::stringstream
21 #include <iomanip> // std::setw
22 #include <limits> // std::numeric_limits
23 
24 #include "eli/constants/math.hpp"
27 
28 template<typename data__>
29 class piecewise_polygon_creator_test_suite : public Test::Suite
30 {
31  private:
39 
40  tolerance_type tol;
41 
42  protected:
43  void AddTests(const float &)
44  {
45  // add the tests
48  }
49  void AddTests(const double &)
50  {
51  // add the tests
54  }
55  void AddTests(const long double &)
56  {
57  // add the tests
60  }
61 
62  public:
64  {
65  AddTests(data__());
66  }
68  {
69  }
70 
71  private:
72  void octave_print(int figno, const piecewise_curve_type &pc) const
73  {
74  index_type i, pp, ns;
75  data_type tmin, tmax;
76 
77  ns=pc.number_segments();
78  pc.get_parameter_min(tmin);
79  pc.get_parameter_max(tmax);
80 
81  std::cout << "figure(" << figno << ");" << std::endl;
82 
83  // get control points and print
84  std::cout << "cp_x=[";
85  for (pp=0; pp<ns; ++pp)
86  {
87  curve_type bez;
88  pc.get(bez, pp);
89  for (i=0; i<=bez.degree(); ++i)
90  {
91  std::cout << bez.get_control_point(i).x();
92  if (i<bez.degree())
93  std::cout << ", ";
94  else if (pp<ns-1)
95  std::cout << "; ";
96  }
97  std::cout << std::endl;
98  }
99  std::cout << "];" << std::endl;
100 
101  std::cout << "cp_y=[";
102  for (pp=0; pp<ns; ++pp)
103  {
104  curve_type bez;
105  pc.get(bez, pp);
106  for (i=0; i<=bez.degree(); ++i)
107  {
108  std::cout << bez.get_control_point(i).y();
109  if (i<bez.degree())
110  std::cout << ", ";
111  else if (pp<ns-1)
112  std::cout << "; ";
113  }
114  std::cout << std::endl;
115  }
116  std::cout << "];" << std::endl;
117 
118  std::cout << "cp_z=[";
119  for (pp=0; pp<ns; ++pp)
120  {
121  curve_type bez;
122  pc.get(bez, pp);
123  for (i=0; i<=bez.degree(); ++i)
124  {
125  std::cout << bez.get_control_point(i).z();
126  if (i<bez.degree())
127  std::cout << ", ";
128  else if (pp<ns-1)
129  std::cout << "; ";
130  }
131  std::cout << std::endl;
132  }
133  std::cout << "];" << std::endl;
134 
135  // initialize the t parameters
136  std::vector<data__> t(129);
137  for (i=0; i<static_cast<index_type>(t.size()); ++i)
138  {
139  t[i]=tmin+(tmax-tmin)*static_cast<data__>(i)/(t.size()-1);
140  }
141 
142  // set the surface points
143  std::cout << "surf_x=[";
144  for (i=0; i<static_cast<index_type>(t.size()); ++i)
145  {
146  std::cout << pc.f(t[i]).x();
147  if (i<static_cast<index_type>(t.size()-1))
148  std::cout << ", ";
149  }
150  std::cout << "];" << std::endl;
151 
152  std::cout << "surf_y=[";
153  for (i=0; i<static_cast<index_type>(t.size()); ++i)
154  {
155  std::cout << pc.f(t[i]).y();
156  if (i<static_cast<index_type>(t.size()-1))
157  std::cout << ", ";
158  }
159  std::cout << "];" << std::endl;
160 
161  std::cout << "surf_z=[";
162  for (i=0; i<static_cast<index_type>(t.size()); ++i)
163  {
164  std::cout << pc.f(t[i]).z();
165  if (i<static_cast<index_type>(t.size()-1))
166  std::cout << ", ";
167  }
168  std::cout << "];" << std::endl;
169 
170  std::cout << "setenv('GNUTERM', 'x11');" << std::endl;
171  std::cout << "plot3(surf_x, surf_y, surf_z, '-k');" << std::endl;
172  std::cout << "hold on;" << std::endl;
173  std::cout << "plot3(cp_x', cp_y', cp_z', '-ok', 'MarkerFaceColor', [0 0 0]);" << std::endl;
174  std::cout << "hold off;" << std::endl;
175  }
176 
178  {
179  // create triangle with specified parameterization
180  {
181  piecewise_curve_type pc;
182  polygon_creator_type poly_creator(3);
183  data_type dt0(3), dt1(2), dt2(3), t0(-1), dt;
184  point_type p0, p1, p2, ptemp;
185 
186  // set the corners
187  p0 << 1, 2, 3;
188  p1 << 2, 1, 1;
189  p2 << 1, 1, 3;
190  poly_creator.set_corner(p0, 0);
191  poly_creator.set_corner(p1, 1);
192  poly_creator.set_corner(p2, 2);
193 
194  // set the times
195  poly_creator.set_t0(t0);
196  poly_creator.set_segment_dt(dt0, 0);
197  poly_creator.set_segment_dt(dt1, 1);
198  poly_creator.set_segment_dt(dt2, 2);
199 
200  // test corner settings
201  ptemp=poly_creator.get_corner(0);
202  TEST_ASSERT(p0==ptemp);
203  ptemp=poly_creator.get_corner(1);
204  TEST_ASSERT(p1==ptemp);
205  ptemp=poly_creator.get_corner(2);
206  TEST_ASSERT(p2==ptemp);
207 
208  // test time step settings
209  TEST_ASSERT(poly_creator.get_t0()==t0);
210  dt=poly_creator.get_segment_dt(0);
211  TEST_ASSERT(dt==dt0);
212  dt=poly_creator.get_segment_dt(1);
213  TEST_ASSERT(dt==dt1);
214  dt=poly_creator.get_segment_dt(2);
215  TEST_ASSERT(dt==dt2);
216 
217  // create the polygon
218  TEST_ASSERT(poly_creator.create(pc));
219  }
220 
221  // create triangle with default parameterization
222  {
223  piecewise_curve_type pc;
224  polygon_creator_type poly_creator(3);
225  data_type dt;
226  point_type p0, p1, p2, ptemp;
227 
228  // set the corners
229  p0 << 1, 0, 0;
230  p1 << 0, 1, 0;
231  p2 << 0, 0, 1;
232  poly_creator.set_corner(p0, 0);
233  poly_creator.set_corner(p1, 1);
234  poly_creator.set_corner(p2, 2);
235 
236  // test corner settings
237  ptemp=poly_creator.get_corner(0);
238  TEST_ASSERT(p0==ptemp);
239  ptemp=poly_creator.get_corner(1);
240  TEST_ASSERT(p1==ptemp);
241  ptemp=poly_creator.get_corner(2);
242  TEST_ASSERT(p2==ptemp);
243 
244  // test time step settings
245  TEST_ASSERT(poly_creator.get_t0()==0);
246  dt=poly_creator.get_segment_dt(0);
247  TEST_ASSERT(dt==1);
248  dt=poly_creator.get_segment_dt(1);
249  TEST_ASSERT(dt==1);
250  dt=poly_creator.get_segment_dt(2);
251  TEST_ASSERT(dt==1);
252 
253  // create the polygon
254  TEST_ASSERT(poly_creator.create(pc));
255  }
256  }
257 
259  {
260  // create box with specified parameterization
261  {
262  piecewise_curve_type pc;
263  polygon_creator_type poly_creator(4);
264  data_type dt0(3), dt1(2), dt2(3), dt3(2), t0(-1), dt;
265  point_type p0, p1, p2, p3, ptemp;
266 
267  // set the corners
268  p0 << 1, 2, 3;
269  p1 << 2, 1, 1;
270  p2 << 1, 1, 3;
271  p3 << 3, 3, 2;
272  poly_creator.set_corner(p0, 0);
273  poly_creator.set_corner(p1, 1);
274  poly_creator.set_corner(p2, 2);
275  poly_creator.set_corner(p3, 3);
276 
277  // set the times
278  poly_creator.set_t0(t0);
279  poly_creator.set_segment_dt(dt0, 0);
280  poly_creator.set_segment_dt(dt1, 1);
281  poly_creator.set_segment_dt(dt2, 2);
282  poly_creator.set_segment_dt(dt3, 3);
283 
284  // test corner settings
285  ptemp=poly_creator.get_corner(0);
286  TEST_ASSERT(p0==ptemp);
287  ptemp=poly_creator.get_corner(1);
288  TEST_ASSERT(p1==ptemp);
289  ptemp=poly_creator.get_corner(2);
290  TEST_ASSERT(p2==ptemp);
291  ptemp=poly_creator.get_corner(3);
292  TEST_ASSERT(p3==ptemp);
293 
294  // test time step settings
295  TEST_ASSERT(poly_creator.get_t0()==t0);
296  dt=poly_creator.get_segment_dt(0);
297  TEST_ASSERT(dt==dt0);
298  dt=poly_creator.get_segment_dt(1);
299  TEST_ASSERT(dt==dt1);
300  dt=poly_creator.get_segment_dt(2);
301  TEST_ASSERT(dt==dt2);
302  dt=poly_creator.get_segment_dt(3);
303  TEST_ASSERT(dt==dt3);
304 
305  // create the polygon
306  TEST_ASSERT(poly_creator.create(pc));
307 
308 // if (typeid(data_type)==typeid(double))
309 // octave_print(0, pc);
310  }
311 
312  // create box with default parameterization
313  {
314  piecewise_curve_type pc;
315  polygon_creator_type poly_creator(4);
316  data_type dt;
317  point_type p0, p1, p2, p3, ptemp;
318 
319  // set the corners
320  p0 << 0, 0, 0;
321  p1 << 1, 0, 0;
322  p2 << 1, 1, 0;
323  p3 << 0, 1, 0;
324  poly_creator.set_corner(p0, 0);
325  poly_creator.set_corner(p1, 1);
326  poly_creator.set_corner(p2, 2);
327  poly_creator.set_corner(p3, 3);
328 
329  // test corner settings
330  ptemp=poly_creator.get_corner(0);
331  TEST_ASSERT(p0==ptemp);
332  ptemp=poly_creator.get_corner(1);
333  TEST_ASSERT(p1==ptemp);
334  ptemp=poly_creator.get_corner(2);
335  TEST_ASSERT(p2==ptemp);
336  ptemp=poly_creator.get_corner(3);
337  TEST_ASSERT(p3==ptemp);
338 
339  // test time step settings
340  TEST_ASSERT(poly_creator.get_t0()==0);
341  dt=poly_creator.get_segment_dt(0);
342  TEST_ASSERT(dt==1);
343  dt=poly_creator.get_segment_dt(1);
344  TEST_ASSERT(dt==1);
345  dt=poly_creator.get_segment_dt(2);
346  TEST_ASSERT(dt==1);
347  dt=poly_creator.get_segment_dt(3);
348  TEST_ASSERT(dt==1);
349 
350  // create the polygon
351  TEST_ASSERT(poly_creator.create(pc));
352 
353 // if (typeid(data_type)==typeid(double))
354 // octave_print(0, pc);
355 
356  }
357  }
358 };
359 
360 #endif
361 
void set_segment_dt(const data_type &dtt, const index_type &i)
Definition: piecewise_creator_base.hpp:64
piecewise_polygon_creator_test_suite()
Definition: piecewise_polygon_creator_test_suite.hpp:63
eli::geom::curve::piecewise< eli::geom::curve::bezier, data__, 3 > piecewise_curve_type
Definition: piecewise_polygon_creator_test_suite.hpp:32
tol__ tolerance_type
Definition: piecewise.hpp:278
data__ data_type
Definition: piecewise.hpp:276
data_type get_parameter_min() const
Definition: piecewise.hpp:366
Definition: piecewise_polygon_creator.hpp:31
curve_type::index_type index_type
Definition: piecewise.hpp:271
index_type number_segments() const
Definition: piecewise.hpp:419
Definition: piecewise.hpp:244
eli::geom::curve::piecewise_polygon_creator< data__, 3, tolerance_type > polygon_creator_type
Definition: piecewise_polygon_creator_test_suite.hpp:38
void create_box_test()
Definition: piecewise_polygon_creator_test_suite.hpp:258
curve__< data__, dim__, tol__ > curve_type
Definition: piecewise.hpp:270
void AddTests(const float &)
Definition: piecewise_polygon_creator_test_suite.hpp:43
~piecewise_polygon_creator_test_suite()
Definition: piecewise_polygon_creator_test_suite.hpp:67
Definition: piecewise_polygon_creator_test_suite.hpp:29
piecewise_curve_type::index_type index_type
Definition: piecewise_polygon_creator_test_suite.hpp:36
tolerance_type tol
Definition: piecewise_polygon_creator_test_suite.hpp:40
void set_corner(const point_type &c, const index_type &i)
Definition: piecewise_polygon_creator.hpp:46
data_type get_segment_dt(const index_type &i) const
Definition: piecewise_creator_base.hpp:78
void AddTests(const long double &)
Definition: piecewise_polygon_creator_test_suite.hpp:55
piecewise_curve_type::point_type point_type
Definition: piecewise_polygon_creator_test_suite.hpp:34
void AddTests(const double &)
Definition: piecewise_polygon_creator_test_suite.hpp:49
data_type get_parameter_max() const
Definition: piecewise.hpp:374
piecewise_curve_type::tolerance_type tolerance_type
Definition: piecewise_polygon_creator_test_suite.hpp:37
piecewise_curve_type::data_type data_type
Definition: piecewise_polygon_creator_test_suite.hpp:35
void octave_print(int figno, const piecewise_curve_type &pc) const
Definition: piecewise_polygon_creator_test_suite.hpp:72
point_type get_corner(const index_type &i) const
Definition: piecewise_polygon_creator.hpp:53
piecewise_curve_type::curve_type curve_type
Definition: piecewise_polygon_creator_test_suite.hpp:33
point_type f(const data_type &t) const
Definition: piecewise.hpp:1732
error_code get(curve_type &curve, const index_type &index) const
Definition: piecewise.hpp:729
data_type get_t0() const
Definition: piecewise_creator_base.hpp:62
curve_type::point_type point_type
Definition: piecewise.hpp:272
void set_t0(const data_type &tt0)
Definition: piecewise_creator_base.hpp:61
virtual bool create(piecewise< bezier, data_type, dim__, tolerance_type > &pc) const
Definition: piecewise_polygon_creator.hpp:63
void create_triangle_test()
Definition: piecewise_polygon_creator_test_suite.hpp:177