Biomechanical Joint Model  Author: Anderson Maciel

---

blob.h

Go to the documentation of this file.

#ifndef MC_BLOBBY_H
#define MC_BLOBBY_H

#include <LinAlg/linalg.h>
#include <RayCasting/bbox.h>
#include "private_marching_cubes.h"
#include "primitive.h"
#include <vector>
#include <algorithm>

//namespace MarchingCubes {

//using namespace RayCasting;
//using namespace std;

class Quadric
{
public:   
   Quadric(HMAT M_, REAL a_=1, REAL b_=1, REAL c_=1) : a(a_), b(b_), c(c_), M(M_), T(inverse(M_)) 
   { init(); /*cout << "a,b,c = " << a << " "<< b << " "<< c << "\nT = " << T << endl;*/ };
   Quadric(const Quadric &q) : a(q.a), b(q.b), c(q.c), M(q.M), T(q.T) { init(); };

   virtual bool intersectedBy(Ray &ray, REAL root[]) const;

protected:   
   void init() { a2 = a*a; b2 = b*b; c2 = c*c; };

public:
   REAL a,b,c;    // semi-axis lengths
   REAL a2,b2,c2; // square of the coeffcients a,b,c
   HMAT T;        // homogeneous matrix from g.c.s. to l.c.s.
   HMAT M;        // homogeneous matrix from l.c.s to g.c.s. (i.e matrix of lcs expressed in gcs)
};

class Blob : public Quadric
{
public:
   // constructors
   Blob(HMAT M_, REAL a_=1, REAL b_=1, REAL c_=1, REAL w_=1) : Quadric(M_,a_,b_,c_), w(w_) {};
   virtual bool intersectedBy(Ray &ray, REAL root[]) const;

   REAL w;        // weight
};

class Sphere{
public:
   Sphere(const VEC &centre, REAL thick=1, REAL stiff=1) :
      C(centre), ro(thick), k(stiff) { R = ro + (2.0/k); };
   Sphere(int FctId, const VEC &centre, REAL thick, REAL stiff)
       { C=centre; ro=thick; k=stiff; FId=FctId; R = ro + (2.0/k);};
   Sphere(const Sphere &s) : C(s.C), ro(s.ro), k(s.k), R(s.R), FId(s.FId) {};
   //  virtual bool intersectedBy(RayCasting::Ray &ray, REAL root[]) const;
   
public:          
   // definition de la sphere:  
   VEC  C;       // center
   REAL ro;      // thickness
   REAL R;       // scope of influence
   REAL k;       // stiffness

   // Facet from which sphere has been created
   int FId;
 
};

class TrianglePrimitive{
 public:
  TrianglePrimitive(const VEC &V1, const VEC &V2, const VEC &V3, double *norm, REAL thick=1.0, REAL stiff=1.0)
    :P1(V1), P2(V2), P3(V3), n(norm), ro(thick), k(stiff) { R = ro + (2.0/k); };
  TrianglePrimitive(int FctId, const VEC &V1, const VEC &V2, const VEC &V3, double *norm, REAL thick, REAL stiff)
       { P1=V1; P2=V2; P3=V3; n=norm; ro=thick; k=stiff; FId=FctId; R = ro + (2.0/k);};
  TrianglePrimitive(const TrianglePrimitive &s) : P1(s.P1), P2(s.P2), P3(s.P3), n(s.n), ro(s.ro), k(s.k), R(s.R), FId(s.FId) {};

 public:
  VEC P1, P2, P3;  // triangle vertices
  double *n;       // triangle normal
  REAL ro;         // thickness
  REAL k;          // stiffness
  REAL R;          // scope of influence
  int FId;         // Facet from which sphere has been created
};


class Ellipsoids : public Primitive
{
public:
   Ellipsoids() : Primitive(), quadlist() {};
   void addQuadric(const Quadric &quad) { quadlist.push_back(quad); };

   virtual bool intersectedBy(Ray &ray) const;
   virtual REAL getDistance(const VEC &X) const;
   virtual BBox getBoundingBox();
   virtual void findIntersection(const VEC &P1, const VEC &P2, REAL valp1, REAL valp2, 
                                 VEC &P, VEC &N) const;
protected:
   vector<Quadric> quadlist;
};

class Metaballs : public ImplicitPrimitive
{
public:
   Metaballs(REAL isolevel=0.5) : ImplicitPrimitive(isolevel), bloblist() {};
   void addBlob(const Blob &blob) { bloblist.push_back(blob); };
    
   virtual BBox getBoundingBox();

protected:
    vector<Blob> bloblist;
};

// Metaballs represented as the spheres with Raquel's density function
class MetaballsSphere : public ImplicitPrimitive{
 public:
  MetaballsSphere(REAL isolevel=1.0):ImplicitPrimitive(isolevel){};
  void addSphere(const Sphere &sph) { spherelist.push_back(sph); };
  
  virtual BBox getBoundingBox();
  vector<Sphere> spherelist;
 protected:
  virtual REAL   density(const VEC& U) const;
  virtual VEC    gradient(const VEC& U) const;
};

// Metaballs represented as the spheres with exponential density function
class MetaballsSphere_exp : public MetaballsSphere{

 public:
  MetaballsSphere_exp(REAL isolevel=0.5,  REAL dist_coeff = 2):MetaballsSphere(isolevel),coeff(dist_coeff){};

 protected:
  virtual REAL  density(const VEC& U) const;
  virtual VEC   gradient(const VEC& U) const;

 private:
  REAL coeff;  
};

// Genralized metaballs built on the triagle as the geometric primitive with Raquel's density function
class MetaballsTriangle : public ImplicitPrimitive{
 public:
  MetaballsTriangle(REAL isolevel=1.0):ImplicitPrimitive(isolevel){};
  void addTriangle(const TrianglePrimitive &trg) { trianglelist.push_back(trg); };
  
  virtual BBox getBoundingBox();
  vector<TrianglePrimitive> trianglelist;
  // protected:
  double  EuclidDistFromTriangle(const VEC &P1, const VEC &P2, const VEC &P3, const VEC &Pt, const double *Plane, VEC &N) const;
  virtual REAL   density(const VEC& U) const;
  virtual VEC    gradient(const VEC& U) const;
};


// Metaballs with Shen's density function
class Metaballs_Shen : public Metaballs
{
public:
   Metaballs_Shen(REAL isolevel=0.5) : Metaballs(isolevel) {};   
   virtual bool intersectedBy(Ray &ray) const;

protected:   
   virtual REAL  density(const VEC& U) const;
   virtual VEC   gradient(const VEC& U) const;
};

// metaballs with an exponential(-dist_coeff * distance^2) density function
class Metaballs_exp : public Metaballs
{
public:
   Metaballs_exp(REAL isolevel=0.5, REAL dist_coeff = 2) : coeff(dist_coeff), 
      Metaballs(isolevel) {};

protected:   
   virtual REAL  density(const VEC& U) const;
   virtual VEC   gradient(const VEC& U) const;

private:
   REAL coeff;
};

//}

#endif

---