← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/fooextension/fooextension/commands/dicomizecommand.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/fooextension/fooextension/commands/dicomizecommand.cpp
 
1
/*
 
2
 *
 
3
 *  $Id: dicomizecommand.cpp 3681 2011-04-12 10:53:31Z 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
#include <api/globals.h>
 
15
#include <sstream>
 
16
#include <api/icontexto.h>
 
17
#include "dicomizecommand.h"
 
18
#include <map>
 
19
#include <wx/filename.h>
 
20
#include <wx/dir.h>
 
21
#include <wx/file.h>
 
22
#include <wx/msgdlg.h>
 
23
#include <wx/image.h>
 
24
 
 
25
#include <api/icontroladoreventos.h>
 
26
#include <api/icontroladorcomandos.h>
 
27
#include <api/icontroladorimportacionpacs.h>
 
28
#include <api/idicomizador.h>
 
29
#include <api/idicommanager.h>
 
30
#include <eventos/eventosginkgo.h>
 
31
#include <commands/comandoavisarficheros.h>
 
32
#include <api/internacionalizacion.h>
 
33
#include <export/tagsprivadoscomunes.h>
 
34
#include <main/controllers/controladorlog.h>
 
35
 
 
36
 
 
37
 
 
38
 
 
39
//0-1000000 are metaemotion's reserved
 
40
//it's used to implement politics of command preferences, pararell execution...
 
41
#define IDC_Dicomization           1000001
 
42
 
 
43
// Singleton de persistencia
 
44
namespace FooExtension {
 
45
        namespace GADAPI {
 
46
 
 
47
                DicomizeCommandParameters::DicomizeCommandParameters(GnkPtr< ::FooExtension::GUI::ImportationPersistentData > pPersistentData, GNC::GCS::IEntorno* pEntorno) 
 
48
                {
 
49
                        m_pPersistentData = pPersistentData;
 
50
                        m_pEntorno = pEntorno;
 
51
                        //creates new temp dir
 
52
                        wxString wxNewTmpDir;
 
53
                        do {
 
54
                                wxNewTmpDir = FROMPATH(m_pEntorno->GetGinkgoTempDir()) + wxFileName::GetPathSeparator(wxPATH_NATIVE) + wxT("_gnktmp_") + wxString::Format(wxT("%d"), rand());
 
55
                        } while(wxDir::Exists(wxNewTmpDir));
 
56
 
 
57
        #ifdef _WIN32
 
58
                        wxFileName::Mkdir(wxNewTmpDir);
 
59
        #else
 
60
                        wxFileName::Mkdir(wxNewTmpDir.c_str(), 0777);
 
61
        #endif
 
62
                        m_TmpDir = TOPATH(wxNewTmpDir);
 
63
                        ///
 
64
                        m_errorMessage = "";
 
65
                }
 
66
 
 
67
                DicomizeCommandParameters::~DicomizeCommandParameters() {
 
68
                }
 
69
 
 
70
 
 
71
                DicomizeCommand::DicomizeCommand(DicomizeCommandParameters* pParams) : IComando(pParams)
 
72
                {
 
73
                        m_pDicomizationParameters = pParams;
 
74
                        //this is used to set command dependencies like WaitFor(EsperaA), Cancel(CancelaA), AbortIf(AbortaSi)
 
75
                        SetId(IDC_Dicomization);
 
76
                        //this command waits untill last IDC_Dicomization command has finished
 
77
                        EsperaA(IDC_Dicomization);
 
78
                }
 
79
 
 
80
                //background processing
 
81
                void DicomizeCommand::Execute()
 
82
                {
 
83
                        //dicomizeFiles
 
84
                        if (ImportFiles())
 
85
                        {
 
86
                                //copy to Ginkgo CADx
 
87
                                CopyDICOMToGinkgoCADx();
 
88
                        }
 
89
                }
 
90
 
 
91
                //synchronized processing
 
92
                void DicomizeCommand::Update()
 
93
                {
 
94
                        //shows an error or finish message
 
95
                        if(m_pDicomizationParameters->m_errorMessage != "") {
 
96
                                wxString mensaje = _("Import process failed:\n\t") + wxString::FromUTF8(m_pDicomizationParameters->m_errorMessage.c_str());
 
97
                                wxMessageBox(mensaje,_("Error"), wxOK|wxICON_WARNING);
 
98
                        } else {
 
99
                                wxMessageBox(_("Importation has finished successfully"),_("Info"), wxOK|wxICON_INFORMATION);
 
100
                        }
 
101
                        RemoveTempDir(FROMPATH(m_pDicomizationParameters->m_TmpDir));
 
102
                }
 
103
 
 
104
                //called if the command is cancelled
 
105
                void DicomizeCommand::OnAbort()
 
106
                {
 
107
                        RemoveTempDir(FROMPATH(m_pDicomizationParameters->m_TmpDir));
 
108
                }
 
109
 
 
110
                //performs importation, in this example we are going to call itk algorithm and performs dicomization
 
111
                bool DicomizeCommand::ImportFiles()
 
112
                {
 
113
                        bool isFirst=true;
 
114
 
 
115
                        GIL::DICOM::IControladorImportacionPACS* pCI = m_pDicomizationParameters->m_pEntorno->GetControladorImportacionPACS();
 
116
 
 
117
                        int instanceNumber = 0;
 
118
 
 
119
                        int fileNumber = 1;
 
120
 
 
121
                        for(FooExtension::GUI::ImportationPersistentData::TFileList::iterator it= m_pDicomizationParameters->m_pPersistentData->m_dicomizedFiles.begin(); it!= m_pDicomizationParameters->m_pPersistentData->m_dicomizedFiles.end(); it++, fileNumber++) 
 
122
                        {
 
123
                                //progress message...
 
124
                                {
 
125
                                        std::ostringstream ostr;
 
126
                                        ostr <<  _Std("Importing file ") << fileNumber << " of " << m_pDicomizationParameters->m_pPersistentData->m_dicomizedFiles.size();
 
127
                                        NotificarProgreso(0.05f, ostr.str() );
 
128
                                }
 
129
                                
 
130
                                //perform some proccessing, for example blur image
 
131
                                wxImage img(FROMPATH((*it).imagePath));
 
132
                                img = img.Blur(50);
 
133
                                //
 
134
 
 
135
                                //dicomManager, to read dicomized files
 
136
                                GIL::DICOM::IDICOMManager*      pDICOMManager = NULL;
 
137
                                //dicomizer
 
138
                                GIL::DICOM::IDICOMImg2DCM* pI2D = NULL;
 
139
 
 
140
                                //end itk processing, stores output in tempFilePathSobel
 
141
                                try {
 
142
 
 
143
                                        //we create instance of importation, it will help us in importation process
 
144
                                        pI2D = pCI->CrearInstanciaDeImportacion();
 
145
 
 
146
                                        //initialization of dicomizer with filtered image
 
147
                                        pI2D->Inicializar(img.GetData(), img.GetWidth(), img.GetHeight());
 
148
 
 
149
                                        //common tags
 
150
                                        GIL::DICOM::TipoJerarquia base = m_pDicomizationParameters->m_pPersistentData->baseImages;
 
151
 
 
152
                                        //instance number, it's a sequence for this series
 
153
                                        {
 
154
                                                std::ostringstream ostr;
 
155
                                                ostr << instanceNumber++;
 
156
                                                base.tags[std::string("0020|0013")] = ostr.str();
 
157
                                        }
 
158
 
 
159
                                        //insert tags
 
160
                                        pI2D->InsertarJerarquia(base);
 
161
 
 
162
                                        //we are going to write dicomized file in temp dir
 
163
                                        wxFileName inputFileName = wxFileName::FileName(FROMPATH((*it).imagePath));
 
164
                                        wxString tempFilePath = FROMPATH(m_pDicomizationParameters->m_TmpDir) + wxFileName::GetPathSeparator(wxPATH_NATIVE) + inputFileName.GetName() + wxT(".dcm");
 
165
                                        while (wxFile::Exists(tempFilePath)) {
 
166
                                                tempFilePath = FROMPATH(m_pDicomizationParameters->m_TmpDir) + wxFileName::GetPathSeparator(wxPATH_NATIVE) + inputFileName.GetName() + wxString::Format(wxT("%d.dcm"),rand());
 
167
                                        }
 
168
 
 
169
                                        //write DCM
 
170
                                        std::string outDCM(TOPATH(tempFilePath));
 
171
                                        pI2D->Convertir(outDCM);
 
172
 
 
173
                                        //free dicomizer
 
174
                                        pCI->LiberarInstanciaDeImportacion(pI2D);
 
175
                                        pI2D = NULL;
 
176
 
 
177
                                        //we are going to read tags from dicomized file
 
178
                                        {                                               
 
179
                                                std::string tag;
 
180
                                                //create instance
 
181
                                                pDICOMManager = pCI->CrearInstanciaDeDICOMManager();
 
182
                                                //load DICOM file
 
183
                                                pDICOMManager->CargarFichero(outDCM);
 
184
                                                if(isFirst || m_pDicomizationParameters->m_pPersistentData->AccessionNumber=="" || m_pDicomizationParameters->m_pPersistentData->StudyInstanceUID == "" || m_pDicomizationParameters->m_pPersistentData->SeriesUID == ""){
 
185
                                                        isFirst=false;
 
186
 
 
187
                                                        if(pDICOMManager->GetTag(0x0008,0x0050,tag)) {//accession number
 
188
                                                                m_pDicomizationParameters->m_pPersistentData->AccessionNumber = tag;
 
189
                                                                //set accession number in common tags
 
190
                                                                m_pDicomizationParameters->m_pPersistentData->baseImages.tags[std::string("0008|0050")] = tag;
 
191
                                                        }
 
192
 
 
193
                                                        if(pDICOMManager->GetTag(0x0020,0x000d,tag)) {//studyUID
 
194
                                                                m_pDicomizationParameters->m_pPersistentData->StudyInstanceUID = tag;
 
195
                                                                //set study instance UID in common tags
 
196
                                                                m_pDicomizationParameters->m_pPersistentData->baseImages.tags[std::string("0020|000d")] = tag;
 
197
                                                        }
 
198
 
 
199
                                                        if(pDICOMManager->GetTag(0x0020,0x000e,tag)) {//series instance uid
 
200
                                                                m_pDicomizationParameters->m_pPersistentData->SeriesUID = tag;
 
201
                                                                //set series instance UID in common tags
 
202
                                                                m_pDicomizationParameters->m_pPersistentData->baseImages.tags[std::string("0020|000e")] = tag;
 
203
                                                        }
 
204
                                                }
 
205
                                                pDICOMManager->GetTag(0x0008,0x0018,(*it).sopInstanceUID); //sop instance uid
 
206
                                                pDICOMManager->GetTag(0x0008,0x0016,(*it).sopClassUID);//sop class uid
 
207
 
 
208
                                                pCI->LiberarInstanciaDeDICOMManager(pDICOMManager);
 
209
                                                pDICOMManager = NULL;
 
210
 
 
211
                                                (*it).pathDCM = outDCM;
 
212
                                        }//fin leer tags
 
213
 
 
214
                                }
 
215
                                catch (GIL::DICOM::I2DException& e) {
 
216
                                        LOG_ERROR("DICOMIZATION", "Error in dicomization process: " << e);
 
217
                                        if (pI2D != NULL) {                                             
 
218
                                                pCI->LiberarInstanciaDeImportacion(pI2D);
 
219
                                        }
 
220
                                        if (pDICOMManager != NULL) {
 
221
                                                pCI->LiberarInstanciaDeDICOMManager(pDICOMManager);
 
222
                                        }
 
223
                                        return false;
 
224
                                }                               
 
225
                                catch (std::exception& e) {
 
226
                                        LOG_ERROR("DICOMIZATION", "Error doing dicomization: " << e.what() );
 
227
                                        if (pI2D != NULL) {                                             
 
228
                                                pCI->LiberarInstanciaDeImportacion(pI2D);
 
229
                                        }
 
230
                                        if (pDICOMManager != NULL) {
 
231
                                                pCI->LiberarInstanciaDeDICOMManager(pDICOMManager);
 
232
                                        }
 
233
                                        return false;
 
234
                                }
 
235
                                catch (...) {
 
236
                                        LOG_ERROR("Internal error in dicomization process", "DICOMIZATION");
 
237
                                        if (pI2D != NULL) {
 
238
                                                pCI->LiberarInstanciaDeImportacion(pI2D);
 
239
                                        }
 
240
                                        if (pDICOMManager != NULL) {
 
241
                                                pCI->LiberarInstanciaDeDICOMManager(pDICOMManager);
 
242
                                        }
 
243
                                        return false;
 
244
                                }
 
245
                                
 
246
                        }
 
247
                        return true;
 
248
                }
 
249
 
 
250
 
 
251
                bool DicomizeCommand::CopyDICOMToGinkgoCADx()
 
252
                {
 
253
                        bool correct = true;
 
254
 
 
255
                        std::list<std::string> fileList;
 
256
                        //we are going to move imported files to it's place into de DicomDir, to know where to move it, we have to ask entorno the series path
 
257
                        wxDir dir;
 
258
                        if (dir.Open(FROMPATH(m_pDicomizationParameters->m_TmpDir))) {
 
259
                                wxString sourcePathWx,targetPathWx;
 
260
                                bool cont = dir.GetFirst(&sourcePathWx,wxT("*.dcm"));
 
261
                                std::string targetPathStd,sourcePathStd;
 
262
                                GIL::DICOM::IDICOMManager*      pDICOMManager;
 
263
                                GIL::DICOM::TipoJerarquia base;
 
264
 
 
265
                                while (cont) {
 
266
                                        sourcePathWx=dir.GetName()+ wxFileName::GetPathSeparator(wxPATH_NATIVE) +sourcePathWx;
 
267
                                        sourcePathStd = TOPATH(sourcePathWx);
 
268
 
 
269
                                        std::string idPaciente,uidEstudio,uidSerie,uidImagen;
 
270
                                        pDICOMManager= m_pDicomizationParameters->m_pEntorno->GetControladorImportacionPACS()->CrearInstanciaDeDICOMManager();
 
271
                                        pDICOMManager->CargarFichero(sourcePathStd);
 
272
                                        pDICOMManager->GetTag(0x0010,0x0020,idPaciente);
 
273
                                        pDICOMManager->GetTag(0x0020,0x000d,uidEstudio);
 
274
                                        pDICOMManager->GetTag(0x0020,0x000e,uidSerie);
 
275
                                        pDICOMManager->GetTag(0x0008,0x0018,uidImagen);
 
276
                                        m_pDicomizationParameters->m_pEntorno->GetControladorImportacionPACS()->LiberarInstanciaDeDICOMManager(pDICOMManager);
 
277
 
 
278
                                        //we ask for the path
 
279
                                        correct = correct && m_pDicomizationParameters->m_pEntorno->GetControladorImportacionPACS()->GetRutaImagen(idPaciente,uidEstudio,uidSerie,uidImagen,targetPathStd);
 
280
                                        targetPathWx = FROMPATH(targetPathStd);
 
281
 
 
282
                                        correct = correct && wxCopyFile(sourcePathWx,targetPathWx,true);
 
283
 
 
284
                                        fileList.push_back(targetPathStd);
 
285
 
 
286
                                        cont = dir.GetNext(&sourcePathWx);
 
287
                                }
 
288
                        }
 
289
 
 
290
                        if(correct) {
 
291
                                //add files to the history
 
292
                                ::GADAPI::ComandoAvisarFicherosParams * pParams = new ::GADAPI::ComandoAvisarFicherosParams(fileList);
 
293
                                ::GADAPI::ComandoAvisarFicheros * pCmd = new ::GADAPI::ComandoAvisarFicheros(pParams);
 
294
                                m_pDicomizationParameters->m_pEntorno->GetControladorComandos()->ProcessAsync("Including files", pCmd, NULL);
 
295
                        }
 
296
                        return correct;
 
297
                }
 
298
 
 
299
                bool  DicomizeCommand::RemoveTempDir(const wxString& dirPath)
 
300
                {
 
301
                        //delete on cascade
 
302
                        if(!wxRmdir(dirPath)){
 
303
                                wxDir dir;
 
304
                                if (dir.Open(dirPath)) {
 
305
                                        wxString fileName;
 
306
                                        bool cont = dir.GetFirst(&fileName);
 
307
                                        while (cont) {
 
308
                                                fileName=dir.GetName()+ wxFileName::GetPathSeparator(wxPATH_NATIVE) +fileName;
 
309
                                                if(wxDir::Exists(fileName)){
 
310
                                                        if (RemoveTempDir(fileName)) {
 
311
                                                                cont = dir.GetFirst(&fileName);
 
312
                                                        } else {
 
313
                                                                cont = dir.GetNext(&fileName);
 
314
                                                        }
 
315
                                                }else{
 
316
                                                        if (wxRemoveFile(fileName)) {
 
317
                                                                cont = dir.GetFirst(&fileName);
 
318
                                                        } else {
 
319
                                                                cont = dir.GetNext(&fileName);
 
320
                                                        }
 
321
                                                }
 
322
                                        }
 
323
                                }
 
324
                        }
 
325
                        if(wxDir::Exists(dirPath)){
 
326
                                return wxRmdir(dirPath);
 
327
                        }
 
328
                        return true;
 
329
                }
 
330
        }
 
331
}
 
332