DistanceObject.hh

Go to the documentation of this file.

 
#include "VectorTools.hh"
#include "Effect.hh"
 
class DistanceObject
{
public:
  virtual int NumDistances() const=0;
  virtual float Distance(int idx, Point ps) const=0;
  virtual bool Inside(Point p) const=0;
  virtual int Idx(Point p) const=0;
  virtual Color ColorValue(int idx, Point p) const=0;
};
 
class ArrayDistanceObject : public DistanceObject
{
public:
  ArrayDistanceObject(DistanceObject *array, int size) : array(array), size(size) { }
  virtual int NumDistances() const
  {
    int s = size;
    int num = 0;
    for(int i=0;i<s;i++)
      {
    DistanceObject *obj = &array[i];
    num += obj->NumDistances();
      }
    return num;
  }
  virtual bool Inside(Point p) const
  {
    int s = size;
    //int num = 0;
    for(int i=0;i<s;i++)
      {
    DistanceObject *obj = &array[i];
    if (obj->Inside(p)) return true;
      }
    return false;
  }
  virtual int idx(Point p) const
  {
    int s = size;
    //int num = 0;
    for(int i=0;i<s;i++)
      {
    DistanceObject *obj = &array[i];
    if (obj->Inside(p)) return i;
      }
    return -1;
  }
  virtual float Distance(int idx, Point ps) const
  {
    int s = size;
    int num = 0;
    int oldnum=0;
    for(int i=0;i<s;i++)
      {
    DistanceObject *obj = &array[i];
    for(int j=0;j<obj->NumDistances();j++)
      {
        if (num==idx) return obj->Distance(num-oldnum, ps);
        num++;
      }
         oldnum = num;
      }
    return 0.0;
  }
  virtual Color ColorValue(int idx, Point p) const
  {
    int s = size;
    int num = 0;
    int oldnum=0;
    for(int i=0;i<s;i++)
      {
    DistanceObject *obj = &array[i];
    for(int j=0;j<obj->NumDistances();j++)
      {
        if (num==idx) return obj->ColorValue(num-oldnum, p);
        num++;
      }
         oldnum = num;
      }
    Color c;
    return c;
  }
  
private:
  DistanceObject *array;
  int size;
};
 
class DistanceObjectFunction : public Function<float,float>
{
public:
  DistanceObjectFunction(const DistanceObject &o, float val, Ray &r) : o(o), /*val(val),*/r(r) { }
  float Index(float val) const
  {
    return o.Distance(0,r.Index(val));
  }
private:
  const DistanceObject &o;
  //float val;
  Ray &r;
};
 
Point find_pos(const DistanceObject &o, float val, Ray &r, float raydist);
Color find_color(const DistanceObject &o, float val, Ray &r, float raydist);
 
 
class MinDistance : public DistanceObject
{
public:
  MinDistance(DistanceObject &array) : array(array) { }
  virtual int NumDistances() const { return 1; }
  virtual float Distance(int idx, Point ps) const
  {
    int mn = 9999999;
    int s = array.NumDistances();
    for(int i=0;i<s;i++)
      {
    float d = array.Distance(i, ps);
    if (d<mn) mn=d;
 
      }
    return mn;
  }
private:
  DistanceObject &array;
};
 
class SphereDistance : public DistanceObject
{
public:
  SphereDistance(Point center) : center(center) { }
  virtual int NumDistances() const { return 1; }
  virtual float Distance(int idx, Point ps) const
  {
    ps-=center;
    return sqrt(ps.x*ps.x+ps.y*ps.y+ps.z*ps.z);
  }
private:
  Point center;
};
 
class PlaneDistance : public DistanceObject
{
public:
  PlaneDistance(Point p, Vector dir) : p(p), dir(dir) { }
  virtual int NumDistances() const { return 1; }
  virtual float Distance(int idx, Point ps) const
  {
    std::pair<Vector,Vector> split = Vector::SplitToComponents(ps-p, dir);
    return split.first.Dist();
  }
private:
  Point p;
  Vector dir;
};
 
//
// Separate objects
//
 
class Separate
{
public:
  virtual ~Separate() { }
  virtual float x_sep(Point p) const=0;
  virtual float y_sep(Point p) const=0;
  virtual float dist_sep(Point p) const=0;
};
 
class SeparateEmpty : public Separate
{
public:
  virtual float x_sep(Point p) const { return 0.0; }
  virtual float y_sep(Point p) const { return 0.0; }
  virtual float dist_sep(Point p) const { return 0.0; }
};
#if 0
class SeparateX : public Separate
{
public:
  SeparateX(Separate *next, float (*fptr)(float,float,float,void*), void *data) : next(next), fptr(fptr), data(data) { }
  virtual float x_sep(Point p) const { return fptr(p.x,p.y,p.z,data); }
  virtual float y_sep(Point p) const { return next->y_sep(p); }
  virtual float dist_sep(Point p) const { return next->dist_sep(p); }
private:
  Separate *next;
  float (*fptr)(float,float,float,void*); 
  void *data;
};
 
class SeparateY : public Separate
{
public:
  SeparateY(Separate *next, float (*fptr)(float,float,float,void*), void *data) : next(next), fptr(fptr), data(data) { }
  virtual float x_sep(Point p) const { return next->x_sep(p); }
  virtual float y_sep(Point p) const { return fptr(p.x,p.y,p.z,data); }
  virtual float dist_sep(Point p) const { return next->dist_sep(p); }
private:
  Separate *next;
  float (*fptr)(float,float,float,void*); 
  void *data;
};
#endif
 
#if 0
class SeparateDist : public Separate
{
public:
  SeparateDist(Separate *next, float (*fptr)(float,float,float,void*), void *data) : next(next), fptr(fptr), data(data) { }
  virtual float x_sep(Point p) const { return next->x_sep(p); }
  virtual float y_sep(Point p) const { return next->y_sep(p); }
  virtual float dist_sep(Point p) const { return fptr(p.x,p.y,p.z,data); }
private:
  Separate *next;
  float (*fptr)(float,float,float,void*); 
  void *data;
};
#endif
#if 0
class SeparateRender : public SingleForwardFaceCollection
{
public:
  struct Key { int kx; int ky; 
    friend bool operator<(const Key &k1, const Key &k2);
  };
  SeparateRender(Separate &s, float dist, float dist_accuracy,
         float x_range_start, float x_range_end, float x_step,
         float y_range_start, float y_range_end, float y_step,
         float z_range_start, float z_range_end, float z_step,
         float u_range_start, float u_range_end, float u_step,
         float v_range_start, float v_range_end, float v_step
         ) : /*s(s),*/ /*dist(dist), dist_accuracy(dist_accuracy/2.0),*/
             x_range_start(x_range_start), x_range_end(x_range_end), x_step(x_step),
             y_range_start(y_range_start), y_range_end(y_range_end), y_step(y_step)//,
             //z_range_start(z_range_start), z_range_end(z_range_end), z_step(z_step)
  {
    for(float x=x_range_start;x<x_range_end;x+=x_step)
      {
    for(float y=y_range_start;y<y_range_end;y+=y_step)
      {
        for(float z=z_range_start;z<z_range_end;z+=z_step)
          {
        Point p(x,y,z);
        float sz = s.dist_sep(p);
        if (sz >= dist-dist_accuracy && sz <= dist+dist_accuracy)
          {
            
            float u = s.x_sep(p);
            float v = s.y_sep(p);
 
            int ssx = int((u-u_range_start)/u_step);
            int ssy = int((v-v_range_start)/v_step);
            Key k;
            k.kx = ssx;
            k.ky = ssy;
            points[k] = p;
            //std::cout << "Key: " << k.kx << " " << k.ky << ":= " << p << std::endl;
          }
          }
      }
      }
    
  }
  int X_Count() const { return (x_range_end-x_range_start)/x_step; }
  int Y_Count() const { return (y_range_end-y_range_start)/y_step; }
  void Collect(CollectVisitor &vis) { }
  void HeavyPrepare() { }
  virtual int NumFaces() const
  {
    return X_Count()*Y_Count();
  }
  virtual int NumPoints(int face) const
  {
    return 4;
  }
  virtual Point FacePoint(int face, int point) const
  {
    // std::cout << face << " " << point << std::endl;
    Point p;
   switch(point)
      {
      case 0: p=points[Face_to_key(face)]; break;
      case 1: {
    Key k = Face_to_key(face);
    k.kx+=1;
    p=points[k]; break;}
      case 2: {
    Key k = Face_to_key(face);
    k.kx+=1;
    k.ky+=1;
    p=points[k];break; }
      case 3: {
    Key k = Face_to_key(face);
    k.ky+=1;
    p=points[k];break;}
      }
   //std::cout << "Point: " << p << std::endl;
   return p;
  }
  virtual Vector PointNormal(int face, int point) const
  {
    Point p1 = FacePoint(face, 0);
    Point p2 = FacePoint(face, 1);
    Point p3 = FacePoint(face, 2);
    return -Vector::CrossProduct(p2-p1,p3-p1);
  }
  virtual float Attrib(int face, int point, int id) const { return 0.0; }
  virtual int AttribI(int face, int point, int id) const { return 0; }
  virtual unsigned int Color(int face, int point) const { return 0xffffffff; }
  virtual Point2d TexCoord(int face, int point) const
  {
    Point2d p = { 0.0, 0.0 };
    return p;
  }
  Key Face_to_key(int face) const
  {
    Key k;
    k.kx = face/X_Count();
    k.ky = face-k.kx*X_Count();
    //std::cout << "FaceToKey" << face << ":" << k.kx << " " << k.ky << std::endl;
    return k;
  }
private:
  //Separate &s;
  //float dist;
  //float dist_accuracy;
  float x_range_start; float x_range_end; float x_step;
  float y_range_start; float y_range_end; float y_step;
  //float z_range_start; float z_range_end; float z_step;
  //float u_range_start; float u_range_end; float u_step;
  //float v_range_start; float v_range_end; float v_step;
  mutable std::map<Key, Point> points;
};
#endif
// (x,y,z)|- r
// 
// (alfa,beta) |- (x,y,z)
 
 
// Intersection