DGtal 1.4.2
Loading...
Searching...
No Matches
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}
timingsFullConvexityNonConvex
void timingsFullConvexityNonConvex(std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t range)
Definition pConvexity-benchmark.cpp:261
timingsFullConvexity
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)
Definition pConvexity-benchmark.cpp:122
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
timingsPConvexityNonConvex
void timingsPConvexityNonConvex(std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t range)
Definition pConvexity-benchmark.cpp:220
timingsFullConvexityFast
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)
Definition pConvexity-benchmark.cpp:170
timingsPConvexity
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)
Definition pConvexity-benchmark.cpp:74
timingsFullConvexityFastNonConvex
void timingsFullConvexityFastNonConvex(std::vector< std::tuple< std::size_t, double, bool > > &results, std::size_t nb_tries, std::size_t range)
Definition pConvexity-benchmark.cpp:303
srand
srand(0)

References outputResults(), srand(), timingsFullConvexity(), timingsFullConvexityFast(), timingsFullConvexityFastNonConvex(), timingsFullConvexityNonConvex(), timingsPConvexity(), and timingsPConvexityNonConvex().

◆ 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}

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().

Referenced by main().

◆ 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().

Referenced by main().

◆ 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().

Referenced by main().

◆ 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().

Referenced by main().

◆ 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().

Referenced by main().

◆ 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().

Referenced by main().