DrawWithDisplay3DModifier.h

#pragma once

#if defined(DrawWithDisplay3DModifier_RECURSES)
#error Recursive header files inclusion detected in DrawWithDisplay3DModifier.h
#else // defined(DrawWithDisplay3DModifier_RECURSES)

#define DrawWithDisplay3DModifier_RECURSES

#if !defined DrawWithDisplay3DModifier_h

#define DrawWithDisplay3DModifier_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/base/Alias.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/images/CConstImage.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/topology/KhalimskySpaceND.h"

namespace DGtal
{

struct DrawWithDisplay3DModifier
{
  std::string className() const;
};



struct SetMode3D : public DrawWithDisplay3DModifier
{
  SetMode3D( std::string classname, std::string mode )
    : myClassname( classname ), myMode( mode )
  {}

  std::string myClassname;
  std::string myMode;
};




struct CustomStyle3D : public DrawWithDisplay3DModifier
{
  CustomStyle3D( std::string aClassname, DrawableWithDisplay3D* style ): myClassname( aClassname ), myStyle( style )
  {}

  std::string className() const;

  std::string myClassname;
  CountedPtr<DrawableWithDisplay3D> myStyle;
};




struct CustomColors3D : public DrawWithDisplay3DModifier
{
  Color myPenColor;
  Color myFillColor;

  CustomColors3D( const Color & penColor,
                  const Color & fillColor )
    : myPenColor( penColor ), myFillColor( fillColor )
  {}


};




struct ClippingPlane : public DrawWithDisplay3DModifier
{
  ClippingPlane( double a, double b, double c, double d, bool drawPlane=true )
    : myA( a ), myB( b ), myC( c ), myD ( d ), myDrawPlane(drawPlane)
  {}

  double * getEquation();
  double myA;
  double myB;
  double myC;
  double myD;
  bool myDrawPlane;
};



struct TransformedPrism : public DrawWithDisplay3DModifier
{
  TransformedPrism( const DGtal::Z3i::SCell  & aSurfel,
                          double aShift, double aSizeFactor=1.0 ):mySurfel(aSurfel), myShift(aShift), mySizeFactor(aSizeFactor)
  {
  }


  TransformedPrism( const DGtal::Z3i::SCell  & aSurfel,
                          const DGtal::Z3i::SCell  & aVoxel,
                          double aShift=0.05, double aSizeFactor=0.75  )
    : mySurfel(aSurfel), myShift(aShift), mySizeFactor(aSizeFactor)
  {
    auto const& preSurfel = aSurfel.preCell();
    auto const& preVoxel  = aVoxel.preCell();

    bool xodd = (preSurfel.coordinates[ 0 ] & 1 );
    bool yodd = (preSurfel.coordinates[ 1 ] & 1 );
    bool zodd = (preSurfel.coordinates[ 2 ] & 1 );
    if(!xodd )
    {
      myShift*= ((preVoxel.coordinates[ 0 ]-preSurfel.coordinates[ 0 ] <0)? -1.0: 1.0);
    }else if(!yodd )
    {
      myShift*=((preVoxel.coordinates[ 1 ]-preSurfel.coordinates[ 1 ] <0)? -1.0: 1.0);
    }else if(!zodd )
    {
      myShift*=((preVoxel.coordinates[ 2 ]-preSurfel.coordinates[ 2 ] <0)? -1.0: 1.0);
    }
  }

  DGtal::Z3i::SCell mySurfel;
  double myShift;
  double mySizeFactor;
};


  struct SetName3D : public DrawWithDisplay3DModifier {
    SetName3D( DGtal::int32_t aName = -1 ) : name( aName ) {}
    std::string className() const { return "SetName3D"; }
    DGtal::int32_t name;
  };

  struct SetSelectCallback3D : public DrawWithDisplay3DModifier {
    typedef int (*CallbackFct)( void* viewer, DGtal::int32_t name, void* data );
    SetSelectCallback3D( CallbackFct f,
                         void* data,
                         DGtal::int32_t min = 0, DGtal::int32_t max = 0x7fffffff )
      : myFct( f ), myData( data ), myMin( min ), myMax( max ) {}
    std::string className() const { return "SetSelectCallback3D"; }
    CallbackFct myFct;
    void* myData;
    DGtal::int32_t myMin;
    DGtal::int32_t myMax;
  };
} // namespace DGtal


// Includes inline functions.
#include "DGtal/io/DrawWithDisplay3DModifier.ih"


//                                                                           //

#endif // !defined DrawWithDisplay3DModifier_h

#undef DrawWithDisplay3DModifier_RECURSES
#endif // else defined(DrawWithDisplay3DModifier_RECURSES)