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 391 of file pConvexity-benchmark.cpp.

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

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

References dim().

Referenced by main().

◆ rand01()

double rand01 ( )

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

70 { 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 122 of file pConvexity-benchmark.cpp.

125 {
126  typedef KhalimskySpaceND<dim,int64_t> KSpace;
127  typedef typename KSpace::Point Point;
128  typedef typename KSpace::Space Space;
129  typedef HyperRectDomain< Space > Domain;
130  typedef DigitalConvexity< KSpace > DConvexity;
131  typedef PConvexity< Space > PConvexity;
132  DConvexity dconv( Point::diagonal( -1 ), Point::diagonal( range ) );
133  PConvexity pconv;
134  Domain domain( Point::diagonal( 0 ), Point::diagonal( range ) );
135  std::cout << "Computing " << nb_tries << " full convexities in Z" << dim << std::endl;
136  for ( auto n = 0; n < nb_tries; ++n )
137  {
138  // Create vertices
139  std::vector< Point > V;
140  for ( auto i = 0; i < nb_vertices; i++ ) {
141  Point p;
142  for ( auto j = 0; j < dim; j++ ) p[ j ] = rand() % range;
143  V.push_back( p );
144  }
145  // create 0-convex or fully convex set.
146  std::vector< Point > X;
147  bool force_fconvexity = rand01() < fconvexity_probability;
148  if ( force_fconvexity )
149  X = dconv.envelope( V );
150  else
151  {
152  auto P = dconv.CvxH( V );
153  P.getPoints( X );
154  }
155  // Analyse full convexity
156  std::chrono::high_resolution_clock::time_point
157  t1 = std::chrono::high_resolution_clock::now();
158  bool is_fconvex = dconv.isFullyConvex( X );
159  std::chrono::high_resolution_clock::time_point
160  t2 = std::chrono::high_resolution_clock::now();
161  double dt = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
162  results.push_back( std::make_tuple( X.size(), dt/1e6, is_fconvex ) );
163  if ( force_fconvexity && ! is_fconvex )
164  trace.warning() << "Invalid computation of either FC* or full convexity !" << std::endl;
165  }
166 }
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:70
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 170 of file pConvexity-benchmark.cpp.

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

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

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 260 of file pConvexity-benchmark.cpp.

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

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 74 of file pConvexity-benchmark.cpp.

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

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

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