← Back to branch summary

~ubuntu-branches/ubuntu/wily/ginkgocadx/wily-proposed

« back to all changes in this revision

Viewing changes to src/cadxcore/api/icontextoestudio.h

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Tille
  • Date: 2011-05-02 08:09:26 UTC
  • Revision ID: james.westby@ubuntu.com-20110502080926-bql5wep49c7hg91t
Tags: upstream-2.4.1.1
Import upstream version 2.4.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cadxcore/api/icontextoestudio.h
 
1
/*
 
2
 *
 
3
 *  $Id: icontextoestudio.h 3645 2011-04-04 09:21:08Z tovar $
 
4
 *  Ginkgo CADx Project
 
5
 *
 
6
 *  Copyright 2008-10 MetaEmotion S.L. All rights reserved.
 
7
 *  http://ginkgo-cadx.com
 
8
 *
 
9
 *  This file is licensed under LGPL v3 license.
 
10
 *  See License.txt for details
 
11
 *
 
12
 */
 
13
#pragma once
 
14
#include <api/api.h>
 
15
#include <string>
 
16
#include <vector>
 
17
#if defined(__DEPRECATED)
 
18
#undef __DEPRECATED
 
19
#endif
 
20
#include <vtkSmartPointer.h>
 
21
#include <yasper/yasper.h>
 
22
#include "ilock.h"
 
23
#include "idicom.h"
 
24
 
 
25
class vtkGinkgoImageViewer;
 
26
class vtkAlgorithmOutput;
 
27
class vtkImageData;
 
28
 
 
29
class wxWindow;
 
30
 
 
31
namespace GNC {
 
32
        namespace GCS {
 
33
                class IEntorno;
 
34
                class IVista;
 
35
                class IStreamingLoader;
 
36
                class IContextoEstudioReferido;
 
37
                class IControladorModulo;
 
38
        }
 
39
}
 
40
 
 
41
namespace GIL {
 
42
        class IModeloIntegracion;
 
43
}
 
44
 
 
45
namespace GIL {
 
46
        namespace DICOM {
 
47
                struct TipoJerarquia;
 
48
                struct TipoPrivateTags;
 
49
                class IDICOMManager;
 
50
        }
 
51
}
 
52
 
 
53
namespace GNC {
 
54
        namespace GCS {
 
55
                //region Interfaz de gestion de entrada (ficheros, diagnosticos, etc..)
 
56
                class EXTAPI IContextoEstudio: public ILockable{
 
57
                public:
 
58
                        typedef enum TModoFuncionamiento {
 
59
                                TMF_UNDiagnostico,
 
60
                                TMF_NDiagnosticos
 
61
                        } TModoFuncionamiento;
 
62
                        typedef struct TFicheroEstudio {
 
63
                                std::string RutaImagen;
 
64
                                std::string RutaDiagnostico;
 
65
                                bool                    Modificado;
 
66
                                bool                    WidgetsCargados;
 
67
                                GnkPtr<GIL::DICOM::TipoMetaInfo> MetaInfo;
 
68
                                GnkPtr<GIL::DICOM::TipoJerarquia> TagsImagen;
 
69
                                GnkPtr<GIL::DICOM::TipoJerarquia> TagsDiagnostico;
 
70
                                GnkPtr<GIL::DICOM::TipoPrivateTags> TagsPrivados;
 
71
 
 
72
                                TFicheroEstudio()
 
73
                                {
 
74
                                        RutaImagen = "";
 
75
                                        RutaImagen = "";
 
76
                                        Modificado = false;
 
77
                                        WidgetsCargados = false;
 
78
                                }
 
79
 
 
80
                        } TFicheroEstudio;
 
81
 
 
82
 
 
83
                        typedef std::vector<GnkPtr<TFicheroEstudio> >     TVectorFicherosEstudio;
 
84
 
 
85
                        GNC::GCS::IEntorno*                               Entorno;
 
86
                        GNC::GCS::IVista*                                 Vista;
 
87
                        GNC::GCS::IControladorModulo*                     Modulo;
 
88
                        vtkSmartPointer<vtkGinkgoImageViewer>             Viewer;
 
89
                        wxWindow*                                         VentanaPadre; // La ventana WX de la que es padre la vista (Notebook/Grid..)
 
90
                        wxWindow*                                         Ventana;      // La ventana WX propia de la vista
 
91
 
 
92
                        GnkPtr<GNC::GCS::IStreamingLoader>                Loader;
 
93
 
 
94
                        vtkSmartPointer<vtkAlgorithmOutput>               renderConnection; // Conexion hacia renderer
 
95
 
 
96
                        int                                               IndiceFicheroActivo;
 
97
                        std::list<std::string>                            ListaUIDsSerie;
 
98
                protected:
 
99
                        TVectorFicherosEstudio                                    Ficheros;
 
100
                        GnkPtr<GIL::IModeloIntegracion>                   ModeloIntegracion;
 
101
                        bool                                              IgnorarModificaciones;
 
102
                        TModoFuncionamiento                               ModoFuncionamiento;
 
103
 
 
104
 
 
105
                        std::string                                       UIDEstudioDiagnostico;
 
106
                public:
 
107
 
 
108
                        IContextoEstudio();
 
109
 
 
110
                        IContextoEstudio(const IContextoEstudio& o);
 
111
                        IContextoEstudio(const IContextoEstudio* o);
 
112
 
 
113
                        virtual ~IContextoEstudio();
 
114
 
 
115
                        static GnkPtr<GNC::GCS::IContextoEstudioReferido> NewRef(const GnkPtr<GNC::GCS::IContextoEstudio>& parent);
 
116
 
 
117
                        IContextoEstudio& operator = (const IContextoEstudio& o);
 
118
 
 
119
                        bool GetIgnorarModificaciones();
 
120
                        void SetIgnorarModificaciones(bool ignorar = true);
 
121
 
 
122
                        /** Obtiene el puerto de conexion de salida del StreamingLoader. Se usa para inyectar pipelines que necesiten las vistas graficas
 
123
                                Pipeline: Loader.ruta_fichero => [...] => Loader.loaderOutputConnection => [PIPELINE_ESPECIFICO] => Viewer.renderInputConnection => [...]
 
124
                        **/
 
125
                        vtkSmartPointer<vtkAlgorithmOutput> GetLoaderOutputConnection();
 
126
 
 
127
                        /** Obtiene el puerto de conexion de entrada hacia el renderer. Por defecto es la salida del StreamingLoader
 
128
                                Pipeline: Loader.ruta_fichero => [...] => Loader.loaderOutputConnection => [PIPELINE_ESPECIFICO] => Viewer.renderInputConnection => [...]
 
129
                        **/
 
130
                        void SetRendererInputConnection(const vtkSmartPointer<vtkAlgorithmOutput>& input);
 
131
 
 
132
                        void SetViewer(const vtkSmartPointer<vtkGinkgoImageViewer>& viewer);
 
133
 
 
134
                        void SetIndiceActivo(int indice);
 
135
 
 
136
                        virtual void InicializarContextoEstudio(std::vector<std::string>& rutas, const std::string uidEstudioDiagnostico, TModoFuncionamiento modoFuncionamiento);
 
137
                        std::vector<std::string> GetRutasImagenes();
 
138
 
 
139
                        std::vector<std::string> GetRutasDiagnosticos();
 
140
 
 
141
                        std::list<std::string> GetListaFicherosYDiagnosticos();
 
142
 
 
143
                        void SetModeloIntegracion(GnkPtr<GIL::IModeloIntegracion> modeloIntegracion);
 
144
                        GnkPtr<GIL::IModeloIntegracion>& GetModeloIntegracion();
 
145
 
 
146
                        const std::string& GetRutaDeImagenActiva();
 
147
                        const std::string& GetRutaDeImagen(const int indice);
 
148
                        const std::string& GetRutaDeDiagnosticoActivo();
 
149
 
 
150
                        const std::string& GetUIDEstudioDiagnostico();
 
151
 
 
152
                        //tags
 
153
                        GnkPtr<GIL::DICOM::TipoMetaInfo>    GetMetaInfoDeImagenActiva();
 
154
                        GnkPtr<GIL::DICOM::TipoJerarquia>   GetTagsImagenDeImagenActiva();
 
155
                        GnkPtr<GIL::DICOM::TipoJerarquia>   GetTagsDiagnosticoDeImagenActiva();
 
156
                        GnkPtr<GIL::DICOM::TipoPrivateTags> GetTagsPrivadosDeImagenActiva();
 
157
 
 
158
                        GnkPtr<GIL::DICOM::TipoMetaInfo>    GetMetaInfo(const int indice);
 
159
                        GnkPtr<GIL::DICOM::TipoJerarquia>   GetTagsImagen(const int indice);
 
160
                        GnkPtr<GIL::DICOM::TipoJerarquia>   GetTagsDiagnostico(int indice);
 
161
                        GnkPtr<GIL::DICOM::TipoPrivateTags> GetTagsPrivados(int indice);
 
162
 
 
163
                        int GetNumeroCortes();
 
164
                        virtual void RecalibrarImagenActiva(double spacing[3], double origin[3]);
 
165
                        virtual void RecalibrarImagen(const int indice, double spacing[3], double origin[3]);
 
166
 
 
167
                        bool GetSpacingActiva(double* spacing);
 
168
                        bool GetSpacingActiva(double& x, double& y, double& z);
 
169
                        // Returns true if image has spacing
 
170
                        bool GetSpacing(const int indice, double& x, double& y, double& z);
 
171
                        virtual void SetSpacing(const int indice, const double x, const double y, const double z);
 
172
 
 
173
                        void GetOriginActiva(double* origin);
 
174
                        void GetOriginActiva(double& x, double& y, double& z);
 
175
                        void GetOrigin(const int indice, double& x, double& y, double& z);
 
176
 
 
177
                        void GetDimensionsImagenActiva(int* dimensions);
 
178
                        void GetDimensionsImagenActiva(int& x, int& y, int& z);
 
179
                        void GetDimensionsImagen(const int indice, int& x, int& y, int& z);
 
180
 
 
181
                        int GetTSizeActiva();
 
182
                        const std::string GetNombreMedico();
 
183
                        const std::string GetNombreCentro();
 
184
 
 
185
                        bool GetTagImagenActiva(const std::string& tag, std::string& valor);
 
186
                        bool GetTagDiagnosticoActivo(const std::string& tag, std::string& valor);
 
187
 
 
188
                        int GetIndicePath(const std::string& path);
 
189
 
 
190
                        TModoFuncionamiento GetModoFuncionamiento();
 
191
 
 
192
                        //modificado...
 
193
                        bool EstaModificadoActivo();
 
194
                        bool EstaModificado();
 
195
                        void SetModificadoFicheroActivo();
 
196
                        void SetModificado(const int indice);
 
197
 
 
198
                        //Guardar
 
199
                        bool Guardar();
 
200
                        void GuardarWidgets(int indice);
 
201
                        void CargarWidgetsActivo(bool force = false);
 
202
                        void CargarWidgets(int indice = 0, bool force = false);
 
203
                        virtual bool CallbackPreGuardarDiagnostico(const int /*indice*/, GIL::DICOM::IDICOMManager* /*pDicomManager*/) = 0;
 
204
                        virtual bool CallbackPreCrearDiagnostico(const int /*indice*/, GIL::DICOM::TipoJerarquia* /*pJerarquiaSR*/, std::list<GnkPtr<GIL::DICOM::TipoPrivateTags> >&/*listaTagsPrivados*/) = 0;
 
205
 
 
206
                        void CreateLoader();
 
207
 
 
208
 
 
209
                protected:
 
210
                        void SetTagsDiagnostico( GIL::DICOM::TipoJerarquia& baseSR, GnkPtr<GIL::DICOM::TipoJerarquia> pTagDiagnostico );
 
211
                        bool GuardarUnDiagnostico();
 
212
                        bool GuardarNDiagnosticos();
 
213
                        void CargarMetaInfo(const int indice);
 
214
                        void CargarTagsImagen(const int indice);
 
215
                        virtual void CallbackCargarTagsImagen(const int /*indice*/, GIL::DICOM::IDICOMManager* /*pDicomManager*/) = 0;
 
216
                        void CrearMapaValoracionUnsignedChar(vtkSmartPointer<vtkImageData>& pMapa, GnkPtr<GIL::DICOM::TipoPrivateTags> pTagsPrivados, const unsigned char tag, const int indice, unsigned char valorInicial = 0);
 
217
 
 
218
                        friend class IContextoEstudioReferido;
 
219
                };
 
220
 
 
221
                class EXTAPI IContextoEstudioReferido : public IContextoEstudio
 
222
                {
 
223
                public:
 
224
                        IContextoEstudioReferido();
 
225
 
 
226
                        virtual ~IContextoEstudioReferido();
 
227
 
 
228
                        void UnRefViewer();
 
229
 
 
230
                        virtual bool CallbackPreGuardarDiagnostico(const int indice, GIL::DICOM::IDICOMManager* pDicomManager) {return EstudioPadre->CallbackPreGuardarDiagnostico(indice, pDicomManager);}
 
231
                        virtual bool CallbackPreCrearDiagnostico(const int indice, GIL::DICOM::TipoJerarquia* pJerarquiaSR, std::list<GnkPtr<GIL::DICOM::TipoPrivateTags> >&listaTagsPrivados) {return EstudioPadre->CallbackPreCrearDiagnostico(indice, pJerarquiaSR,listaTagsPrivados);}
 
232
                        virtual void CallbackCargarTagsImagen(const int indice, GIL::DICOM::IDICOMManager* pDicomManager) {EstudioPadre->CallbackCargarTagsImagen(indice, pDicomManager);}
 
233
 
 
234
 
 
235
                        GnkPtr<IContextoEstudio> EstudioPadre;
 
236
 
 
237
                };
 
238
        }
 
239
}