Removed macros.h and pimpl

src/Detectors/HitMC.h

@@ -28,7 +28,6 @@
 #ifndef U_HITMC_H
 #define U_HITMC_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 #include "Hit.h"
 
@@ -43,10 +42,10 @@ public:
         DeltaRay
     };
 
-    uLibConstRefMacro(Position,HPoint3f)
+    inline const HPoint3f & Position() const { return this->m_Position; }
-    uLibGetMacro(Type, enum Type)
+    inline enum Type GetType() const { return this->m_Type; }
 
-private:
+protected:
     HPoint3f  m_Position;
     enum Type m_Type;
 };
@@ -54,8 +53,8 @@ private:
 
 class HitMC : public HitMCData {
 public:
-    uLibRefMacro(Position,HPoint3f)
+    inline HPoint3f & Position() { return this->m_Position; }
-    uLibSetMacro(Type, enum Type)
+    inline void SetType(enum Type name) { this->m_Type = name; }
 };
 
 

src/Detectors/LinearFit.h

@@ -28,7 +28,6 @@
 #ifndef U_LINEARFIT_H
 #define U_LINEARFIT_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 #include "ChamberDetector.h"
 
@@ -37,15 +36,14 @@ namespace uLib {
 
 class LinearFitData {
 public:
-    uLibConstRefMacro(Position,Vector2f)
+    inline const Vector2f & Position() const { return this->m_Position; }
-    uLibConstRefMacro(Slope,Vector2f)
+    inline const Vector2f & Slope() const { return this->m_Slope; }
-    uLibConstRefMacro(PositionError,Vector2f)
+    inline const Vector2f & PositionError() const { return this->m_PositionError; }
-    uLibConstRefMacro(SlopeError,Vector2f)
+    inline const Vector2f & SlopeError() const { return this->m_SlopeError; }
-    uLibGetMacro(HitsNumber,int)
+    inline int GetHitsNumber() const { return this->m_HitsNumber; }
-    uLibGetMacro(Idv,ChamberDetector::ID)
+    inline ChamberDetector::ID GetIdv() const { return this->m_Idv; }
 
-private:
+protected:
-        friend class LinearFit;
     Vector2f            m_Position;
     Vector2f            m_Slope;
     Vector2f            m_PositionError;
@@ -57,12 +55,12 @@ private:
 
 class LinearFit : public LinearFitData {
 public:
-    uLibRefMacro(Position,Vector2f)
+    inline Vector2f & Position() { return this->m_Position; }
-    uLibRefMacro(Slope,Vector2f)
+    inline Vector2f & Slope() { return this->m_Slope; }
-    uLibRefMacro(PositionError,Vector2f)
+    inline Vector2f & PositionError() { return this->m_PositionError; }
-    uLibRefMacro(SlopeError,Vector2f)
+    inline Vector2f & SlopeError() { return this->m_SlopeError; }
-    uLibSetMacro(HitsNumber,int)
+    inline void SetHitsNumber(int name) { this->m_HitsNumber = name; }
-    uLibSetMacro(Idv,ChamberDetector::ID)
+    inline void SetIdv(ChamberDetector::ID name) { this->m_Idv = name; }
 };
 
 

src/Detectors/MuonError.h

@@ -28,18 +28,16 @@
 #ifndef U_MUONERROR_H
 #define U_MUONERROR_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
 
 
 class MuonErrorData {
-    friend class MuonError;
 public:
-    uLibConstRefMacro(Theta,Scalarf)
+    inline const Scalarf & Theta() const { return this->m_Theta; }
-    uLibConstRefMacro(Phi,Scalarf)
+    inline const Scalarf & Phi() const { return this->m_Phi; }
-private:
+protected:
     Scalarf m_Theta;
     Scalarf m_Phi;
 };
@@ -47,8 +45,8 @@ private:
 
 class MuonError  : public MuonErrorData {
 public:
-    uLibRefMacro(Theta,Scalarf)
+    inline Scalarf & Theta() { return this->m_Theta; }
-    uLibRefMacro(Phi,Scalarf)
+    inline Scalarf & Phi() { return this->m_Phi; }
 };
 
 

src/Detectors/MuonEvent.h

@@ -28,20 +28,18 @@
 #ifndef U_MUONEVENT_H
 #define U_MUONEVENT_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
 
 
 class MuonEventData {
-    friend class MuonEvent;
 public:
-    uLibConstRefMacro(LineIn,HLine3f)
+    inline const HLine3f & LineIn() const { return this->m_LineIn; }
-    uLibConstRefMacro(LineOut,HLine3f)
+    inline const HLine3f & LineOut() const { return this->m_LineOut; }
-    uLibGetMacro(Momentum,Scalarf)
+    inline Scalarf GetMomentum() const { return this->m_Momentum; }
 
-private:
+protected:
     HLine3f  m_LineIn;
     HLine3f  m_LineOut;
     Scalarf  m_Momentum;
@@ -50,9 +48,9 @@ private:
 
 class MuonEvent  : public MuonEventData {
 public:
-    uLibRefMacro(LineIn,HLine3f)
+    inline HLine3f & LineIn() { return this->m_LineIn; }
-    uLibRefMacro(LineOut,HLine3f)
+    inline HLine3f & LineOut() { return this->m_LineOut; }
-    uLibRefMacro(Momentum,Scalarf)
+    inline Scalarf & Momentum() { return this->m_Momentum; }
 
 };
 

src/Detectors/MuonScatter.h

@@ -29,7 +29,6 @@
 #ifndef U_MUONSCATTER_H
 #define U_MUONSCATTER_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
@@ -37,20 +36,21 @@ namespace uLib {
 
 class MuonScatter {
 public:
-    uLibConstRefMacro(LineIn,HLine3f)
+    inline const HLine3f & LineIn() const { return this->m_LineIn; }
-    uLibConstRefMacro(ErrorIn,HError3f)
+    inline const HError3f & ErrorIn() const { return this->m_ErrorIn; }
-    uLibConstRefMacro(LineOut,HLine3f)
+    inline const HLine3f & LineOut() const { return this->m_LineOut; }
-    uLibConstRefMacro(ErrorOut,HError3f)
+    inline const HError3f & ErrorOut() const { return this->m_ErrorOut; }
 
-    uLibRefMacro(LineIn,HLine3f)
+    inline HLine3f & LineIn() { return this->m_LineIn; }
-    uLibRefMacro(ErrorIn,HError3f)
+    inline HError3f & ErrorIn() { return this->m_ErrorIn; }
-    uLibRefMacro(LineOut,HLine3f)
+    inline HLine3f & LineOut() { return this->m_LineOut; }
-    uLibRefMacro(ErrorOut,HError3f)
+    inline HError3f & ErrorOut() { return this->m_ErrorOut; }
-    uLibSetMacro(Momentum,Scalarf)
-    uLibSetMacro(MomentumPrime,Scalarf)
 
-    uLibGetMacro(Momentum,Scalarf)
+    inline void SetMomentum(Scalarf name) { this->m_Momentum = name; }
-    uLibGetMacro(MomentumPrime,Scalarf)
+    inline void SetMomentumPrime(Scalarf name) { this->m_MomentumPrime = name; }
+
+    inline Scalarf GetMomentum() const { return this->m_Momentum; }
+    inline Scalarf GetMomentumPrime() const { return this->m_MomentumPrime; }
 
 protected:
     HLine3f  m_LineIn;

src/Math/StructuredData.h

@@ -28,7 +28,6 @@
 #ifndef STRUCTUREDDATA_H
 #define STRUCTUREDDATA_H
 
-#include "Core/Macros.h"
 #include "Core/Object.h"
 #include "Math/Dense.h"
 
@@ -60,15 +59,17 @@ public:
     {}
 
 
-    uLibGetMacro(Dims,Vector3i)
+    inline Vector3i GetDims() const { return this->m_Dims; }
 
     void SetDims(const Vector3i &size);
 
-    uLibGetSetMacro(Increments,Vector3i)
+    inline Vector3i GetIncrements() const { return this->m_Increments; }
+
+    inline void SetIncrements(Vector3i name) { this->m_Increments = name; }
 
     void SetDataOrder(Order order = YXZ);
 
-    uLibGetMacro(DataOrder,Order)
+    inline Order GetDataOrder() const { return this->m_DataOrder; }
 
     bool IsInsideGrid(const Vector3i &v) const;
 

src/Math/Transform.h

@@ -49,7 +49,6 @@
 #ifndef U_TRANSFORM_H
 #define U_TRANSFORM_H
 
-#include <Core/Macros.h>
 #include <Eigen/Geometry>
 
 
@@ -80,7 +79,10 @@ public:
     {}
 
     Eigen::Affine3f& GetTransform() { return m_T; }
-    uLibGetSetMacro(Parent,AffineTransform *)
+
+    inline AffineTransform *GetParent() const { return this->m_Parent; }
+
+    inline void SetParent(AffineTransform *name) { this->m_Parent = name; }
 
     inline void SetMatrix (Matrix4f &mat) { m_T.matrix() = mat; }
     inline Matrix4f& GetMatrix () { return m_T.matrix(); }

src/Vtk/vtkMuonContainerScattering.h

@@ -30,7 +30,6 @@
 
 
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -66,8 +65,6 @@ protected:
 private:
     void InstallPipe();
 
-    friend class vtkMuonContainerScatteringPimpl;
-    class vtkMuonContainerScatteringPimpl *d;
 };
 
 

src/Vtk/vtkMuonEvent.cxx

@@ -29,22 +29,6 @@
 #include "config.h"
 #endif
 
-
-#include <vtkSmartPointer.h>
-#include <vtkSphereSource.h>
-#include <vtkAppendPolyData.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkLineSource.h>
-#include <vtkActor.h>
-
-#include <vtk3DWidget.h>
-#include <vtkBoxWidget.h>
-
-#include <vtkRenderWindowInteractor.h>
-
-#include <vtkCommand.h>
-#include <vtkTransform.h>
-
 #include "vtkMuonEvent.h"
 #include "Math/Dense.h"
 
@@ -72,105 +56,77 @@ private:
 };
 
 
-//// PIMPL /////////////////////////////////////////////////////////////////////
-
-class vtkMuonEventPimpl {
-    typedef vtkWidgetCallback Callback;
-public:
-    vtkMuonEventPimpl() :
-        m_Prop(vtkActor::New()),
-        m_PolyData(NULL),
-        m_Appender(vtkAppendPolyData::New()),
-        content(NULL)
-    {}
-
-    ~vtkMuonEventPimpl()
-    {
-        m_Prop->Delete();
-    }
-
-    // members //
-    vtkMuonEvent::Content *content;
-    vtkPolyData *m_PolyData;
-    vtkActor    *m_Prop;
-
-    vtkAppendPolyData *m_Appender;
-    vtkBoxWidget *m_WidgetIN, *m_WidgetOUT;
-    HPoint3f m_Poca;
-};
-
-
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 /////  VTK MUON EVENT  /////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 
 vtkMuonEvent::vtkMuonEvent(MuonEventData &content) :
-    d(new vtkMuonEventPimpl)
+    m_Prop(vtkActor::New()),
+    m_PolyData(NULL),
+    m_Appender(vtkAppendPolyData::New()),
+    content(&content)
 {
-      d->content = &content;
     InstallPipe();
 }
 
 vtkMuonEvent::vtkMuonEvent(const MuonEventData &content) :
-    d(new vtkMuonEventPimpl)
+    m_Prop(vtkActor::New()),
+    m_PolyData(NULL),
+    m_Appender(vtkAppendPolyData::New()),
+    content(const_cast<MuonEventData *>(&content))
 {
-      d->content = const_cast<MuonEventData *>(&content);
     InstallPipe();
 }
 
 
 vtkMuonEvent::~vtkMuonEvent()
 {
-    if (d->m_Prop) d->m_Prop->Delete();
+    if (m_Prop) m_Prop->Delete();
 }
 
 vtkMuonEvent::Content &vtkMuonEvent::GetContent()
 {
-    return *d->content;
+    return *content;
 }
 
 void vtkMuonEvent::PrintSelf(std::ostream &o) const
 {
     o << "..:: MuonEvent ::..\n" \
-         "\t[in]  Origin    > " << d->content->LineIn().origin.transpose()    << "\n" <<
+         "\t[in]  Origin    > " << content->LineIn().origin.transpose()    << "\n" <<
-         "\t[in]  Direction > " << d->content->LineIn().direction.transpose() << "\n" <<
+         "\t[in]  Direction > " << content->LineIn().direction.transpose() << "\n" <<
-         "\t[out] Origin    > " << d->content->LineOut().origin.transpose()   << "\n" <<
+         "\t[out] Origin    > " << content->LineOut().origin.transpose()   << "\n" <<
-         "\t[out] Direction > " << d->content->LineOut().direction.transpose()<< "\n" <<
+         "\t[out] Direction > " << content->LineOut().direction.transpose()<< "\n" <<
-         "\tMomentum        > " << d->content->GetMomentum() << "\n" <<
+         "\tMomentum        > " << content->GetMomentum() << "\n" <<
          "...................\n";
 }
 
 vtkProp *vtkMuonEvent::GetProp()
 {
-    return d->m_Prop;
+    return m_Prop;
 }
 
 void vtkMuonEvent::InstallPipe()
 {
 
 
-    vtkAppendPolyData *appender = d->m_Appender;
+    vtkAppendPolyData *appender = m_Appender;
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
-    if(d->content) {
+    if(content) {
         vtkSmartPointer<vtkLineSource> line_in = vtkSmartPointer<vtkLineSource>::New();
         vtkSmartPointer<vtkLineSource> line_out = vtkSmartPointer<vtkLineSource>::New();
 
-        float distance = (d->content->LineIn().origin - d->content->LineOut().origin).norm() / 10;
+        float distance = (content->LineIn().origin - content->LineOut().origin).norm() / 10;
 
         HPoint3f pt;
-        pt = d->content->LineIn().origin;
+        pt = content->LineIn().origin;
         line_in->SetPoint1(pt(0),pt(1),pt(2));
-        pt= d->content->LineIn().origin + d->content->LineIn().direction * distance;
+        pt= content->LineIn().origin + content->LineIn().direction * distance;
         line_in->SetPoint2(pt(0),pt(1),pt(2));
-        pt = d->content->LineOut().origin;
+        pt = content->LineOut().origin;
         line_out->SetPoint1(pt(0),pt(1),pt(2));
-        pt = d->content->LineOut().origin + d->content->LineOut().direction * distance;
+        pt = content->LineOut().origin + content->LineOut().direction * distance;
         line_out->SetPoint2(pt(0),pt(1),pt(2));
 
         appender->AddInputConnection(line_in->GetOutputPort());
@@ -180,31 +136,31 @@ void vtkMuonEvent::InstallPipe()
     appender->Update();
     mapper->SetInputConnection(appender->GetOutputPort());
     mapper->Update();
-    d->m_Prop->SetMapper(mapper);
+    m_Prop->SetMapper(mapper);
 }
 
 vtkPolyData *vtkMuonEvent::GetPolyData() const
 {
-    return d->m_Appender->GetOutput();
+    return m_Appender->GetOutput();
 }
 
 void vtkMuonEvent::AddPocaPoint(HPoint3f poca)
 {
-    d->m_Poca = poca;
+    m_Poca = poca;
     vtkSmartPointer<vtkSphereSource> sphere =
             vtkSmartPointer<vtkSphereSource>::New();
-    float size = (d->content->LineIn().origin - d->content->LineOut().origin).head(3).norm();
+    float size = (content->LineIn().origin - content->LineOut().origin).head(3).norm();
     size /= 100;
     sphere->SetRadius(size);
     sphere->SetCenter(poca(0),poca(1),poca(2));
     sphere->Update();
-    d->m_Appender->AddInputConnection(sphere->GetOutputPort());
+    m_Appender->AddInputConnection(sphere->GetOutputPort());
-    d->m_Appender->Update();
+    m_Appender->Update();
 }
 
 HPoint3f vtkMuonEvent::GetPocaPoint()
 {
-    return d->m_Poca;
+    return m_Poca;
 }
 
 

src/Vtk/vtkMuonEvent.h

@@ -28,7 +28,21 @@
 #ifndef VTKMUONEVENT_H
 #define VTKMUONEVENT_H
 
-#include "Core/Macros.h"
+#include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
+#include <vtkAppendPolyData.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkLineSource.h>
+#include <vtkActor.h>
+
+#include <vtk3DWidget.h>
+#include <vtkBoxWidget.h>
+
+#include <vtkRenderWindowInteractor.h>
+
+#include <vtkCommand.h>
+#include <vtkTransform.h>
+
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -64,8 +78,14 @@ public:
 private:
     void InstallPipe();
 
-    friend class vtkMuonEventPimpl;
+    vtkMuonEvent::Content *content;
-    class vtkMuonEventPimpl *d;
+    vtkPolyData           *m_PolyData;
+    vtkActor              *m_Prop;
+
+    vtkAppendPolyData     *m_Appender;
+    vtkBoxWidget          *m_WidgetIN;
+    vtkBoxWidget          *m_WidgetOUT;
+    HPoint3f               m_Poca;
 };
 
 

src/Vtk/vtkMuonScatter.cxx

@@ -30,23 +30,6 @@
 #include "config.h"
 #endif
 
-
-#include <vtkConfigure.h>
-#include <vtkSmartPointer.h>
-#include <vtkSphereSource.h>
-#include <vtkAppendPolyData.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkLineSource.h>
-#include <vtkActor.h>
-
-#include <vtk3DWidget.h>
-#include <vtkBoxWidget.h>
-
-#include <vtkRenderWindowInteractor.h>
-
-#include <vtkCommand.h>
-#include <vtkTransform.h>
-
 #include "vtkMuonScatter.h"
 #include "Math/Dense.h"
 
@@ -78,36 +61,6 @@ namespace Vtk {
 
 //}
 
-//// PIMPL /////////////////////////////////////////////////////////////////////
-
-class vtkMuonScatterPimpl {
-public:
-    vtkMuonScatterPimpl() :
-        m_Content(NULL),
-        m_LineIn(vtkLineSource::New()),
-        m_LineOut(vtkLineSource::New()),
-        m_PolyData(vtkPolyData::New()),
-        m_SpherePoca(NULL)
-    {}
-
-    ~vtkMuonScatterPimpl()
-    {
-        m_LineIn->Delete();
-        m_LineOut->Delete();
-        if(m_SpherePoca) m_SpherePoca->Delete();
-    }
-
-    // members //
-    vtkMuonScatter::Content *m_Content;
-    vtkLineSource   *m_LineIn, *m_LineOut;
-    vtkSphereSource *m_SpherePoca;
-    vtkPolyData *m_PolyData;
-};
-
-
-
-
-
 
 ////////////////////////////////////////////////////////////////////////////////
 /////  VTK MUON Scatter  /////////////////////////////////////////////////////////
@@ -115,63 +68,69 @@ public:
 
 
 vtkMuonScatter::vtkMuonScatter(MuonScatter &content) :
-    d(new vtkMuonScatterPimpl)
+    m_Content(&content),
+    m_LineIn(vtkLineSource::New()),
+    m_LineOut(vtkLineSource::New()),
+    m_PolyData(vtkPolyData::New()),
+    m_SpherePoca(NULL)
 {
-      d->m_Content = &content;
     InstallPipe();
 }
 
 vtkMuonScatter::vtkMuonScatter(const MuonScatter &content) :
-    d(new vtkMuonScatterPimpl)
+    m_Content(const_cast<MuonScatter *>(&content)),
+    m_LineIn(vtkLineSource::New()),
+    m_LineOut(vtkLineSource::New()),
+    m_PolyData(vtkPolyData::New()),
+    m_SpherePoca(NULL)
 {
-      d->m_Content = const_cast<MuonScatter *>(&content);
     InstallPipe();
 }
 
 
 vtkMuonScatter::~vtkMuonScatter()
 {
-    delete d;
+    m_LineIn->Delete();
+    m_LineOut->Delete();
+    if(m_SpherePoca) m_SpherePoca->Delete();
 }
 
 vtkMuonScatter::Content &vtkMuonScatter::GetContent()
 {
-    return *d->m_Content;
+    return *m_Content;
 }
 
 void vtkMuonScatter::PrintSelf(std::ostream &o) const
-{
+{}
-    //    o << d->content;
-}
 
 
 void vtkMuonScatter::InstallPipe()
 {
-    if(d->m_Content) {
+    if(m_Content) {
-        vtkLineSource *line_in = d->m_LineIn;
+        vtkLineSource *line_in = m_LineIn;
-        vtkLineSource *line_out = d->m_LineOut;
+        vtkLineSource *line_out = m_LineOut;
 
-        float distance = (d->m_Content->LineIn().origin - d->m_Content->LineOut().origin).norm() / 10;
+        float distance = (m_Content->LineIn().origin - m_Content->LineOut().origin).norm() / 10;
 
         HPoint3f pt;
-        pt = d->m_Content->LineIn().origin;
+        pt = m_Content->LineIn().origin;
         line_in->SetPoint1(pt(0),pt(1),pt(2));
-        pt= d->m_Content->LineIn().origin + d->m_Content->LineIn().direction * distance;
+        pt= m_Content->LineIn().origin + m_Content->LineIn().direction * distance;
         line_in->SetPoint2(pt(0),pt(1),pt(2));
-        pt = d->m_Content->LineOut().origin;
+        pt = m_Content->LineOut().origin;
         line_out->SetPoint1(pt(0),pt(1),pt(2));
-        pt = d->m_Content->LineOut().origin + d->m_Content->LineOut().direction * distance;
+        pt = m_Content->LineOut().origin + m_Content->LineOut().direction * distance;
         line_out->SetPoint2(pt(0),pt(1),pt(2));
     }
 
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(d->m_LineIn->GetOutputPort());
+    mapper->SetInputConnection(m_LineIn->GetOutputPort());
     vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(mapper);
     this->SetProp(actor);
 
     mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(d->m_LineOut->GetOutputPort());
+    mapper->SetInputConnection(m_LineOut->GetOutputPort());
     actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(mapper);
     this->SetProp(actor);
@@ -180,32 +139,26 @@ void vtkMuonScatter::InstallPipe()
 vtkPolyData *vtkMuonScatter::GetPolyData() const
 {
     vtkSmartPointer<vtkAppendPolyData> append = vtkSmartPointer<vtkAppendPolyData>::New();
-//#   if VTK_MAJOR_VERSION <= 5
+    append->AddInputConnection(m_LineIn->GetOutputPort());
-    append->AddInputConnection(d->m_LineIn->GetOutputPort());
+    append->AddInputConnection(m_LineOut->GetOutputPort());
-    append->AddInputConnection(d->m_LineOut->GetOutputPort());
+    if(m_SpherePoca) append->AddInputConnection(m_SpherePoca->GetOutputPort());
-    if(d->m_SpherePoca) append->AddInputConnection(d->m_SpherePoca->GetOutputPort());
-//#   else
-//    append->AddInputData(d->m_LineIn->GetOutput());
-//    append->AddInputData(d->m_LineOut->GetOutput());
-//    if(d->m_SpherePoca) append->AddInputData(d->m_SpherePoca->GetOutput());
-//#   endif
     append->Update();
-    d->m_PolyData->DeepCopy(append->GetOutput());
+    m_PolyData->DeepCopy(append->GetOutput());
-    return d->m_PolyData;
+    return m_PolyData;
 }
 
 void vtkMuonScatter::AddPocaPoint(HPoint3f poca)
 {
     vtkSphereSource *sphere = vtkSphereSource::New();
-    float size = (d->m_Content->LineIn().origin - d->m_Content->LineOut().origin).head(3).norm();
+    float size = (m_Content->LineIn().origin - m_Content->LineOut().origin).head(3).norm();
     size /= 100;
     sphere->SetRadius(size);
     sphere->SetCenter(poca(0),poca(1),poca(2));
     sphere->Update();
-    d->m_SpherePoca = sphere;
+    m_SpherePoca = sphere;
 
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(d->m_SpherePoca->GetOutputPort());
+    mapper->SetInputConnection(m_SpherePoca->GetOutputPort());
     vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(mapper);
     this->SetProp(actor);
@@ -214,8 +167,8 @@ void vtkMuonScatter::AddPocaPoint(HPoint3f poca)
 HPoint3f vtkMuonScatter::GetPocaPoint()
 {
     double center[3];
-    if(d->m_SpherePoca) {
+    if(m_SpherePoca) {
-        d->m_SpherePoca->GetCenter(center);
+        m_SpherePoca->GetCenter(center);
         return HPoint3f(center[0],center[1],center[2]);
     }
     else {

src/Vtk/vtkMuonScatter.h

@@ -28,7 +28,22 @@
 #ifndef VTKMUONSCATTER_H
 #define VTKMUONSCATTER_H
 
-#include "Core/Macros.h"
+#include <vtkConfigure.h>
+#include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
+#include <vtkAppendPolyData.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkLineSource.h>
+#include <vtkActor.h>
+
+#include <vtk3DWidget.h>
+#include <vtkBoxWidget.h>
+
+#include <vtkRenderWindowInteractor.h>
+
+#include <vtkCommand.h>
+#include <vtkTransform.h>
+
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -66,8 +81,11 @@ protected:
 private:
     void InstallPipe();
 
-    friend class vtkMuonScatterPimpl;
+    vtkMuonScatter::Content *m_Content;
-    class vtkMuonScatterPimpl *d;
+    vtkLineSource           *m_LineIn;
+    vtkLineSource           *m_LineOut;
+    vtkSphereSource         *m_SpherePoca;
+    vtkPolyData             *m_PolyData;
 };
 
 } // vtk

src/Vtk/vtkStructuredGrid.cpp

@@ -29,82 +29,12 @@
 #include "config.h"
 #endif
 
-#include <vtkLineSource.h>
-#include <vtkBoundingBox.h>
-#include <vtkCubeSource.h>
-#include <vtkSmartPointer.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkActor.h>
-#include <vtkProperty.h>
-
-#include <vtkTransform.h>
-#include <vtkTransformPolyDataFilter.h>
-#include <vtkBoxWidget.h>
-#include <vtkCommand.h>
-
 #include "Math/StructuredGrid.h"
 #include "Vtk/vtkStructuredGrid.h"
 
 namespace uLib {
 namespace Vtk {
 
-////////////////////////////////////////////////////////////////////////////////
-////// PIMPL  //////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-class vtkStructuredGridPimpl {
-
-    // ---- WIDGET CBK ------------------------------------------------------ //
-    class vtkWidgetCallback : public vtkCommand
-    {
-    public:
-      static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
-      void SetParent(uLib::Vtk::vtkStructuredGrid *parent) { this->parent = parent; }
-      virtual void Execute(vtkObject *caller, unsigned long, void*)
-        {
-          vtkSmartPointer<vtkTransform> t =
-                  vtkSmartPointer<vtkTransform>::New();
-          vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
-          widget->GetTransform(t);
-          parent->SetTransform(t);
-          //std::cout << "event\n";
-      }
-    private:
-      uLib::Vtk::vtkStructuredGrid *parent;
-    };
-    // ---------------------------------------------------------------------- //
-
-public:
-    vtkStructuredGridPimpl(vtkStructuredGrid *parent, StructuredGrid &content) :
-        p(parent),
-        m_Content(&content),
-        m_Actor(vtkActor::New()),
-        m_Widget(vtkBoxWidget::New()),
-        m_Transform(vtkTransform::New())
-    {
-        vtkSmartPointer<vtkWidgetCallback> callback =
-            vtkSmartPointer<vtkWidgetCallback>::New();
-        callback->SetParent(p);
-        m_Widget->AddObserver(vtkCommand::InteractionEvent, callback);
-    }
-
-    ~vtkStructuredGridPimpl()
-    {
-        m_Actor->Delete();
-        m_Widget->Delete();
-        m_Transform->Delete();
-    }
-
-    // members //
-    vtkActor       *m_Actor;
-    vtkBoxWidget   *m_Widget;
-    StructuredGrid *m_Content;
-    vtkTransform   *m_Transform;
-private:
-    vtkStructuredGrid *p;
-};
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////// VTK STRUCTURED GRID /////////////////////////////////////////////////////
@@ -113,14 +43,24 @@ private:
 
 
 vtkStructuredGrid::vtkStructuredGrid(Content &content) :
-    d(new vtkStructuredGridPimpl(this,content))
+    m_Content(&content),
+    m_Actor(vtkActor::New()),
+    m_Widget(vtkBoxWidget::New()),
+    m_Transform(vtkTransform::New())
 {
+    vtkSmartPointer<vtkWidgetCallback> callback =
+        vtkSmartPointer<vtkWidgetCallback>::New();
+    callback->SetGrid(this);
+    m_Widget->AddObserver(vtkCommand::InteractionEvent, callback);
+
     this->InstallPipe();
 }
 
 vtkStructuredGrid::~vtkStructuredGrid()
 {
-    delete d;
+    m_Actor->Delete();
+    m_Widget->Delete();
+    m_Transform->Delete();
 }
 
 
@@ -131,26 +71,26 @@ void vtkStructuredGrid::SetTransform(vtkTransform *t)
     for(int i=0; i<4; ++i)
         for(int j=0; j<4; ++j)
             mat(i,j) = vmat->GetElement(i,j);
-    d->m_Content->SetMatrix(mat);
+    m_Content->SetMatrix(mat);
 
     vtkSmartPointer<vtkMatrix4x4> vmat2 = vtkSmartPointer<vtkMatrix4x4>::New();
-    mat = d->m_Content->GetWorldMatrix();
+    mat = m_Content->GetWorldMatrix();
     for(int i=0; i<4; ++i)
         for(int j=0; j<4; ++j)
             vmat2->SetElement(i,j,mat(i,j));
-    d->m_Transform->SetMatrix(vmat2);
+    m_Transform->SetMatrix(vmat2);
-    d->m_Transform->Update();
+    m_Transform->Update();
     this->Update();
 }
 
 vtkBoxWidget *vtkStructuredGrid::GetWidget()
 {
-    return d->m_Widget;
+    return m_Widget;
 }
 
 void vtkStructuredGrid::Update()
 {
-    d->m_Actor->GetMapper()->Update();
+    m_Actor->GetMapper()->Update();
 }
 
 void vtkStructuredGrid::InstallPipe()
@@ -161,15 +101,15 @@ void vtkStructuredGrid::InstallPipe()
             vtkSmartPointer<vtkTransformPolyDataFilter>::New();
 
     vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
-    Matrix4f mat = d->m_Content->GetWorldMatrix();
+    Matrix4f mat = m_Content->GetWorldMatrix();
     for(int i=0; i<4; ++i)
         for(int j=0; j<4; ++j)
             vmat->SetElement(i,j,mat(i,j));
-    d->m_Transform->SetMatrix(vmat);
+    m_Transform->SetMatrix(vmat);
-    filter->SetTransform(d->m_Transform);
+    filter->SetTransform(m_Transform);
     filter->SetInputConnection(cube->GetOutputPort());
 
-    Vector3i dims = d->m_Content->GetDims();
+    Vector3i dims = m_Content->GetDims();
     cube->SetBounds(0,dims(0),0,dims(1),0,dims(2));
     cube->Update();
     filter->Update();
@@ -178,16 +118,16 @@ void vtkStructuredGrid::InstallPipe()
             vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputConnection(filter->GetOutputPort());
 
-    d->m_Actor->SetMapper(mapper);
+    m_Actor->SetMapper(mapper);
-    d->m_Actor->GetProperty()->SetRepresentationToSurface();
+    m_Actor->GetProperty()->SetRepresentationToSurface();
-    d->m_Actor->GetProperty()->SetEdgeVisibility(true);
+    m_Actor->GetProperty()->SetEdgeVisibility(true);
-    d->m_Actor->GetProperty()->SetOpacity(0.4);
+    m_Actor->GetProperty()->SetOpacity(0.4);
-    d->m_Actor->GetProperty()->SetAmbient(0.7);
+    m_Actor->GetProperty()->SetAmbient(0.7);
     // set content transform to actor //
     this->Update();
-    d->m_Widget->SetProp3D(d->m_Actor);
+    m_Widget->SetProp3D(m_Actor);
 
-    this->SetProp(d->m_Actor);
+    this->SetProp(m_Actor);
 }
 
 

src/Vtk/vtkStructuredGrid.h

@@ -28,7 +28,19 @@
 #ifndef U_VTKSTRUCTUREDGRID_H
 #define U_VTKSTRUCTUREDGRID_H
 
-#include "Core/Macros.h"
+#include <vtkLineSource.h>
+#include <vtkBoundingBox.h>
+#include <vtkCubeSource.h>
+#include <vtkSmartPointer.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkActor.h>
+#include <vtkProperty.h>
+
+#include <vtkTransform.h>
+#include <vtkTransformPolyDataFilter.h>
+#include <vtkBoxWidget.h>
+#include <vtkCommand.h>
+
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -55,8 +67,28 @@ public:
 private:
     void InstallPipe();
 
-    friend class vtkStructuredGridPimpl;
+    class vtkWidgetCallback : public vtkCommand
-    class vtkStructuredGridPimpl *d;
+    {
+    public:
+        static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
+
+        void SetGrid(uLib::Vtk::vtkStructuredGrid *grid) { this->grid = grid; }
+
+        virtual void Execute(vtkObject *caller, unsigned long, void*)
+        {
+          vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
+          vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
+          widget->GetTransform(t);
+          grid->SetTransform(t);
+        }
+    private:
+        uLib::Vtk::vtkStructuredGrid *grid;
+    };
+
+    vtkActor          *m_Actor;
+    vtkBoxWidget      *m_Widget;
+    StructuredGrid    *m_Content;
+    vtkTransform      *m_Transform;
 };
 
 

src/Vtk/vtkVoxRaytracerRepresentation.cpp

@@ -29,25 +29,6 @@
 #include "config.h"
 #endif
 
-#include <vtkLine.h>
-#include <vtkCellArray.h>
-
-#include <vtkLineSource.h>
-#include <vtkSphereSource.h>
-#include <vtkBoundingBox.h>
-#include <vtkCubeSource.h>
-#include <vtkSmartPointer.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkAppendPolyData.h>
-#include <vtkActor.h>
-#include <vtkAssembly.h>
-#include <vtkProp3DCollection.h>
-#include <vtkProperty.h>
-#include <vtkPolyData.h>
-#include <vtkTransform.h>
-#include <vtkTransformPolyDataFilter.h>
-
-
 
 #include "vtkVoxRaytracerRepresentation.h"
 
@@ -60,12 +41,13 @@
 namespace uLib {
 namespace Vtk {
 
-///// PIMPL ////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////// VOX RAYTRACER REPRESENTATION  ///////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
-class vtkVoxRaytracerRepresentationPimpl {
 
-public:
+
-    vtkVoxRaytracerRepresentationPimpl(VoxRaytracer &content) :
+vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content) :
     m_Content(&content),
     m_Assembly(vtkAssembly::New()),
     m_Sphere1(vtkSphereSource::New()),
@@ -78,86 +60,52 @@ public:
     m_RayRepresentation(vtkAppendPolyData::New()),
     m_RayRepresentationActor(vtkActor::New()),
     m_Transform(vtkTransform::New())
-    {
+{
     default_radius = content.GetImage()->GetSpacing()(0)/4;
     m_Sphere1->SetRadius(default_radius);
     m_Sphere2->SetRadius(default_radius);
     m_SelectedElement = m_RayLine;
-    }
-    ~vtkVoxRaytracerRepresentationPimpl()
-    {
-        m_Assembly->Delete();
-        m_RayLine->Delete();
-        m_RayLineActor->Delete();
-        m_RayRepresentationActor->Delete();
-        m_Transform->Delete();
-    }
 
-    // members //
-    VoxRaytracer *m_Content;
-
-    Scalarf                            default_radius;
-    vtkAssembly                       *m_Assembly;
-    vtkAppendPolyData                 *m_RayLine;
-    vtkActor                          *m_RayLineActor;
-    vtkActor                          *m_RayRepresentationActor;
-    vtkSmartPointer<vtkTransform>      m_Transform;
-    VoxRaytracer::RayData              m_Ray;
-    vtkSmartPointer<vtkSphereSource>   m_Sphere1,m_Sphere2;
-    vtkSmartPointer<vtkLineSource>     m_Line1,  m_Line2, m_Line3;
-    vtkSmartPointer<vtkAppendPolyData> m_RayRepresentation;
-
-    vtkAppendPolyData                *m_SelectedElement;
-};
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////// VOX RAYTRACER REPRESENTATION  ///////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-
-vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content) :
-    d(new vtkVoxRaytracerRepresentationPimpl(content))
-{
     InstallPipe();
 }
 
 vtkVoxRaytracerRepresentation::~vtkVoxRaytracerRepresentation()
 {
-    delete d;
+    m_Assembly->Delete();
+    m_RayLine->Delete();
+    m_RayLineActor->Delete();
+    m_RayRepresentationActor->Delete();
+    m_Transform->Delete();
 }
 
 VoxRaytracer *vtkVoxRaytracerRepresentation::GetRaytracerAlgorithm()
 {
-    return d->m_Content;
+    return m_Content;
 }
 
 vtkProp *vtkVoxRaytracerRepresentation::GetProp()
 {
-    return d->m_Assembly;
+    return m_Assembly;
 }
 
 vtkPolyData *vtkVoxRaytracerRepresentation::GetPolyData() const
 {
     std::cout << "get Raytracer polydata\n";
-    d->m_SelectedElement->Update();
+    m_SelectedElement->Update();
-    return d->m_SelectedElement->GetOutput();
+    return m_SelectedElement->GetOutput();
 }
 
 void vtkVoxRaytracerRepresentation::SetRepresentationElements(vtkVoxRaytracerRepresentation::RepresentationElements el)
 {
     switch(el) {
     case Vtk::vtkVoxRaytracerRepresentation::RayElements:
-        d->m_SelectedElement = d->m_RayLine;
+        m_SelectedElement = m_RayLine;
         break;
     case Vtk::vtkVoxRaytracerRepresentation::VoxelsElements:
-        d->m_SelectedElement = d->m_RayRepresentation;
+        m_SelectedElement = m_RayRepresentation;
         break;
     default:
-        d->m_SelectedElement = d->m_RayLine;
+        m_SelectedElement = m_RayLine;
         break;
     }
 }
@@ -167,22 +115,22 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon)
 {
     HPoint3f pt1,pt2,src;
     src = muon.LineIn().origin;
-    d->m_Content->GetEntryPoint(muon.LineIn(),pt1);
+    m_Content->GetEntryPoint(muon.LineIn(),pt1);
-    d->m_Sphere1->SetCenter(pt1(0),pt1(1),pt1(2));
+    m_Sphere1->SetCenter(pt1(0),pt1(1),pt1(2));
-    d->m_Line1->SetPoint1(src(0),src(1),src(2));
+    m_Line1->SetPoint1(src(0),src(1),src(2));
-    d->m_Line1->SetPoint2(pt1(0),pt1(1),pt1(2));
+    m_Line1->SetPoint2(pt1(0),pt1(1),pt1(2));
 
     HLine3f line_out = muon.LineOut();
     src = line_out.origin;
     float *direction = line_out.direction.data();
     for(int i=0;i<3;++i) direction[i] *= -1;
-    d->m_Content->GetEntryPoint(line_out,pt2);
+    m_Content->GetEntryPoint(line_out,pt2);
-    d->m_Sphere2->SetCenter(pt2(0),pt2(1),pt2(2));
+    m_Sphere2->SetCenter(pt2(0),pt2(1),pt2(2));
-    d->m_Line2->SetPoint1(src(0),src(1),src(2));
+    m_Line2->SetPoint1(src(0),src(1),src(2));
-    d->m_Line2->SetPoint2(pt2(0),pt2(1),pt2(2));
+    m_Line2->SetPoint2(pt2(0),pt2(1),pt2(2));
 
-    d->m_Line3->SetPoint1(pt1(0),pt1(1),pt1(2));
+    m_Line3->SetPoint1(pt1(0),pt1(1),pt1(2));
-    d->m_Line3->SetPoint2(pt2(0),pt2(1),pt2(2));
+    m_Line3->SetPoint2(pt2(0),pt2(1),pt2(2));
 
     // Create a vtkPoints object and store the points in it
       vtkSmartPointer<vtkPoints> points =
@@ -210,25 +158,22 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon)
       // Add the lines to the dataset
       linesPolyData->SetLines(lines);
 
-      d->m_RayLine->RemoveAllInputs();
+      m_RayLine->RemoveAllInputs();
 #     if VTK_MAJOR_VERSION <= 5
-      d->m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
+      m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
-#     else
-      d->m_RayLine->AddInputData(linesPolyData);
 #     endif
-      d->m_RayLine->AddInputConnection(d->m_Line1->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Line1->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Sphere1->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Sphere1->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Line2->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Line2->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Sphere2->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Sphere2->GetOutputPort());
-//      d->m_RayLine->AddInputConnection(d->m_Line3->GetOutputPort());
 
 
     vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
-    Matrix4f mat = d->m_Content->GetImage()->GetWorldMatrix();
+    Matrix4f mat = m_Content->GetImage()->GetWorldMatrix();
     for(int i=0; i<4; ++i)
         for(int j=0; j<4; ++j)
             vmat->SetElement(i,j,mat(i,j));
-    d->m_Transform->SetMatrix(vmat);
+    m_Transform->SetMatrix(vmat);
 
     this->SetRay(pt1,pt2);
 }
@@ -237,22 +182,22 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca)
 {
     HPoint3f pt1,pt2,src;
     src = muon.LineIn().origin;
-    d->m_Content->GetEntryPoint(muon.LineIn(),pt1);
+    m_Content->GetEntryPoint(muon.LineIn(),pt1);
-    d->m_Sphere1->SetCenter(pt1(0),pt1(1),pt1(2));
+    m_Sphere1->SetCenter(pt1(0),pt1(1),pt1(2));
-    d->m_Line1->SetPoint1(src(0),src(1),src(2));
+    m_Line1->SetPoint1(src(0),src(1),src(2));
-    d->m_Line1->SetPoint2(pt1(0),pt1(1),pt1(2));
+    m_Line1->SetPoint2(pt1(0),pt1(1),pt1(2));
 
     HLine3f line_out = muon.LineOut();
     src = line_out.origin;
     float *direction = line_out.direction.data();
     for(int i=0;i<3;++i) direction[i] *= -1;
-    d->m_Content->GetEntryPoint(line_out,pt2);
+    m_Content->GetEntryPoint(line_out,pt2);
-    d->m_Sphere2->SetCenter(pt2(0),pt2(1),pt2(2));
+    m_Sphere2->SetCenter(pt2(0),pt2(1),pt2(2));
-    d->m_Line2->SetPoint1(src(0),src(1),src(2));
+    m_Line2->SetPoint1(src(0),src(1),src(2));
-    d->m_Line2->SetPoint2(pt2(0),pt2(1),pt2(2));
+    m_Line2->SetPoint2(pt2(0),pt2(1),pt2(2));
 
-    d->m_Line3->SetPoint1(pt1(0),pt1(1),pt1(2));
+    m_Line3->SetPoint1(pt1(0),pt1(1),pt1(2));
-    d->m_Line3->SetPoint2(pt2(0),pt2(1),pt2(2));
+    m_Line3->SetPoint2(pt2(0),pt2(1),pt2(2));
 
     // Create a vtkPoints object and store the points in it
       vtkSmartPointer<vtkPoints> points =
@@ -284,34 +229,31 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca)
       // Add the lines to the dataset
       linesPolyData->SetLines(lines);
 
-      d->m_RayLine->RemoveAllInputs();
+      m_RayLine->RemoveAllInputs();
 #     if VTK_MAJOR_VERSION <= 5
-      d->m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
+      m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
-#     else
-      d->m_RayLine->AddInputData(linesPolyData);
 #     endif
-      d->m_RayLine->AddInputConnection(d->m_Line1->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Line1->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Sphere1->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Sphere1->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Line2->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Line2->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Sphere2->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Sphere2->GetOutputPort());
-//      d->m_RayLine->AddInputConnection(d->m_Line3->GetOutputPort());
 
 
       vtkSmartPointer<vtkSphereSource> poca_sphere =
               vtkSmartPointer<vtkSphereSource>::New();
-      poca_sphere->SetRadius(d->default_radius);
+      poca_sphere->SetRadius(default_radius);
       poca_sphere->SetCenter(poca(0),poca(1),poca(2));
-      d->m_RayLine->AddInputConnection(poca_sphere->GetOutputPort());
+      m_RayLine->AddInputConnection(poca_sphere->GetOutputPort());
 
 
     vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
-    Matrix4f mat = d->m_Content->GetImage()->GetWorldMatrix();
+    Matrix4f mat = m_Content->GetImage()->GetWorldMatrix();
     for(int i=0; i<4; ++i)
         for(int j=0; j<4; ++j)
             vmat->SetElement(i,j,mat(i,j));
-    d->m_Transform->SetMatrix(vmat);
+    m_Transform->SetMatrix(vmat);
 
-    if(d->m_Content->GetImage()->IsInsideBounds(poca))
+    if(m_Content->GetImage()->IsInsideBounds(poca))
         this->SetRay(pt1,poca,pt2);
     else
         this->SetRay(pt1,pt2);
@@ -328,38 +270,36 @@ void vtkVoxRaytracerRepresentation::SetMuon(vtkMuonScatter &muon)
 
 VoxRaytracer::RayData vtkVoxRaytracerRepresentation::GetRay()
 {
-    return d->m_Ray;
+    return m_Ray;
 }
 
 void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f out)
 {
-    d->m_Ray = d->m_Content->TraceBetweenPoints(in,out);
+    m_Ray = m_Content->TraceBetweenPoints(in,out);
-    this->SetRay(&d->m_Ray);
+    this->SetRay(&m_Ray);
 }
 
 void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f mid, HPoint3f out)
 {
-    d->m_Ray = d->m_Content->TraceBetweenPoints(in,mid);
+    m_Ray = m_Content->TraceBetweenPoints(in,mid);
-    d->m_Ray.AppendRay( d->m_Content->TraceBetweenPoints(mid,out) );
+    m_Ray.AppendRay( m_Content->TraceBetweenPoints(mid,out) );
-    this->SetRay(&d->m_Ray);
+    this->SetRay(&m_Ray);
 }
 
 void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray)
 {
-    vtkAppendPolyData *appender = d->m_RayRepresentation;
+    vtkAppendPolyData *appender = m_RayRepresentation;
     appender->RemoveAllInputs();
 
     for(int i=0; i<ray->Data().size(); ++i) {
         int id = ray->Data().at(i).vox_id;
-        Vector3i idv = d->m_Content->GetImage()->UnMap(id);
+        Vector3i idv = m_Content->GetImage()->UnMap(id);
         vtkSmartPointer<vtkCubeSource> cube =
                 vtkSmartPointer<vtkCubeSource>::New();
         cube->SetBounds(idv(0),idv(0)+1,idv(1),idv(1)+1,idv(2),idv(2)+1);
         cube->Update();
 #       if VTK_MAJOR_VERSION <= 5
         appender->AddInput(cube->GetOutput());
-#       else
-        appender->AddInputData(cube->GetOutput());
 #       endif
         appender->Update();
     }
@@ -368,12 +308,12 @@ void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray)
 
 void vtkVoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba)
 {
-    this->SetColor(d->m_RayRepresentationActor,rgba);
+    this->SetColor(m_RayRepresentationActor,rgba);
 }
 
 void vtkVoxRaytracerRepresentation::SetRayColor(Vector4f rgba)
 {
-    this->SetColor(d->m_RayLineActor,rgba);
+    this->SetColor(m_RayLineActor,rgba);
 }
 
 void vtkVoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba)
@@ -395,10 +335,10 @@ void vtkVoxRaytracerRepresentation::InstallPipe()
 
     vtkSmartPointer<vtkAppendPolyData> append =
             vtkSmartPointer<vtkAppendPolyData>::New();
-    append->AddInputConnection(d->m_Sphere1->GetOutputPort());
+    append->AddInputConnection(m_Sphere1->GetOutputPort());
-    append->AddInputConnection(d->m_Sphere2->GetOutputPort());
+    append->AddInputConnection(m_Sphere2->GetOutputPort());
-    append->AddInputConnection(d->m_Line1->GetOutputPort());
+    append->AddInputConnection(m_Line1->GetOutputPort());
-    append->AddInputConnection(d->m_Line2->GetOutputPort());
+    append->AddInputConnection(m_Line2->GetOutputPort());
 
     append->Update();
     vtkSmartPointer<vtkPolyDataMapper> mapper =
@@ -413,34 +353,24 @@ void vtkVoxRaytracerRepresentation::InstallPipe()
     this->SetProp(actor);
 
     mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(d->m_RayLine->GetOutputPort());
+    mapper->SetInputConnection(m_RayLine->GetOutputPort());
     mapper->Update();
 
-    d->m_RayLineActor->SetMapper(mapper);
+    m_RayLineActor->SetMapper(mapper);
-    d->m_RayLineActor->GetProperty()->SetColor(1,0,0);
+    m_RayLineActor->GetProperty()->SetColor(1,0,0);
-    this->SetProp(d->m_RayLineActor);
+    this->SetProp(m_RayLineActor);
-
-//    mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-//    mapper->SetInputConnection(d->m_Line3->GetOutputPort());
-//    mapper->Update();
-
-//    actor = vtkSmartPointer<vtkActor>::New();
-//    actor->SetMapper(mapper);
-//    actor->GetProperty()->SetColor(1,0,0);
-//    d->m_Assembly->AddPart(actor);
-
 
     vtkSmartPointer<vtkTransformPolyDataFilter> polyfilter =
             vtkSmartPointer<vtkTransformPolyDataFilter>::New();
 
-    polyfilter->SetInputConnection(d->m_RayRepresentation->GetOutputPort());
+    polyfilter->SetInputConnection(m_RayRepresentation->GetOutputPort());
-    polyfilter->SetTransform(d->m_Transform);
+    polyfilter->SetTransform(m_Transform);
 
     mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputConnection(polyfilter->GetOutputPort());
     mapper->Update();
 
-    vtkActor *vra = d->m_RayRepresentationActor;
+    vtkActor *vra = m_RayRepresentationActor;
     vra->SetMapper(mapper);
     vra->GetProperty()->SetOpacity(0.2);
     vra->GetProperty()->SetEdgeVisibility(true);

src/Vtk/vtkVoxRaytracerRepresentation.h

@@ -28,8 +28,24 @@
 #ifndef U_VTKVOXRAYTRACERREPRESENTATION_H
 #define U_VTKVOXRAYTRACERREPRESENTATION_H
 
+#include <vtkLine.h>
+#include <vtkCellArray.h>
+
+#include <vtkLineSource.h>
+#include <vtkSphereSource.h>
+#include <vtkBoundingBox.h>
+#include <vtkCubeSource.h>
+#include <vtkSmartPointer.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkAppendPolyData.h>
+#include <vtkActor.h>
+#include <vtkAssembly.h>
+#include <vtkProp3DCollection.h>
+#include <vtkProperty.h>
+#include <vtkPolyData.h>
+#include <vtkTransform.h>
+#include <vtkTransformPolyDataFilter.h>
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -89,8 +105,23 @@ private:
 
     void SetColor(vtkActor *actor, Vector4f rgba);
 
-    friend class vtkVoxRaytracerRepresentationPimpl;
+    VoxRaytracer                      *m_Content;
-    class vtkVoxRaytracerRepresentationPimpl *d;
+
+    Scalarf                            default_radius;
+    vtkAssembly                       *m_Assembly;
+    vtkAppendPolyData                 *m_RayLine;
+    vtkActor                          *m_RayLineActor;
+    vtkActor                          *m_RayRepresentationActor;
+    vtkSmartPointer<vtkTransform>      m_Transform;
+    VoxRaytracer::RayData              m_Ray;
+    vtkSmartPointer<vtkSphereSource>   m_Sphere1;
+    vtkSmartPointer<vtkSphereSource>   m_Sphere2;
+    vtkSmartPointer<vtkLineSource>     m_Line1;
+    vtkSmartPointer<vtkLineSource>     m_Line2;
+    vtkSmartPointer<vtkLineSource>     m_Line3;
+    vtkSmartPointer<vtkAppendPolyData> m_RayRepresentation;
+
+    vtkAppendPolyData                 *m_SelectedElement;
 };