]> Creatis software - gdcm.git/blob - src/gdcmSegmentedPalette.h
re indent
[gdcm.git] / src / gdcmSegmentedPalette.h
1 /*=========================================================================
2  
3   Program:   gdcm
4   Module:    $RCSfile: gdcmSegmentedPalette.h,v $
5   Language:  C++
6   Date:      $Date: 2007/11/13 09:37:22 $
7   Version:   $Revision: 1.20 $
8                                                                                 
9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
10   l'Image). All rights reserved. See Doc/License.txt or
11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
12                                                                                 
13      This software is distributed WITHOUT ANY WARRANTY; without even
14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15      PURPOSE.  See the above copyright notices for more information.
16                                                                                 
17 =========================================================================*/
18
19 #ifndef _GDCMSEGMENTEDPALETTE_H_
20 #define _GDCMSEGMENTEDPALETTE_H_
21
22 #include "gdcmFile.h"
23 #include "gdcmTagKey.h"
24 #include "gdcmDataEntry.h"
25
26 // Notepad from Satomi Takeo:
27 // http://blog.goo.ne.jp/satomi_takeo/e/3643e5249b2a9650f9e10ef1c830e8b8
28 // I bet the code was compiled on VS6. Make it compile on other platform:
29 // * typedef are not inherited
30 // * need to explicitely add typename keyword
31 // * Uint8 / Uint16 are neither C nor C++
32 // * replace all dcmtk code with equivalent gdcm code
33 // * Add extra parameter to ReadPaletteInto to save extracted info
34
35 // MM: Over 50000 DICOM files I only found two that had a Segmented Palette LUT
36 // And both were coming from a ALOKA SSD-4000 station
37 //
38 // JPRx :
39 // It compiles fine under gcc 4.1.2, msvc 7 and DarwinG5-g++
40 // It doesn't compile on msvc 6, borland and SunOS
41 // Any fix welcome !
42
43 #include <assert.h>
44 #include <algorithm>
45 #include <deque>
46 #include <map>
47 #include <vector>
48 #include <iterator>
49
50 // Hack for VS6
51 #if defined(_MSC_VER) && (_MSC_VER < 1310)
52 #define GDCM_TYPENAME
53 #else
54 #define GDCM_TYPENAME typename
55 #endif
56
57 // Hack for Borland
58 #if (defined(_MSC_VER) && (_MSC_VER < 1310)) || defined(__BORLANDC__)
59 #define GDCM_TYPENAME2
60 #else
61 #define GDCM_TYPENAME2 typename
62 #endif
63
64
65 namespace GDCM_NAME_SPACE
66 {
67 // Long stody short: Sun compiler only provide the second interface of 
68 // std::distance, since the implementation is so trivial, I'd rather redo it myself.
69 // Ref:
70 // http://www.sgi.com/tech/stl/distance.html#2
71 // The second version of distance was the one defined in the original STL, and
72 // the first version is the one defined in the draft C++ standard; the definition
73 // was changed because the older interface was clumsy and error-prone. 
74 // The older interface required the use of a temporary variable, and it has semantics 
75 // that are somewhat nonintuitive: it increments n by the distance from first to last, 
76 // rather than storing that distance in n
77   template<typename InputIterator>
78     inline int32_t
79     mydistance(InputIterator first, InputIterator last)
80       {
81       int32_t n = 0;
82       while (first != last)
83         {
84         ++first;
85         ++n;
86         }
87       return n;
88       }
89
90     // abstract class for segment.
91     template <typename EntryType>
92     class Segment {
93     public:
94         typedef std::map<const EntryType* const, const Segment*> SegmentMap;
95         virtual bool Expand(const SegmentMap& instances,
96             std::vector<EntryType>& expanded) const = 0;
97         const EntryType* First() const { return _first; }
98         const EntryType* Last()  const { return _last;  }
99         struct ToMap {
100             typename SegmentMap::value_type
101                 operator()(const Segment* segment) const
102             { return std::make_pair(segment->First(), segment); }
103         };
104     protected:
105         Segment(const EntryType* first, const EntryType* last) {
106             _first = first; _last = last;
107         }
108         const EntryType* _first;
109         const EntryType* _last;
110     };
111
112     // discrete segment (opcode = 0)
113     template <typename EntryType>
114     class DiscreteSegment : public Segment<EntryType> {
115     public:
116 #if !defined(__sun__)
117         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
118 #endif
119         DiscreteSegment(const EntryType* first)
120             : Segment<EntryType>(first, first+2+*(first+1)) {}
121         virtual bool Expand(const SegmentMap&,
122             std::vector<EntryType>& expanded) const
123         {
124             std::copy(this->_first + 2, this->_last, std::back_inserter(expanded));
125             return true;
126         }
127     };
128
129     // linear segment (opcode = 1)
130     template <typename EntryType>
131     class LinearSegment : public Segment<EntryType> {
132     public:
133 #if !defined(__sun__)
134         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
135 #endif
136         LinearSegment(const EntryType* first)
137             : Segment<EntryType>(first, first+3) {}
138         virtual bool Expand(const SegmentMap&,
139             std::vector<EntryType>& expanded) const
140         {
141             if ( expanded.empty() ) {
142                 // linear segment can't be the first segment.
143                 return false;
144             }
145             EntryType length = *(this->_first + 1);
146             EntryType y0 = expanded.back();
147             EntryType y1 = *(this->_first + 2);
148             double y01 = y1 - y0;
149             for ( EntryType i = 0; i <length; ++i ) {
150                 double value_float
151                     = static_cast<double>(y0)
152                     + (static_cast<double>(i)/static_cast<double>(length)) * y01;
153                 EntryType value_int = static_cast<EntryType>(value_float + 0.5);
154                 expanded.push_back(value_int);
155             }
156             return true;
157         }
158     };
159
160     // indirect segment (opcode = 2)
161     template <typename EntryType>
162     class IndirectSegment : public Segment<EntryType> {
163     public:
164 #if !defined(__sun__)
165         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
166 #endif
167         IndirectSegment(const EntryType* first)
168             : Segment<EntryType>(first, first+2+4/sizeof(EntryType)) {}
169         virtual bool Expand(const SegmentMap& instances,
170             std::vector<EntryType>& expanded) const
171         {
172             if ( instances.empty() ) {
173                 // some other segments are required as references.
174                 return false;
175             }
176             const EntryType* first_segment = instances.begin()->first;
177             const unsigned short* pOffset
178                 = reinterpret_cast<const unsigned short*>(this->_first + 2);
179             unsigned long offsetBytes
180                 = (*pOffset) | (static_cast<unsigned long>(*(pOffset + 1)) << 16);
181             const EntryType* copied_part_head
182                 = first_segment + offsetBytes / sizeof(EntryType);
183             GDCM_TYPENAME SegmentMap::const_iterator ppHeadSeg = instances.find(copied_part_head);
184             if ( ppHeadSeg == instances.end() ) {
185                 // referred segment not found
186                 return false;
187             }
188             EntryType nNumCopies = *(this->_first + 1);
189             GDCM_TYPENAME SegmentMap::const_iterator ppSeg = ppHeadSeg;
190             while ( mydistance(ppHeadSeg, ppSeg) < nNumCopies ) {
191                 // assert( mydistance(ppHeadSeg, ppSeg) == std::distance(ppHeadSeg, ppSeg) );
192                 assert( ppSeg != instances.end() );
193                 ppSeg->second->Expand(instances, expanded);
194                 ++ppSeg;
195             }
196             return true;
197         }
198     };
199
200     template <typename EntryType>
201     void ExpandPalette(const EntryType* raw_values, uint32_t length,
202         std::vector<EntryType>& palette)
203     {
204         typedef std::deque<Segment<EntryType>*> SegmentList;
205         SegmentList segments;
206         const EntryType* raw_seg = raw_values;
207         while ( (mydistance(raw_values, raw_seg) * sizeof(EntryType)) < length ) {
208             // assert( mydistance(raw_values, raw_seg) == std::distance(raw_values, raw_seg) );
209             Segment<EntryType>* segment = NULL;
210             if ( *raw_seg == 0 ) {
211                 segment = new DiscreteSegment<EntryType>(raw_seg);
212             } else if ( *raw_seg == 1 ) {
213                 segment = new LinearSegment<EntryType>(raw_seg);
214             } else if ( *raw_seg == 2 ) {
215                 segment = new IndirectSegment<EntryType>(raw_seg);
216             }
217             if ( segment ) {
218                 segments.push_back(segment);
219                 raw_seg = segment->Last();
220             } else {
221                 // invalid opcode
222                 break;
223             }
224
225         }
226         GDCM_TYPENAME Segment<EntryType>::SegmentMap instances;
227         std::transform(segments.begin(), segments.end(),
228             std::inserter(instances, instances.end()), GDCM_TYPENAME2 Segment<EntryType>::ToMap());
229         GDCM_TYPENAME SegmentList::iterator ppSeg = segments.begin();
230         GDCM_TYPENAME SegmentList::iterator endOfSegments = segments.end();
231         for ( ; ppSeg != endOfSegments; ++ppSeg ) {
232             (*ppSeg)->Expand(instances, palette);
233         }
234         ppSeg = segments.begin();
235         for ( ; ppSeg != endOfSegments; ++ppSeg ) {
236             delete *ppSeg;
237         }
238     }
239
240     void ReadPaletteInto(GDCM_NAME_SPACE::File* pds, const GDCM_NAME_SPACE::TagKey& descriptor,
241       const GDCM_NAME_SPACE::TagKey& segment, uint8_t* lut)
242       {
243       unsigned int desc_values[3] = {0,0,0};
244       unsigned long count = 0;
245       //if ( pds->findAndGetUint16Array(descriptor, desc_values, &count).good() )
246       std::string desc_values_str = pds->GetEntryString(descriptor.GetGroup(), descriptor.GetElement() );
247       count = sscanf( desc_values_str.c_str(), "%u\\%u\\%u", desc_values, desc_values+1, desc_values+2 );
248         {
249         assert( count == 3 );
250         unsigned int num_entries = desc_values[0];
251         if ( num_entries == 0 ) {
252           num_entries = 0x10000;
253         }
254         unsigned int min_pixel_value = desc_values[1];
255         assert( min_pixel_value == 0 ); // FIXME
256         unsigned int entry_size = desc_values[2];
257         assert( entry_size == 8 || entry_size == 16 );
258         //DcmElement* pe = NULL;
259         GDCM_NAME_SPACE::DataEntry* pe = NULL;
260
261         pe = pds->GetDataEntry(segment.GetGroup(), segment.GetElement() );
262           {
263           //if ( pds->findAndGetElement(segment, pe).good() )
264           unsigned long length = pe->GetLength();
265           if ( entry_size == 8 )
266             {
267             uint8_t* segment_values = NULL;
268             //if ( pe->getUint8Array(segment_values).good() )
269             segment_values = (uint8_t*)pe->GetBinArea();
270               {
271               std::vector<uint8_t> palette;
272               palette.reserve(num_entries);
273               ExpandPalette(segment_values, length, palette);
274               memcpy(lut, &palette[0], palette.size() );
275               }
276             } 
277           else if ( entry_size == 16 ) 
278             {
279             uint16_t* segment_values = NULL;
280             segment_values = (uint16_t*)pe->GetBinArea();
281               {
282               //if ( pe->getUint16Array(segment_values).good() )
283               std::vector<uint16_t> palette;
284               palette.reserve(num_entries);
285               ExpandPalette(segment_values, length, palette);
286               memcpy(lut, &palette[0], palette.size()*2 );
287
288               }
289             }
290           }
291         }
292       }
293 } // end namespace gdcm
294
295
296 // do not pollute namespace:
297 #undef GDCM_TYPENAME
298
299 #endif