testLabelledMap-benchmark.cpp File Reference

#include <cstdio>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <forward_list>
#include <boost/version.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_smallint.hpp>
#include <boost/random/uniform_01.hpp>
#include <boost/random/geometric_distribution.hpp>
#include <boost/random/variate_generator.hpp>
#include "DGtal/base/Common.h"
#include "DGtal/base/LabelledMap.h"

Include dependency graph for testLabelledMap-benchmark.cpp:

Go to the source code of this file.

Macros
#define	BOOST_MAJOR_VERSION   (BOOST_VERSION / 100000)
#define	BOOST_MINOR_VERSION   (( BOOST_VERSION / 100) % 1000)
#define	BOOST_SUBMINOR_VERSION   (BOOST_VERSION % 100)

Functions
template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>
unsigned int	generateData (MapLXY &m, double proba_no_label, double proba_label)
template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>
double	sumAllData (MapLXY &m)
template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>
double	sumOneData (MapLXY &m, unsigned int l)
template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>
unsigned int	locateThreeData (MapLXY &m, unsigned int l1, unsigned int l2, unsigned int l3)
template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>
unsigned int	eraseOneData (MapLXY &m, unsigned int l)
int	main ()

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 5807), University of Savoie, France

Date

2012/07/02

This file is part of the DGtal library

Definition in file testLabelledMap-benchmark.cpp.

Macro Definition Documentation

BOOST_MAJOR_VERSION

#define BOOST_MAJOR_VERSION   (BOOST_VERSION / 100000)

Definition at line 50 of file testLabelledMap-benchmark.cpp.

BOOST_MINOR_VERSION

#define BOOST_MINOR_VERSION   (( BOOST_VERSION / 100) % 1000)

Definition at line 51 of file testLabelledMap-benchmark.cpp.

BOOST_SUBMINOR_VERSION

#define BOOST_SUBMINOR_VERSION   (BOOST_VERSION % 100)

Definition at line 52 of file testLabelledMap-benchmark.cpp.

Function Documentation

eraseOneData()

template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>

unsigned int eraseOneData	(	MapLXY &	m,
		unsigned int	l
	)

Definition at line 608 of file testLabelledMap-benchmark.cpp.

{
  unsigned int nb = 0;
  for ( unsigned int y = 0; y < Y; ++y )
    for ( unsigned int x = 0; x < X; ++x )
      {
        nb += m.erase( l, x, y );
      }
  std::cerr << "- " << nb << " values deleted." << endl;
  return nb;
}

generateData()

template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>

unsigned int generateData	(	MapLXY &	m,
		double	proba_no_label,
		double	proba_label
	)

Definition at line 522 of file testLabelledMap-benchmark.cpp.

{
  boost::mt19937 rng;         // produces randomness out of thin air
  rng.seed( 0 );
  boost::uniform_smallint<> diceL(0, L-1);  
  boost::uniform_01<> diceDouble;
  boost::geometric_distribution<> nbLabelsDist( proba_label ); // Y
  boost::variate_generator
    <boost::mt19937&, 
     boost::geometric_distribution<> > diceNbLabels( rng, nbLabelsDist);
  // E(Y) = (1-p)/p,  Var(Y) = (1-p)/p^2
  std::cerr << "E(Y)=" << ( (1-proba_label)/proba_label )
            << " Var(Y)=" << ( (1-proba_label)/(proba_label*proba_label) )
            << std::endl;
  unsigned int total = 0;
  for ( unsigned int y = 0; y < Y; ++y )
    for ( unsigned int x = 0; x < X; ++x )
      {
        if ( diceDouble( rng ) >= proba_no_label )
          {
            unsigned int nb = diceNbLabels();
            for ( unsigned int i = 0; i < nb; ++i )
              {
                unsigned int l = diceL( rng );
                double v = diceDouble( rng );
                m.setValue( v, l, x, y );
              }
            total += nb;
          }
      }
  std::cerr << "- " << total << " insertions." << endl;
  return total;
}

References DGtal::L.

locateThreeData()

template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>

unsigned int locateThreeData	(	MapLXY &	m,
		unsigned int	l1,
		unsigned int	l2,
		unsigned int	l3
	)

Definition at line 591 of file testLabelledMap-benchmark.cpp.

{
  unsigned int loc3 = 0;
  for ( unsigned int y = 0; y < Y; ++y )
    for ( unsigned int x = 0; x < X; ++x )
      {
        if ( ( m.hasLabel( l1, x, y ) ) 
             && ( m.hasLabel( l2, x, y ) ) 
             && ( m.hasLabel( l3, x, y ) ) )
          ++loc3;
      }
  std::cerr << "- " << loc3 << " places with " << l1 << ", " << l2 << " ," << l3 << endl;
  return loc3;
}

main()

int main

(

void

)

Probability that there is no data at this location.

If there is a possibility to have a data, this probability is used to define a geometric distribution that defines the number of data (ie valid labels) at this place. The smaller, the higher is the expectation. 0.5 means E(X) = 1.

Definition at line 620 of file testLabelledMap-benchmark.cpp.

{
  typedef double Value;
  static const unsigned int X = 100;
  static const unsigned int Y = 100;
  static const unsigned int L = 16;
  typedef DGtal::uint8_t Word;
  static const unsigned int N = 1;
  static const unsigned int M = 5;
  static const double PROBA_NO_LABEL = 0.75;
  static const double PROBA_LABEL = 0.5;
 
  typedef ArrayLXY<Value, L, X, Y> MyArrayLXY;
  typedef ArrayXYOfMap<Value, L, X, Y> MyArrayXYOfMap;
  typedef ArrayXYOfList<Value, L, X, Y> MyArrayXYOfList;
  typedef ArrayXYOfLabelledMap<Value, L, X, Y, Word, N, M > MyArrayXYOfLabelledMap;
 
  //----------------------------------------------------------------------
  trace.beginBlock ( "---------- ArrayLXY ---------------" );
  trace.beginBlock ( "Generating ArrayLXY" );
  MyArrayLXY* arrayLXY = new MyArrayLXY( -1.0 );
  generateData< MyArrayLXY, L, X, Y> ( *arrayLXY, PROBA_NO_LABEL, PROBA_LABEL );
  trace.endBlock();
 
  trace.beginBlock ( "Memory usage in ArrayLXY" );
  std::cerr << arrayLXY->area() << " bytes." << std::endl;
  trace.endBlock();
 
  trace.beginBlock ( "Sum all values ArrayLXY" );
  sumAllData< MyArrayLXY, L, X, Y> ( *arrayLXY );
  trace.endBlock();
 
  trace.beginBlock ( "Sum label 0 values ArrayLXY" );
  sumOneData< MyArrayLXY, L, X, Y> ( *arrayLXY, 0 );
  trace.endBlock();
 
  trace.beginBlock ( "Sum label 15 values ArrayLXY" );
  sumOneData< MyArrayLXY, L, X, Y> ( *arrayLXY, 15 );
  trace.endBlock();
 
  trace.beginBlock ( "Locate places (3, 7, 8) in ArrayLXY" );
  locateThreeData< MyArrayLXY, L, X, Y> ( *arrayLXY, 3, 7, 8 );
  trace.endBlock();
 
  trace.beginBlock ( "Erase label 9 in ArrayLXY" );
  eraseOneData< MyArrayLXY, L, X, Y> ( *arrayLXY, 9 );
  trace.endBlock();
 
  trace.beginBlock ( "Delete ArrayLXY" );
  delete arrayLXY;
  trace.endBlock();
  trace.endBlock();
 
  //----------------------------------------------------------------------
  trace.beginBlock ( "---------- ArrayXYOfMap ---------------" );
  trace.beginBlock ( "Generating ArrayXYOfMap" );
  MyArrayXYOfMap* arrayXYOfMap = new MyArrayXYOfMap();
  generateData< MyArrayXYOfMap, L, X, Y> ( *arrayXYOfMap, PROBA_NO_LABEL, PROBA_LABEL );
  trace.endBlock();
 
  trace.beginBlock ( "Memory usage in ArrayXYOfMap" );
  std::cerr << arrayXYOfMap->area() << " bytes." << std::endl;
  trace.endBlock();
 
  trace.beginBlock ( "Sum all values ArrayXYOfMap" );
  sumAllData< MyArrayXYOfMap, L, X, Y> ( *arrayXYOfMap );
  trace.endBlock();
 
  trace.beginBlock ( "Sum label 0 values ArrayXYOfMap" );
  sumOneData< MyArrayXYOfMap, L, X, Y> ( *arrayXYOfMap, 0 );
  trace.endBlock();
 
  trace.beginBlock ( "Sum label 15 values ArrayXYOfMap" );
  sumOneData< MyArrayXYOfMap, L, X, Y> ( *arrayXYOfMap, 15 );
  trace.endBlock();
 
  trace.beginBlock ( "Locate places (3, 7, 8) in ArrayXYOfMap" );
  locateThreeData< MyArrayXYOfMap, L, X, Y> ( *arrayXYOfMap, 3, 7, 8 );
  trace.endBlock();
 
  trace.beginBlock ( "Erase label 9 in ArrayXYOfMap" );
  eraseOneData< MyArrayXYOfMap, L, X, Y> ( *arrayXYOfMap, 9 );
  trace.endBlock();
 
  trace.beginBlock ( "Delete ArrayXYOfMap" );
  delete arrayXYOfMap;
  trace.endBlock();
  trace.endBlock();
 
  //----------------------------------------------------------------------
  trace.beginBlock ( "---------- ArrayXYOfList ---------------" );
  trace.beginBlock ( "Generating ArrayXYOfList" );
  MyArrayXYOfList* arrayXYOfList = new MyArrayXYOfList();
  generateData< MyArrayXYOfList, L, X, Y> ( *arrayXYOfList, PROBA_NO_LABEL, PROBA_LABEL );
  trace.endBlock();
 
  trace.beginBlock ( "Memory usage in ArrayXYOfList" );
  std::cerr << arrayXYOfList->area() << " bytes." << std::endl;
  trace.endBlock();
 
  trace.beginBlock ( "Sum all values ArrayXYOfList" );
  sumAllData< MyArrayXYOfList, L, X, Y> ( *arrayXYOfList );
  trace.endBlock();
 
  trace.beginBlock ( "Sum label 0 values ArrayXYOfList" );
  sumOneData< MyArrayXYOfList, L, X, Y> ( *arrayXYOfList, 0 );
  trace.endBlock();
 
  trace.beginBlock ( "Sum label 15 values ArrayXYOfList" );
  sumOneData< MyArrayXYOfList, L, X, Y> ( *arrayXYOfList, 15 );
  trace.endBlock();
 
  trace.beginBlock ( "Locate places (3, 7, 8) in ArrayXYOfList" );
  locateThreeData< MyArrayXYOfList, L, X, Y> ( *arrayXYOfList, 3, 7, 8 );
  trace.endBlock();
 
  trace.beginBlock ( "Erase label 9 in ArrayXYOfList" );
  eraseOneData< MyArrayXYOfList, L, X, Y> ( *arrayXYOfList, 9 );
  trace.endBlock();
 
  trace.beginBlock ( "Delete ArrayXYOfList" );
  delete arrayXYOfList;
  trace.endBlock();
  trace.endBlock();
 
  //----------------------------------------------------------------------
  trace.beginBlock ( "---------- ArrayXYOfLabelledMap ---------------" );
  trace.beginBlock ( "Generating ArrayXYOfLabelledMap" );
  MyArrayXYOfLabelledMap* arrayXYOfLabelledMap = new MyArrayXYOfLabelledMap;
  generateData< MyArrayXYOfLabelledMap, L, X, Y > ( *arrayXYOfLabelledMap, PROBA_NO_LABEL, PROBA_LABEL );
  trace.endBlock();
 
  trace.beginBlock ( "Memory usage in ArrayXYOfLabelledMap" );
  std::cerr << arrayXYOfLabelledMap->area() << " bytes." << std::endl;
  trace.endBlock();
 
  trace.beginBlock ( "Sum all values ArrayXYOfLabelledMap" );
  sumAllData< MyArrayXYOfLabelledMap, L, X, Y> ( *arrayXYOfLabelledMap );
  trace.endBlock();
 
  trace.beginBlock ( "Sum label 0 values ArrayXYOfLabelledMap" );
  sumOneData< MyArrayXYOfLabelledMap, L, X, Y> ( *arrayXYOfLabelledMap, 0 );
  trace.endBlock();
 
  trace.beginBlock ( "Sum label 15 values ArrayXYOfLabelledMap" );
  sumOneData< MyArrayXYOfLabelledMap, L, X, Y> ( *arrayXYOfLabelledMap, 15 );
  trace.endBlock();
 
  trace.beginBlock ( "Locate places (3, 7, 8) in ArrayXYOfLabelledMap" );
  locateThreeData< MyArrayXYOfLabelledMap, L, X, Y> ( *arrayXYOfLabelledMap, 3, 7, 8 );
  trace.endBlock();
 
  trace.beginBlock ( "Erase label 9 in ArrayXYOfLabelledMap" );
  eraseOneData< MyArrayXYOfLabelledMap, L, X, Y> ( *arrayXYOfLabelledMap, 9 );
  trace.endBlock();
 
  trace.beginBlock ( "Delete ArrayXYOfLabelledMap" );
  delete arrayXYOfLabelledMap;
  trace.endBlock();
  trace.endBlock();
 
  return 0;
}

References DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::L, and DGtal::trace.

sumAllData()

template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>

double sumAllData

(

MapLXY &

m

)

Definition at line 559 of file testLabelledMap-benchmark.cpp.

{
  double sum = 0.0;
  std::vector<unsigned int> labels;
  for ( unsigned int y = 0; y < Y; ++y )
    for ( unsigned int x = 0; x < X; ++x )
      {
        m.getLabels( labels, x, y );
        for ( unsigned int i = 0; i < labels.size(); ++i )
          sum += m.value( labels[ i ], x, y );
      }
  std::cerr << "- sum = " << sum << "." << endl;
  return sum;
}

sumOneData()

template<typename MapLXY , unsigned int L, unsigned int X, unsigned int Y>

double sumOneData	(	MapLXY &	m,
		unsigned int	l
	)

Definition at line 576 of file testLabelledMap-benchmark.cpp.

{
  double sum = 0.0;
  for ( unsigned int y = 0; y < Y; ++y )
    for ( unsigned int x = 0; x < X; ++x )
      {
        if ( m.hasLabel( l, x, y ) )
          sum += m.value( l, x, y );
      }
  std::cerr << "- sum = " << sum << "." << endl;
  return sum;
}