ArithmeticalDSS3d.ih

// IMPLEMENTATION of inline methods.

#include <cstdlib>
#include <boost/math/common_factor_rt.hpp>
#include "DGtal/io/Color.h"





// Implementation of inline methods                                          //

template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::ArithmeticalDSS3d()
{

  //projections
  std::vector<DGtal::Dimension> v1,v2,v3;
  v1.push_back(0);
  v1.push_back(1);
  v2.push_back(0);
  v2.push_back(2);
  v3.push_back(1);
  v3.push_back(2);
  
  myProjXY.init(v1.begin(),v1.end());
  myProjXZ.init(v2.begin(),v2.end());
  myProjYZ.init(v3.begin(),v3.end());

}

template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::ArithmeticalDSS3d(const ConstIterator& it)
{
  //projections
  std::vector<DGtal::Dimension> v1,v2,v3;
  v1.push_back(0);
  v1.push_back(1);
  v2.push_back(0);
  v2.push_back(2);
  v3.push_back(1);
  v3.push_back(2);
  
  myProjXY.init(v1.begin(),v1.end());
  myProjXZ.init(v2.begin(),v2.end());
  myProjYZ.init(v3.begin(),v3.end());

  init(it);
}

template <typename TIterator, typename TInteger, int connectivity>
inline
void DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::init(const ConstIterator& it)
{

  //begin and end iterators
  myBegin = it;
  myEnd = it;
  
  myEnd++;
  
  //adapters and projections
  IteratorAdapter XYit(it,myProjXY); 
  myXYalgo.init(XYit);
  
  IteratorAdapter XZit(it,myProjXZ); 
  myXZalgo.init(XZit);
  
  IteratorAdapter YZit(it,myProjYZ); 
  myYZalgo.init(YZit);

}

template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::ArithmeticalDSS3d ( 
                                                                              const ArithmeticalDSS3d<TIterator,TInteger,connectivity> & other ) : 
  myProjXY(other.myProjXY), myProjXZ(other.myProjXZ), myProjYZ(other.myProjYZ),
  myXYalgo(other.myXYalgo), myXZalgo(other.myXZalgo), myYZalgo(other.myYZalgo),
  myBegin(other.myBegin), myEnd(other.myEnd) {}


template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity> &
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::operator= ( 
                                                                      const ArithmeticalDSS3d<TIterator,TInteger,connectivity> & other ) 
{

  myProjXY = other.myProjXY;
  myProjXZ = other.myProjXZ; 
  myProjYZ = other.myProjYZ;
  myXYalgo = other.myXYalgo;
  myXZalgo = other.myXZalgo; 
  myYZalgo = other.myYZalgo;
  myBegin = other.myBegin;
  myEnd = other.myEnd;

  return *this;
}

template <typename TIterator, typename TInteger, int connectivity>
inline
typename DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::Self
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::getSelf() const {
  return Self();
} 


template <typename TIterator, typename TInteger, int connectivity>
inline
typename DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::Reverse
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::getReverse() const {
  return Reverse();
} 





template <typename TIterator, typename TInteger, int connectivity>
inline
bool
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::operator==( 
                                                                      const ArithmeticalDSS3d<TIterator,TInteger,connectivity>& other ) const 
{
  return (  (   myXYalgo == other.myXYalgo ) &&
            (   myXZalgo == other.myXZalgo ) &&
            (   myYZalgo == other.myYZalgo ) &&
            (*myBegin == *other.myBegin) &&  
            (*myEnd == *other.myEnd) );
}

template <typename TIterator, typename TInteger, int connectivity>
inline
bool
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::operator!=( 
                                                                      const ArithmeticalDSS3d<TIterator,TInteger,connectivity> & other ) const 
{
  return (!(*this == other));
}




template <typename TIterator, typename TInteger, int connectivity>
inline
bool 
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::extendForward()
{
  if( isExtendableForward() ) {

    bool XYflag = myXYalgo.extendForward();
    bool XZflag = myXZalgo.extendForward();
    bool YZflag = myYZalgo.extendForward();
    ASSERT( (XYflag)&&(XZflag)&&(YZflag) );

    myEnd++;
    return true;
  } else return false;
}



template <typename TIterator, typename TInteger, int connectivity>
inline
bool 
DGtal::ArithmeticalDSS3d<TIterator, TInteger,connectivity>::isExtendableForward()
{
  //projection on xy-plane
  bool XYflag = myXYalgo.isExtendableForward();
  
  //projection on xz-plane
  bool XZflag = myXZalgo.isExtendableForward();
  
  //projection on yz-plane
  bool YZflag = myYZalgo.isExtendableForward();
  
  if ( (XYflag)&&(XZflag)&&(YZflag) ) 
    return true;
  else return false;  
}




template <typename TIterator, typename TInteger, int connectivity>
inline
TIterator
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::begin() const {
  return myBegin;
}

template <typename TIterator, typename TInteger, int connectivity>
inline
TIterator
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::end() const {
  return myEnd;
}




//-----------------------------------------------------------------
template <typename TIterator, typename TInteger, int connectivity>
inline
bool
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::isValid() const
{
  return ( (myXYalgo.isValid())&&
           (myXZalgo.isValid())&&
           (myYZalgo.isValid()) );
}


template <typename TIterator, typename TInteger, int connectivity>
inline
void
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>
::getParameters(Point3d& direction,
                PointD3d& intercept,
                PointD3d& thickness) const
{

  //let us take the pair of projection planes for which
  //the common coordinate of the main vector cannot be 0

  if (myXYalgo.getB() != 0) { //XY-plane, XZ-plane

    Integer a1 = myXYalgo.getB();
    Integer b1 = myXYalgo.getA();
    Integer a2 = myXZalgo.getB();
    Integer c1 = myXZalgo.getA();

    direction = Point3d(a1*a2,a2*b1,a1*c1);     

    Integer mu1 = myXYalgo.getMu();
    Integer mu2 = myXZalgo.getMu();
    double y = (double) -NumberTraits<TInteger>::castToInt64_t(mu1) / a1;
    double z = (double) -NumberTraits<TInteger>::castToInt64_t(mu2) / a2;
    intercept = PointD3d(0,y,z);

    Integer omega1 = myXYalgo.getOmega()-1;
    Integer omega2 = myXZalgo.getOmega()-1;
    double ty = (double) -NumberTraits<TInteger>::castToInt64_t(omega1) / a1;
    double tz = (double) -NumberTraits<TInteger>::castToInt64_t(omega2) / a2;
    thickness = PointD3d(0,ty,tz);

  } else {                     

    if (myXYalgo.getA() != 0) {//XY-plane, YZ-plane

      Integer a1 = myXYalgo.getB();
      Integer b1 = myXYalgo.getA();
      Integer b2 = myYZalgo.getB();
      Integer c2 = myYZalgo.getA();

      direction = Point3d(b1*a1,b1*b2,b2*c2);

      Integer mu1 = myXYalgo.getMu();
      Integer mu2 = myYZalgo.getMu();
      double x = (double) NumberTraits<TInteger>::castToInt64_t(mu1) / b1;
      double z = (double) -NumberTraits<TInteger>::castToInt64_t(mu2) / b2;
      intercept = PointD3d(x,0,z);

      Integer omega1 = myXYalgo.getOmega()-1;
      Integer omega2 = myYZalgo.getOmega()-1;
      double tx = (double) NumberTraits<TInteger>::castToInt64_t(omega1) / b1;
      double tz = (double) -NumberTraits<TInteger>::castToInt64_t(omega2) / b2;
      thickness = PointD3d(tx,0,tz);

    } else {                  

      if (myYZalgo.getA() != 0) {//YZ-plane, XZ-plane

        Integer b2 = myYZalgo.getB();
        Integer c2 = myYZalgo.getA();
        Integer a2 = myXZalgo.getB();
        Integer c1 = myXZalgo.getA();

        direction = Point3d(c2*a2,c1*b2,c1*c2); 

        Integer mu1 = myYZalgo.getMu();
        Integer mu2 = myXZalgo.getMu();
        double y = (double) NumberTraits<TInteger>::castToInt64_t(mu1) / c2;
        double x = (double) NumberTraits<TInteger>::castToInt64_t(mu2) / c1;
        intercept = PointD3d(x,y,0);

        Integer omega1 = myYZalgo.getOmega()-1;
        Integer omega2 = myXZalgo.getOmega()-1;
        double ty = (double) NumberTraits<TInteger>::castToInt64_t(omega1) / c2;
        double tx = (double) NumberTraits<TInteger>::castToInt64_t(omega2) / c1;
        thickness = PointD3d(tx,ty,0);

      } else {//degenerated case
        direction = Point3d(0,0,0);             
        intercept = PointD3d(0,0,0);
        thickness = PointD3d(0,0,0);            
      }
    } 
  }

}
template <typename TIterator, typename TInteger, int connectivity>
inline
std::string
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::className() const
{
  return "ArithmeticalDSS3d";
}

//------------------------------------------------------------------------------
//   TEXT DISPLAY 

template <typename TIterator, typename TInteger, int connectivity>
inline
void
DGtal::ArithmeticalDSS3d<TIterator,TInteger,connectivity>::selfDisplay ( std::ostream & out)
{
  
  out << "[ArithmeticalDSS3d]" <<  endl;
  out << "[XYprojection]" <<  endl;
  out << myXYalgo <<  endl;
  out << "[XZprojection]" <<  endl;
  out << myXZalgo <<  endl;
  out << "[YZprojection]" <<  endl;
  out << myYZalgo <<  endl;
  out << "[End ArithmeticalDSS3d]" <<  endl;
  
}


//------------------------------------------------------------------------------
//   3D DRAWING