Commit 27d9921d authored by Alexander Wiebel's avatar Alexander Wiebel

[MERGE]

parents fe424a95 ee4c22e9
......@@ -23,64 +23,45 @@
//---------------------------------------------------------------------------
#include <algorithm>
#include <iomanip>
#include <numeric>
#include "WAssert.h"
#include "WHistogram.h"
#include "WLimits.h"
#include "WLogger.h"
WHistogram::WHistogram( double min, double max, size_t size )
: m_bins( size, 0 ),
m_min( min ),
m_max( max )
WHistogram::WHistogram( double min, double max, size_t buckets ):
m_minimum( min ),
m_maximum( max ),
m_nbBuckets( buckets )
{
if( min > max )
{
std::swap( m_min, m_max );
std::swap( m_minimum, m_maximum );
}
WAssert( m_bins.size() > 0, "Error: A histogram with a size of 0 does not make any sense" );
m_intervalWidth = std::abs( m_min - m_max ) / m_bins.size();
WAssert( buckets > 0, "Error: A histogram with a size of 0 does not make any sense." );
}
WHistogram::~WHistogram()
WHistogram::WHistogram( const WHistogram& hist ):
m_minimum( hist.m_minimum ),
m_maximum( hist.m_maximum ),
m_nbBuckets( hist.m_nbBuckets )
{
}
void WHistogram::insert( double value )
WHistogram::~WHistogram()
{
if( value > m_max || value < m_min )
{
wlog::warn( "WHistogram" ) << std::scientific << std::setprecision( 16 ) << "Inserted value out of bounds, thread: "
<< value << " as min, resp. max: " << m_min << "," << m_max;
return; // value = ( value > m_max ? m_max : m_min );
}
if( value == m_max )
{
value = m_max - wlimits::DBL_EPS;
}
m_bins.at( static_cast< size_t >( std::abs( value - m_min ) / m_intervalWidth ) )++;
}
size_t WHistogram::binSize() const
size_t WHistogram::size() const
{
return m_bins.size();
return m_nbBuckets;
}
size_t WHistogram::valuesSize() const
double WHistogram::getMinimum() const
{
return std::accumulate( m_bins.begin(), m_bins.end(), 0 );
return m_minimum;
}
size_t WHistogram::operator[]( size_t index ) const
double WHistogram::getMaximum() const
{
if( index >= m_bins.size() )
{
wlog::error( "WHistogram" ) << index << "th interval is not available, there are only: " << m_bins.size();
return 0;
}
return m_bins[ index ];
return m_maximum;
}
......@@ -25,80 +25,113 @@
#ifndef WHISTOGRAM_H
#define WHISTOGRAM_H
#include <vector>
#include <utility>
/**
* Container which associate values with (uniform width) bins (aka intervals or buckets).
* Container which associate values with (uniform width) bins (aka intervals or buckets). This class implements the abstract interface and
* therefore builds the base class for all histogram classes. The interface also allows programming histogram of different bucket sizes.
*/
class WHistogram
{
public:
/**
* Default constructor.
* Default constructor. Creates an empty histogram covering the specified min and max values with the specified number of buckets.
*
* \param min
* \param max
* \param size
* \param min the smallest value
* \param max the largest value
* \param buckets the number of buckets
*/
WHistogram( double min, double max, size_t size = 1000 );
WHistogram( double min, double max, size_t buckets = 1000 );
/**
* Copy constructor. Creates a deep copy of the specified histogram.
*
* \param hist the histogram to copy.
*/
WHistogram( const WHistogram& hist );
/**
* Default destructor.
*/
~WHistogram();
virtual ~WHistogram();
/**
* Inserts a given value within the given range (min, max) into exactly one bin and increment its size.
* Get the count of the specified bucket.
*
* \param index which buckets count is to be returned; starts with 0 which is the bucket containing the smallest values.
*
* \param value Value to insert.
* \return elements in the bucket.
*/
void insert( double value );
virtual size_t operator[]( size_t index ) const = 0;
/**
* Computes number of invervals.
* Get the count of the specified bucket. Testing if the position is valid.
*
* \param index which buckets count is to be returned; starts with 0 which is the bucket containing the smallest values.
*
* \return Number of intervals.
* \return elements in the bucket
*/
size_t binSize() const;
virtual size_t at( size_t index ) const = 0;
/**
* Computes the number of inserted values so far.
* Returns the number of buckets in the histogram with the actual mapping.
*
* \return Number of values so far.
* \return number of buckets
*/
size_t valuesSize() const;
virtual size_t size() const;
/**
* LooksUp how many elements are in this bin with the given index.
* Returns the minimum value.
*
* \param index The bin number to look up for
* \return minimum
*/
virtual double getMinimum() const;
/**
* Returns the maximum value.
*
* \return Number of values associated with this interval.
* \return maximum
*/
size_t operator[]( size_t index ) const;
virtual double getMaximum() const;
protected:
/**
* Return the size of one specific bucket.
*
* \param index the width for this bucket is queried.
*
* \return the size of a bucket.
*/
virtual double getBucketSize( size_t index = 0 ) const = 0;
private:
/**
* Bins to associate with the values. Each bin has the width of m_intervalWidth;
* Returns the actual interval associated with the given index. The interval is open, meaning that
* getIntervalForIndex( i ).second == getIntervalForIndex( i + 1 ).first but does not belong anymore to the interval itself but every value
* smaller than getIntervalForIndex( i ).second.
*
* \param index the intex
*
* \return the open interval.
*/
std::vector< size_t > m_bins;
virtual std::pair< double, double > getIntervalForIndex( size_t index ) const = 0;
protected:
/**
* Minimal value
* The smallest value
*/
double m_min;
double m_minimum;
/**
* Maximal value
* The biggest value
*/
double m_max;
double m_maximum;
/**
* The width of an interval is precomputed to save performance.
* The number of buckets.
*/
double m_intervalWidth;
double m_nbBuckets;
private:
};
#endif // WHISTOGRAM_H
//---------------------------------------------------------------------------
//
// Project: OpenWalnut ( http://www.openwalnut.org )
//
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
//
// This file is part of OpenWalnut.
//
// OpenWalnut 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.
//
// OpenWalnut 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
//
//---------------------------------------------------------------------------
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <utility>
#include "WAssert.h"
#include "WHistogramBasic.h"
#include "WLimits.h"
#include "WLogger.h"
WHistogramBasic::WHistogramBasic( double min, double max, size_t buckets ):
WHistogram( min, max, buckets ),
m_bins( buckets, 0 ),
m_intervalWidth( ( m_maximum - m_minimum ) / static_cast< double >( m_nbBuckets ) )
{
}
WHistogramBasic::WHistogramBasic( const WHistogramBasic& hist ):
WHistogram( hist ),
m_bins( hist.m_bins ),
m_intervalWidth( hist.m_intervalWidth )
{
}
WHistogramBasic::~WHistogramBasic()
{
}
size_t WHistogramBasic::operator[]( size_t index ) const
{
return m_bins[ index ];
}
size_t WHistogramBasic::at( size_t index ) const
{
if( index >= m_bins.size() )
{
wlog::error( "WHistogramBasic" ) << index << "th interval is not available, there are only: " << m_bins.size();
return 0;
}
return m_bins[ index ];
}
double WHistogramBasic::getBucketSize( size_t /* index */ ) const
{
return m_intervalWidth;
}
std::pair< double, double > WHistogramBasic::getIntervalForIndex( size_t index ) const
{
double first = m_minimum + m_intervalWidth * index;
double second = m_minimum + m_intervalWidth * ( index + 1 );
return std::make_pair( first, second );
}
void WHistogramBasic::insert( double value )
{
if( value > m_maximum || value < m_minimum )
{
wlog::warn( "WHistogramBasic" ) << std::scientific << std::setprecision( 16 ) << "Inserted value out of bounds, thread: "
<< value << " as min, resp. max: " << m_minimum << "," << m_maximum;
return; // value = ( value > m_maximum ? m_maximum : m_minimum );
}
if( value == m_maximum )
{
value = m_maximum - wlimits::DBL_EPS;
}
m_bins.at( static_cast< size_t >( std::abs( value - m_minimum ) / m_intervalWidth ) )++;
}
size_t WHistogramBasic::valuesSize() const
{
return std::accumulate( m_bins.begin(), m_bins.end(), 0 );
}
//---------------------------------------------------------------------------
//
// Project: OpenWalnut ( http://www.openwalnut.org )
//
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
//
// This file is part of OpenWalnut.
//
// OpenWalnut 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.
//
// OpenWalnut 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
//
//---------------------------------------------------------------------------
#ifndef WHISTOGRAMBASIC_H
#define WHISTOGRAMBASIC_H
#include <utility>
#include <vector>
#include "WHistogram.h"
/**
* Container which associate values with (uniform width) bins (aka intervals or buckets). This class implements a very simple and easy to use
* generic histogram with uniform bucket sizes.
*/
class WHistogramBasic: public WHistogram
{
public:
/**
* Default constructor. Creates an empty histogram covering the specified min and max values with the specified number of buckets.
*
* \param min the smallest value
* \param max the largest value
* \param buckets the number of buckets
*/
WHistogramBasic( double min, double max, size_t buckets = 1000 );
/**
* Copy constructor. Creates a deep copy of the specified histogram.
*
* \param hist the histogram to copy.
*/
WHistogramBasic( const WHistogramBasic& hist );
/**
* Default destructor.
*/
~WHistogramBasic();
/**
* Get the count of the specified bucket.
*
* \param index which buckets count is to be returned; starts with 0 which is the bucket containing the smallest values.
*
* \return elements in the bucket.
*/
virtual size_t operator[]( size_t index ) const;
/**
* Get the count of the specified bucket. Testing if the position is valid.
*
* \param index which buckets count is to be returned; starts with 0 which is the bucket containing the smallest values.
*
* \return elements in the bucket
*/
virtual size_t at( size_t index ) const;
/**
* Return the size of one specific bucket.
*
* \param index the width for this bucket is queried.
*
* \return the size of a bucket.
*/
virtual double getBucketSize( size_t index = 0 ) const;
/**
* Returns the actual interval associated with the given index. The interval is open, meaning that
* getIntervalForIndex( i ).second == getIntervalForIndex( i + 1 ).first but does not belong anymore to the interval itself but every value
* smaller than getIntervalForIndex( i ).second.
*
* \param index the intex
*
* \return the open interval.
*/
virtual std::pair< double, double > getIntervalForIndex( size_t index ) const;
/**
* Computes the number of inserted values so far.
*
* \return Number of values so far.
*/
size_t valuesSize() const;
/**
* Inserts a given value within the given range (min, max) into exactly one bin and increment its size.
*
* \param value Value to insert.
*/
virtual void insert( double value );
protected:
private:
/**
* Bins to associate with the values. Each bin has the width of m_intervalWidth;
*/
std::vector< size_t > m_bins;
/**
* The width of an interval is precomputed to save performance.
*/
double m_intervalWidth;
};
#endif // WHISTOGRAMBASIC_H
......@@ -22,21 +22,21 @@
//
//---------------------------------------------------------------------------
#ifndef WHISTOGRAM_TEST_H
#define WHISTOGRAM_TEST_H
#ifndef WHISTOGRAMBASIC_TEST_H
#define WHISTOGRAMBASIC_TEST_H
#include <cxxtest/TestSuite.h>
#include "../WHistogram.h"
#include "../WHistogramBasic.h"
#include "../WLimits.h"
#include "../WLogger.h"
static WLogger logger;
/**
* Unit tests the WHistogram class.
* Unit tests the WHistogramBasic class.
*/
class WHistogramTest : public CxxTest::TestSuite
class WHistogramBasicTest : public CxxTest::TestSuite
{
public:
/**
......@@ -44,8 +44,8 @@ public:
*/
void testInitialization( void )
{
WHistogram h( 0.0, 1.0 );
TS_ASSERT_EQUALS( h.binSize(), 1000 );
WHistogramBasic h( 0.0, 1.0 );
TS_ASSERT_EQUALS( h.size(), 1000 );
TS_ASSERT_EQUALS( h.valuesSize(), 0 );
}
......@@ -54,9 +54,9 @@ public:
*/
void testInsert( void )
{
WHistogram h( 0.0, 1.0 );
WHistogramBasic h( 0.0, 1.0 );
h.insert( 0.7234 );
TS_ASSERT_EQUALS( h.binSize(), 1000 );
TS_ASSERT_EQUALS( h.size(), 1000 );
TS_ASSERT_EQUALS( h.valuesSize(), 1 );
TS_ASSERT_EQUALS( h[723], 1 );
}
......@@ -66,7 +66,7 @@ public:
*/
void testInsertOnIntervalBorder( void )
{
WHistogram h( 0.0, 1.0 );
WHistogramBasic h( 0.0, 1.0 );
h.insert( 0.001 );
TS_ASSERT_EQUALS( h[1], 1 );
h.insert( 0.0039999 );
......@@ -80,7 +80,7 @@ public:
*/
void testInsertMin( void )
{
WHistogram h( 0.0, 1.0 );
WHistogramBasic h( 0.0, 1.0 );
h.insert( 0.0 );
TS_ASSERT_EQUALS( h[0], 1 );
TS_ASSERT_EQUALS( h[1], 0 );
......@@ -91,7 +91,7 @@ public:
*/
void testInsertMax( void )
{
WHistogram h( 0.0, 1.0 );
WHistogramBasic h( 0.0, 1.0 );
h.insert( 0.0 );
h.insert( 1.0 );
TS_ASSERT_EQUALS( h[999], 1 );
......@@ -103,10 +103,10 @@ public:
*/
void testInsertOutOfBounds( void )
{
WHistogram h( 0.0, 1.0 );
WHistogramBasic h( 0.0, 1.0 );
h.insert( 1.0 + wlimits::DBL_EPS );
h.insert( 0.0 - wlimits::DBL_EPS );
for( size_t i = 0; i < h.binSize(); ++i )
for( size_t i = 0; i < h.size(); ++i )
{
TS_ASSERT_EQUALS( h[i], 0 );
}
......@@ -117,8 +117,8 @@ public:
*/
void testOperatorToGetNumberOfElementsInsideTheBin( void )
{
WHistogram h( 0.0, 1.0 );
for( size_t i = 0; i < h.binSize(); ++i )
WHistogramBasic h( 0.0, 1.0 );
for( size_t i = 0; i < h.size(); ++i )
{
TS_ASSERT_EQUALS( h[i], 0 );
}
......@@ -128,4 +128,4 @@ public:
}
};
#endif // WHISTOGRAM_TEST_H
#endif // WHISTOGRAMBASIC_TEST_H
......@@ -27,6 +27,7 @@
#include "../common/WAssert.h"
#include "../common/WLimits.h"
#include "datastructures/WValueSetHistogram.h"
#include "WDataSetSingle.h"
#include "WDataSetScalar.h"
......@@ -42,18 +43,6 @@ WDataSetScalar::WDataSetScalar( boost::shared_ptr< WValueSetBase > newValueSet,
WAssert( newGrid, "No grid given." );
WAssert( newValueSet->size() == newGrid->size(), "Number of values unequal number of positions in grid." );
WAssert( newValueSet->order() == 0, "The value set does not contain scalars." );
double max = wlimits::MIN_DOUBLE;
double min = wlimits::MAX_DOUBLE;
for( size_t i = 0; i < newValueSet->size(); ++i )
{
double tmp = newValueSet->getScalarDouble( i );
max = max < tmp ? tmp : max;
min = min > tmp ? tmp : min;
}
m_maximum = max;
m_minimum = min;
}
WDataSetScalar::WDataSetScalar()
......@@ -62,34 +51,18 @@ WDataSetScalar::WDataSetScalar()
// default constructor used by the prototype mechanism
}
WDataSetScalar::WDataSetScalar( boost::shared_ptr< WValueSetBase > newValueSet,
boost::shared_ptr< WGrid > newGrid,
double max,
double min )
: WDataSetSingle( newValueSet, newGrid )
{
WAssert( newValueSet, "No value set given." );
WAssert( newGrid, "No grid given." );
WAssert( newValueSet->size() == newGrid->size(), "Number of values unequal number of positions in grid." );
WAssert( newValueSet->order() == 0, "The value set does not contain scalars." );
WAssert( max >= min, "max must be at least as large as min." );
m_maximum = max;
m_minimum = min;
}
WDataSetScalar::~WDataSetScalar()
{
}
double WDataSetScalar::getMax() const
{
return m_maximum;
return m_valueSet->getMaximumValue();
}
double WDataSetScalar::getMin() const
{
return m_minimum;
return m_valueSet->getMinimumValue();
}
boost::shared_ptr< WPrototyped > WDataSetScalar::getPrototype()
......@@ -161,3 +134,19 @@ double WDataSetScalar::getValueAt( int x, int y, int z ) const
return WDataSetSingle::getValueAt( id );
}
boost::shared_ptr< const WValueSetHistogram > WDataSetScalar::getHistogram( size_t buckets )
{
boost::lock_guard<boost::mutex> lock( m_histogramLock );
if ( m_histograms.count( buckets ) != 0 )
{
return m_histograms[ buckets ];
}
// create if not yet existing
m_histograms[ buckets ] = boost::shared_ptr< WValueSetHistogram >( new WValueSetHistogram( m_valueSet, buckets ) );
return m_histograms[ buckets ];
}