/vol/vipdata/irtk/geometry++/include/irtkPointSet.h

/*=========================================================================

  Library   : Image Registration Toolkit (IRTK)
  Module    : $Id: irtkPointSet.h 2 2008-12-23 12:40:14Z dr $
  Copyright : Imperial College, Department of Computing
              Visual Information Processing (VIP), 2008 onwards
  Date      : $Date: 2008-12-23 12:40:14 +0000 (Tue, 23 Dec 2008) $
  Version   : $Revision: 2 $
  Changes   : $Author: dr $

=========================================================================*/

#ifndef _IRTKPOINTSET_H

#define _IRTKPOINTSET_H

#define POINTSET_SIZE 4096

class irtkPointSet : public irtkObject
{

private:

  int _m;

  int _n;

  irtkPoint *_data;

public:

  //
  // Constructors and destructor
  //

  irtkPointSet();

  irtkPointSet(const irtkPointSet &);

  virtual ~irtkPointSet();

  //
  // Size get acccessor and clearing of irtkPointSet
  //

  int  Size() const;

  void Clear();

  //
  // Operators for access
  //

  irtkPoint   &operator()(int);

  irtkPoint    operator()(int) const;

  irtkPointSet operator()(int, int) const;

  //
  // Operators for irtkPointSet arithmetic
  //

  // irtkPointSet operation for =
  irtkPointSet &operator=(const irtkPointSet &);

  // irtkPointSet operator for Point adding
  irtkPointSet& operator+=(const irtkPoint&);

  // irtkPointSet operator for Point substraction
  irtkPointSet& operator-=(const irtkPoint&);

  // irtkPointSet operator for irtkPointSet adding
  irtkPointSet& operator+=(const irtkPointSet&);

  // irtkPointSet operator for irtkPointSet substraction
  irtkPointSet& operator-=(const irtkPointSet&);

  virtual irtkPoint CenterOfGravity() const;

  virtual void BoundingBox(irtkPoint &, irtkPoint &) const;

  //
  // Explicit methods to add or delete points
  //

  void Add(const irtkPoint&);

  void Del(const irtkPoint&);

  void Add(const irtkPointSet &);

  void Del(const irtkPointSet &);

  void Add(double *);

  void Del(double *);

  //
  // irtkPointSet in- and output
  //

  friend ostream& operator<< (ostream&, const irtkPointSet&);

  friend istream& operator>> (istream&, irtkPointSet&);

  void Read (char *);

  void Write(char *);

  void ReadVTK (char *);

  void WriteVTK(char *);

  //
  // Misc. functions
  //

  irtkPoint StandardDeviationEllipsoid() const;

  int IsInside(double, double) const;

};

inline irtkPointSet::irtkPointSet()
{
  // Initialize
  _n = 0;
  _m = POINTSET_SIZE;
  _data = new irtkPoint[POINTSET_SIZE];
}

inline irtkPointSet::irtkPointSet(const irtkPointSet &pset)
{
  int i;

  // Initialize
  _n = 0;
  _m = 0;
  _data = NULL;

  // Allocate memory
  if (pset._m  > 0) {
    _data = new irtkPoint[pset._m];
    _m = pset._m;
    _n = pset._n;
  }

  // Copy points
  for (i = 0; i < _n; i++) {
    _data[i] = pset._data[i];
  }
}

inline irtkPointSet::~irtkPointSet()
{
  if (_m > 0) {
    delete []_data;
    _m = 0;
    _n = 0;
  }
  _m = 0;
  _n = 0;
  _data = NULL;
}

inline irtkPoint& irtkPointSet::operator()(int j)
{
#ifdef NO_BOUNDS
  return _data[j];
#else
  if ((j >= 0) && (j < _n)) {
    return _data[j];
  } else {
    cerr << "irtkPointSet::operator(int) parameter out of range\n";
    exit(1);
  }
#endif
}

inline irtkPoint  irtkPointSet::operator()(int j) const
{
#ifdef NO_BOUNDS
  return _data[j];
#else
  if ((j >= 0) && (j < _n)) {
    return _data[j];
  } else {
    cerr << "irtkPointSet::operator(int) parameter out of range\n";
    exit(1);
  }
#endif
}

inline irtkPointSet& irtkPointSet::operator+=(const irtkPoint &p)
{
  this->Add(p);
  return *this;
}

inline irtkPointSet& irtkPointSet::operator-=(const irtkPoint &p)
{
  this->Del(p);
  return *this;
}

inline irtkPointSet& irtkPointSet::operator+=(const irtkPointSet &pset)
{
  this->Add(pset);
  return *this;
}

inline irtkPointSet& irtkPointSet::operator-=(const irtkPointSet &pset)
{
  this->Del(pset);
  return *this;
}

inline irtkPointSet irtkPointSet::operator()(int j, int k) const
{
  int i;
  irtkPointSet pset;

#ifdef NO_BOUNDS
  for (i = j; i < k; j++) {
    pset += _data[i];
  }
  return pset;
#else
  if ((j >= 0) && (k < _n)) {
    for (i = j; i < k; j++) {
      pset += _data[i];
    }
    return pset;
  } else {
    cerr << "irtkPointSet::operator(int, int) parameter out of range\n";
    exit(1);
  }
  return pset;
#endif
}

inline int irtkPointSet::Size() const
{
  return _n;
}

inline void irtkPointSet::Add(double *p)
{
  this->Add(irtkPoint(p[0], p[1], p[2]));
}

inline void irtkPointSet::Del(double *p)
{
  this->Del(irtkPoint(p[0], p[1], p[2]));
}

#endif

Generated on Mon Mar 23 16:55:52 2009 for IRTK by Doxygen 1.5.4