334 lines
10 KiB
C++
334 lines
10 KiB
C++
/*//////////////////////////////////////////////////////////////////////////////
|
|
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
|
|
All rights reserved
|
|
|
|
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
|
|
|
|
------------------------------------------------------------------
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 3.0 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library.
|
|
|
|
//////////////////////////////////////////////////////////////////////////////*/
|
|
|
|
#ifndef ULIBVTKINTERFACE_H
|
|
#define ULIBVTKINTERFACE_H
|
|
|
|
#include "Core/Monitor.h"
|
|
#include "Core/Object.h"
|
|
#include "Core/Property.h"
|
|
#include <boost/mpl/bool.hpp>
|
|
#include <boost/serialization/serialization.hpp>
|
|
#include <boost/type_traits/is_class.hpp>
|
|
#include <iomanip>
|
|
#include <ostream>
|
|
#include <vector>
|
|
#include <set>
|
|
#include <boost/type_traits/is_base_of.hpp>
|
|
|
|
// vtk classes forward declaration //
|
|
class vtkProp;
|
|
class vtkProp3D;
|
|
class vtkPolyData;
|
|
class vtkPropCollection;
|
|
class vtkRenderer;
|
|
class vtkRendererCollection;
|
|
class vtkRenderWindowInteractor;
|
|
|
|
namespace uLib {
|
|
namespace Archive {
|
|
class display_properties_archive;
|
|
}
|
|
namespace Vtk {
|
|
class Prop3D;
|
|
class Viewer;
|
|
} // namespace Vtk
|
|
} // namespace uLib
|
|
|
|
namespace uLib {
|
|
namespace Vtk {
|
|
|
|
class Prop3D : public uLib::Object {
|
|
|
|
uLibTypeMacro(Prop3D, uLib::Object)
|
|
|
|
public:
|
|
Prop3D();
|
|
virtual ~Prop3D();
|
|
|
|
virtual vtkProp *GetProp();
|
|
virtual vtkProp3D *GetProxyProp();
|
|
|
|
virtual vtkPropCollection *GetParts();
|
|
|
|
virtual vtkPropCollection *GetProps();
|
|
|
|
virtual uLib::Object *GetContent() const { return nullptr; }
|
|
|
|
void ConnectRenderer(vtkRenderer *renderer);
|
|
|
|
void DisconnectRenderer(vtkRenderer *renderer);
|
|
|
|
void ConnectViewer(Viewer *viewer);
|
|
|
|
void DisonnectViewer(Viewer *viewer);
|
|
|
|
void SetColor(double r, double g, double b);
|
|
void GetColor(double &r, double &g, double &b) const;
|
|
|
|
void SetOpacity(double alpha);
|
|
double GetOpacity() const;
|
|
|
|
void SetSelectable(bool selectable = true);
|
|
bool IsSelectable() const;
|
|
|
|
void SetSelected(bool selected = true);
|
|
bool IsSelected() const;
|
|
|
|
/**
|
|
* @brief Synchronizes the VTK representation with the internal state and properties.
|
|
*
|
|
* This method should be called whenever the underlying model or display properties
|
|
* are modified to ensure the visual representation in VTK is consistent.
|
|
*/
|
|
virtual void Update();
|
|
|
|
/**
|
|
* @brief Synchronizes the internal state and properties from the VTK representation.
|
|
*
|
|
* This method should be called when the VTK representation has been modified
|
|
* (e.g., via a gizmo) and the changes need to be pushed back to the model.
|
|
*/
|
|
virtual void SyncFromVtk();
|
|
|
|
enum Representation {
|
|
Points = 0,
|
|
Wireframe = 1,
|
|
Surface = 2,
|
|
SurfaceWithEdges = 3,
|
|
Volume = 4,
|
|
Outline = 5,
|
|
Slice = 6
|
|
};
|
|
void SetRepresentation(Representation mode);
|
|
void SetRepresentation(const char *mode);
|
|
|
|
enum HighlightMode {
|
|
HighlightPlain = 0,
|
|
HighlightCorners = 1
|
|
};
|
|
void SetHighlightMode(HighlightMode mode);
|
|
|
|
virtual void PrintSelf(std::ostream &o) const;
|
|
|
|
void ShowBoundingBox(bool show);
|
|
void ShowScaleMeasures(bool show);
|
|
|
|
vtkRendererCollection *GetRenderers() const;
|
|
|
|
const std::vector<uLib::PropertyBase *> &GetDisplayProperties() const override {
|
|
return m_DisplayProperties;
|
|
}
|
|
void RegisterDisplayProperty(uLib::PropertyBase *prop) override {
|
|
m_DisplayProperties.push_back(prop);
|
|
}
|
|
|
|
virtual void serialize_display(uLib::Archive::display_properties_archive &ar,
|
|
const unsigned int version = 0);
|
|
|
|
virtual void ConnectInteractor(class vtkRenderWindowInteractor *interactor);
|
|
|
|
void AddToViewer(class Viewport &viewer);
|
|
void RemoveFromViewer(class Viewport &viewer);
|
|
|
|
protected:
|
|
void SetProp(vtkProp *prop);
|
|
|
|
void RemoveProp(vtkProp *prop);
|
|
|
|
virtual void ApplyAppearance(vtkProp *prop);
|
|
virtual void ApplyTransform(vtkProp3D *p3d);
|
|
virtual void ApplyProp3DTransform(vtkProp3D *p3d);
|
|
|
|
std::vector<uLib::PropertyBase *> m_DisplayProperties;
|
|
mutable uLib::RecursiveMutex m_UpdateMutex;
|
|
|
|
private:
|
|
Prop3D(const Prop3D &) = delete;
|
|
Prop3D &operator=(const Prop3D &) = delete;
|
|
|
|
friend class Prop3DData;
|
|
class Prop3DData *pd;
|
|
};
|
|
|
|
} // namespace Vtk
|
|
} // namespace uLib
|
|
|
|
|
|
|
|
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// DISPLAY PROPERTIES SERIALIZE
|
|
// -------------------------------------------------------------------------- //
|
|
|
|
namespace uLib {
|
|
namespace Archive {
|
|
|
|
/**
|
|
* @brief Specialized archive for registering display-only properties in
|
|
* Prop3Ds.
|
|
*/
|
|
class display_properties_archive
|
|
: public boost::archive::detail::common_oarchive<
|
|
display_properties_archive> {
|
|
public:
|
|
friend class boost::archive::detail::interface_oarchive<display_properties_archive>;
|
|
friend class boost::archive::save_access;
|
|
|
|
using boost::archive::detail::common_oarchive<display_properties_archive>::save_override;
|
|
display_properties_archive(Vtk::Prop3D *p)
|
|
: boost::archive::detail::common_oarchive<display_properties_archive>(
|
|
boost::archive::no_header),
|
|
m_Prop3D(p) {
|
|
if (p)
|
|
m_Visited.insert(dynamic_cast<const void *>(p));
|
|
}
|
|
|
|
std::string GetCurrentGroup() const {
|
|
std::string group;
|
|
for (const auto &g : m_GroupStack) {
|
|
if (!group.empty())
|
|
group += ".";
|
|
group += g;
|
|
}
|
|
return group;
|
|
}
|
|
|
|
template <class T> void save_override(const boost::serialization::hrp<T> &t) {
|
|
if (m_Prop3D) {
|
|
uLib::Property<T> *p = new uLib::Property<T>(
|
|
m_Prop3D, t.name(),
|
|
&const_cast<boost::serialization::hrp<T> &>(t).value(),
|
|
t.units() ? t.units() : "", GetCurrentGroup());
|
|
if (t.has_range())
|
|
p->SetRange(t.min_val(), t.max_val());
|
|
if (t.has_default())
|
|
p->SetDefault(t.default_val());
|
|
|
|
m_Prop3D->RegisterDisplayProperty(p);
|
|
Vtk::Prop3D *prop3d = m_Prop3D;
|
|
uLib::Object::connect(p, &uLib::Object::Updated,
|
|
[prop3d]() { prop3d->Update(); });
|
|
}
|
|
}
|
|
|
|
template <class T>
|
|
void save_override(const boost::serialization::hrp_enum<T> &t) {
|
|
if (m_Prop3D) {
|
|
uLib::EnumProperty *p = new uLib::EnumProperty(
|
|
m_Prop3D, t.name(),
|
|
(int *)&const_cast<boost::serialization::hrp_enum<T> &>(t).value(),
|
|
t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
|
|
m_Prop3D->RegisterDisplayProperty(p);
|
|
Vtk::Prop3D *prop3d = m_Prop3D;
|
|
uLib::Object::connect(p, &uLib::Object::Updated,
|
|
[prop3d]() { prop3d->Update(); });
|
|
}
|
|
}
|
|
|
|
template <class T> void save_override(const boost::serialization::nvp<T> &t) {
|
|
if (t.name())
|
|
m_GroupStack.push_back(t.name());
|
|
this->save_helper(t.const_value(), typename boost::is_class<T>::type());
|
|
if (t.name())
|
|
m_GroupStack.pop_back();
|
|
}
|
|
|
|
// Follow pointers to discover properties in child objects
|
|
template<class T>
|
|
void save_override(T * const & t) {
|
|
if (!t) return;
|
|
this->save_pointer_helper(t, typename boost::is_base_of<uLib::Object, T>::type());
|
|
}
|
|
|
|
template<class T>
|
|
void save_pointer_helper(T* t, boost::mpl::true_) {
|
|
const void* ptr = dynamic_cast<const void*>(t);
|
|
if (m_Visited.find(ptr) != m_Visited.end()) return;
|
|
m_Visited.insert(ptr);
|
|
this->save_override(*t);
|
|
}
|
|
|
|
template<class T>
|
|
void save_pointer_helper(T* t, boost::mpl::false_) {}
|
|
|
|
// Recursion for nested classes, ignore primitives
|
|
template <class T> void save_override(const T &t) {
|
|
this->save_helper(t, typename boost::is_class<T>::type());
|
|
}
|
|
|
|
template <class T> void save_helper(const T &t, boost::mpl::true_) {
|
|
boost::serialization::serialize_adl(*this, const_cast<T &>(t), 0);
|
|
}
|
|
|
|
void save_helper(const std::string &t, boost::mpl::true_) {}
|
|
|
|
template <class T> void save_helper(const T &t, boost::mpl::false_) {}
|
|
|
|
void save_override(const boost::archive::object_id_type &t) {}
|
|
void save_override(const boost::archive::object_reference_type &t) {}
|
|
void save_override(const boost::archive::version_type &t) {}
|
|
void save_override(const boost::archive::class_id_type &t) {}
|
|
void save_override(const boost::archive::class_id_optional_type &t) {}
|
|
void save_override(const boost::archive::class_id_reference_type &t) {}
|
|
void save_override(const boost::archive::class_name_type &t) {}
|
|
void save_override(const boost::archive::tracking_type &t) {}
|
|
|
|
// Called by Property<T>::serialize() and EnumProperty::serialize() to
|
|
// directly register an existing property object as a display property.
|
|
void register_property(uLib::PropertyBase &p) {
|
|
if (m_Prop3D) {
|
|
m_Prop3D->RegisterDisplayProperty(&p);
|
|
Vtk::Prop3D *prop3d = m_Prop3D;
|
|
uLib::Object::connect(&p, &uLib::Object::Updated,
|
|
[prop3d]() { prop3d->Update(); });
|
|
}
|
|
}
|
|
|
|
void register_enum_property(uLib::EnumProperty &p) {
|
|
register_property(p);
|
|
}
|
|
|
|
private:
|
|
Vtk::Prop3D *m_Prop3D;
|
|
std::vector<std::string> m_GroupStack;
|
|
std::set<const void *> m_Visited;
|
|
};
|
|
|
|
} // namespace Archive
|
|
|
|
// This macro MUST be defined after both Prop3D and display_properties_archive
|
|
// are fully defined.
|
|
#define ULIB_ACTIVATE_DISPLAY_PROPERTIES \
|
|
{ \
|
|
uLib::Archive::display_properties_archive dar(this); \
|
|
this->serialize_display(dar, 0); \
|
|
}
|
|
|
|
} // namespace uLib
|
|
|
|
#endif // ULIBVTKINTERFACE_H
|