← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/ginkgocadx/oneiric

« back to all changes in this revision

Viewing changes to src/cadxcore/main/controllers/dcmtk/dicomimg2dcm.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/main/controllers/dcmtk/dicomimg2dcm.h
 
1
/*
 
2
 *  
 
3
 *  $Id: dicomimg2dcm.h 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
#pragma once
 
15
#include <api/globals.h>
 
16
#include <api/idicomizador.h>
 
17
#ifdef verify
 
18
#define MACRO_QUE_ESTORBA verify
 
19
#undef verify
 
20
#endif
 
21
 
 
22
#include <dcmtk/config/osconfig.h>
 
23
#include "libi2d/i2d.h"
 
24
#include "libi2d/i2djpgs.h"
 
25
#include "libi2d/i2dplsc.h"
 
26
#include "libi2d/i2dplvlp.h"
 
27
#include "libi2d/i2dplnsc.h"
 
28
#include "dcmtk/dcmdata/dcdict.h"
 
29
#include "dcmtk/dcmdata/dchashdi.h"
 
30
 
 
31
class DcmElement;
 
32
 
 
33
namespace GIL {
 
34
        namespace DICOM {
 
35
                
 
36
                class DICOMImg2DCM : public IDICOMImg2DCM {
 
37
                public:
 
38
                        /* Constructor */
 
39
                        DICOMImg2DCM() {
 
40
                                i2d = NULL;
 
41
                                outputPlug = NULL;
 
42
                                inputPlug = NULL;
 
43
                                resultObject = NULL;
 
44
                                writeXfer = EXS_Unknown;
 
45
                        };
 
46
                        
 
47
                        /* Destructor */
 
48
                        ~DICOMImg2DCM() {
 
49
                                LiberarMemoria();
 
50
                        }
 
51
                        
 
52
                        void LiberarMemoria() {
 
53
                                if (resultObject != NULL) {
 
54
                                        delete resultObject;
 
55
                                        resultObject = NULL;
 
56
                                }
 
57
                                if (inputPlug != NULL) {
 
58
                                        delete inputPlug;
 
59
                                        inputPlug = NULL;
 
60
                                }
 
61
                                if (outputPlug != NULL) {
 
62
                                        delete outputPlug;
 
63
                                        outputPlug = NULL;
 
64
                                }
 
65
                                if (i2d != NULL) {
 
66
                                        delete i2d;
 
67
                                        i2d = NULL;
 
68
                                }
 
69
                        };
 
70
                        
 
71
                        /* Inicializa una conversión. IInspectCallback sirve para especificar un callback mediante el cual se pueden inspeccionar los atributos buscados.
 
72
                         *
 
73
                         * Formatos de entrada soportados:
 
74
                         *        JPEG
 
75
                         * Formatos de salida soportados (DICOM SOP a generar):
 
76
                         *   VLP (Visible Light Photography)
 
77
                         *   SC (Secondary Capture)
 
78
                         *   NSC (New Secondary Capture)
 
79
                         */
 
80
                        virtual void Inicializar(std::string& inputFile, IInspectCallBack* pICallback = NULL, bool debug = false, TDICOMOutputFormat outputFormat = TDOF_VLP);
 
81
 
 
82
                        virtual void Inicializar(unsigned char* pixelData, const int ancho, const int alto, IInspectCallBack* pICallback = NULL, bool debug = false, TDICOMOutputFormat outputFormat = TDOF_VLP);
 
83
 
 
84
                        void Inicializar(I2DImgSource* plugEntrada, IInspectCallBack* pICallback, bool debug, TDICOMOutputFormat outputFormat);
 
85
                        
 
86
                        virtual int InsertarJerarquia(TipoJerarquia& base); 
 
87
 
 
88
                        virtual int InsertarTagsPrivados(TipoPrivateTags& base);
 
89
 
 
90
                        virtual int InsertarTagsPrivados(TipoPrivateTags& base, DcmDataset* dcmDataSet);
 
91
 
 
92
                        int InsertarJerarquia(TipoJerarquia& base,DcmDataset* dcmDataSet, DcmItem* itemPadre, DcmSequenceOfItems* seqPadre);
 
93
                        
 
94
                        /* Actualiza los campos DICOM a sobreescribir */
 
95
                        virtual void ActualizarCampos(IInspectCallBack* pICallback);
 
96
                        
 
97
                        /* Realiza una conversión ya inicializada */
 
98
                        virtual bool Convertir(std::string& outputFile);
 
99
 
 
100
                        unsigned int GetElementIdentifier(GIL::DICOM::TipoPrivateTags& tags, DcmDataset* dataset);
 
101
 
 
102
                        bool CrearSRDoc(std::string& outputFile, TipoJerarquia& base, std::list<GnkPtr<TipoPrivateTags> >& tagsPrivados);
 
103
 
 
104
                        virtual void Reset() {
 
105
                                LiberarMemoria();
 
106
                        }
 
107
                        
 
108
                protected:
 
109
                        
 
110
                        /* Crea un elemento de DCMTK parseando la cadena pasada como parámetro que debe tener el formato:
 
111
                         <hex_2_bytes>|<hex_2_bytes>
 
112
                         o bien:
 
113
                         <hex_2_bytes>|<hex_2_bytes>=<cadena>
 
114
                         Nota: <cadena> puede ser vacía
 
115
                         */
 
116
                        DcmElement* CrearElementoConValor(const char* s);
 
117
                        
 
118
                        // Main class for controlling conversion
 
119
                        Image2Dcm*       i2d;
 
120
                        // Output plugin to use (ie. SOP class to write)
 
121
                        I2DOutputPlug*   outputPlug;
 
122
                        // Input plugin to use (ie. file format to read)
 
123
                        I2DImgSource*    inputPlug;
 
124
                        // Result object
 
125
                        DcmDataset*      resultObject;
 
126
                        // The transfersytanx proposed to be written by output plugin
 
127
                        E_TransferSyntax writeXfer;
 
128
                };
 
129
        };
 
130
};