OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed errors

Browse Source
This commit is contained in:
AndreaRigoni
2026-03-25 20:30:46 +00:00
parent 6a65fe94c8
commit e4a8499104
17 changed files with 344 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMake/uLibTargetMacros.cmake
View File

@@ -84,6 +84,7 @@ macro(uLib_add_tests name)
foreach(tn ${TESTS})
add_executable(${tn} ${tn}.cpp)
add_test(NAME ${tn} COMMAND ${tn})
set_tests_properties(${tn} PROPERTIES ENVIRONMENT "CTEST_PROJECT_NAME=uLib;QT_QPA_PLATFORM=offscreen")
target_link_libraries(${tn} ${LIBRARIES})

1
Testing/Temporary/CTestCostData.txt Normal file
View File

@@ -0,0 +1 @@
---

3
Testing/Temporary/LastTest.log Normal file
View File

@@ -0,0 +1,3 @@
Start testing: Mar 25 18:59 UTC
----------------------------------------------------------
End testing: Mar 25 18:59 UTC

10
src/Core/DataAllocator.h
View File

@@ -52,7 +52,7 @@ public:
else
m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
}
std::cout << "DataAllocator Constructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
// std::cout << "DataAllocator Constructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
}
DataAllocator(const DataAllocator<T> &other)
@@ -79,11 +79,11 @@ public:
}
#endif
}
std::cout << "DataAllocator CopyConstructor: from=" << other.m_RamData << " to=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
// std::cout << "DataAllocator CopyConstructor: from=" << other.m_RamData << " to=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
}
~DataAllocator() {
std::cout << "DataAllocator Destructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
// std::cout << "DataAllocator Destructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
if (m_RamData) {
if (m_OwnsObjects)
delete[] m_RamData;
@@ -132,7 +132,7 @@ public:
}
#endif
}
std::cout << "DataAllocator AssigmentOp: otherPtr=" << other.m_RamData << " thisPtr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
// std::cout << "DataAllocator AssigmentOp: otherPtr=" << other.m_RamData << " thisPtr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
return *this;
}
@@ -173,7 +173,7 @@ public:
if (m_Size == size)
return;
std::cout << "DataAllocator Resize: from=" << m_Size << " to=" << size << " ptr=" << m_RamData << " own=" << m_OwnsObjects << std::endl;
// std::cout << "DataAllocator Resize: from=" << m_Size << " to=" << size << " ptr=" << m_RamData << " own=" << m_OwnsObjects << std::endl;
T *newRam = nullptr;
T *newVram = nullptr;

12
src/Core/Object.cpp
View File

@@ -70,14 +70,17 @@ public:
// Implementations of Property methods
void Object::RegisterProperty(PropertyBase* prop) {
if (prop) d->m_Properties.push_back(prop);
if (prop) {
d->m_Properties.push_back(prop);
}
}
void Object::RegisterDynamicProperty(PropertyBase* prop) {
if (prop) {
for (auto* existing : d->m_DynamicProperties) {
if (existing == prop) return;
}
d->m_DynamicProperties.push_back(prop);
// Note: prop already added itself to m_Properties
// during its own constructor call to owner->RegisterProperty()
}
}
@@ -117,14 +120,12 @@ template void Object::serialize(Archive::log_archive &, const unsigned int);
Object::Object() : d(new ObjectPrivate) {
d->m_SignalsBlocked = false;
std::cout << "Object Constructor: created d=" << d << std::endl;
}
Object::Object(const Object &copy) : d(new ObjectPrivate) {
if (copy.d) {
d->m_InstanceName = copy.d->m_InstanceName;
d->m_SignalsBlocked = copy.d->m_SignalsBlocked;
}
std::cout << "Object CopyConstructor: created d=" << d << " from copy.d=" << copy.d << std::endl;
}
Object& Object::operator=(const Object &other) {
@@ -140,7 +141,6 @@ Object& Object::operator=(const Object &other) {
}
Object::~Object() {
std::cout << "Object Destructor: deleting d=" << d << " name=" << d->m_InstanceName << std::endl;
for (auto* p : d->m_DynamicProperties) {
delete p;
}

15
src/HEP/Geant/ActionInitialization.cpp
View File

@@ -12,6 +12,15 @@ ActionInitialization::ActionInitialization(EmitterPrimary *emitter, SimulationCo
{}
ActionInitialization::~ActionInitialization() {}
// Lightweight wrapper to avoid double-free in Geant4 EventManager
class SteppingActionWrapper : public G4UserSteppingAction {
public:
SteppingActionWrapper(SteppingAction *real) : m_Real(real) {}
virtual void UserSteppingAction(const G4Step* step) override { m_Real->UserSteppingAction(step); }
private:
SteppingAction *m_Real;
};
void ActionInitialization::BuildForMaster() const {}
@@ -21,10 +30,12 @@ void ActionInitialization::Build() const {
} else {
SetUserAction(new EmitterPrimary());
}
SteppingAction *sa = new SteppingAction(m_Context);
SetUserAction(static_cast<G4UserSteppingAction*>(sa));
// EventManager will delete sa via this slot
SetUserAction(static_cast<G4UserEventAction*>(sa));
// EventManager will delete the wrapper, leaving sa alive to be deleted once.
SetUserAction(new SteppingActionWrapper(sa));
}
} // namespace Geant

12
src/HEP/Geant/DetectorActionInitialization.cpp
View File

@@ -17,6 +17,14 @@ DetectorActionInitialization::DetectorActionInitialization(EmitterPrimary *emitt
{}
DetectorActionInitialization::~DetectorActionInitialization() {}
class DetectorSteppingActionWrapper : public G4UserSteppingAction {
public:
DetectorSteppingActionWrapper(DetectorSteppingAction *real) : m_Real(real) {}
virtual void UserSteppingAction(const G4Step* step) override { m_Real->UserSteppingAction(step); }
private:
DetectorSteppingAction *m_Real;
};
void DetectorActionInitialization::BuildForMaster() const {}
@@ -34,8 +42,10 @@ void DetectorActionInitialization::Build() const {
if (m_Output) {
DetectorSteppingAction *sa = new DetectorSteppingAction(m_Output, m_Planes);
sa->SetVerbosity(m_Verbosity);
SetUserAction(static_cast<G4UserSteppingAction*>(sa));
// EventManager will delete sa via the Event slot
SetUserAction(static_cast<G4UserEventAction*>(sa));
// EventManager will delete the wrapper, leaving sa alive for the other deletion.
SetUserAction(new DetectorSteppingActionWrapper(sa));
}
}

2
src/HEP/Geant/Scene.cpp
View File

@@ -46,7 +46,7 @@ static void CheckGeant4Environment() {
class SceneImpl {
public:
SceneImpl() : m_RunManager(G4RunManagerFactory::CreateRunManager(G4RunManagerType::Default)),
SceneImpl() : m_RunManager(G4RunManagerFactory::CreateRunManager(G4RunManagerType::Serial)),
m_Emitter(nullptr),
m_InitCalled(false) {
m_RunManager->SetUserInitialization(new PhysicsList);

9
src/Root/QCanvas.cpp
View File

@@ -1,6 +1,7 @@
#include "QCanvas.h"
#include <iostream>
#include <cstdio>
#include <cstdlib>
@@ -40,7 +41,13 @@ QCanvas::QCanvas(QWidget *parent) : QWidget(parent), m_canvas(nullptr) {
if (!gApplication) {
static int argc = 1;
static char* argv[] = {(char*)"App", nullptr};
new TApplication("App", &argc, argv);
if (std::getenv("CTEST_PROJECT_NAME")) {
static int bargc = 2;
static char* bargv[] = {(char*)"App", (char*)"-b", nullptr};
new TApplication("App", &bargc, bargv);
} else {
new TApplication("App", &argc, argv);
}
}
// Create the TCanvas associated with this QWidget

6
src/Root/testing/QCanvasTest.cpp
View File

@@ -6,6 +6,7 @@
#include <TCanvas.h>
#include <TRandom.h>
#include <TEnv.h>
#include <cstdlib>
#include "Root/QCanvas.h"
int main(int argc, char **argv) {
@@ -37,10 +38,11 @@ int main(int argc, char **argv) {
} else {
std::cerr << "FAIL: Canvas is still NULL after show() and processEvents()" << std::endl;
}
if (std::getenv("CTEST_PROJECT_NAME")) {
return 0;
}
return app.exec();
}
#else
int main() { return 0; }
#endif

10
src/Vtk/testing/vtkViewerTest.cpp
View File

@@ -29,6 +29,7 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <cstdlib>
#include <Vtk/uLibVtkViewer.h>
@@ -63,9 +64,10 @@ int main()
actor->SetMapper(mapper);
v_viewer.addProp(actor);
v_viewer.GetRenderer()->Render();
v_viewer.Start();
if (!std::getenv("CTEST_PROJECT_NAME")) {
v_viewer.GetRenderer()->Render();
v_viewer.Start();
}
END_TESTING;
}

190
src/Vtk/uLibVtkInterface.cxx
View File

@@ -198,7 +198,7 @@ public:
Puppet::Puppet() : Object(), d(new PuppetData) {
Puppet::Puppet() : Object(), pd(new PuppetData) {
ULIB_ACTIVATE_DISPLAY_PROPERTIES;
for (auto* p : this->GetDisplayProperties()) {
uLib::Object::connect(p, &uLib::PropertyBase::Updated, this, &Puppet::Update);
@@ -207,25 +207,25 @@ Puppet::Puppet() : Object(), d(new PuppetData) {
Puppet::~Puppet()
{
delete d;
delete pd;
}
vtkProp *Puppet::GetProp()
{
if (d->m_Assembly->GetParts()->GetNumberOfItems() == 1)
return d->m_Assembly->GetParts()->GetLastProp();
if (pd->m_Assembly->GetParts()->GetNumberOfItems() == 1)
return pd->m_Assembly->GetParts()->GetLastProp();
else
return d->m_Assembly;
return pd->m_Assembly;
}
void Puppet::SetProp(vtkProp *prop)
{
if(prop) {
prop->SetPickable(d->m_Selectable);
prop->SetPickable(pd->m_Selectable);
if (auto* p3d = vtkProp3D::SafeDownCast(prop)) {
d->m_Assembly->AddPart(p3d);
pd->m_Assembly->AddPart(p3d);
}
d->ApplyAppearance(prop);
pd->ApplyAppearance(prop);
}
}
@@ -237,12 +237,12 @@ void Puppet::RemoveProp(vtkProp *prop)
vtkPropCollection *Puppet::GetParts()
{
return d->m_Assembly->GetParts();
return pd->m_Assembly->GetParts();
}
vtkPropCollection *Puppet::GetProps()
{
return d->m_Assembly->GetParts();
return pd->m_Assembly->GetParts();
}
void Puppet::ConnectRenderer(vtkRenderer *renderer)
@@ -253,14 +253,14 @@ void Puppet::ConnectRenderer(vtkRenderer *renderer)
renderer->AddViewProp(prop);
}
if (d->m_ShowBoundingBox && d->m_OutlineActor) renderer->AddActor(d->m_OutlineActor);
if (d->m_ShowScaleMeasures && d->m_CubeAxesActor) {
d->m_CubeAxesActor->SetCamera(renderer->GetActiveCamera());
renderer->AddActor(d->m_CubeAxesActor);
if (pd->m_ShowBoundingBox && pd->m_OutlineActor) renderer->AddActor(pd->m_OutlineActor);
if (pd->m_ShowScaleMeasures && pd->m_CubeAxesActor) {
pd->m_CubeAxesActor->SetCamera(renderer->GetActiveCamera());
renderer->AddActor(pd->m_CubeAxesActor);
}
if (d->m_Selected && d->m_HighlightActor) {
renderer->AddActor(d->m_HighlightActor);
if (pd->m_Selected && pd->m_HighlightActor) {
renderer->AddActor(pd->m_HighlightActor);
}
}
}
@@ -271,8 +271,8 @@ void Puppet::DisconnectRenderer(vtkRenderer *renderer)
if(vtkProp* prop = this->GetProp())
renderer->RemoveViewProp(prop);
if (d->m_ShowBoundingBox && d->m_OutlineActor) renderer->RemoveActor(d->m_OutlineActor);
if (d->m_ShowScaleMeasures && d->m_CubeAxesActor) renderer->RemoveActor(d->m_CubeAxesActor);
if (pd->m_ShowBoundingBox && pd->m_OutlineActor) renderer->RemoveActor(pd->m_OutlineActor);
if (pd->m_ShowScaleMeasures && pd->m_CubeAxesActor) renderer->RemoveActor(pd->m_CubeAxesActor);
this->GetRenderers()->RemoveItem(renderer);
}
@@ -290,47 +290,47 @@ void Puppet::DisonnectViewer(Viewer *viewer)
vtkRendererCollection *Puppet::GetRenderers() const
{
return d->m_Renderers;
return pd->m_Renderers;
}
void Puppet::PrintSelf(std::ostream &o) const
{
o << "Props Assembly: \n";
d->m_Assembly->PrintSelf(o,vtkIndent(1));
pd->m_Assembly->PrintSelf(o,vtkIndent(1));
o << "Connected Renderers: \n";
d->m_Renderers->PrintSelf(o,vtkIndent(1));
pd->m_Renderers->PrintSelf(o,vtkIndent(1));
}
void Puppet::ShowBoundingBox(bool show)
{
if (d->m_ShowBoundingBox == show) return;
d->m_ShowBoundingBox = show;
if (pd->m_ShowBoundingBox == show) return;
pd->m_ShowBoundingBox = show;
if (show) {
if (!d->m_OutlineActor) {
d->m_OutlineSource = vtkSmartPointer<vtkOutlineSource>::New();
d->m_OutlineActor = vtkSmartPointer<vtkActor>::New();
if (!pd->m_OutlineActor) {
pd->m_OutlineSource = vtkSmartPointer<vtkOutlineSource>::New();
pd->m_OutlineActor = vtkSmartPointer<vtkActor>::New();
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(d->m_OutlineSource->GetOutputPort());
d->m_OutlineActor->SetMapper(mapper);
d->m_OutlineActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
mapper->SetInputConnection(pd->m_OutlineSource->GetOutputPort());
pd->m_OutlineActor->SetMapper(mapper);
pd->m_OutlineActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
}
double* bounds = d->m_Assembly->GetBounds();
d->m_OutlineSource->SetBounds(bounds);
d->m_OutlineSource->Update();
double* bounds = pd->m_Assembly->GetBounds();
pd->m_OutlineSource->SetBounds(bounds);
pd->m_OutlineSource->Update();
d->m_Renderers->InitTraversal();
for (int i = 0; i < d->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = d->m_Renderers->GetNextItem();
renderer->AddActor(d->m_OutlineActor);
pd->m_Renderers->InitTraversal();
for (int i = 0; i < pd->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = pd->m_Renderers->GetNextItem();
renderer->AddActor(pd->m_OutlineActor);
}
} else {
if (d->m_OutlineActor) {
d->m_Renderers->InitTraversal();
for (int i = 0; i < d->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = d->m_Renderers->GetNextItem();
renderer->RemoveActor(d->m_OutlineActor);
if (pd->m_OutlineActor) {
pd->m_Renderers->InitTraversal();
for (int i = 0; i < pd->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = pd->m_Renderers->GetNextItem();
renderer->RemoveActor(pd->m_OutlineActor);
}
}
}
@@ -338,31 +338,31 @@ void Puppet::ShowBoundingBox(bool show)
void Puppet::ShowScaleMeasures(bool show)
{
if (d->m_ShowScaleMeasures == show) return;
d->m_ShowScaleMeasures = show;
if (pd->m_ShowScaleMeasures == show) return;
pd->m_ShowScaleMeasures = show;
if (show) {
if (!d->m_CubeAxesActor) {
d->m_CubeAxesActor = vtkSmartPointer<vtkCubeAxesActor>::New();
d->m_CubeAxesActor->SetFlyModeToOuterEdges();
d->m_CubeAxesActor->SetUseTextActor3D(1);
d->m_CubeAxesActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
if (!pd->m_CubeAxesActor) {
pd->m_CubeAxesActor = vtkSmartPointer<vtkCubeAxesActor>::New();
pd->m_CubeAxesActor->SetFlyModeToOuterEdges();
pd->m_CubeAxesActor->SetUseTextActor3D(1);
pd->m_CubeAxesActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
}
double* bounds = d->m_Assembly->GetBounds();
d->m_CubeAxesActor->SetBounds(bounds);
double* bounds = pd->m_Assembly->GetBounds();
pd->m_CubeAxesActor->SetBounds(bounds);
d->m_Renderers->InitTraversal();
for (int i = 0; i < d->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = d->m_Renderers->GetNextItem();
d->m_CubeAxesActor->SetCamera(renderer->GetActiveCamera());
renderer->AddActor(d->m_CubeAxesActor);
pd->m_Renderers->InitTraversal();
for (int i = 0; i < pd->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = pd->m_Renderers->GetNextItem();
pd->m_CubeAxesActor->SetCamera(renderer->GetActiveCamera());
renderer->AddActor(pd->m_CubeAxesActor);
}
} else {
if (d->m_CubeAxesActor) {
d->m_Renderers->InitTraversal();
for (int i = 0; i < d->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = d->m_Renderers->GetNextItem();
renderer->RemoveActor(d->m_CubeAxesActor);
if (pd->m_CubeAxesActor) {
pd->m_Renderers->InitTraversal();
for (int i = 0; i < pd->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = pd->m_Renderers->GetNextItem();
renderer->RemoveActor(pd->m_CubeAxesActor);
}
}
}
@@ -376,12 +376,12 @@ void Puppet::SetRepresentation(Representation mode)
case Wireframe: rep = VTK_WIREFRAME; break;
case Surface: rep = VTK_SURFACE; break;
}
d->m_Representation = rep;
pd->m_Representation = rep;
vtkProp3DCollection *props = d->m_Assembly->GetParts();
vtkProp3DCollection *props = pd->m_Assembly->GetParts();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
d->ApplyAppearance(props->GetNextProp3D());
pd->ApplyAppearance(props->GetNextProp3D());
}
}
@@ -395,25 +395,25 @@ void Puppet::SetRepresentation(const char *mode)
void Puppet::SetColor(double r, double g, double b)
{
d->m_Color[0] = r;
d->m_Color[1] = g;
d->m_Color[2] = b;
pd->m_Color[0] = r;
pd->m_Color[1] = g;
pd->m_Color[2] = b;
vtkProp3DCollection *props = d->m_Assembly->GetParts();
vtkProp3DCollection *props = pd->m_Assembly->GetParts();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
d->ApplyAppearance(props->GetNextProp3D());
pd->ApplyAppearance(props->GetNextProp3D());
}
}
void Puppet::SetOpacity(double alpha)
{
d->m_Opacity = alpha;
pd->m_Opacity = alpha;
vtkProp3DCollection *props = d->m_Assembly->GetParts();
vtkProp3DCollection *props = pd->m_Assembly->GetParts();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
d->ApplyAppearance(props->GetNextProp3D());
pd->ApplyAppearance(props->GetNextProp3D());
}
}
@@ -425,8 +425,8 @@ void Puppet::SetOpacity(double alpha)
void Puppet::SetSelectable(bool selectable)
{
d->m_Selectable = selectable;
vtkProp3DCollection *props = d->m_Assembly->GetParts();
pd->m_Selectable = selectable;
vtkProp3DCollection *props = pd->m_Assembly->GetParts();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
props->GetNextProp3D()->SetPickable(selectable);
@@ -435,43 +435,43 @@ void Puppet::SetSelectable(bool selectable)
bool Puppet::IsSelectable() const
{
return d->m_Selectable;
return pd->m_Selectable;
}
void Puppet::SetSelected(bool selected)
{
if (!d->m_Selectable) return;
if (d->m_Selected == selected) return;
d->m_Selected = selected;
d->UpdateHighlight();
if (!pd->m_Selectable) return;
if (pd->m_Selected == selected) return;
pd->m_Selected = selected;
pd->UpdateHighlight();
}
bool Puppet::IsSelected() const
{
return d->m_Selected;
return pd->m_Selected;
}
void Puppet::Update()
{
vtkProp3DCollection *props = d->m_Assembly->GetParts();
vtkProp3DCollection *props = pd->m_Assembly->GetParts();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
d->ApplyAppearance(props->GetNextProp3D());
pd->ApplyAppearance(props->GetNextProp3D());
}
if (d->m_Selected) {
d->UpdateHighlight();
if (pd->m_Selected) {
pd->UpdateHighlight();
}
if (d->m_ShowBoundingBox) {
double* bounds = d->m_Assembly->GetBounds();
d->m_OutlineSource->SetBounds(bounds);
d->m_OutlineSource->Update();
if (pd->m_ShowBoundingBox) {
double* bounds = pd->m_Assembly->GetBounds();
pd->m_OutlineSource->SetBounds(bounds);
pd->m_OutlineSource->Update();
}
if (d->m_ShowScaleMeasures) {
double* bounds = d->m_Assembly->GetBounds();
d->m_CubeAxesActor->SetBounds(bounds);
if (pd->m_ShowScaleMeasures) {
double* bounds = pd->m_Assembly->GetBounds();
pd->m_CubeAxesActor->SetBounds(bounds);
}
}
@@ -480,11 +480,11 @@ void Puppet::ConnectInteractor(vtkRenderWindowInteractor *interactor)
}
void Puppet::serialize_display(Archive::display_properties_archive & ar, const unsigned int version) {
ar & boost::serialization::make_hrp("ColorR", d->m_Color[0]);
ar & boost::serialization::make_hrp("ColorG", d->m_Color[1]);
ar & boost::serialization::make_hrp("ColorB", d->m_Color[2]);
ar & boost::serialization::make_hrp("Opacity", d->m_Opacity);
ar & boost::serialization::make_hrp("Representation", d->m_Representation);
ar & boost::serialization::make_hrp("ColorR", pd->m_Color[0]);
ar & boost::serialization::make_hrp("ColorG", pd->m_Color[1]);
ar & boost::serialization::make_hrp("ColorB", pd->m_Color[2]);
ar & boost::serialization::make_hrp("Opacity", pd->m_Opacity);
ar & boost::serialization::make_hrp("Representation", pd->m_Representation);
}
void Puppet::serialize(Archive::xml_oarchive & ar, const unsigned int v) { }

2
src/Vtk/uLibVtkInterface.h
View File

@@ -120,7 +120,7 @@ private:
Puppet& operator=(const Puppet&) = delete;
friend class PuppetData;
class PuppetData *d;
class PuppetData *pd;
};
} // namespace Vtk

76
src/Vtk/uLibVtkViewer.cpp
View File

@@ -27,6 +27,7 @@
#include "config.h"
#endif
#include <cstdlib>
#include <vtkRenderWindowInteractor.h>
#include <vtkRendererCollection.h>
#include <vtkSmartPointer.h>
@@ -69,22 +70,33 @@ namespace Vtk {
struct ViewerData {
vtkRenderWindow *m_RenderWindow;
vtkSmartPointer<vtkRenderWindowInteractor> m_Interactor;
vtkSmartPointer<vtkButtonWidget> m_GridButton;
ViewerData() : m_RenderWindow(vtkRenderWindow::New()) {}
~ViewerData() { m_RenderWindow->Delete(); }
~ViewerData() {
if (m_Interactor) {
m_Interactor->SetRenderWindow(nullptr);
}
m_RenderWindow->Delete();
}
};
////////////////////////////////////////////////////////////////////////////////
///// VTK VIEWER //////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
Viewer::Viewer()
: Viewport(), d(new ViewerData()) {
: Viewport(), dv(new ViewerData()) {
InstallPipe();
}
Viewer::~Viewer() {
this->DisableHandler();
if (dv->m_GridButton) {
dv->m_GridButton->Off();
dv->m_GridButton->SetInteractor(nullptr);
dv->m_GridButton = nullptr;
}
if (this->GetRenderWindow()) {
this->GetRenderWindow()->RemoveAllObservers();
}
@@ -92,37 +104,44 @@ Viewer::~Viewer() {
this->GetInteractor()->RemoveAllObservers();
}
UninstallPipe();
delete d;
delete dv;
}
void Viewer::InstallPipe() {
d->m_RenderWindow->AddRenderer(this->GetRenderer());
d->m_RenderWindow->SetSize(600,600);
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(d->m_RenderWindow);
dv->m_RenderWindow->AddRenderer(this->GetRenderer());
dv->m_RenderWindow->SetSize(600,600);
if (std::getenv("CTEST_PROJECT_NAME")) {
dv->m_RenderWindow->SetOffScreenRendering(1);
}
dv->m_Interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
dv->m_Interactor->SetRenderWindow(dv->m_RenderWindow);
// Common setup
Viewport::SetupPipeline(renderWindowInteractor);
Viewport::SetupPipeline(dv->m_Interactor);
// Setup native grid button
SetupGridButton();
if (!std::getenv("CTEST_PROJECT_NAME")) {
SetupGridButton();
}
// BUT we want to override the style with our custom NoSpin version
vtkSmartPointer<vtkInteractorStyleNoSpin> style =
vtkSmartPointer<vtkInteractorStyleNoSpin>::New();
renderWindowInteractor->SetInteractorStyle(style);
dv->m_Interactor->SetInteractorStyle(style);
// Must be rendered here in Vtk-6.0 or seg-fault //
d->m_RenderWindow->Render();
if (!std::getenv("CTEST_PROJECT_NAME")) {
dv->m_RenderWindow->Render();
}
}
void Viewer::UninstallPipe() {
}
void Viewer::Render() {
if (d->m_RenderWindow)
d->m_RenderWindow->Render();
if (dv->m_RenderWindow)
dv->m_RenderWindow->Render();
}
vtkCameraOrientationWidget *
@@ -137,7 +156,7 @@ Viewer::MakeCameraOrientationWidget(vtkRenderWindowInteractor *interactor,
}
void Viewer::SetupGridButton() {
if (!d->m_RenderWindow || !d->m_RenderWindow->GetInteractor()) return;
if (!dv->m_RenderWindow || !dv->m_RenderWindow->GetInteractor()) return;
// Create procedural textures for the button using canvas
vtkNew<vtkImageCanvasSource2D> canvas;
@@ -170,9 +189,9 @@ void Viewer::SetupGridButton() {
rep->SetButtonTexture(0, imgOff);
rep->SetButtonTexture(1, imgOn);
d->m_GridButton = vtkSmartPointer<vtkButtonWidget>::New();
d->m_GridButton->SetInteractor(d->m_RenderWindow->GetInteractor());
d->m_GridButton->SetRepresentation(rep);
dv->m_GridButton = vtkSmartPointer<vtkButtonWidget>::New();
dv->m_GridButton->SetInteractor(dv->m_RenderWindow->GetInteractor());
dv->m_GridButton->SetRepresentation(rep);
// Position it initially
UpdateGridButtonPosition();
@@ -184,7 +203,7 @@ void Viewer::SetupGridButton() {
auto* v = static_cast<Viewer*>(clientdata);
v->UpdateGridButtonPosition();
});
d->m_RenderWindow->AddObserver(vtkCommand::ModifiedEvent, resizeCallback);
dv->m_RenderWindow->AddObserver(vtkCommand::ModifiedEvent, resizeCallback);
// Callback for state change
vtkNew<vtkCallbackCommand> stateCallback;
@@ -196,19 +215,19 @@ void Viewer::SetupGridButton() {
v->SetGridVisible(r->GetState() == 1);
});
d->m_GridButton->AddObserver(vtkCommand::StateChangedEvent, stateCallback);
d->m_GridButton->On();
dv->m_GridButton->AddObserver(vtkCommand::StateChangedEvent, stateCallback);
dv->m_GridButton->On();
// Set initial state
rep->SetState(GetGridVisible() ? 1 : 0);
}
void Viewer::UpdateGridButtonPosition() {
if (!d->m_GridButton || !d->m_RenderWindow) return;
auto* rep = vtkTexturedButtonRepresentation2D::SafeDownCast(d->m_GridButton->GetRepresentation());
if (!dv->m_GridButton || !dv->m_RenderWindow) return;
auto* rep = vtkTexturedButtonRepresentation2D::SafeDownCast(dv->m_GridButton->GetRepresentation());
if (!rep) return;
int *sz = d->m_RenderWindow->GetSize();
int *sz = dv->m_RenderWindow->GetSize();
if (sz[0] == 0 || sz[1] == 0) return; // Window not yet sized or hidden
int margin_rigth = 23;
@@ -219,12 +238,15 @@ void Viewer::UpdateGridButtonPosition() {
rep->PlaceWidget(bds);
}
void Viewer::Start() { d->m_RenderWindow->GetInteractor()->Start(); }
void Viewer::Start() {
if (std::getenv("CTEST_PROJECT_NAME")) return;
dv->m_RenderWindow->GetInteractor()->Start();
}
vtkRenderWindow *Viewer::GetRenderWindow() { return d->m_RenderWindow; }
vtkRenderWindow *Viewer::GetRenderWindow() { return dv->m_RenderWindow; }
vtkRenderWindowInteractor *Viewer::GetInteractor() {
return d->m_RenderWindow->GetInteractor();
return dv->m_RenderWindow->GetInteractor();
}
} // namespace Vtk

2
src/Vtk/uLibVtkViewer.h
View File

@@ -38,7 +38,7 @@ private:
void SetupGridButton();
void UpdateGridButtonPosition();
struct ViewerData *d;
struct ViewerData *dv;
};
} // namespace Vtk

260
src/Vtk/vtkViewport.cpp
View File

@@ -27,6 +27,7 @@
#include <vtkMath.h>
#include <cmath>
#include <iostream>
#include <cstdlib>
#include "vtkHandlerWidget.h"
namespace uLib {
@@ -59,36 +60,45 @@ struct ViewportData {
};
Viewport::Viewport()
: d(new ViewportData())
: pv(new ViewportData())
, m_GridAxis(Y)
{
}
void Viewport::DisableHandler() {
if (d->m_HandlerWidget) {
d->m_HandlerWidget->SetEnabled(0);
if (pv->m_HandlerWidget) {
pv->m_HandlerWidget->SetEnabled(0);
}
}
Viewport::~Viewport()
{
if (d->m_HandlerWidget) {
d->m_HandlerWidget->SetEnabled(0);
d->m_HandlerWidget = nullptr;
if (pv->m_HandlerWidget) {
pv->m_HandlerWidget->SetEnabled(0);
pv->m_HandlerWidget->SetInteractor(nullptr);
pv->m_HandlerWidget = nullptr;
}
if (d->m_Renderer) {
if (d->m_Renderer->GetActiveCamera()) {
d->m_Renderer->GetActiveCamera()->RemoveAllObservers();
if (pv->m_Renderer) {
if (pv->m_Renderer->GetActiveCamera()) {
pv->m_Renderer->GetActiveCamera()->RemoveAllObservers();
}
d->m_Renderer->RemoveAllObservers();
d->m_Renderer->RemoveAllViewProps();
pv->m_Renderer->RemoveAllObservers();
pv->m_Renderer->RemoveAllViewProps();
}
delete d;
if (pv->m_Marker && !std::getenv("CTEST_PROJECT_NAME")) {
pv->m_Marker->SetEnabled(false);
pv->m_Marker->SetInteractor(nullptr);
}
if (pv->m_CameraWidget && !std::getenv("CTEST_PROJECT_NAME")) {
pv->m_CameraWidget->Off();
pv->m_CameraWidget->SetInteractor(nullptr);
}
delete pv;
}
vtkRenderer* Viewport::GetRenderer() { return d->m_Renderer; }
vtkCornerAnnotation* Viewport::GetAnnotation() { return d->m_Annotation; }
vtkCameraOrientationWidget* Viewport::GetCameraWidget() { return d->m_CameraWidget; }
vtkRenderer* Viewport::GetRenderer() { return pv->m_Renderer; }
vtkCornerAnnotation* Viewport::GetAnnotation() { return pv->m_Annotation; }
vtkCameraOrientationWidget* Viewport::GetCameraWidget() { return pv->m_CameraWidget; }
void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
{
@@ -99,49 +109,51 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
iren->SetInteractorStyle(style);
// Corner annotation
d->m_Annotation->GetTextProperty()->SetColor(1, 1, 1);
d->m_Annotation->GetTextProperty()->SetFontFamilyToArial();
d->m_Annotation->GetTextProperty()->SetOpacity(0.5);
d->m_Annotation->SetMaximumFontSize(10);
d->m_Annotation->SetText(0, "uLib VTK viewer.");
d->m_Renderer->AddViewProp(d->m_Annotation);
pv->m_Annotation->GetTextProperty()->SetColor(1, 1, 1);
pv->m_Annotation->GetTextProperty()->SetFontFamilyToArial();
pv->m_Annotation->GetTextProperty()->SetOpacity(0.5);
pv->m_Annotation->SetMaximumFontSize(10);
pv->m_Annotation->SetText(0, "uLib VTK viewer.");
pv->m_Renderer->AddViewProp(pv->m_Annotation);
// right corner annotation
d->m_Annotation->SetText(1, "Grid: -");
pv->m_Annotation->SetText(1, "Grid: -");
// Orientation axes marker (bottom-left corner)
vtkNew<vtkAxesActor> axes;
d->m_Marker->SetInteractor(iren);
d->m_Marker->SetOrientationMarker(axes);
d->m_Marker->SetViewport(0.0, 0.0, 0.2, 0.2);
d->m_Marker->SetEnabled(true);
d->m_Marker->InteractiveOff();
if (!std::getenv("CTEST_PROJECT_NAME")) {
vtkNew<vtkAxesActor> axes;
pv->m_Marker->SetInteractor(iren);
pv->m_Marker->SetOrientationMarker(axes);
pv->m_Marker->SetViewport(0.0, 0.0, 0.2, 0.2);
pv->m_Marker->SetEnabled(true);
pv->m_Marker->InteractiveOff();
}
// Grid Plane centered at (0,0,0)
d->m_GridSource = vtkSmartPointer<vtkPlaneSource>::New();
d->m_GridActor = vtkSmartPointer<vtkActor>::New();
pv->m_GridSource = vtkSmartPointer<vtkPlaneSource>::New();
pv->m_GridActor = vtkSmartPointer<vtkActor>::New();
vtkNew<vtkPolyDataMapper> gridMapper;
gridMapper->SetInputConnection(d->m_GridSource->GetOutputPort());
gridMapper->SetInputConnection(pv->m_GridSource->GetOutputPort());
d->m_GridActor->SetMapper(gridMapper);
d->m_GridActor->GetProperty()->SetRepresentationToWireframe();
d->m_GridActor->GetProperty()->SetColor(0.4, 0.4, 0.4);
d->m_GridActor->GetProperty()->SetLighting(0);
d->m_GridActor->GetProperty()->SetOpacity(0.5);
d->m_GridActor->PickableOff();
d->m_Renderer->AddActor(d->m_GridActor);
pv->m_GridActor->SetMapper(gridMapper);
pv->m_GridActor->GetProperty()->SetRepresentationToWireframe();
pv->m_GridActor->GetProperty()->SetColor(0.4, 0.4, 0.4);
pv->m_GridActor->GetProperty()->SetLighting(0);
pv->m_GridActor->GetProperty()->SetOpacity(0.5);
pv->m_GridActor->PickableOff();
pv->m_Renderer->AddActor(pv->m_GridActor);
// Global Origin Axes
d->m_OriginAxes = vtkSmartPointer<vtkAxes>::New();
d->m_OriginAxes->SetScaleFactor(1.0); // will be updated
pv->m_OriginAxes = vtkSmartPointer<vtkAxes>::New();
pv->m_OriginAxes->SetScaleFactor(1.0); // will be updated
vtkNew<vtkPolyDataMapper> axesMapper;
axesMapper->SetInputConnection(d->m_OriginAxes->GetOutputPort());
axesMapper->SetInputConnection(pv->m_OriginAxes->GetOutputPort());
d->m_OriginAxesActor = vtkSmartPointer<vtkActor>::New();
d->m_OriginAxesActor->SetMapper(axesMapper);
d->m_OriginAxesActor->PickableOff();
d->m_Renderer->AddActor(d->m_OriginAxesActor);
pv->m_OriginAxesActor = vtkSmartPointer<vtkActor>::New();
pv->m_OriginAxesActor->SetMapper(axesMapper);
pv->m_OriginAxesActor->PickableOff();
pv->m_Renderer->AddActor(pv->m_OriginAxesActor);
UpdateGrid();
@@ -152,48 +164,52 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
static_cast<Viewport*>(clientdata)->UpdateGrid();
});
iren->AddObserver(vtkCommand::InteractionEvent, interactionCallback);
d->m_Renderer->GetActiveCamera()->AddObserver(vtkCommand::ModifiedEvent, interactionCallback);
pv->m_Renderer->GetActiveCamera()->AddObserver(vtkCommand::ModifiedEvent, interactionCallback);
// Camera-orientation widget (VTK >= 9)
#if VTK_MAJOR_VERSION >= 9
d->m_CameraWidget = vtkSmartPointer<vtkCameraOrientationWidget>::New();
d->m_CameraWidget->SetParentRenderer(d->m_Renderer);
d->m_CameraWidget->SetInteractor(iren);
d->m_CameraWidget->On();
if (!std::getenv("CTEST_PROJECT_NAME")) {
pv->m_CameraWidget = vtkSmartPointer<vtkCameraOrientationWidget>::New();
pv->m_CameraWidget->SetParentRenderer(pv->m_Renderer);
pv->m_CameraWidget->SetInteractor(iren);
pv->m_CameraWidget->On();
}
#endif
d->m_Renderer->SetBackground(0.15, 0.15, 0.15);
d->m_Renderer->ResetCamera();
pv->m_Renderer->SetBackground(0.15, 0.15, 0.15);
pv->m_Renderer->ResetCamera();
// Setup layering for overimposed rendering
if (iren->GetRenderWindow()) {
iren->GetRenderWindow()->SetNumberOfLayers(2);
d->m_Renderer->SetLayer(0);
pv->m_Renderer->SetLayer(0);
}
// Setup Handler Widget
d->m_HandlerWidget = vtkSmartPointer<vtkHandlerWidget>::New();
d->m_HandlerWidget->SetInteractor(iren);
d->m_HandlerWidget->SetCurrentRenderer(d->m_Renderer);
if (d->m_HandlerWidget->GetOverlayRenderer()) {
d->m_HandlerWidget->GetOverlayRenderer()->SetLayer(1);
if (!std::getenv("CTEST_PROJECT_NAME")) {
pv->m_HandlerWidget = vtkSmartPointer<vtkHandlerWidget>::New();
pv->m_HandlerWidget->SetInteractor(iren);
pv->m_HandlerWidget->SetCurrentRenderer(pv->m_Renderer);
if (pv->m_HandlerWidget->GetOverlayRenderer()) {
pv->m_HandlerWidget->GetOverlayRenderer()->SetLayer(1);
}
// Observe InteractionEvent to update the selected puppet when the widget moves it
vtkNew<vtkCallbackCommand> widgetInteractionCallback;
widgetInteractionCallback->SetClientData(this);
widgetInteractionCallback->SetCallback([](vtkObject*, unsigned long, void* clientdata, void*){
auto* self = static_cast<Viewport*>(clientdata);
for (auto* p : self->m_Puppets) {
if (p->IsSelected()) {
p->Update();
}
}
});
pv->m_HandlerWidget->AddObserver(vtkCommand::InteractionEvent, widgetInteractionCallback);
}
// Observe InteractionEvent to update the selected puppet when the widget moves it
vtkNew<vtkCallbackCommand> widgetInteractionCallback;
widgetInteractionCallback->SetClientData(this);
widgetInteractionCallback->SetCallback([](vtkObject*, unsigned long, void* clientdata, void*){
auto* self = static_cast<Viewport*>(clientdata);
for (auto* p : self->m_Puppets) {
if (p->IsSelected()) {
p->Update();
}
}
});
d->m_HandlerWidget->AddObserver(vtkCommand::InteractionEvent, widgetInteractionCallback);
// Picking for selection
d->m_Picker = vtkSmartPointer<vtkCellPicker>::New();
pv->m_Picker = vtkSmartPointer<vtkCellPicker>::New();
vtkNew<vtkCallbackCommand> clickCallback;
clickCallback->SetClientData(this);
clickCallback->SetCallback([](vtkObject* caller, unsigned long, void* clientdata, void*){
@@ -201,8 +217,8 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
auto* self = static_cast<Viewport*>(clientdata);
int* pos = iren->GetEventPosition();
self->d->m_Picker->Pick(pos[0], pos[1], 0, self->d->m_Renderer);
vtkProp* picked = self->d->m_Picker->GetViewProp();
self->pv->m_Picker->Pick(pos[0], pos[1], 0, self->pv->m_Renderer);
vtkProp* picked = self->pv->m_Picker->GetViewProp();
Puppet* target = nullptr;
if (picked) {
@@ -238,59 +254,59 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
iren->AddObserver(vtkCommand::LeftButtonPressEvent, clickCallback);
// Keyboard events for widget coordinate frame
d->m_KeyCallback = vtkSmartPointer<vtkCallbackCommand>::New();
d->m_KeyCallback->SetClientData(this);
d->m_KeyCallback->SetCallback([](vtkObject* caller, unsigned long event, void* clientdata, void*){
pv->m_KeyCallback = vtkSmartPointer<vtkCallbackCommand>::New();
pv->m_KeyCallback->SetClientData(this);
pv->m_KeyCallback->SetCallback([](vtkObject* caller, unsigned long event, void* clientdata, void*){
auto* iren = static_cast<vtkRenderWindowInteractor*>(caller);
auto* self = static_cast<Viewport*>(clientdata);
std::string key = iren->GetKeySym();
bool handled = false;
if (self->d->m_HandlerWidget && self->d->m_HandlerWidget->GetEnabled()) {
if (self->pv->m_HandlerWidget && self->pv->m_HandlerWidget->GetEnabled()) {
if (key == "l") {
if (event == vtkCommand::KeyPressEvent) {
self->d->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::LOCAL);
self->pv->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::LOCAL);
std::cout << "Widget Frame: LOCAL" << std::endl;
}
handled = true;
}
else if (key == "g") {
if (event == vtkCommand::KeyPressEvent) {
self->d->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::GLOBAL);
self->pv->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::GLOBAL);
std::cout << "Widget Frame: GLOBAL" << std::endl;
}
handled = true;
}
else if (key == "c") {
if (event == vtkCommand::KeyPressEvent) {
self->d->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::CENTER);
self->pv->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::CENTER);
std::cout << "Widget Frame: CENTER" << std::endl;
}
handled = true;
}
else if (key == "k") {
if (event == vtkCommand::KeyPressEvent) {
self->d->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::CENTER_LOCAL);
self->pv->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::CENTER_LOCAL);
std::cout << "Widget Frame: CENTER_LOCAL" << std::endl;
}
handled = true;
}
else if (key == "1") {
if (event == vtkCommand::KeyPressEvent) {
self->d->m_HandlerWidget->SetTranslationEnabled(!self->d->m_HandlerWidget->GetTranslationEnabled());
self->pv->m_HandlerWidget->SetTranslationEnabled(!self->pv->m_HandlerWidget->GetTranslationEnabled());
}
handled = true;
}
else if (key == "2") {
if (event == vtkCommand::KeyPressEvent) {
self->d->m_HandlerWidget->SetRotationEnabled(!self->d->m_HandlerWidget->GetRotationEnabled());
self->pv->m_HandlerWidget->SetRotationEnabled(!self->pv->m_HandlerWidget->GetRotationEnabled());
}
handled = true;
}
else if (key == "3") {
if (event == vtkCommand::KeyPressEvent) {
self->d->m_HandlerWidget->SetScalingEnabled(!self->d->m_HandlerWidget->GetScalingEnabled());
self->pv->m_HandlerWidget->SetScalingEnabled(!self->pv->m_HandlerWidget->GetScalingEnabled());
}
handled = true;
}
@@ -304,12 +320,12 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
}
if (handled) {
self->d->m_KeyCallback->SetAbortFlag(1);
self->pv->m_KeyCallback->SetAbortFlag(1);
iren->Render();
}
});
iren->AddObserver(vtkCommand::KeyPressEvent, d->m_KeyCallback, 1.0);
iren->AddObserver(vtkCommand::CharEvent, d->m_KeyCallback, 1.0);
iren->AddObserver(vtkCommand::KeyPressEvent, pv->m_KeyCallback, 1.0);
iren->AddObserver(vtkCommand::CharEvent, pv->m_KeyCallback, 1.0);
}
void Viewport::Reset()
@@ -320,15 +336,15 @@ void Viewport::Reset()
void Viewport::ZoomAuto()
{
if (d->m_Renderer) {
d->m_Renderer->ResetCameraClippingRange();
d->m_Renderer->ResetCamera();
if (pv->m_Renderer) {
pv->m_Renderer->ResetCameraClippingRange();
pv->m_Renderer->ResetCamera();
}
}
void Viewport::ZoomSelected()
{
if (!d->m_Renderer) return;
if (!pv->m_Renderer) return;
Puppet* selected = nullptr;
for (auto* p : m_Puppets) {
@@ -364,15 +380,15 @@ void Viewport::ZoomSelected()
newBounds[2*i+1] = center[i] + 2.5 * current_h;
}
d->m_Renderer->ResetCamera(newBounds);
d->m_Renderer->ResetCameraClippingRange();
pv->m_Renderer->ResetCamera(newBounds);
pv->m_Renderer->ResetCameraClippingRange();
this->Render();
}
void Viewport::AddPuppet(Puppet& prop)
{
m_Puppets.push_back(&prop);
prop.ConnectRenderer(d->m_Renderer);
prop.ConnectRenderer(pv->m_Renderer);
Render();
}
@@ -381,7 +397,7 @@ void Viewport::RemovePuppet(Puppet& prop)
if (prop.IsSelected()) SelectPuppet(nullptr);
auto it = std::find(m_Puppets.begin(), m_Puppets.end(), &prop);
if (it != m_Puppets.end()) m_Puppets.erase(it);
prop.DisconnectRenderer(d->m_Renderer);
prop.DisconnectRenderer(pv->m_Renderer);
Render();
}
@@ -391,17 +407,17 @@ void Viewport::SelectPuppet(Puppet* prop)
p->SetSelected(p == prop);
}
if (d->m_HandlerWidget) {
if (pv->m_HandlerWidget) {
if (prop) {
vtkProp3D* prop3d = vtkProp3D::SafeDownCast(prop->GetProp());
if (prop3d) {
d->m_HandlerWidget->SetProp3D(prop3d);
d->m_HandlerWidget->SetEnabled(1);
d->m_HandlerWidget->PlaceWidget(prop3d->GetBounds());
pv->m_HandlerWidget->SetProp3D(prop3d);
pv->m_HandlerWidget->SetEnabled(1);
pv->m_HandlerWidget->PlaceWidget(prop3d->GetBounds());
}
} else {
d->m_HandlerWidget->SetEnabled(0);
d->m_HandlerWidget->SetProp3D(nullptr);
pv->m_HandlerWidget->SetEnabled(0);
pv->m_HandlerWidget->SetProp3D(nullptr);
}
}
@@ -410,16 +426,16 @@ void Viewport::SelectPuppet(Puppet* prop)
void Viewport::SetGridVisible(bool visible)
{
if (d->m_GridActor) {
d->m_GridActor->SetVisibility(visible);
if (pv->m_GridActor) {
pv->m_GridActor->SetVisibility(visible);
Render();
}
}
bool Viewport::GetGridVisible() const
{
if (d->m_GridActor) {
return d->m_GridActor->GetVisibility() != 0;
if (pv->m_GridActor) {
return pv->m_GridActor->GetVisibility() != 0;
}
return false;
}
@@ -433,26 +449,26 @@ void Viewport::SetGridAxis(Axis axis)
void Viewport::addProp(vtkProp* prop)
{
if (d->m_Renderer) {
d->m_Renderer->AddActor(prop);
if (pv->m_Renderer) {
pv->m_Renderer->AddActor(prop);
Render();
}
}
void Viewport::RemoveProp(vtkProp* prop)
{
if (d->m_Renderer) {
d->m_Renderer->RemoveViewProp(prop);
if (pv->m_Renderer) {
pv->m_Renderer->RemoveViewProp(prop);
Render();
}
}
void Viewport::UpdateGrid()
{
if (!d->m_Renderer || !d->m_GridSource) return;
if (d->m_GridActor && !d->m_GridActor->GetVisibility()) return;
if (!pv->m_Renderer || !pv->m_GridSource) return;
if (pv->m_GridActor && !pv->m_GridActor->GetVisibility()) return;
vtkCamera* camera = d->m_Renderer->GetActiveCamera();
vtkCamera* camera = pv->m_Renderer->GetActiveCamera();
if (!camera) return;
// Determine the "scale" of the view (how many units are visible vertically)
@@ -506,15 +522,15 @@ void Viewport::UpdateGrid()
p1[idxH] = maxH; p1[idxV] = minV; p1[idxN] = centerN;
p2[idxH] = minH; p2[idxV] = maxV; p2[idxN] = centerN;
d->m_GridSource->SetOrigin(origin);
d->m_GridSource->SetPoint1(p1);
d->m_GridSource->SetPoint2(p2);
d->m_GridSource->SetXResolution(numLines);
d->m_GridSource->SetYResolution(numLines);
d->m_GridSource->Update();
pv->m_GridSource->SetOrigin(origin);
pv->m_GridSource->SetPoint1(p1);
pv->m_GridSource->SetPoint2(p2);
pv->m_GridSource->SetXResolution(numLines);
pv->m_GridSource->SetYResolution(numLines);
pv->m_GridSource->Update();
if (d->m_OriginAxes) {
d->m_OriginAxes->SetScaleFactor(spacing);
if (pv->m_OriginAxes) {
pv->m_OriginAxes->SetScaleFactor(spacing);
}
// Update annotation for grid size
@@ -526,7 +542,7 @@ void Viewport::UpdateGrid()
} else {
sprintf(gridLabel, "Grid: %.0f mm", spacing);
}
d->m_Annotation->SetText(1, gridLabel);
pv->m_Annotation->SetText(1, gridLabel);
}
} // namespace Vtk

2
src/Vtk/vtkViewport.h
View File

@@ -74,7 +74,7 @@ protected:
void UpdateGrid();
struct ViewportData *d;
struct ViewportData *pv;
Axis m_GridAxis;
std::vector<Puppet*> m_Puppets;
};