DGtal  1.5.beta
Functions
pConvexity-benchmark.cpp File Reference
DGtal Examples
#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/kernel/sets/DigitalSetBySTLSet.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/shapes/Shapes.h"
#include "DGtal/geometry/volumes/PConvexity.h"
#include "DGtal/geometry/volumes/DigitalConvexity.h"
Include dependency graph for pConvexity-benchmark.cpp:

Go to the source code of this file.

Functions

double rand01 ()
 
template<Dimension dim>
void timingsPConvexity (std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t nb_vertices, std::size_t range, double pconvexity_probability=0.5)
 
template<Dimension dim>
void timingsFullConvexity (std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t nb_vertices, std::size_t range, double fconvexity_probability=0.5)
 
template<Dimension dim>
void timingsFullConvexityFast (std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t nb_vertices, std::size_t range, double fconvexity_probability=0.5)
 
template<Dimension dim>
void timingsPConvexityNonConvex (std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t range)
 
template<Dimension dim>
void timingsFullConvexityNonConvex (std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t range)
 
template<Dimension dim>
void timingsFullConvexityFastNonConvex (std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t range)
 
void outputResults (Dimension dim, const std::vector< std::tuple< std::size_t, double, bool > > &results, const std::string &fname)
 
int main (int argc, char *argv[])
 

Detailed Description

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author
Jacques-Olivier Lachaud (jacqu.nosp@m.es-o.nosp@m.livie.nosp@m.r.la.nosp@m.chaud.nosp@m.@uni.nosp@m.v-sav.nosp@m.oie..nosp@m.fr ) Laboratory of Mathematics (CNRS, UMR 5127), University of Savoie, France
Date
2024/06/26

An example file named pConvexity-benchmark

This file is part of the DGtal library.

Definition in file pConvexity-benchmark.cpp.

Function Documentation

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 392 of file pConvexity-benchmark.cpp.

393 {
394  // P-convexity
395  srand( 0 );
396  if ( false )
397  {
398  std::vector< std::tuple< std::size_t, double, bool > > R2;
399  timingsPConvexity<2>( R2, 50, 3, 100, 0.5 );
400  timingsPConvexity<2>( R2, 50, 4, 200, 0.5 );
401  timingsPConvexity<2>( R2, 50, 5, 400, 0.5 );
402  timingsPConvexity<2>( R2, 50, 5, 600, 0.5 );
403  timingsPConvexity<2>( R2, 50, 5, 800, 0.5 );
404  timingsPConvexity<2>( R2, 25, 5,1200, 0.5 );
405  timingsPConvexity<2>( R2, 25, 5,2000, 0.5 );
406  outputResults( 2, R2, "timings-p-convexity-Z2.txt" );
407  }
408  if ( false )
409  {
410  std::vector< std::tuple< std::size_t, double, bool > > R3;
411  timingsPConvexity<3>( R3, 50, 3, 10, 0.5 );
412  timingsPConvexity<3>( R3, 50, 4, 20, 0.5 );
413  timingsPConvexity<3>( R3, 50, 5, 40, 0.5 );
414  timingsPConvexity<3>( R3, 50, 5, 80, 0.5 );
415  timingsPConvexity<3>( R3, 25, 5, 160, 0.5 );
416  timingsPConvexity<3>( R3, 25, 5, 320, 0.5 );
417  outputResults( 3, R3, "timings-p-convexity-Z3.txt" );
418  }
419  if ( false )
420  {
421  std::vector< std::tuple< std::size_t, double, bool > > R4;
422  timingsPConvexity<4>( R4, 50, 5, 10, 0.5 );
423  timingsPConvexity<4>( R4, 50, 5, 15, 0.5 );
424  timingsPConvexity<4>( R4, 50, 5, 20, 0.5 );
425  timingsPConvexity<4>( R4, 50, 5, 30, 0.5 );
426  timingsPConvexity<4>( R4, 25, 5, 40, 0.5 );
427  timingsPConvexity<4>( R4, 25, 5, 60, 0.5 );
428  timingsPConvexity<4>( R4, 15, 6, 80, 0.5 );
429  timingsPConvexity<4>( R4, 15, 6, 100, 0.5 );
430  timingsPConvexity<4>( R4, 15, 6, 120, 0.5 );
431  outputResults( 4, R4, "timings-p-convexity-Z4.txt" );
432  }
433 
434  // Full convexity
435  srand( 0 );
436  if ( false )
437  {
438  std::vector< std::tuple< std::size_t, double, bool > > R2;
439  timingsFullConvexity<2>( R2, 50, 3, 100, 0.5 );
440  timingsFullConvexity<2>( R2, 50, 4, 200, 0.5 );
441  timingsFullConvexity<2>( R2, 50, 5, 400, 0.5 );
442  timingsFullConvexity<2>( R2, 50, 5, 600, 0.5 );
443  timingsFullConvexity<2>( R2, 50, 5, 800, 0.5 );
444  timingsFullConvexity<2>( R2, 25, 5,1200, 0.5 );
445  timingsFullConvexity<2>( R2, 25, 5,2000, 0.5 );
446  outputResults( 2, R2, "timings-fc-convexity-Z2.txt" );
447  }
448  if ( false )
449  {
450  std::vector< std::tuple< std::size_t, double, bool > > R3;
451  timingsFullConvexity<3>( R3, 50, 3, 10, 0.5 );
452  timingsFullConvexity<3>( R3, 50, 4, 20, 0.5 );
453  timingsFullConvexity<3>( R3, 50, 5, 40, 0.5 );
454  timingsFullConvexity<3>( R3, 50, 5, 80, 0.5 );
455  timingsFullConvexity<3>( R3, 25, 5, 160, 0.5 );
456  timingsFullConvexity<3>( R3, 25, 5, 320, 0.5 );
457  outputResults( 3, R3, "timings-fc-convexity-Z3.txt" );
458  }
459  if ( false )
460  {
461  std::vector< std::tuple< std::size_t, double, bool > > R4;
462  timingsFullConvexity<4>( R4, 50, 5, 10, 0.5 );
463  timingsFullConvexity<4>( R4, 50, 5, 15, 0.5 );
464  timingsFullConvexity<4>( R4, 50, 5, 20, 0.5 );
465  timingsFullConvexity<4>( R4, 50, 5, 30, 0.5 );
466  timingsFullConvexity<4>( R4, 25, 5, 40, 0.5 );
467  timingsFullConvexity<4>( R4, 25, 5, 60, 0.5 );
468  timingsFullConvexity<4>( R4, 15, 6, 80, 0.5 );
469  timingsFullConvexity<4>( R4, 10, 6, 100, 0.5 );
470  timingsFullConvexity<4>( R4, 5, 6, 120, 0.5 );
471  outputResults( 4, R4, "timings-fc-convexity-Z4.txt" );
472  }
473 
474  // Full convexity fast
475  srand( 0 );
476  if ( false )
477  {
478  std::vector< std::tuple< std::size_t, double, bool > > R2;
479  timingsFullConvexityFast<2>( R2, 50, 3, 100, 0.5 );
480  timingsFullConvexityFast<2>( R2, 50, 4, 200, 0.5 );
481  timingsFullConvexityFast<2>( R2, 50, 5, 400, 0.5 );
482  timingsFullConvexityFast<2>( R2, 50, 5, 600, 0.5 );
483  timingsFullConvexityFast<2>( R2, 50, 5, 800, 0.5 );
484  timingsFullConvexityFast<2>( R2, 25, 5,1200, 0.5 );
485  timingsFullConvexityFast<2>( R2, 25, 5,2000, 0.5 );
486  outputResults( 2, R2, "timings-fcf-convexity-Z2.txt" );
487  }
488  if ( false )
489  {
490  std::vector< std::tuple< std::size_t, double, bool > > R3;
491  timingsFullConvexityFast<3>( R3, 50, 3, 10, 0.5 );
492  timingsFullConvexityFast<3>( R3, 50, 4, 20, 0.5 );
493  timingsFullConvexityFast<3>( R3, 50, 5, 40, 0.5 );
494  timingsFullConvexityFast<3>( R3, 50, 5, 80, 0.5 );
495  timingsFullConvexityFast<3>( R3, 25, 5, 160, 0.5 );
496  timingsFullConvexityFast<3>( R3, 25, 5, 320, 0.5 );
497  outputResults( 3, R3, "timings-fcf-convexity-Z3.txt" );
498  }
499  if ( false )
500  {
501  std::vector< std::tuple< std::size_t, double, bool > > R4;
502  timingsFullConvexityFast<4>( R4, 50, 5, 10, 0.5 );
503  timingsFullConvexityFast<4>( R4, 50, 5, 15, 0.5 );
504  timingsFullConvexityFast<4>( R4, 50, 5, 20, 0.5 );
505  timingsFullConvexityFast<4>( R4, 50, 5, 30, 0.5 );
506  timingsFullConvexityFast<4>( R4, 25, 5, 40, 0.5 );
507  timingsFullConvexityFast<4>( R4, 25, 5, 60, 0.5 );
508  timingsFullConvexityFast<4>( R4, 15, 6, 80, 0.5 );
509  timingsFullConvexityFast<4>( R4, 10, 6, 100, 0.5 );
510  timingsFullConvexityFast<4>( R4, 5, 6, 120, 0.5 );
511  outputResults( 4, R4, "timings-fcf-convexity-Z4.txt" );
512  }
513 
514  // P-convexity
515  srand( 0 );
516  if ( false )
517  {
518  std::vector< std::tuple< std::size_t, double, bool > > R2;
519  timingsPConvexityNonConvex<2>( R2, 50, 100 );
520  timingsPConvexityNonConvex<2>( R2, 50, 200 );
521  timingsPConvexityNonConvex<2>( R2, 50, 400 );
522  timingsPConvexityNonConvex<2>( R2, 50, 600 );
523  timingsPConvexityNonConvex<2>( R2, 50, 800 );
524  timingsPConvexityNonConvex<2>( R2, 50, 1200 );
525  timingsPConvexityNonConvex<2>( R2, 50, 2000 );
526  outputResults( 2, R2, "timings-p-convexity-ncvx-Z2.txt" );
527  }
528  if ( false )
529  {
530  std::vector< std::tuple< std::size_t, double, bool > > R3;
531  timingsPConvexityNonConvex<3>( R3, 50, 20 );
532  timingsPConvexityNonConvex<3>( R3, 50, 40 );
533  timingsPConvexityNonConvex<3>( R3, 50, 80 );
534  timingsPConvexityNonConvex<3>( R3, 50, 160 );
535  timingsPConvexityNonConvex<3>( R3, 50, 320 );
536  outputResults( 3, R3, "timings-p-convexity-ncvx-Z3.txt" );
537  }
538  if ( false )
539  {
540  std::vector< std::tuple< std::size_t, double, bool > > R4;
541  timingsPConvexityNonConvex<4>( R4, 50, 10 );
542  timingsPConvexityNonConvex<4>( R4, 50, 20 );
543  timingsPConvexityNonConvex<4>( R4, 50, 30 );
544  timingsPConvexityNonConvex<4>( R4, 40, 40 );
545  timingsPConvexityNonConvex<4>( R4, 20, 50 );
546  outputResults( 4, R4, "timings-p-convexity-ncvx-Z4.txt" );
547  }
548  if ( false )
549  {
550  std::vector< std::tuple< std::size_t, double, bool > > R2;
551  timingsFullConvexityNonConvex<2>( R2, 50, 100 );
552  timingsFullConvexityNonConvex<2>( R2, 50, 200 );
553  timingsFullConvexityNonConvex<2>( R2, 50, 400 );
554  timingsFullConvexityNonConvex<2>( R2, 50, 600 );
555  timingsFullConvexityNonConvex<2>( R2, 50, 800 );
556  timingsFullConvexityNonConvex<2>( R2, 50, 1200 );
557  timingsFullConvexityNonConvex<2>( R2, 50, 2000 );
558  outputResults( 2, R2, "timings-fc-convexity-ncvx-Z2.txt" );
559  }
560  if ( false )
561  {
562  std::vector< std::tuple< std::size_t, double, bool > > R3;
563  timingsFullConvexityNonConvex<3>( R3, 50, 20 );
564  timingsFullConvexityNonConvex<3>( R3, 50, 40 );
565  timingsFullConvexityNonConvex<3>( R3, 50, 80 );
566  timingsFullConvexityNonConvex<3>( R3, 40, 160 );
567  timingsFullConvexityNonConvex<3>( R3, 25, 320 );
568  outputResults( 3, R3, "timings-fc-convexity-ncvx-Z3.txt" );
569  }
570  if ( false )
571  {
572  std::vector< std::tuple< std::size_t, double, bool > > R4;
573  timingsFullConvexityNonConvex<4>( R4, 50, 10 );
574  timingsFullConvexityNonConvex<4>( R4, 50, 20 );
575  timingsFullConvexityNonConvex<4>( R4, 50, 30 );
576  timingsFullConvexityNonConvex<4>( R4, 40, 40 );
577  timingsFullConvexityNonConvex<4>( R4, 20, 50 );
578  outputResults( 4, R4, "timings-fc-convexity-ncvx-Z4.txt" );
579  }
580  if ( false )
581  {
582  std::vector< std::tuple< std::size_t, double, bool > > R2;
583  timingsFullConvexityFastNonConvex<2>( R2, 50, 100 );
584  timingsFullConvexityFastNonConvex<2>( R2, 50, 200 );
585  timingsFullConvexityFastNonConvex<2>( R2, 50, 400 );
586  timingsFullConvexityFastNonConvex<2>( R2, 50, 600 );
587  timingsFullConvexityFastNonConvex<2>( R2, 50, 800 );
588  timingsFullConvexityFastNonConvex<2>( R2, 50, 1200 );
589  timingsFullConvexityFastNonConvex<2>( R2, 50, 2000 );
590  outputResults( 2, R2, "timings-fcf-convexity-ncvx-Z2.txt" );
591  }
592  if ( false )
593  {
594  std::vector< std::tuple< std::size_t, double, bool > > R3;
595  timingsFullConvexityFastNonConvex<3>( R3, 50, 20 );
596  timingsFullConvexityFastNonConvex<3>( R3, 50, 40 );
597  timingsFullConvexityFastNonConvex<3>( R3, 50, 80 );
598  timingsFullConvexityFastNonConvex<3>( R3, 40, 160 );
599  timingsFullConvexityFastNonConvex<3>( R3, 25, 320 );
600  outputResults( 3, R3, "timings-fcf-convexity-ncvx-Z3.txt" );
601  }
602  if ( false )
603  {
604  std::vector< std::tuple< std::size_t, double, bool > > R4;
605  timingsFullConvexityFastNonConvex<4>( R4, 50, 10 );
606  timingsFullConvexityFastNonConvex<4>( R4, 50, 20 );
607  timingsFullConvexityFastNonConvex<4>( R4, 50, 30 );
608  timingsFullConvexityFastNonConvex<4>( R4, 40, 40 );
609  timingsFullConvexityFastNonConvex<4>( R4, 20, 50 );
610  outputResults( 4, R4, "timings-fcf-convexity-ncvx-Z4.txt" );
611  }
612 
613 
614  return 0;
615 }
outputResults
void outputResults(Dimension dim, const std::vector< std::tuple< std::size_t, double, bool > > &results, const std::string &fname)
Definition: pConvexity-benchmark.cpp:344
srand
srand(0)

References outputResults(), and srand().

◆ outputResults()

void outputResults ( Dimension  dim,
const std::vector< std::tuple< std::size_t, double, bool > > &  results,
const std::string &  fname 
)
Examples
geometry/volumes/pConvexity-benchmark.cpp.

Definition at line 344 of file pConvexity-benchmark.cpp.

347 {
348  std::ofstream output( fname );
349  output << "# Results of " << results.size() << " P-convexity computations in Z"
350  << dim << std::endl
351  << "# Card(X) time(ms) p-convex?" << std::endl;
352  for ( auto&& r : results )
353  output << std::get<0>( r ) << " " << std::get<1>( r ) << " " << std::get<2>( r )
354  << std::endl;
355  output.close();
356 }
dim
unsigned int dim(const Vector &z)
Definition: viewDualSurface.cpp:174

References dim().

Referenced by main().

◆ rand01()

double rand01 ( )

Definition at line 71 of file pConvexity-benchmark.cpp.

71 { return double( rand() ) / double( RAND_MAX ); }

Referenced by timingsFullConvexity(), timingsFullConvexityFast(), and timingsPConvexity().

◆ timingsFullConvexity()

template<Dimension dim>
void timingsFullConvexity ( std::vector< std::tuple< std::size_t, double, bool > > &  results,
std::size_t  nb_tries,
std::size_t  nb_vertices,
std::size_t  range,
double  fconvexity_probability = 0.5 
)
Examples
geometry/volumes/pConvexity-benchmark.cpp.

Definition at line 123 of file pConvexity-benchmark.cpp.

126 {
127  typedef KhalimskySpaceND<dim,int64_t> KSpace;
128  typedef typename KSpace::Point Point;
129  typedef typename KSpace::Space Space;
130  typedef HyperRectDomain< Space > Domain;
131  typedef DigitalConvexity< KSpace > DConvexity;
132  typedef PConvexity< Space > PConvexity;
133  DConvexity dconv( Point::diagonal( -1 ), Point::diagonal( range ) );
134  PConvexity pconv;
135  Domain domain( Point::diagonal( 0 ), Point::diagonal( range ) );
136  std::cout << "Computing " << nb_tries << " full convexities in Z" << dim << std::endl;
137  for ( auto n = 0; n < nb_tries; ++n )
138  {
139  // Create vertices
140  std::vector< Point > V;
141  for ( auto i = 0; i < nb_vertices; i++ ) {
142  Point p;
143  for ( auto j = 0; j < dim; j++ ) p[ j ] = rand() % range;
144  V.push_back( p );
145  }
146  // create 0-convex or fully convex set.
147  std::vector< Point > X;
148  bool force_fconvexity = rand01() < fconvexity_probability;
149  if ( force_fconvexity )
150  X = dconv.envelope( V );
151  else
152  {
153  auto P = dconv.CvxH( V );
154  P.getPoints( X );
155  }
156  // Analyse full convexity
157  std::chrono::high_resolution_clock::time_point
158  t1 = std::chrono::high_resolution_clock::now();
159  bool is_fconvex = dconv.isFullyConvex( X );
160  std::chrono::high_resolution_clock::time_point
161  t2 = std::chrono::high_resolution_clock::now();
162  double dt = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
163  results.push_back( std::make_tuple( X.size(), dt/1e6, is_fconvex ) );
164  if ( force_fconvexity && ! is_fconvex )
165  trace.warning() << "Invalid computation of either FC* or full convexity !" << std::endl;
166  }
167 }
DGtal::BoundedLatticePolytope::getPoints
void getPoints(std::vector< Point > &pts) const
DGtal::DigitalConvexity::CvxH
LatticePolytope CvxH(const PointRange &X) const
Definition: DigitalConvexity.h:522
DGtal::DigitalConvexity::isFullyConvex
bool isFullyConvex(const PointRange &X, bool convex0=false) const
DGtal::DigitalConvexity::envelope
PointRange envelope(const PointRange &Z, EnvelopeAlgorithm algo=EnvelopeAlgorithm::DIRECT) const
DGtal::KhalimskySpaceND
Aim: This class is a model of CCellularGridSpaceND. It represents the cubical grid as a cell complex,...
Definition: KhalimskySpaceND.h:394
DGtal::PConvexity
Aim: A class to check if digital sets are P-convex. The P-convexity is defined as follows: A digital ...
Definition: PConvexity.h:355
DGtal::Trace::warning
std::ostream & warning()
DGtal::trace
Trace trace
Definition: Common.h:153
rand01
double rand01()
Definition: pConvexity-benchmark.cpp:71
Point
MyPointD Point
Definition: testClone2.cpp:383
domain
Domain domain
Definition: testProjection.cpp:88
Domain
HyperRectDomain< Space > Domain
Definition: testSimpleRandomAccessRangeFromPoint.cpp:44

References DGtal::DigitalConvexity< TKSpace >::CvxH(), dim(), domain, dt, DGtal::DigitalConvexity< TKSpace >::envelope(), DGtal::BoundedLatticePolytope< TSpace >::getPoints(), DGtal::DigitalConvexity< TKSpace >::isFullyConvex(), rand01(), DGtal::trace, and DGtal::Trace::warning().

◆ timingsFullConvexityFast()

template<Dimension dim>
void timingsFullConvexityFast ( std::vector< std::tuple< std::size_t, double, bool > > &  results,
std::size_t  nb_tries,
std::size_t  nb_vertices,
std::size_t  range,
double  fconvexity_probability = 0.5 
)
Examples
geometry/volumes/pConvexity-benchmark.cpp.

Definition at line 171 of file pConvexity-benchmark.cpp.

174 {
175  typedef KhalimskySpaceND<dim,int64_t> KSpace;
176  typedef typename KSpace::Point Point;
177  typedef typename KSpace::Space Space;
178  typedef HyperRectDomain< Space > Domain;
179  typedef DigitalConvexity< KSpace > DConvexity;
180  typedef PConvexity< Space > PConvexity;
181  DConvexity dconv( Point::diagonal( -1 ), Point::diagonal( range ) );
182  PConvexity pconv;
183  Domain domain( Point::diagonal( 0 ), Point::diagonal( range ) );
184  std::cout << "Computing " << nb_tries << " full convexities in Z" << dim << std::endl;
185  for ( auto n = 0; n < nb_tries; ++n )
186  {
187  // Create vertices
188  std::vector< Point > V;
189  for ( auto i = 0; i < nb_vertices; i++ ) {
190  Point p;
191  for ( auto j = 0; j < dim; j++ ) p[ j ] = rand() % range;
192  V.push_back( p );
193  }
194  // create 0-convex or fully convex set.
195  std::vector< Point > X;
196  bool force_fconvexity = rand01() < fconvexity_probability;
197  if ( force_fconvexity )
198  X = dconv.envelope( V );
199  else
200  {
201  auto P = dconv.CvxH( V );
202  P.getPoints( X );
203  }
204  // Analyse full convexity
205  std::chrono::high_resolution_clock::time_point
206  t1 = std::chrono::high_resolution_clock::now();
207  bool is_fconvex = dconv.isFullyConvexFast( X );
208  std::chrono::high_resolution_clock::time_point
209  t2 = std::chrono::high_resolution_clock::now();
210  double dt = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
211  results.push_back( std::make_tuple( X.size(), dt/1e6, is_fconvex ) );
212  if ( force_fconvexity && ! is_fconvex )
213  trace.warning() << "Invalid computation of either FC* or full convexity !" << std::endl;
214  }
215 }
DGtal::DigitalConvexity::isFullyConvexFast
bool isFullyConvexFast(const PointRange &X) const

References DGtal::DigitalConvexity< TKSpace >::CvxH(), dim(), domain, dt, DGtal::DigitalConvexity< TKSpace >::envelope(), DGtal::BoundedLatticePolytope< TSpace >::getPoints(), DGtal::DigitalConvexity< TKSpace >::isFullyConvexFast(), rand01(), DGtal::trace, and DGtal::Trace::warning().

◆ timingsFullConvexityFastNonConvex()

template<Dimension dim>
void timingsFullConvexityFastNonConvex ( std::vector< std::tuple< std::size_t, double, bool > > &  results,
std::size_t  nb_tries,
std::size_t  range 
)
Examples
geometry/volumes/pConvexity-benchmark.cpp.

Definition at line 303 of file pConvexity-benchmark.cpp.

306 {
307  typedef KhalimskySpaceND<dim,int64_t> KSpace;
308  typedef typename KSpace::Point Point;
309  typedef typename KSpace::Space Space;
310  typedef HyperRectDomain< Space > Domain;
311  typedef DigitalConvexity< KSpace > DConvexity;
312  typedef PConvexity< Space > PConvexity;
313  DConvexity dconv( Point::diagonal( -1 ), Point::diagonal( range ) );
314  PConvexity pconv;
315  Domain domain( Point::diagonal( 0 ), Point::diagonal( range ) );
316  std::cout << "Computing " << nb_tries << " full convexities (fast) in Z" << dim << std::endl;
317  for ( auto n = 0; n < nb_tries; ++n )
318  {
319  double filling_probability = 0.1 + 0.9 * double( n ) / double( nb_tries );
320  // Create vertices
321  std::set< Point > S;
322  std::size_t nb_vertices
323  = std::size_t( filling_probability * ceil( pow( range, dim ) ) );
324  for ( auto i = 0; i < nb_vertices; i++ ) {
325  Point p;
326  for ( auto j = 0; j < dim; j++ ) p[ j ] = rand() % range;
327  S.insert( p );
328  }
329  // create digital set.
330  std::vector< Point > X( S.cbegin(), S.cend() );
331  // Analyse full convexity
332  std::chrono::high_resolution_clock::time_point
333  t1 = std::chrono::high_resolution_clock::now();
334  bool is_fconvex = dconv.isFullyConvexFast( X );
335  std::chrono::high_resolution_clock::time_point
336  t2 = std::chrono::high_resolution_clock::now();
337  double dt = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
338  results.push_back( std::make_tuple( X.size(), dt/1e6, is_fconvex ) );
339  }
340 }

References dim(), domain, dt, and DGtal::DigitalConvexity< TKSpace >::isFullyConvexFast().

◆ timingsFullConvexityNonConvex()

template<Dimension dim>
void timingsFullConvexityNonConvex ( std::vector< std::tuple< std::size_t, double, bool > > &  results,
std::size_t  nb_tries,
std::size_t  range 
)
Examples
geometry/volumes/pConvexity-benchmark.cpp.

Definition at line 261 of file pConvexity-benchmark.cpp.

264 {
265  typedef KhalimskySpaceND<dim,int64_t> KSpace;
266  typedef typename KSpace::Point Point;
267  typedef typename KSpace::Space Space;
268  typedef HyperRectDomain< Space > Domain;
269  typedef DigitalConvexity< KSpace > DConvexity;
270  typedef PConvexity< Space > PConvexity;
271  DConvexity dconv( Point::diagonal( -1 ), Point::diagonal( range ) );
272  PConvexity pconv;
273  Domain domain( Point::diagonal( 0 ), Point::diagonal( range ) );
274  std::cout << "Computing " << nb_tries << " full convexities in Z" << dim << std::endl;
275  for ( auto n = 0; n < nb_tries; ++n )
276  {
277  double filling_probability = 0.1 + 0.9 * double( n ) / double( nb_tries );
278  // Create vertices
279  std::set< Point > S;
280  std::size_t nb_vertices
281  = std::size_t( filling_probability * ceil( pow( range, dim ) ) );
282  for ( auto i = 0; i < nb_vertices; i++ ) {
283  Point p;
284  for ( auto j = 0; j < dim; j++ ) p[ j ] = rand() % range;
285  S.insert( p );
286  }
287  // create digital set.
288  std::vector< Point > X( S.cbegin(), S.cend() );
289  // Analyse full convexity
290  std::chrono::high_resolution_clock::time_point
291  t1 = std::chrono::high_resolution_clock::now();
292  bool is_fconvex = dconv.isFullyConvex( X );
293  std::chrono::high_resolution_clock::time_point
294  t2 = std::chrono::high_resolution_clock::now();
295  double dt = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
296  results.push_back( std::make_tuple( X.size(), dt/1e6, is_fconvex ) );
297  }
298 }

References dim(), domain, dt, and DGtal::DigitalConvexity< TKSpace >::isFullyConvex().

◆ timingsPConvexity()

template<Dimension dim>
void timingsPConvexity ( std::vector< std::tuple< std::size_t, double, bool > > &  results,
std::size_t  nb_tries,
std::size_t  nb_vertices,
std::size_t  range,
double  pconvexity_probability = 0.5 
)
Examples
geometry/volumes/pConvexity-benchmark.cpp.

Definition at line 75 of file pConvexity-benchmark.cpp.

78 {
79  typedef KhalimskySpaceND<dim,int64_t> KSpace;
80  typedef typename KSpace::Point Point;
81  typedef typename KSpace::Space Space;
82  typedef HyperRectDomain< Space > Domain;
83  typedef DigitalConvexity< KSpace > DConvexity;
84  typedef PConvexity< Space > PConvexity;
85  DConvexity dconv( Point::diagonal( -1 ), Point::diagonal( range ) );
86  PConvexity pconv;
87  Domain domain( Point::diagonal( 0 ), Point::diagonal( range ) );
88  std::cout << "Computing " << nb_tries << " P-convexities in Z" << dim << std::endl;
89  for ( auto n = 0; n < nb_tries; ++n )
90  {
91  // Create vertices
92  std::vector< Point > V;
93  for ( auto i = 0; i < nb_vertices; i++ ) {
94  Point p;
95  for ( auto j = 0; j < dim; j++ ) p[ j ] = rand() % range;
96  V.push_back( p );
97  }
98  // create 0-convex or fully convex set.
99  std::vector< Point > X;
100  bool force_pconvexity = rand01() < pconvexity_probability;
101  if ( force_pconvexity )
102  X = dconv.envelope( V );
103  else
104  {
105  auto P = dconv.CvxH( V );
106  P.getPoints( X );
107  }
108  // Analyse P-convexity
109  std::chrono::high_resolution_clock::time_point
110  t1 = std::chrono::high_resolution_clock::now();
111  bool is_pconvex = pconv.isPConvex( X );
112  std::chrono::high_resolution_clock::time_point
113  t2 = std::chrono::high_resolution_clock::now();
114  double dt = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
115  results.push_back( std::make_tuple( X.size(), dt/1e6, is_pconvex ) );
116  if ( force_pconvexity && ! is_pconvex )
117  trace.warning() << "Invalid computation of either FC* or P-convexity !" << std::endl;
118  }
119 }
DGtal::PConvexity::isPConvex
bool isPConvex(const std::vector< Point > &X) const
Definition: PConvexity.h:407

References DGtal::DigitalConvexity< TKSpace >::CvxH(), dim(), domain, dt, DGtal::DigitalConvexity< TKSpace >::envelope(), DGtal::BoundedLatticePolytope< TSpace >::getPoints(), DGtal::PConvexity< TSpace >::isPConvex(), rand01(), DGtal::trace, and DGtal::Trace::warning().

◆ timingsPConvexityNonConvex()

template<Dimension dim>
void timingsPConvexityNonConvex ( std::vector< std::tuple< std::size_t, double, bool > > &  results,
std::size_t  nb_tries,
std::size_t  range 
)
Examples
geometry/volumes/pConvexity-benchmark.cpp.

Definition at line 220 of file pConvexity-benchmark.cpp.

223 {
224  typedef KhalimskySpaceND<dim,int64_t> KSpace;
225  typedef typename KSpace::Point Point;
226  typedef typename KSpace::Space Space;
227  typedef HyperRectDomain< Space > Domain;
228  typedef DigitalConvexity< KSpace > DConvexity;
229  typedef PConvexity< Space > PConvexity;
230  DConvexity dconv( Point::diagonal( -1 ), Point::diagonal( range ) );
231  PConvexity pconv;
232  Domain domain( Point::diagonal( 0 ), Point::diagonal( range ) );
233  std::cout << "Computing " << nb_tries << " P-convexities in Z" << dim << std::endl;
234  for ( auto n = 0; n < nb_tries; ++n )
235  {
236  double filling_probability = 0.1 + 0.9 * double( n ) / double( nb_tries );
237  // Create vertices
238  std::set< Point > S;
239  std::size_t nb_vertices
240  = std::size_t( filling_probability * ceil( pow( range, dim ) ) );
241  for ( auto i = 0; i < nb_vertices; i++ ) {
242  Point p;
243  for ( auto j = 0; j < dim; j++ ) p[ j ] = rand() % range;
244  S.insert( p );
245  }
246  // create digital set.
247  std::vector< Point > X( S.cbegin(), S.cend() );
248  // Analyse P-convexity
249  std::chrono::high_resolution_clock::time_point
250  t1 = std::chrono::high_resolution_clock::now();
251  bool is_pconvex = pconv.isPConvex( X );
252  std::chrono::high_resolution_clock::time_point
253  t2 = std::chrono::high_resolution_clock::now();
254  double dt = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
255  results.push_back( std::make_tuple( X.size(), dt/1e6, is_pconvex ) );
256  }
257 }

References dim(), domain, dt, and DGtal::PConvexity< TSpace >::isPConvex().