[VTK] Visualisation dans une scène VTK, impossible de la modifier

Bonjour,

Je suis en train de réaliser un logiciel de visualisation couplant QT et VTK. La visualisation fonctionnait très bien avec un code simple liant QT et VTK dans un seul fichier.

Mais J'ai depuis créé une classe Visualisation permettant de créer mes acteurs et ma fenêtre de rendu à partir d'un fichier de type .mha. Ma classe semble fonctionné mais certains problèmes semblent indiqués le contraire.

Au début, ma classe permettait de renvoyer le renderer et l'interactor afin de l'intégrer directement à mon QVTKwidget. Mais quand j'initialisais mon interactor, une segmentation fault survenait. A force de chercher des solutions, l'idée de faire sortir non plus les éléments précités mais directement le QVTKRendreWindow m'est venu. Maintenant, la visualisation se lance, mes mes méthodes de gestion de la visualisation par QT ne fonctionne plus. Par exemple, j'ai créé une fonction permettant de remettre la caméra en position initiale. Cette méthode marchait lorsque que je n'avais pas ma classe, mais ne fonctionne plus maintenant.

Pourriez vous me diriger vers une méthode me permettant de résoudre ce problème?

Merci d'avance

Bonjour,

Peut être un problème de copie ? Vous copiez une structure et donc, vous ne modifiez que la copie.
Sans code, dur à voir, du coup.

Je peux déjà copier ma classe visualisation pour donner une idée plus claire de la classe.

Voila le .cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
 
#include <iostream>
 
#include "visualisation.h"
 
#include <QVTKInteractor.h>
 
//Vtk inclusions
 
#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkLookupTable.h>
#include <vtkOpenGLStateCache.h>
#include <vtkOutlineFilter.h>
#include <vtkCellPicker.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkRenderWindowInteractor.h>
 
Visualisation::Visualisation()
{
 
  int imageDims[3];
 
  //VTK elements
 
  isosurfaceFunction=vtkSmartPointer<vtkVolumeRayCastIsosurfaceFunction>::New();
 
  actor=vtkSmartPointer<vtkActor>::New();
 
  isoSurface=vtkSmartPointer<vtkContourFilter>::New();
 
  planexy=vtkSmartPointer<vtkImagePlaneWidget>::New();
 
  planeyz=vtkSmartPointer<vtkImagePlaneWidget>::New();
 
  planezx=vtkSmartPointer<vtkImagePlaneWidget>::New();
 
  imageviewer=vtkSmartPointer<vtkImageViewer2>::New();
 
  mapper=vtkSmartPointer<vtkPolyDataMapper>::New();
 
  ipwProp=vtkSmartPointer<vtkProperty>::New();
 
  iren=vtkSmartPointer<QVTKInteractor>::New();
 
  ren=vtkSmartPointer<vtkRenderer>::New();
 
  renderWindow=vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();  
 
  style=vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
 
  renderWindow->AddRenderer(ren);
 
  iren->SetRenderWindow(renderWindow);
 
  iren->SetInteractorStyle(style);
}
 
void Visualisation::SetReader(vtkSmartPointer<vtkMetaImageReader> reader)
{  
  picker=vtkSmartPointer<vtkCellPicker>::New();
  picker->SetTolerance(0.005);
 
  //Isosurface
    //function
 
  isoSurface->SetInputConnection(reader->GetOutputPort());
  isoSurface->ComputeNormalsOn();
  isoSurface->ComputeGradientsOn();
  isoSurface->SetValue(0,110);
 
    //Mapper
  mapper->SetInputConnection(isoSurface->GetOutputPort());
 
    //Actor
  actor->SetMapper(mapper);
 
  // ren->AddActor(actor);
 
  //Plane Vizualisation
 
 
    // xy Plane
  planexy->SetInputConnection(reader->GetOutputPort());
  planexy->SetInteractor(iren);
  planexy->SetPicker(picker);
  planexy->SetDefaultRenderer(ren);
  planexy->SetPlaneOrientation(0);
  planexy->GetTexturePlaneProperty()->SetEdgeColor(1,0,0);
  planexy->GetTexturePlaneProperty()->EdgeVisibilityOn();
  planexy->SetSliceIndex(imageDims[0]/2);
  planexy->DisplayTextOn();
  planexy->On();
  planexy->InteractionOn();
 
    // yz Plane
  planeyz->SetInteractor(iren);
  planeyz->SetPicker(picker);
  planeyz->SetInputConnection(reader->GetOutputPort());
  planeyz->SetDefaultRenderer(ren);
  planeyz->SetPlaneOrientation(1);
  planeyz->GetTexturePlaneProperty()->SetEdgeColor(0,1,0);
  planeyz->GetTexturePlaneProperty()->EdgeVisibilityOn();
  planeyz->SetSliceIndex(imageDims[1]/2);
  planeyz->DisplayTextOn();
  planeyz->On();
  planeyz->InteractionOn();
 
      // zx Plane
  planezx->SetInputConnection(reader->GetOutputPort());
  planezx->SetPlaneOrientation(2);
  planezx->GetTexturePlaneProperty()->SetEdgeColor(0,0,1);
  planezx->GetTexturePlaneProperty()->EdgeVisibilityOn();
  planezx->SetSliceIndex(imageDims[1]/2);
  planezx->SetPicker(picker);
  planezx->SetInteractor(iren);
  planezx->SetDefaultRenderer(ren);
  planezx->DisplayTextOn();
  planezx->On();
  planezx->InteractionOn();
 
  vtkSmartPointer<vtkOutlineFilter> outline=
    vtkSmartPointer<vtkOutlineFilter>::New();
  outline->SetInputData(reader->GetOutput());
 
  vtkSmartPointer<vtkPolyDataMapper> outlineMapper=
    vtkSmartPointer<vtkPolyDataMapper>::New();
  outlineMapper->SetInputConnection(outline->GetOutputPort());
 
  vtkSmartPointer<vtkActor> outlineActor=vtkSmartPointer<vtkActor>::New();
  outlineActor->SetMapper(outlineMapper);
  outlineActor->GetProperty()->SetColor(1,1,1);
 
  ren->AddActor(outlineActor);
 
  ren->SetBackground(0.15,0.15,0.15); // Background color black
  ren->ResetCamera();
  ren->GetActiveCamera()->Azimuth(45);
  ren->GetActiveCamera()->Elevation(45);
 
  iren->Initialize();
 
  // widget.show();
  // renderWindow->Initialize();
}
 
void Visualisation::SetXYSlice(int index)
{
  planexy->SetSliceIndex(index);
}
 
void Visualisation::ResetCamera()
{
  ren->ResetCamera();
}
 
void Visualisation::AddIso()
{
  ren->AddActor(actor);
  renderWindow->AddRenderer(ren);
}
 
void Visualisation::DeleteIso()
{
  ren->RemoveActor(actor);
}
 
 
Visualisation::~Visualisation()
{
 
}

puis le .h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
#ifndef VISUALISATION_H
#define VISUALISATION_H
 
// #include <QVTKWidget2.h>
 
#include <QVTKInteractor.h>
 
#include <QGridLayout>
 
#include "vtkGenericOpenGLRenderWindow.h"
 
//VtkInclusions
#include <vtkCellPicker.h>
#include <vtkContourFilter.h>
#include <vtkImageData.h>
#include <vtkImageMapToColors.h>
#include <vtkImagePlaneWidget.h>
#include <vtkImageViewer2.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkMetaImageReader.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkResliceImageViewer.h>
#include <vtkStructuredPoints.h>
#include <vtkMetaImageReader.h>
#include <vtkVolumeRayCastIsosurfaceFunction.h>
 
class Visualisation
{
 
public:
 
    // QVTKWidget2 widget;
 
    int imageDims[3];
 
    Visualisation();
    ~Visualisation();
 
    void SetReader(vtkSmartPointer<vtkMetaImageReader> reader);
 
    //VTK elements
 
    vtkSmartPointer<vtkGenericOpenGLRenderWindow> renderWindow;
 
    // vtkSmartPointer<vtkRenderer> ren;
 
    // vtkSmartPointer<QVTKInteractor> iren;
 
// public slots:
    void AddIso();
    void DeleteIso();
    // void ActiveXY();
    // void ActiveYZ();
    // void ActiveZX();
    // void Update();
    // void ResetXY();
    // void ResetYZ();
    // void ResetZX();
    void ResetCamera();
    // void MoveIsoSlider();
    // void ReleaseIsoSlider();
    // void MoveSliderxy();
    // void spinBoxValueChangedxy();
    // void MoveSlideryz();
    // void spinBoxValueChangedyz();
    // void MoveSliderzx();
    // void spinBoxValueChangedzx();
 
    void SetXYSlice(int index);
 
private:
 
    vtkSmartPointer<vtkActor>actor;
 
    vtkSmartPointer<vtkImagePlaneWidget> planexy;
 
    vtkSmartPointer<vtkImagePlaneWidget> planeyz;
 
    vtkSmartPointer<vtkImagePlaneWidget> planezx;
 
    // int imageDims[3];
 
    //VTK elements
 
    vtkSmartPointer<vtkVolumeRayCastIsosurfaceFunction> isosurfaceFunction;
 
    vtkSmartPointer<vtkContourFilter> isoSurface;
 
    vtkSmartPointer<vtkImageViewer2> imageviewer;
 
    vtkSmartPointer<vtkPolyDataMapper> mapper;
 
    vtkSmartPointer<vtkProperty> ipwProp;
 
    vtkSmartPointer<vtkCellPicker>picker;
 
    vtkSmartPointer<vtkRenderer> ren;
 
    vtkSmartPointer<QVTKInteractor> iren;
 
    vtkSmartPointer<vtkInteractorStyleTrackballCamera> style;
};
 
#endif // VISUALISATION_H

J'espere que ces fichiers n'est pas trop long.

La fonction SetReader est là pour mettre en place la visualisation, et les fonctions suivantes sont là pour permettre l'interaction avec ma fenètre QT.
Je n'ai pas encore mis en place les fonctions permettant de rendre privé ce que j'utilise ensuite, comme la renderingWindow
Merci d'avance