← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/visualizator/visualizator/estudios/visualizatorstudy.cpp

  • 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/visualizator/visualizator/estudios/visualizatorstudy.cpp
 
1
/*
 
2
 *  
 
3
 *  $Id: visualizatorstudy.cpp 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
 */
 
14
//#define _GINKGO_TRACE
 
15
 
 
16
#include <wx/app.h>
 
17
#include <wx/xml/xml.h>
 
18
#include <wx/file.h>
 
19
#include <wx/filename.h>
 
20
#include <wx/confbase.h>
 
21
#include <wx/mstream.h>
 
22
 
 
23
#include <api/globals.h>
 
24
//#include <api/filename.h>
 
25
#include <api/icontroladorherramientas.h>
 
26
#include <api/ientorno.h>
 
27
 
 
28
#include <api/idicommanager.h>
 
29
#include <api/idicomizador.h>
 
30
#include <api/icontroladorcarga.h>
 
31
#include <api/imodelointegracion.h>
 
32
#include <api/icontroladorhistorial.h>
 
33
#include <api/internacionalizacion.h>
 
34
 
 
35
#include "visualizatorstudy.h"
 
36
 
 
37
#include <vtkPointData.h>
 
38
#include <vtkImageData.h>
 
39
 
 
40
 
 
41
GNKVisualizator::VisualizatorStudy::VisualizatorStudy(){
 
42
        GTRACE(">> VisualizatorStudy::VisualizatorStudy()" << this);
 
43
        GTRACE("<< VisualizatorStudy::VisualizatorStudy()" << this);
 
44
}
 
45
 
 
46
GNKVisualizator::VisualizatorStudy::~VisualizatorStudy(){
 
47
        GTRACE(">> VisualizatorStudy::~VisualizatorStudy()" << this);
 
48
        ListaOverlays.clear();
 
49
        GTRACE("<< VisualizatorStudy::~VisualizatorStudy()" << this);
 
50
}
 
51
 
 
52
 
 
53
void GNKVisualizator::VisualizatorStudy::InicializarContextoEstudio(std::vector<std::string>& rutas, const std::string uidEstudioDiagnostico, GNC::GCS::IContextoEstudio::TModoFuncionamiento modoFuncionamiento)
 
54
{
 
55
        GNC::GCS::IContextoEstudio::InicializarContextoEstudio(rutas,uidEstudioDiagnostico, modoFuncionamiento);
 
56
        ListaOverlays.clear();
 
57
        for (std::vector<std::string>::const_iterator it = rutas.begin(); it != rutas.end(); it++)
 
58
        {
 
59
                ListaOverlays.push_back(NULL);
 
60
        }
 
61
}
 
62
 
 
63
bool GNKVisualizator::VisualizatorStudy::TieneOverlaysImagenActiva()
 
64
{
 
65
        return TieneOverlaysImagen(IndiceFicheroActivo);
 
66
}
 
67
 
 
68
bool GNKVisualizator::VisualizatorStudy::TieneOverlaysImagen(const int indice)
 
69
{
 
70
        //se pillan los overlays de la imagen original
 
71
        if(ListaOverlays[indice].IsValid()) {
 
72
                return ListaOverlays[indice]->size()>0;
 
73
        } else {
 
74
                GnkPtr<GIL::DICOM::TipoJerarquia> jerarq = GetTagsImagen(indice);
 
75
                if (jerarq.IsValid()) {
 
76
                        for(GIL::DICOM::TipoJerarquia::ListaTags::iterator it = jerarq->tags.begin(); it != jerarq->tags.end(); it++) {
 
77
                                if((*it).first.substr(0,2) == "60") {
 
78
                                        return true;
 
79
                                }
 
80
                        }
 
81
                        return false;
 
82
                } else {
 
83
                        return false;
 
84
                }
 
85
        }
 
86
}
 
87
 
 
88
GnkPtr<GNKVisualizator::TListaOverlays> GNKVisualizator::VisualizatorStudy::GetOverlaysImagenActiva()
 
89
{
 
90
        return GetOverlaysImagen(IndiceFicheroActivo);
 
91
}
 
92
 
 
93
GnkPtr<GNKVisualizator::TListaOverlays> GNKVisualizator::VisualizatorStudy::GetOverlaysImagen(const int indice)
 
94
{
 
95
        if(!ListaOverlays[indice].IsValid()) {
 
96
                ListaOverlays[indice] = new TListaOverlays();
 
97
 
 
98
                std::string strTmp;
 
99
                GIL::DICOM::IDICOMManager* pDICOMManager= Entorno->GetControladorImportacionPACS()->CrearInstanciaDeDICOMManager();
 
100
                pDICOMManager->CargarFichero(Ficheros[indice]->RutaImagen);
 
101
                int idOver = 0;
 
102
                int filasImagen,columnasImagen;
 
103
                //los overlays van en los grupos pares de 6000 a 601E, ver parte 5 del standard "repeating groups"
 
104
                if(pDICOMManager->GetTag(0x0028,0x0010,filasImagen) && pDICOMManager->GetTag(0x0028,0x0011,columnasImagen)) {
 
105
                        for(int grupo = 0x6000; grupo <0x601E; grupo+=2)
 
106
                        {
 
107
                                int filas,columnas,desplazamiento;
 
108
                                std::string nombreCapa;
 
109
                                std::string origen, tipo;
 
110
                                GIL::DICOM::TagPrivadoUndefined overlayData;
 
111
                                int bitPosition,bitsAllocated;
 
112
                                if(pDICOMManager->GetTag(grupo,0x0010,filas) && pDICOMManager->GetTag(grupo,0x0011,columnas)
 
113
                                        && pDICOMManager->GetTag(grupo,0x0102,bitPosition) && pDICOMManager->GetTag(grupo,0x0100,bitsAllocated)){
 
114
                                                //TODO: si no es del tamanio de la imagen de momento no lo tratamos, tendremos que crear una imagen del tamanio adecuado y pegar el roi en su sitio
 
115
                                                if(filas!= filasImagen || columnas!=columnasImagen) {
 
116
                                                        continue;
 
117
                                                }
 
118
                                                pDICOMManager->GetTag(grupo,0x0040,tipo);
 
119
                                                //TODO TRATAR DISTINTOS A LOS ROI por ejemplo mostrar la media y todo eso...
 
120
                                                if(!pDICOMManager->GetTag(grupo,0x0022,nombreCapa)){
 
121
                                                        std::ostringstream ostrNombre;
 
122
                                                        ostrNombre <<"Capa " << idOver;
 
123
                                                        nombreCapa = ostrNombre.str();
 
124
                                                }
 
125
                                                TOverlay over(nombreCapa,grupo);
 
126
                                                idOver++;
 
127
 
 
128
                                                if(bitPosition==0 && bitsAllocated==1 && pDICOMManager->GetTag(grupo,0x3000,overlayData)) {
 
129
                                                        //este es el caso en el que la capa overlay esta especificada aparte, no usando bits d la imagen
 
130
                                                        //se copia la imagen
 
131
                                                        vtkImageData* pimg = vtkImageData::New();
 
132
                                                        over.img = pimg;
 
133
                                                        pimg->Delete();
 
134
                                                        over.img->SetDimensions(columnas,filas,1);
 
135
                                                        over.img->SetScalarTypeToUnsignedChar();
 
136
                                                        over.img->SetNumberOfScalarComponents(1);
 
137
                                                        {
 
138
                                                                char c;
 
139
                                                                float x,y;
 
140
                                                                x=1.0f;
 
141
                                                                y=1.0f;
 
142
                                                                if(pDICOMManager->GetTag(grupo,0x0050,origen)){
 
143
                                                                        std::istringstream issl(origen);
 
144
                                                                        issl >> x;
 
145
                                                                        if(!issl.eof()){
 
146
                                                                                issl>>c;//la barra
 
147
                                                                                issl>>y;
 
148
                                                                        }
 
149
                                                                }
 
150
                                                                over.img->SetOrigin(x,y,1.0f);
 
151
                                                        }
 
152
                                                        over.img->AllocateScalars();
 
153
 
 
154
                                                        unsigned char* pData = (unsigned char*)over.img->GetScalarPointer();
 
155
                                                        const unsigned char * ptr = (const unsigned char *)overlayData.GetValor();
 
156
 
 
157
                                                        int size = overlayData.GetSize();
 
158
                                                        int sizeOfImage = filas*columnas;
 
159
                                                        //double tuple[1] = {0.0f};
 
160
                                                        char tmp,c;
 
161
                                                        int off = 0;
 
162
                                                        for(int i=0; i<size; i++){
 
163
                                                                c = (const unsigned char) (ptr[i]);
 
164
                                                                tmp = 1;
 
165
                                                                for(int j=0; j<8 && off<sizeOfImage; j++){
 
166
                                                                        if((tmp & c)==0) {
 
167
                                                                                pData[off++] = 0;
 
168
                                                                        } else {
 
169
                                                                                pData[off++] = 1;
 
170
                                                                        }
 
171
                                                                        tmp<<=1;
 
172
                                                                }
 
173
                                                        }
 
174
                                                        ListaOverlays[indice]->push_back(over);
 
175
                                                } else {
 
176
                                                        int bitsAllocatedImagen;
 
177
                                                        //en este caso el overlay esta en el pixeldata, esta retired pero asi funcionan tb los viejos
 
178
                                                        if(pDICOMManager->GetTag(0x0028,0x0100,bitsAllocatedImagen) && pDICOMManager->GetTag(0x7fe0,0x0010,overlayData) && overlayData.GetSize() > 0) {
 
179
                                                                vtkImageData* tmp = vtkImageData::New();
 
180
                                                                over.img = tmp;
 
181
                                                                tmp->Delete();
 
182
                                                                over.img->SetDimensions(columnas,filas,1);
 
183
                                                                over.img->SetScalarTypeToUnsignedChar();
 
184
                                                                over.img->SetNumberOfScalarComponents(1);
 
185
                                                                {
 
186
                                                                        char c;
 
187
                                                                        float x,y;
 
188
                                                                        x=1.0f;
 
189
                                                                        y=1.0f;
 
190
                                                                        if(pDICOMManager->GetTag(grupo,0x0050,origen)){
 
191
                                                                                std::istringstream issl(origen);
 
192
                                                                                issl >> x;
 
193
                                                                                if(!issl.eof()){
 
194
                                                                                        issl>>c;//la barra
 
195
                                                                                        issl>>y;
 
196
                                                                                }
 
197
                                                                        }
 
198
                                                                        over.img->SetOrigin(x,y,1.0f);
 
199
                                                                }
 
200
                                                                over.img->AllocateScalars();
 
201
 
 
202
                                                                unsigned char* pData = (unsigned char*)over.img->GetScalarPointer();
 
203
                                                                const unsigned char * ptr = (const unsigned char *)overlayData.GetValor();
 
204
 
 
205
                                                                int size = overlayData.GetSize();
 
206
                                                                //int sizeOfImage = filas*columnas;
 
207
                                                                //double tuple[1] = {0.0f};
 
208
                                                                if(bitsAllocatedImagen == 8 && bitPosition<8) {
 
209
                                                                        //se itera caracter a caracter...
 
210
                                                                        char mascara,c;
 
211
                                                                        int off = 0;
 
212
                                                                        mascara = 1;
 
213
                                                                        mascara <<= bitPosition;
 
214
                                                                        for (int y = 0; y < filas; y++) {
 
215
                                                                                desplazamiento = y*columnas;
 
216
                                                                                for (int x = 0; x < columnas && off < size; x++) {
 
217
                                                                                        c = (unsigned char) *(ptr + desplazamiento + x);
 
218
                                                                                        if((mascara & c)==0) {
 
219
                                                                                                pData[off++] = 0;
 
220
                                                                                        } else {
 
221
                                                                                                pData[off++] = 1;
 
222
                                                                                        }
 
223
                                                                                }
 
224
                                                                        }
 
225
                                                                        ListaOverlays[indice]->push_back(over);
 
226
                                                                } else if(bitsAllocatedImagen == 16 && bitPosition<16){
 
227
                                                                        //se itera con 16 bits...
 
228
                                                                        unsigned char mascara;
 
229
                                                                        unsigned char* c;
 
230
                                                                        int off=0;
 
231
                                                                        unsigned char bitAConsultar = 0;
 
232
                                                                        if(bitPosition<8) {
 
233
                                                                                mascara = 1;
 
234
                                                                                mascara <<= bitPosition;
 
235
                                                                        } else {
 
236
                                                                                mascara = 1;
 
237
                                                                                mascara <<= (bitPosition-8);
 
238
                                                                                bitAConsultar = 1;
 
239
                                                                        }
 
240
                                                                        for (int y = 0; y < filas; y++) {
 
241
                                                                                desplazamiento = y*columnas;
 
242
                                                                                for (int x = 0; x < columnas && off < size; ++x) {
 
243
                                                                                        c = (unsigned char*) (ptr + 2*(desplazamiento + x)+bitAConsultar);
 
244
                                                                                        if((mascara & (*c))==0) {
 
245
                                                                                                pData[off++] = 0;
 
246
                                                                                        } else {
 
247
                                                                                                pData[off++] = 1;
 
248
                                                                                        }
 
249
                                                                                }
 
250
                                                                        }
 
251
                                                                        ListaOverlays[indice]->push_back(over);
 
252
                                                                }//else bits allocated
 
253
                                                        }//if get pixel data y comprobaciones
 
254
                                                }//else overlay por separado
 
255
                                }//if columnas, bits...
 
256
                        }//for overlays
 
257
                }//si esta especificado filas/columnas de la imagen
 
258
                Entorno->GetControladorImportacionPACS()->LiberarInstanciaDeDICOMManager(pDICOMManager);
 
259
        }
 
260
        return ListaOverlays[indice];
 
261
}
 
262
 
 
263
bool GNKVisualizator::VisualizatorStudy::CallbackPreCrearDiagnostico(const int indice, GIL::DICOM::TipoJerarquia* pJerarquiaSR, std::list<GnkPtr<GIL::DICOM::TipoPrivateTags> >& /*listaTagsPrivados*/)
 
264
{
 
265
        pJerarquiaSR->tags[std::string("0008|1030")] = _Std("Medical Diagnostic"); //descripcion study
 
266
        pJerarquiaSR->tags[std::string("0008|103e")] = _Std("Medical Diagnostic"); //descripcion Serie
 
267
        pJerarquiaSR->tags[std::string("0020|4000")] = _Std("Medical Diagnostic");//descripcion de la imagen
 
268
 
 
269
        return true;
 
270
}