Density.H

Go to the documentation of this file.

// $Revision: 1.21 $  $Author: schwehr $  $Date: 2004/11/03 00:29:22 $
/*
    Copyright (C) 2004  Kurt Schwehr

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 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, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifndef _DENSITY_H_
#define _DENSITY_H_

#include <vector>
#include <string>





enum PackType {PACK_SCALE, PACK_CLIP, PACK_WRAP};



class Density {
public:
  Density();

  Density(const size_t width, const size_t height, const size_t depth,
          const float minX, const float maxX,
          const float minY, const float maxY,
          const float minZ, const float maxZ
          );

  Density(const std::string &filename, bool &ok);

  void resize(const size_t width, const size_t height, const size_t depth,
              const float minX, const float maxX,
              const float minY, const float maxY,
              const float minZ, const float maxZ
              );



  void rescale(const float minX, const float maxX,
               const float minY, const float maxY,
               const float minZ, const float maxZ
              );


  bool addPoint(const float x, const float y, const float z);
  void addPoints(const size_t index,const size_t count) {assert(isValidCell(index)); counts[index]+=count; totalPointsInside+=count;}
  void printCellCounts() const;
  size_t getWidth()  const {return (width);} 
  size_t getHeight() const {return (height);} 
  size_t getDepth()  const {return (depth);} 
  size_t getSize() const {return (counts.size());} 

  size_t getCountInside() const {return(totalPointsInside);}
  size_t getCountOutside() const {return(totalPointsOutside);}

  size_t getCell(const float x, const float y, const float z) const;
  bool   isValidCell(const size_t i) const {return(i<counts.size()?true:false);}
  size_t getCellX(const float x) const {return(size_t((x-xR[0])/dx));}
  size_t getCellY(const float y) const {return(size_t((y-yR[0])/dy));}
  size_t getCellZ(const float z) const {return(size_t((z-zR[0])/dz));}
  void   getCellXYZ(const size_t index, size_t &cx, size_t &cy, size_t &cz) const;
  size_t getCellFromWHD(const size_t xIndex, const size_t yIndex, const size_t zIndex) const;


  enum NeighborEnum {LEFT,RIGHT,FRONT,BACK,BELOW,ABOVE,NUM_NEIGHBORS=6};
  size_t getCellNeighbor(const size_t i, NeighborEnum which) const; 

  void getCellCenter(const size_t cellNum, float &x, float &y, float &z) const;

  size_t getCellCount(size_t i) const{assert(isValidCell(i));return(counts[i]);}


  float getDX() const {return(dx);}  
  float getDY() const {return(dy);}  
  float getDZ() const {return(dz);}  

  bool writeVolScale(const std::string &filename) const;

  size_t scaleValue(const size_t value, const PackType p, const size_t bitsPerVoxel) const;

  bool writeVol(const std::string &filename,const size_t bitsPerPixel,const PackType p) const;

  bool writeVol(const std::string &filename,
                       const size_t bitsPerVoxel,const PackType p,
                       const float scaleX, const float scaleY, const float scaleZ,
                       const float rotX=0.f, const float rotY=0.f,const float rotZ=0.f
                ) const;


  static size_t badValue() {return(std::numeric_limits<size_t>::max());}

  unsigned char scaleCount(const size_t i, const size_t min, const size_t max) const;

  bool buildCDF(std::vector<float> &cdfpercent) const;

private:
  // Computing min/max doesn't change the object, so mutable
  mutable bool stale; 
  mutable size_t maxCache, minCache;
  void invalidateCache() {stale=true; maxCache=minCache=badValue();}
  void computeMinMax() const;

public:

  size_t getMaxCount() const; 
  size_t getMinCount() const; 


#ifndef REGRESSION_TEST
private:
#endif
  //size_t cellSize[3]; 
  size_t width;  
  size_t height; 
  size_t depth;  

  float dx; 
  float dy; 
  float dz; 

  float xR[2]; 
  float yR[2]; 
  float zR[2]; 

  std::vector<size_t> counts; 
  size_t totalPointsInside; 
  size_t totalPointsOutside; 
};
#endif // _DENSITY_H_

---