← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/cadxcore/main/filtering/filtronulo.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/cadxcore/main/filtering/filtronulo.cpp
 
1
/*
 
2
 *  
 
3
 *  $Id: filtronulo.cpp 3526 2011-03-16 19:56:19Z carlos $
 
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
#include "filtros.h"
 
15
 
 
16
#include <vtkPointData.h>
 
17
#include <itkExceptionObject.h>
 
18
#include <itkImageRegionIterator.h>
 
19
#include <api/icontextoestudio.h>
 
20
//#include <AVL.h>
 
21
 
 
22
GNC::FiltroNulo::FiltroNulo(Implementacion implementacion, bool filtro3D) : IFiltro(implementacion, filtro3D)
 
23
{
 
24
        
 
25
}
 
26
GNC::FiltroNulo::~FiltroNulo ()
 
27
{
 
28
        
 
29
}
 
30
 
 
31
void GNC::FiltroNulo::Configurar()
 
32
{
 
33
        
 
34
}
 
35
 
 
36
void GNC::FiltroNulo::Procesar(GNC::GCS::IVista* /*pVista*/)
 
37
{
 
38
        vtkImageData* pImagenOriginal = NULL;
 
39
        int sliceStart;
 
40
        int sliceEnd;
 
41
        int slice = 0;
 
42
        //unsigned long off;
 
43
        //TODOX
 
44
        //pVista->AsignarConexionesDeFiltrado(&pImagenOriginal, &slice);
 
45
        
 
46
        if (pImagenOriginal == NULL) {
 
47
                return;
 
48
        }
 
49
        
 
50
        m_pImagen = pImagenOriginal;
 
51
        
 
52
        int* dims = m_pImagen->GetDimensions();
 
53
        int numComponentes = m_pImagen->GetNumberOfScalarComponents();
 
54
        
 
55
        if (filtro3D) {
 
56
                if(implementacion == IF_ITK) {
 
57
                        double* spacing = m_pImagen->GetSpacing();
 
58
                        double* origin = m_pImagen->GetOrigin();
 
59
                        
 
60
                        
 
61
                        
 
62
                        double tval[3] = {0.0f, 0.0f, 0.0f};
 
63
                        vtkDataArray* scalars = m_pImagen->GetPointData()->GetScalars();
 
64
                        unsigned long off = 0;
 
65
                        if (numComponentes == 1) {
 
66
                                TImagenITKIntensidad3D::Pointer entrada = TImagenITKIntensidad3D::New();
 
67
                                
 
68
                                TImagenITKIntensidad3D::IndexType inputIndex;
 
69
                                inputIndex[0] = 0;
 
70
                                inputIndex[1] = 0;
 
71
                                inputIndex[2] = 0;
 
72
                                
 
73
                                TImagenITKIntensidad3D::SizeType inputSize;
 
74
                                inputSize[0] = dims[0];
 
75
                                inputSize[1] = dims[1];
 
76
                                inputSize[2] = dims[2];
 
77
                                
 
78
                                TImagenITKIntensidad3D::RegionType regionEntrada;
 
79
                                regionEntrada.SetIndex(inputIndex);
 
80
                                regionEntrada.SetSize(inputSize);
 
81
                                
 
82
                                entrada->SetRegions(regionEntrada);
 
83
                                
 
84
                                double inputSpacing[3];
 
85
                                inputSpacing[0] = spacing[0];
 
86
                                inputSpacing[1] = spacing[1];
 
87
                                inputSpacing[2] = spacing[2];
 
88
                                
 
89
                                entrada->SetSpacing(inputSpacing);
 
90
                                
 
91
                                double inputOrigin[3];
 
92
                                inputOrigin[0] = origin[0];
 
93
                                inputOrigin[1] = origin[1];
 
94
                                inputOrigin[2] = origin[2];
 
95
                                
 
96
                                entrada->SetOrigin(inputOrigin);
 
97
                                
 
98
                                entrada->Allocate();
 
99
                                
 
100
                                itk::ImageRegionIterator<TImagenITKIntensidad3D> itEntrada (entrada, regionEntrada);
 
101
                                
 
102
                                off = 0;
 
103
                                for (itEntrada.GoToBegin(); !itEntrada.IsAtEnd(); ++itEntrada) {
 
104
                                        scalars->GetTuple(off++, tval);
 
105
                                        itEntrada.Set(tval[0]);
 
106
                                }
 
107
                                
 
108
                                TImagenITKIntensidad3D::Pointer salida = ProcesarImagen(entrada);
 
109
                                
 
110
                                if (salida.IsNull()) {
 
111
                                        std::cerr << "Filtro Nulo. Accion ignorada." << std::endl;
 
112
                                        return;
 
113
                                }
 
114
                                
 
115
                                int outputSize[3];
 
116
                                
 
117
                                TImagenITKIntensidad3D::RegionType regionSalida = salida->GetLargestPossibleRegion();
 
118
                                outputSize[0] = regionSalida.GetSize()[0];
 
119
                                outputSize[1] = regionSalida.GetSize()[1];
 
120
                                outputSize[2] = regionSalida.GetSize()[2];
 
121
                                
 
122
                                if (outputSize[0] != dims[0] || outputSize[1] != dims[1] || outputSize[2] != dims[2]) {
 
123
                                        std::cerr << "Error. El filtro ha modicado las dimensiones de la imagen. Accion ignorada." << std::endl;
 
124
                                        return;
 
125
                                }
 
126
                                
 
127
                                TImagenITKIntensidad3D::SpacingType outputSpacingitk = salida->GetSpacing();
 
128
                                double outputSpacingvtk[3];
 
129
                                
 
130
                                outputSpacingvtk[0] = outputSpacingitk[0];
 
131
                                outputSpacingvtk[1] = outputSpacingitk[1];
 
132
                                outputSpacingvtk[2] = spacing[2];
 
133
                                m_pImagen->SetSpacing(outputSpacingvtk);
 
134
                                
 
135
                                TImagenITKIntensidad3D::PointType outputOriginitk = salida->GetOrigin();
 
136
                                double outputOriginvtk[3];
 
137
                                outputOriginvtk[0] = outputOriginitk[0];
 
138
                                outputOriginvtk[1] = outputOriginitk[1];
 
139
                                outputOriginvtk[2] = outputOriginitk[2];
 
140
                                m_pImagen->SetOrigin(outputOriginvtk);
 
141
                                
 
142
                                itk::ImageRegionIterator<TImagenITKIntensidad3D> itSalida (salida, regionSalida);
 
143
                                off = 0;
 
144
                                for (itSalida.GoToBegin(); !itSalida.IsAtEnd(); ++itSalida) {
 
145
                                        tval[0] = itSalida.Get();
 
146
                                        scalars->SetTuple(off++, tval);
 
147
                                }
 
148
                                
 
149
                                
 
150
                                
 
151
                        }
 
152
                        else if (numComponentes == 3) {
 
153
                                // No implementado
 
154
                                return;
 
155
                        }
 
156
                        else {
 
157
                                std::cerr << "Error al aplicar el filtro 3D: Numero de componentes no soportado. Accion ignorada" << std::endl;
 
158
                                return;
 
159
                        }
 
160
                        
 
161
                }
 
162
                else if (implementacion == IF_MEF) {
 
163
                        std::cerr << "Error al procesar: MEF no soporta imagenes 3D." << std::endl;
 
164
                        return;
 
165
                }
 
166
                else {
 
167
                        return;
 
168
                }
 
169
        }
 
170
        
 
171
        else {
 
172
                if (implementacion == IF_ITK) {
 
173
                        
 
174
                        if (slice > dims[2]) {
 
175
                                m_pImagen = NULL;
 
176
                                std::cerr << "Error: No se pudo aplicar el filtro. Indice de slice fuera de rango" << std::endl;
 
177
                        }
 
178
                        
 
179
                        if (slice < 0) {
 
180
                                sliceStart = 0;
 
181
                                sliceEnd = dims[2];
 
182
                        }
 
183
                        else {
 
184
                                sliceStart = slice;
 
185
                                sliceEnd = slice + 1;
 
186
                        }
 
187
                        
 
188
                        for (slice = sliceStart; slice < sliceEnd; ++slice) {
 
189
                                
 
190
                                double* spacing = m_pImagen->GetSpacing();
 
191
                                double* origin = m_pImagen->GetOrigin();
 
192
                                
 
193
                                double tval[3] = {0.0f, 0.0f, 0.0f};
 
194
                                vtkDataArray* scalars = m_pImagen->GetPointData()->GetScalars();
 
195
                                unsigned long off = 0;
 
196
                                if (numComponentes == 1) {
 
197
                                        
 
198
                                        TImagenITKIntensidad2D::Pointer entrada = TImagenITKIntensidad2D::New();
 
199
                                        
 
200
                                        TImagenITKIntensidad2D::IndexType inputIndex;
 
201
                                        inputIndex[0] = 0;
 
202
                                        inputIndex[1] = 0;
 
203
                                        
 
204
                                        TImagenITKIntensidad2D::SizeType inputSize;
 
205
                                        inputSize[0] = dims[0];
 
206
                                        inputSize[1] = dims[1];
 
207
                                        
 
208
                                        TImagenITKIntensidad2D::RegionType regionEntrada;
 
209
                                        regionEntrada.SetIndex(inputIndex);
 
210
                                        regionEntrada.SetSize(inputSize);
 
211
                                        
 
212
                                        entrada->SetRegions(regionEntrada);
 
213
                                        
 
214
                                        double inputSpacing[2];
 
215
                                        inputSpacing[0] = spacing[0];
 
216
                                        inputSpacing[1] = spacing[1];
 
217
                                        
 
218
                                        entrada->SetSpacing(inputSpacing);
 
219
                                        
 
220
                                        double inputOrigin[2];
 
221
                                        inputOrigin[0] = origin[0];
 
222
                                        inputOrigin[1] = origin[1];
 
223
                                        
 
224
                                        entrada->SetOrigin(inputOrigin);
 
225
                                        
 
226
                                        entrada->Allocate();
 
227
                                        
 
228
                                        itk::ImageRegionIterator<TImagenITKIntensidad2D> itEntrada (entrada, regionEntrada);
 
229
                                        
 
230
                                        off = dims[0] * dims[1] * slice;
 
231
                                        for (itEntrada.GoToBegin(); !itEntrada.IsAtEnd(); ++itEntrada) {
 
232
                                                scalars->GetTuple(off++, tval);
 
233
                                                itEntrada.Set(tval[0]);
 
234
                                        }
 
235
                                        
 
236
                                        TImagenITKIntensidad2D::Pointer salida = ProcesarImagen(entrada);
 
237
                                        
 
238
                                        if (salida.IsNull()) {
 
239
                                                std::cerr << "Filtro Nulo. Accion ignorada." << std::endl;
 
240
                                                return;
 
241
                                        }
 
242
                                        
 
243
                                        int outputSize[3];
 
244
                                        
 
245
                                        TImagenITKIntensidad2D::RegionType regionSalida = salida->GetLargestPossibleRegion();
 
246
                                        outputSize[0] = regionSalida.GetSize()[0];
 
247
                                        outputSize[1] = regionSalida.GetSize()[1];
 
248
                                        
 
249
                                        if (outputSize[0] != dims[0] || outputSize[1] != dims[1]) {
 
250
                                                std::cerr << "Error. El filtro ha modicado las dimensiones de la imagen. Accion ignorada." << std::endl;
 
251
                                                return;
 
252
                                        }
 
253
                                        
 
254
                                        TImagenITKIntensidad2D::SpacingType outputSpacingitk = salida->GetSpacing();
 
255
                                        double outputSpacingvtk[3];
 
256
                                        
 
257
                                        outputSpacingvtk[0] = outputSpacingitk[0];
 
258
                                        outputSpacingvtk[1] = outputSpacingitk[1];
 
259
                                        outputSpacingvtk[2] = spacing[2];
 
260
                                        m_pImagen->SetSpacing(outputSpacingvtk);
 
261
                                        
 
262
                                        TImagenITKIntensidad2D::PointType outputOriginitk = salida->GetOrigin();
 
263
                                        double outputOriginvtk[3];
 
264
                                        outputOriginvtk[0] = outputOriginitk[0];
 
265
                                        outputOriginvtk[1] = outputOriginitk[1];
 
266
                                        outputOriginvtk[2] = origin[2];
 
267
                                        m_pImagen->SetOrigin(outputOriginvtk);
 
268
                                        
 
269
                                        itk::ImageRegionIterator<TImagenITKIntensidad2D> itSalida (salida, regionSalida);
 
270
                                        
 
271
                                        off = dims[0] * dims[1] * slice;
 
272
                                        for (itSalida.GoToBegin(); !itSalida.IsAtEnd(); ++itSalida) {
 
273
                                                tval[0] = itSalida.Get();
 
274
                                                scalars->SetTuple(off++, tval);
 
275
                                        }
 
276
                                        
 
277
                                }
 
278
                                else if (numComponentes == 3) {
 
279
                                        for (long y = 0; y < dims[1]; ++y) {
 
280
                                                for (long x = 0; x < dims[0]; ++x) {
 
281
                                                        scalars->SetTuple(off++, tval);
 
282
                                                }
 
283
                                        }
 
284
                                        /*
 
285
                                         unsigned long off = 0;
 
286
                                         for (it.GoToBegin(); !it.IsAtEnd(); ++it) {
 
287
                                         ImageType::PixelType& pixel = it.Value();
 
288
                                         scalars->SetTuple(off++, tval);
 
289
                                         pixel.SetValue(tuple[0]);
 
290
                                         data[off++] = pixel.GetRed();
 
291
                                         data[off++] = pixel.GetGreen();
 
292
                                         data[off++] = pixel.GetBlue();
 
293
                                         }
 
294
                                         */
 
295
                                }
 
296
                                else {
 
297
                                        std::cerr << "Error al aplicar el filtro: Numero de componentes no soportado. Accion ignorada" << std::endl;
 
298
                                        return;
 
299
                                }
 
300
                        }
 
301
                }
 
302
                else if (implementacion == IF_MEF) {
 
303
                        //if (slice > dims[2]) {
 
304
                        //      m_pImagen = NULL;
 
305
                        //      std::cerr << "Error: No se pudo aplicar el filtro. Indice de slice fuera de rango" << std::endl;
 
306
                        //      return;
 
307
                        //}
 
308
                        //
 
309
                        //if (slice < 0) {
 
310
                        //      sliceStart = 0;
 
311
                        //      sliceEnd = dims[2];
 
312
                        //}
 
313
                        //else {
 
314
                        //      sliceStart = slice;
 
315
                        //      sliceEnd = slice + 1;
 
316
                        //}
 
317
                        //
 
318
                        //for (slice = sliceStart; slice < sliceEnd; ++slice) {
 
319
                        //      
 
320
                        //      double tval[3] = {0.0f, 0.0f, 0.0f};
 
321
                        //      vtkDataArray* scalars = m_pImagen->GetPointData()->GetScalars();
 
322
                        //      unsigned long off = 0;
 
323
                        //      if (numComponentes == 1) {
 
324
                        //              
 
325
                        //              TImagenMEFIntensidad2D* entrada = new TImagenMEFIntensidad2D(dims[0], dims[1]);
 
326
                        //              
 
327
                        //              if (entrada->Altura < 1 || entrada->Anchura < 1) {
 
328
                        //                      std::cerr << "Dimensiones de la imagen incorrectas" << std::endl;
 
329
                        //                      return;
 
330
                        //              }
 
331
                        //              off = dims[0] * dims[1] * slice;
 
332
                        //              for (int y = entrada->Altura -1; y >= 0; --y) {
 
333
                        //                      for (int x = 0; x < entrada->Anchura; ++x) {
 
334
                        //                              scalars->GetTuple(off++, tval);
 
335
                        //                              entrada->Pixel(x, y) = tval[0];
 
336
                        //                      }
 
337
                        //              }
 
338
                        //              
 
339
                        //              TImagenMEFIntensidad2D* salida = ProcesarImagen(entrada);
 
340
                        //              
 
341
                        //              off = dims[0] * dims[1] * slice;
 
342
                        //              for (int y = entrada->Altura -1; y >= 0; --y) {
 
343
                        //                      for (int x = 0; x < entrada->Anchura; ++x) {
 
344
                        //                              tval[0] = entrada->Pixel(x, y);
 
345
                        //                              scalars->SetTuple(off++, tval);
 
346
                        //                      }
 
347
                        //              }
 
348
                        //              
 
349
                        //              delete salida;
 
350
                        //              delete entrada;
 
351
                        //              
 
352
                        //      }
 
353
                        //      else if (numComponentes == 3) {
 
354
                        //              TImagenMEFRGB2D* entrada = new TImagenMEFRGB2D(dims[0], dims[1]);
 
355
                        //              
 
356
                        //              if (entrada->Altura < 1 || entrada->Anchura < 1) {
 
357
                        //                      std::cerr << "Dimensiones de la imagen incorrectas" << std::endl;
 
358
                        //                      return;
 
359
                        //              }
 
360
                        //              off = dims[0] * dims[1] * slice;
 
361
                        //              for (int y = entrada->Altura -1; y >= 0; --y) {
 
362
                        //                      for (int x = 0; x < entrada->Anchura; ++x) {
 
363
                        //                              scalars->GetTuple(off++, tval);
 
364
                        //                              entrada->Pixel(x, y).r = tval[0];
 
365
                        //                              entrada->Pixel(x, y).g = tval[1];
 
366
                        //                              entrada->Pixel(x, y).b = tval[2];
 
367
                        //                      }
 
368
                        //              }
 
369
                        //              
 
370
                        //              TImagenMEFRGB2D* salida = ProcesarImagen(entrada);
 
371
                        //              
 
372
                        //              off = dims[0] * dims[1] * slice;
 
373
                        //              for (int y = entrada->Altura -1; y >= 0; --y) {
 
374
                        //                      for (int x = 0; x < entrada->Anchura; ++x) {
 
375
                        //                              tval[0] = entrada->Pixel(x, y).r;
 
376
                        //                              tval[1] = entrada->Pixel(x, y).g;
 
377
                        //                              tval[2] = entrada->Pixel(x, y).b;
 
378
                        //                              scalars->SetTuple(off++, tval);
 
379
                        //                      }
 
380
                        //              }
 
381
                        //              
 
382
                        //              delete salida;
 
383
                        //              delete entrada;
 
384
                        //      }
 
385
                        //      else {
 
386
                        //              std::cerr << "Error al aplicar el filtro: Numero de componentes no soportado. Accion ignorada" << std::endl;
 
387
                        //              return;
 
388
                        //      }
 
389
                        //}
 
390
                }
 
391
                else {
 
392
                        return;
 
393
                }
 
394
        }
 
395
        
 
396
        //TODOX
 
397
        //pVista->SolicitarActualizarImagen();
 
398
        
 
399
}
 
400
 
 
401
GNC::FiltroNulo::TImagenITKRGB2D::Pointer GNC::FiltroNulo::ProcesarImagen(GNC::FiltroNulo::TImagenITKRGB2D::Pointer imagen)
 
402
{
 
403
        return imagen;
 
404
}
 
405
 
 
406
GNC::FiltroNulo::TImagenITKRGB3D::Pointer GNC::FiltroNulo::ProcesarImagen(GNC::FiltroNulo::TImagenITKRGB3D::Pointer imagen)
 
407
{
 
408
        return imagen;
 
409
}
 
410
 
 
411
//GNC::FiltroNulo::TImagenMEFRGB2D* GNC::FiltroNulo::ProcesarImagen(GNC::FiltroNulo::TImagenMEFRGB2D* imagen)
 
412
//{
 
413
//      return imagen;
 
414
//}
 
415
 
 
416
GNC::FiltroNulo::TImagenITKIntensidad2D::Pointer GNC::FiltroNulo::ProcesarImagen(GNC::FiltroNulo::TImagenITKIntensidad2D::Pointer imagen)
 
417
{
 
418
        
 
419
        return imagen;
 
420
}
 
421
 
 
422
GNC::FiltroNulo::TImagenITKIntensidad3D::Pointer GNC::FiltroNulo::ProcesarImagen(GNC::FiltroNulo::TImagenITKIntensidad3D::Pointer imagen)
 
423
{
 
424
        
 
425
        return imagen;
 
426
}
 
427
 
 
428
//GNC::FiltroNulo::TImagenMEFIntensidad2D* GNC::FiltroNulo::ProcesarImagen(GNC::FiltroNulo::TImagenMEFIntensidad2D* imagen)
 
429
//{
 
430
//      
 
431
//      return imagen;
 
432
//}