WatchBall.h

Go to the documentation of this file.

#ifndef   gra_WatchBall_H__
#define   gra_WatchBall_H__

#include "Camera.h"

#include "../Self.h"
#include "../geo/Vectors.h"
#include "../math/LinearTransformations.h"
#include "../oo/ObjBase.h"

#include <cmath>
#include <vector>

namespace meow {

template<class Pixel>
class WatchBall: public ObjBase {
public:
  typedef std::vector<Camera<Pixel> > Cameras;
private:
  struct Myself {
    Cameras          cameras_;
    Vector3D<double>  offset_;

    Myself() {
    }
    ~Myself() {
    }
    Myself& copyFrom(Myself const& b) {
      cameras_ = b.cameras_;
      offset_  = b. offset_;
      return *this;
    }
  };

  Self<Myself> const self;
public:
  WatchBall(): self() {
  }
  
  WatchBall(WatchBall const& b): self(b.self, Self<Myself>::COPY_FROM) {
  }
  
  ~WatchBall() {
  }
  
  WatchBall& copyFrom(WatchBall const& b) {
    self().copyFrom(b.self);
    return *this;
  }
  
  WatchBall& referenceFrom(WatchBall const& b) {
    self().referenceFrom(b.self);
    return *this;
  }
  
  size_t cameraSize() const {
    return self->cameras_.size();
  }
  
  Cameras const& cameras() const {
    return self->cameras_;
  }
  
  Cameras& camerasGet() {
    return self()->cameras_;
  }
  
  Cameras const& cameras(Cameras const& c) {
    self()->cameras_ = c;
    return cameras();
  }
  
  Camera<Pixel> const& camera(size_t i) const {
    return cameras()[i];
  }
  
  Camera<Pixel>& camera(size_t i) {
    return cameras()[i];
  }
  
  Camera<Pixel> const& camera(size_t i, Camera<Pixel> const& c) {
    cameras()[i] = c;
    return camera(i);
  }
  
  Vector3D<double> const& offset() const {
    return self->offset_;
  }
  
  Vector3D<double>& offset() {
    return self()->offset_;
  }
  
  Vector3D<double> const& offset(Vector3D<double> const& ofs) {
    self()->offset_ = ofs;
    return offset();
  }
  
  Pixel color(Vector3D<double> p) const {
    Vector3D<double> p2(p - offset());
    Pixel sum(0);
    double ct = 0;
    for (size_t i = 0, I = cameraSize(); i < I; ++i) {
      if (camera(i).inside(p2)) {
        sum = sum + camera(i).color(p2);
        ++ct;
      }
    }
    return (ct > 0 ? sum / ct : sum);
  }
  
  Bitmap<Pixel> expand(double radius) const {
    radius = std::max(radius, 0.5);
    size_t height = std::max<size_t>(1, 2.0 * radius);
    size_t width  = 2.0* PI * radius;
    Bitmap<Pixel> ret(height, width, Pixel(0));
    for (size_t i = 0; i < height; ++i) {
      for (size_t j = 0; j < width; ++j) {
        double theta = (1.0 * j / width - 0.5) * 2 * PI;
        double phi   = asin(-(1.0 * i / height - 0.5) * 2.0);
        ret.pixel(i, j, color(Vector3D<double>(
              sin(theta) * cos(phi),
              sin(phi),
              -cos(theta) * cos(phi)
        )));
      }
    }
    return ret;
  }
  
  WatchBall& operator=(WatchBall const& b) {
    return copyFrom(b);
  }
  
  bool write(FILE* f, bool bin, unsigned int fg) const {
    return false;
  }
  
  bool read(FILE* f, bool bin, unsigned int fg) {
    return false;
  }

  ObjBase* create() const {
    return new WatchBall();
  }
  
  ObjBase* copyFrom(ObjBase const* b) {
    return &(copyFrom(*(WatchBall*)b));
  }
  
  char const* ctype() const{
    static char const* ptr = typeid(*this).name();
    return ptr;
  }
  
  std::string type() const {
    return std::string(ctype());
  }
};

}

#endif // gra_WatchBall_H__