1 /*=========================================================================
4 Module: $RCSfile: gdcmSegmentedPalette.h,v $
6 Date: $Date: 2007/10/30 13:35:08 $
7 Version: $Revision: 1.17 $
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.
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.
17 =========================================================================*/
19 #ifndef _GDCMSEGMENTEDPALETTE_H_
20 #define _GDCMSEGMENTEDPALETTE_H_
23 #include "gdcmTagKey.h"
24 #include "gdcmDataEntry.h"
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
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
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
51 #if defined(_MSC_VER) && (_MSC_VER < 1310)
54 #define GDCM_TYPENAME typename
58 #if (defined(_MSC_VER) && (_MSC_VER < 1310)) || defined(__BORLANDC__)
59 #define GDCM_TYPENAME2
61 #define GDCM_TYPENAME2 typename
65 namespace GDCM_NAME_SPACE
67 // Long stody short: Sun compiler only provide the second interface of std::distance, since the implemenation
68 // is so trivial, I'd rather redo it myself.
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 the first version is the one defined in the draft C++ standard; the definition was changed because the older interface was clumsy and error-prone. The older interface required the use of a temporary variable, and it has semantics that are somewhat nonintuitive: it increments n by the distance from first to last, rather than storing that distance in n
72 template<typename InputIterator>
74 mydistance(InputIterator first, InputIterator last)
85 // abstract class for segment.
86 template <typename EntryType>
89 typedef std::map<const EntryType* const, const Segment*> SegmentMap;
90 virtual bool Expand(const SegmentMap& instances,
91 std::vector<EntryType>& expanded) const = 0;
92 const EntryType* First() const { return _first; }
93 const EntryType* Last() const { return _last; }
95 typename SegmentMap::value_type
96 operator()(const Segment* segment) const
97 { return std::make_pair(segment->First(), segment); }
100 Segment(const EntryType* first, const EntryType* last) {
101 _first = first; _last = last;
103 const EntryType* _first;
104 const EntryType* _last;
107 // discrete segment (opcode = 0)
108 template <typename EntryType>
109 class DiscreteSegment : public Segment<EntryType> {
111 typedef typename Segment<EntryType>::SegmentMap SegmentMap;
112 DiscreteSegment(const EntryType* first)
113 : Segment<EntryType>(first, first+2+*(first+1)) {}
114 virtual bool Expand(const SegmentMap&,
115 std::vector<EntryType>& expanded) const
117 std::copy(this->_first + 2, this->_last, std::back_inserter(expanded));
122 // linear segment (opcode = 1)
123 template <typename EntryType>
124 class LinearSegment : public Segment<EntryType> {
126 typedef typename Segment<EntryType>::SegmentMap SegmentMap;
127 LinearSegment(const EntryType* first)
128 : Segment<EntryType>(first, first+3) {}
129 virtual bool Expand(const SegmentMap&,
130 std::vector<EntryType>& expanded) const
132 if ( expanded.empty() ) {
133 // linear segment can't be the first segment.
136 EntryType length = *(this->_first + 1);
137 EntryType y0 = expanded.back();
138 EntryType y1 = *(this->_first + 2);
139 double y01 = y1 - y0;
140 for ( EntryType i = 0; i <length; ++i ) {
142 = static_cast<double>(y0)
143 + (static_cast<double>(i)/static_cast<double>(length)) * y01;
144 EntryType value_int = static_cast<EntryType>(value_float + 0.5);
145 expanded.push_back(value_int);
151 // indirect segment (opcode = 2)
152 template <typename EntryType>
153 class IndirectSegment : public Segment<EntryType> {
155 typedef typename Segment<EntryType>::SegmentMap SegmentMap;
156 IndirectSegment(const EntryType* first)
157 : Segment<EntryType>(first, first+2+4/sizeof(EntryType)) {}
158 virtual bool Expand(const SegmentMap& instances,
159 std::vector<EntryType>& expanded) const
161 if ( instances.empty() ) {
162 // some other segments are required as references.
165 const EntryType* first_segment = instances.begin()->first;
166 const unsigned short* pOffset
167 = reinterpret_cast<const unsigned short*>(this->_first + 2);
168 unsigned long offsetBytes
169 = (*pOffset) | (static_cast<unsigned long>(*(pOffset + 1)) << 16);
170 const EntryType* copied_part_head
171 = first_segment + offsetBytes / sizeof(EntryType);
172 GDCM_TYPENAME SegmentMap::const_iterator ppHeadSeg = instances.find(copied_part_head);
173 if ( ppHeadSeg == instances.end() ) {
174 // referred segment not found
177 EntryType nNumCopies = *(this->_first + 1);
178 GDCM_TYPENAME SegmentMap::const_iterator ppSeg = ppHeadSeg;
179 while ( mydistance(ppHeadSeg, ppSeg) < nNumCopies ) {
180 // assert( mydistance(ppHeadSeg, ppSeg) == std::distance(ppHeadSeg, ppSeg) );
181 assert( ppSeg != instances.end() );
182 ppSeg->second->Expand(instances, expanded);
189 template <typename EntryType>
190 void ExpandPalette(const EntryType* raw_values, uint32_t length,
191 std::vector<EntryType>& palette)
193 typedef std::deque<Segment<EntryType>*> SegmentList;
194 SegmentList segments;
195 const EntryType* raw_seg = raw_values;
196 while ( (mydistance(raw_values, raw_seg) * sizeof(EntryType)) < length ) {
197 // assert( mydistance(raw_values, raw_seg) == std::distance(raw_values, raw_seg) );
198 Segment<EntryType>* segment = NULL;
199 if ( *raw_seg == 0 ) {
200 segment = new DiscreteSegment<EntryType>(raw_seg);
201 } else if ( *raw_seg == 1 ) {
202 segment = new LinearSegment<EntryType>(raw_seg);
203 } else if ( *raw_seg == 2 ) {
204 segment = new IndirectSegment<EntryType>(raw_seg);
207 segments.push_back(segment);
208 raw_seg = segment->Last();
215 GDCM_TYPENAME Segment<EntryType>::SegmentMap instances;
216 std::transform(segments.begin(), segments.end(),
217 std::inserter(instances, instances.end()), GDCM_TYPENAME2 Segment<EntryType>::ToMap());
218 GDCM_TYPENAME SegmentList::iterator ppSeg = segments.begin();
219 GDCM_TYPENAME SegmentList::iterator endOfSegments = segments.end();
220 for ( ; ppSeg != endOfSegments; ++ppSeg ) {
221 (*ppSeg)->Expand(instances, palette);
223 ppSeg = segments.begin();
224 for ( ; ppSeg != endOfSegments; ++ppSeg ) {
229 void ReadPaletteInto(GDCM_NAME_SPACE::File* pds, const GDCM_NAME_SPACE::TagKey& descriptor,
230 const GDCM_NAME_SPACE::TagKey& segment, uint8_t* lut)
232 unsigned int desc_values[3] = {0,0,0};
233 unsigned long count = 0;
234 //if ( pds->findAndGetUint16Array(descriptor, desc_values, &count).good() )
235 std::string desc_values_str = pds->GetEntryString(descriptor.GetGroup(), descriptor.GetElement() );
236 count = sscanf( desc_values_str.c_str(), "%u\\%u\\%u", desc_values, desc_values+1, desc_values+2 );
238 assert( count == 3 );
239 unsigned int num_entries = desc_values[0];
240 if ( num_entries == 0 ) {
241 num_entries = 0x10000;
243 unsigned int min_pixel_value = desc_values[1];
244 assert( min_pixel_value == 0 ); // FIXME
245 unsigned int entry_size = desc_values[2];
246 assert( entry_size == 8 || entry_size == 16 );
247 //DcmElement* pe = NULL;
248 GDCM_NAME_SPACE::DataEntry* pe = NULL;
250 pe = pds->GetDataEntry(segment.GetGroup(), segment.GetElement() );
252 //if ( pds->findAndGetElement(segment, pe).good() )
253 unsigned long length = pe->GetLength();
254 if ( entry_size == 8 )
256 uint8_t* segment_values = NULL;
257 //if ( pe->getUint8Array(segment_values).good() )
258 segment_values = (uint8_t*)pe->GetBinArea();
260 std::vector<uint8_t> palette;
261 palette.reserve(num_entries);
262 ExpandPalette(segment_values, length, palette);
263 memcpy(lut, &palette[0], palette.size() );
266 else if ( entry_size == 16 )
268 uint16_t* segment_values = NULL;
269 segment_values = (uint16_t*)pe->GetBinArea();
271 //if ( pe->getUint16Array(segment_values).good() )
272 std::vector<uint16_t> palette;
273 palette.reserve(num_entries);
274 ExpandPalette(segment_values, length, palette);
275 memcpy(lut, &palette[0], palette.size()*2 );
282 } // end namespace gdcm
285 // do not pollute namespace: