mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-02-23 05:19:18 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/iSWA' of github.com:OpenSpace/OpenSpace-Development into feature/iSWA

Browse Source
This commit is contained in:
Sebastian Piwell
2016-05-17 14:10:44 -04:00
parent be17e8851e ae131f88c5
commit 08f0204a66
2 changed files with 53 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
include/openspace/util/histogram.h
View File

@@ -33,19 +33,29 @@ class Histogram {
public:
Histogram();
Histogram(float minBin, float maxBin, int numBins);
Histogram(float minBin, float maxBin, int numBins, float *data);
Histogram(float minValue, float maxValue, int numBins);
Histogram(float minValue, float maxValue, int numBins, float *data);
Histogram(Histogram&& other);
~Histogram();
Histogram& operator=(Histogram&& other);
int numBins() const;
float minBin() const;
float maxBin() const;
float minValue() const;
float maxValue() const;
bool isValid() const;
bool add(float bin, float value);
/**
* Enter value into the histogram. The add method takes the given
* value, works out which bin this corresponds to, and increments
* this bin by 'repeat'.
*
* @param value The Value to insert into the histogram
* @param repeat How many times you want to insert it
*
* @return Returns true if succesful insertion, otherwise return false
*/
bool add(float value, float repeat = 1.0f);
bool add(const Histogram& histogram);
bool addRectangle(float lowBin, float highBin, float value);
@@ -63,8 +73,8 @@ public:
private:
int _numBins;
float _minBin;
float _maxBin;
float _minValue;
float _maxValue;
float* _data;
std::vector<float> _equalizer;

73
src/util/histogram.cpp
View File

@@ -35,15 +35,15 @@ namespace {
namespace openspace {
Histogram::Histogram()
: _minBin(0)
, _maxBin(0)
: _minValue(0)
, _maxValue(0)
, _numBins(-1)
, _numValues(0)
, _data(nullptr) {}
Histogram::Histogram(float minBin, float maxBin, int numBins)
: _minBin(minBin)
, _maxBin(maxBin)
Histogram::Histogram(float minValue, float maxValue, int numBins)
: _minValue(minValue)
, _maxValue(maxValue)
, _numBins(numBins)
, _numValues(0)
, _data(nullptr) {
@@ -54,16 +54,16 @@ Histogram::Histogram(float minBin, float maxBin, int numBins)
}
}
Histogram::Histogram(float minBin, float maxBin, int numBins, float *data)
: _minBin(minBin)
, _maxBin(maxBin)
Histogram::Histogram(float minValue, float maxValue, int numBins, float *data)
: _minValue(minValue)
, _maxValue(maxValue)
, _numBins(numBins)
, _numValues(0)
, _data(data) {}
Histogram::Histogram(Histogram&& other) {
_minBin = other._minBin;
_maxBin = other._maxBin;
_minValue = other._minValue;
_maxValue = other._maxValue;
_numBins = other._numBins;
_numValues = other._numValues;
_data = other._data;
@@ -71,8 +71,8 @@ Histogram::Histogram(Histogram&& other) {
}
Histogram& Histogram::operator=(Histogram&& other) {
_minBin = other._minBin;
_maxBin = other._maxBin;
_minValue = other._minValue;
_maxValue = other._maxValue;
_numBins = other._numBins;
_numValues = other._numValues;
_data = other._data;
@@ -92,12 +92,12 @@ int Histogram::numBins() const {
return _numBins;
}
float Histogram::minBin() const {
return _minBin;
float Histogram::minValue() const {
return _minValue;
}
float Histogram::maxBin() const {
return _maxBin;
float Histogram::maxValue() const {
return _maxValue;
}
bool Histogram::isValid() const {
@@ -105,23 +105,22 @@ bool Histogram::isValid() const {
}
bool Histogram::add(float bin, float value) {
if (bin < _minBin || bin > _maxBin) {
bool Histogram::add(float value, float repeat) {
if (value < _minValue || value > _maxValue) {
// Out of range
return false;
}
float normalizedBin = (bin - _minBin) / (_maxBin - _minBin); // [0.0, 1.0]
int binIndex = floor(normalizedBin * _numBins); // [0, _numBins]
if (binIndex == _numBins) binIndex--; // [0, _numBins[
float normalizedValue = (value - _minValue) / (_maxValue - _minValue); // [0.0, 1.0]
int binIndex = std::min( floor(normalizedValue * _numBins), _numBins - 1.0 ); // [0, _numBins - 1]
_data[binIndex] += value;
_numValues++;
_data[binIndex] += repeat;
_numValues += repeat;
return true;
}
bool Histogram::add(const Histogram& histogram) {
if (_minBin == histogram.minBin() && _maxBin == histogram.maxBin() && _numBins == histogram.numBins()) {
if (_minValue == histogram.minValue() && _maxValue == histogram.maxValue() && _numBins == histogram.numBins()) {
const float* data = histogram.data();
for (int i = 0; i < _numBins; i++) {
@@ -142,13 +141,13 @@ bool Histogram::addRectangle(float lowBin, float highBin, float value) {
if (lowBin > highBin) {
std::swap(lowBin, highBin);
}
if (lowBin < _minBin || highBin > _maxBin) {
if (lowBin < _minValue || highBin > _maxValue) {
// Out of range
return false;
}
float normalizedLowBin = (lowBin - _minBin) / (_maxBin - _minBin);
float normalizedHighBin = (highBin - _minBin) / (_maxBin - _minBin);
float normalizedLowBin = (lowBin - _minValue) / (_maxValue - _minValue);
float normalizedHighBin = (highBin - _minValue) / (_maxValue - _minValue);
float lowBinIndex = normalizedLowBin * _numBins;
float highBinIndex = normalizedHighBin * _numBins;
@@ -174,7 +173,7 @@ bool Histogram::addRectangle(float lowBin, float highBin, float value) {
float Histogram::interpolate(float bin) const {
float normalizedBin = (bin - _minBin) / (_maxBin - _minBin);
float normalizedBin = (bin - _minValue) / (_maxValue - _minValue);
float binIndex = normalizedBin * _numBins - 0.5; // Center
float interpolator = binIndex - floor(binIndex);
@@ -236,7 +235,7 @@ void Histogram::generateEqualizer(){
* Will return a equalized histogram
*/
Histogram Histogram::equalize(){
Histogram equalizedHistogram(_minBin, _maxBin, _numBins);
Histogram equalizedHistogram(_minValue, _maxValue, _numBins);
for(int i = 0; i < _numBins; i++){
equalizedHistogram._data[(int)_equalizer[i]] += _data[i];
@@ -246,16 +245,16 @@ Histogram Histogram::equalize(){
}
/*
* Given a value within the domain of this histogram (_minBin < value < maxBin),
* Given a value within the domain of this histogram (_minValue < value < maxValue),
* this method will use its equalizer to return a histogram equalized result.
*/
float Histogram::equalize(float value){
if (value < _minBin || value > _maxBin) {
LWARNING("Equalized value is is not within domain of histogram. min: " + std::to_string(_minBin) + " max: " + std::to_string(_maxBin) + " val: " + std::to_string(value));
if (value < _minValue || value > _maxValue) {
LWARNING("Equalized value is is not within domain of histogram. min: " + std::to_string(_minValue) + " max: " + std::to_string(_maxValue) + " val: " + std::to_string(value));
}
float normalizedValue = (value-_minBin)/(_maxBin-_minBin);
float normalizedValue = (value-_minValue)/(_maxValue-_minValue);
int bin = floor(normalizedValue * _numBins);
// If value == _maxBins then bin == _numBins, which is a invalid index.
// If value == _maxValues then bin == _numBins, which is a invalid index.
bin = std::min(_numBins-1, bin);
return _equalizer[bin];
@@ -272,10 +271,10 @@ float Histogram::entropy(){
void Histogram::print() const {
std::cout << "number of bins: " << _numBins << std::endl
<< "range: " << _minBin << " - " << _maxBin << std::endl << std::endl;
<< "range: " << _minValue << " - " << _maxValue << std::endl << std::endl;
for (int i = 0; i < _numBins; i++) {
float low = _minBin + float(i) / _numBins * (_maxBin - _minBin);
float high = low + (_maxBin - _minBin) / float(_numBins);
float low = _minValue + float(i) / _numBins * (_maxValue - _minValue);
float high = low + (_maxValue - _minValue) / float(_numBins);
std::cout << i << " [" << low << ", " << high << "]"
<< " " << _data[i] << std::endl;
}