HyperVolume.cpp

Go to the documentation of this file.

#include "Mint/HyperVolume.h"

HyperVolume::HyperVolume(int dimension) : 
  _dimension ( dimension )
{ 
}

HyperVolume::HyperVolume(const HyperPoint& lowCorner, const HyperPoint& highCorner) : 
  _dimension ( lowCorner.size() )
{ 
  _hyperCuboids.push_back(HyperCuboid(lowCorner, highCorner));
}


HyperVolume::HyperVolume(const HyperCuboid& cuboid) :
  _dimension ( cuboid.getDimension() )
{

  _hyperCuboids.push_back(cuboid);

}

HyperVolume::HyperVolume(const HyperCuboid& cuboid1, const HyperCuboid& cuboid2) :
  _dimension ( cuboid1.getDimension() )
{
  push_back(cuboid1);
  push_back(cuboid2);
}

bool HyperVolume::inVolume(const HyperPoint& coords) const{

  for(unsigned int i = 0; i < _hyperCuboids.size(); i++){
    if(_hyperCuboids.at(i).inVolume(coords)==1) return 1;
  }
  return 0;

}

bool HyperVolume::inVolume(const HyperPointSet& coords) const{
  
  int ncoords = coords.size();
  for (int i = 0; i < ncoords; i++){
    if ( inVolume(coords.at(i)) == false ) return false;
  }
  return true;
}

HyperVolume HyperVolume::operator+ (const HyperVolume & other) const{
  
  if (getDimension() != other.getDimension()) {
    ERROR_LOG << "You are trying to add HyperVolumes of different dimensions.";
    return *this;
  }
  HyperVolume volume(getDimension());
  for(int i = 0; i < size(); i++){
    volume.addHyperCuboid(getHyperCuboid(i));
  }
  for(int i = 0; i < other.size(); i++){
    volume.addHyperCuboid(other.getHyperCuboid(i));
  }
  return volume;
}

HyperVolume & HyperVolume::operator= (const HyperVolume & other){
  
  _hyperCuboids = other._hyperCuboids;
  _dimension =    other._dimension;

  return *this;
}

void HyperVolume::addHyperCuboid(const HyperPoint& lowCorner,const HyperPoint& highCorner){

  addHyperCuboid( HyperCuboid(lowCorner, highCorner) );
}

void HyperVolume::addHyperCuboid(const HyperCuboid& hyperCuboid){
  if (hyperCuboid.getDimension() == _dimension) _hyperCuboids.push_back(hyperCuboid);
  else ERROR_LOG << "The HyperCuboid you are adding to this HyperVolume has the wrong dimension";
}

void HyperVolume::push_back(const HyperCuboid& hyperCuboid){
  addHyperCuboid(hyperCuboid);
}



HyperPoint HyperVolume::getAverageCenter() const{
  
  HyperPoint binCenter(_dimension);
  double sumW = 0.0;

  for(unsigned int i = 0; i < _hyperCuboids.size(); i++){
    HyperPoint ithBinCenter = _hyperCuboids.at(i).getCenter();
    double weight =           _hyperCuboids.at(i).volume();
    
    binCenter = binCenter + ithBinCenter*weight;
    sumW += weight;
  }

  binCenter = binCenter/sumW;

  return binCenter;

}

double HyperVolume::volume() const{

  double volume = 0.0;
  for(unsigned int i = 0; i < _hyperCuboids.size(); i++){
    volume += _hyperCuboids.at(i).volume();
  }
  return volume;

}

double HyperVolume::getMin(int dimension) const{

  if (dimension < _dimension) {
    double min = _hyperCuboids.at(0).getLowCorner().at(dimension);
    for(unsigned int i = 1; i < _hyperCuboids.size(); i++){
      double temp = _hyperCuboids.at(i).getLowCorner().at(dimension);
      if (min > temp) min = temp;
    }
    return min;
  }

  ERROR_LOG << "You are requesting a dimensionality that does not exist in this HyperVolume";
  return -1.0;

}

double HyperVolume::getMax(int dimension) const{

  if (dimension < _dimension) {
    double max = _hyperCuboids.at(0).getHighCorner().at(dimension);
    for(unsigned int i = 1; i < _hyperCuboids.size(); i++){
      double temp = _hyperCuboids.at(i).getHighCorner().at(dimension);
      if (max < temp) max = temp;
    }
    return max;
  }

  ERROR_LOG << "You are requesting a dimensionality that does not exist in this HyperVolume";
  return -1.0;

}

HyperCuboid HyperVolume::getLimits() const{
  HyperCuboid limits(getDimension());
  for (int i = 0; i < getDimension(); i++){
    limits.getLowCorner ().at(i) = getMin(i);
    limits.getHighCorner().at(i) = getMax(i);
  }
  return limits;
}


void HyperVolume::print(std::ostream& os, int endline) const{

  for(unsigned int i = 0; i < _hyperCuboids.size(); i++){
    _hyperCuboids.at(i).print(os, 1);
  }  
  if (endline == 1) os << std::endl;
}

HyperVolume HyperVolume::slice(const HyperPoint& coords, std::vector<int> dims) const{
  
  int currentDim = getDimension();
  int sliceDim   = (int)dims.size();  
  int newDim     = currentDim - sliceDim;

  HyperVolume slicedVolume(newDim);

  for(unsigned int i = 0; i < _hyperCuboids.size(); i++){
    if(_hyperCuboids.at(i).inVolume(coords, dims)==1){
      //std::cout << "Woohoo - I'm in volume, lets project" << std::endl;
      HyperCuboid cube = _hyperCuboids.at(i).projectOpposite(dims);
      //std::cout << " ---- wow, it worked" << std::endl;
      slicedVolume.addHyperCuboid(cube);
    } 
  }

  return slicedVolume;

}

HyperVolume HyperVolume::splitAll(int dimension, double fractionalSplitPoint){

  HyperVolume hyperCuboidSet( getDimension() );

  for (int i = 0; i < size(); i++){
    at(i).split(dimension, fractionalSplitPoint, hyperCuboidSet);
  }

  return hyperCuboidSet;

}



HyperVolume::~HyperVolume() { 
}