Eye.h

Go to the documentation of this file.

#ifndef   Eye_H__
#define   Eye_H__

#include "Camera.h"

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

namespace meow {

template<class Pixel>
class Eye: public ObjBase {
private:
  struct Myself {
    Camera<Pixel>    cam_;
    Vector3D<double> ofs_;
    
    Myself(): cam_(), ofs_(0.0, 0.0, 0.0) {
    }
    
    Myself(Camera<Pixel> const& c, Vector3D<double> const& o): cam_(c), ofs_(o){
    }
    
    Myself(Myself const& b): cam_(b.cam_), ofs_(b.ofs_) {
    }
    
    ~Myself() {
    }
  };
  
  Self<Myself> const self;
public:
  Eye(): self() {
  }
  
  Eye(Eye const& b): self(b.self(), Self<Myself>::COPY_FROM) {
  }
  
  Eye(Camera<Pixel> const& c, Vector3D<double> const& o): self(Myself(c, o)) {
  }
  
  ~Eye() {
  }
  
  Eye& copyFrom(Eye const& e) {
    self().copyFrom(e.self);
    return *this;
  }
  
  Eye& referenceFrom(Eye const& e) {
    self().referenceFrom(e.self);
    return *this;
  }
  
  Camera<Pixel> const& camera() const {
    return self->cam_;
  }
  
  Camera<Pixel>& cameraGet() {
    return self()->cam_;
  }
  
  Camera<Pixel> const& camera(Camera<Pixel> const& c) {
    self()->cam_.copyFrom(c);
    return camera();
  }
  
  Vector3D<double> const& offset() const {
    return self->ofs_;
  }
  
  Vector3D<double>& offsetGet() {
    return self()->ofs_;
  }
  
  Vector3D<double> const& offset(Vector3D<double> const& ofs) {
    self()->ofs_ = ofs;
    return offset();
  }
  
  bool inside(Vector3D<double> const& v) const {
    return camera().inside(v - offset());
  }
  
  Eye& operator=(Eye const& e) {
    return copyFrom(e);
  }
  
  bool write(FILE* f, bool bin, unsigned int fg) const {
    if (bin) {
      double tmp;
      for (size_t i = 0; i < 3; ++i) {
        if (fwrite(&(tmp = offset()(i)), sizeof(tmp), 1, f) < 1)
          return false;
      }
    }
    else {
      for (size_t i = 0; i < 3; ++i) {
        if (fprintf(f, "%f ", offset()(i)) < 1) return false;
      }
      fprintf(f, "\n");
    }
    return camera().write(f, bin, fg);
  }

  bool read(FILE* f, bool bin, unsigned int fg) {
    if (bin) {
      double tmp[3];
      if (fread(tmp, sizeof(double), 3, f) < 3) return false;
      offsetGet().xyz(tmp[0], tmp[1], tmp[2]);
    }
    else {
      double a, b, c;
      if (fscanf(f, "%lf %lf %lf", &a, &b, &c) < 3) return false;
      offsetGet().x(a);
      offsetGet().y(b);
      offsetGet().z(c);
    }
    return cameraGet().read(f, bin, fg);
  }

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

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

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

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

} // meow

#endif // Eye_H__