FeaturePoint.h

Go to the documentation of this file.

#ifndef   gra_FeaturePoint_H__
#define   gra_FeaturePoint_H__

#include "../oo/ObjBase.h"

#include "../math/Vector.h"

#include <string>
#include <typeinfo>
#include <cstdlib>
#include <cstdio>

namespace meow {

template<class Scalar, class Description>
class FeaturePoint: public ObjBase {
private:
  Vector<Scalar>      pos_;
  Vector<Description> des_;
public:
  FeaturePoint() {
  }

  FeaturePoint(size_t pDim, size_t dDim):
  pos_(pDim, Scalar(0)), des_(dDim, Description(0)) {
  }

  FeaturePoint(FeaturePoint const& fp):
  pos_(fp.pos_), des_(fp.des_) {
  }

  ~FeaturePoint() {
  }

  FeaturePoint& copyFrom(FeaturePoint const& fp) {
    pos_.copyFrom(fp.pos_);
    des_.copyFrom(fp.des_);
    return *this;
  }

  FeaturePoint& referenceFrom(FeaturePoint const& fp) {
    pos_.referenceFrom(fp.pos_);
    des_.referenceFrom(fp.des_);
    return *this;
  }

  Vector<Scalar> const& position() const {
    return pos_;
  }

  Vector<Scalar>& positionGet() {
    return pos_;
  }

  Vector<Description> const& description() const {
    return des_;
  }

  Vector<Description>& descriptionGet() {
    return des_;
  }

  Vector<Scalar> const& position(Vector<Scalar> const& p) const {
    pos_.copyFrom(p);
    return position();
  }

  Vector<Description> const& description(Vector<Description> const& d) {
    des_.copyFrom(d);
    return description();
  }

  Scalar position(size_t index) const {
    return pos_(index);
  }

  Description description(size_t i) const {
    return des_(i);
  }

  Scalar position(size_t i, Scalar const& s) {
    pos_.entry(i, s);
    return position(i);
  }

  Description description(size_t i, Description const& d) {
    des_.entry(i, d);
    return description(i);
  }

  FeaturePoint& operator=(FeaturePoint const& fp) {
    return copyFrom(fp);
  }

  Scalar const& operator()(size_t i) const {
    return position(i);
  }

  Description operator[](size_t i) const {
    return description(i);
  }

  bool write(FILE* f, bool bin, unsigned int fg) const {
    if (bin) {
      double tmp;
      for (size_t i = 0, I = position().dimension(); i < I; ++i) {
        if (fwrite(&(tmp = position(i)), sizeof(tmp), 1, f) < 1) return false;
      }
      for (size_t i = 0, I = description().dimension(); i < I; ++i) {
        if (fwrite(&(tmp = description(i)), sizeof(tmp), 1, f) < 1)
          return false;
      }
    }
    else {
      for (size_t i = 0, I = position().dimension(); i < I; ++i) {
        if (fprintf(f, "%f ", (double)position(i)) < 1) return false;
      }
      fprintf(f, "\n");
      for (size_t i = 0, I = description().dimension(); i < I; ++i) {
        if (fprintf(f, "%f ", (double)description(i)) < 1) return false;
      }
      fprintf(f, "\n");
    }
    return true;
  }

  bool read (FILE* f, bool bin, unsigned int fg) {
    if (bin) {
      double tmp;
      for (size_t i = 0, I = position().dimension(); i < I; ++i) {
        if (fread(&tmp, sizeof(tmp), 1, f) < 1) return false;
        position(i, tmp);
      }
      for (size_t i = 0, I = description().dimension(); i < I; ++i) {
        if (fread(&tmp, sizeof(tmp), 1, f) < 1) return false;
        description(i, tmp);
      }
    }
    else {
      double tmp;
      for (size_t i = 0, I = position().dimension(); i < I; ++i) {
        if (fscanf(f, "%lf", &tmp) < 1) return false;
        position(i, tmp);
      }
      for (size_t i = 0, I = description().dimension(); i < I; ++i) {
        if (fscanf(f, "%lf", &tmp) < 1) return false;
        description(i, tmp);
      }
    }
    return true;
  }

  ObjBase* create() const {
    return new FeaturePoint();
  }

  ObjBase* copyFrom(ObjBase const& b) {
    return &(copyFrom(*(FeaturePoint*)b));
  }

  char const* ctype() const {
    return typeid(*this).name();
  }

  std::string type() const {
    return std::string(ctype());
  }
};

} // meow

#endif // gra_FeaturePoint_H__