X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmSegmentedPalette.h;h=1a53fa745138d9a1fed40664b61a0f49f156a7b0;hb=bd7bec4c367d671a9da358584e98a8ec29bb641e;hp=fff7bfaec7eb007a6eda56cb6cc7f80c55b6a84b;hpb=6cfef0bc2e3ab5ba9c4665f8d985d79089daae27;p=gdcm.git

diff --git a/src/gdcmSegmentedPalette.h b/src/gdcmSegmentedPalette.h
index fff7bfae..1a53fa74 100644
--- a/src/gdcmSegmentedPalette.h
+++ b/src/gdcmSegmentedPalette.h
@@ -3,8 +3,8 @@
   Program:   gdcm
   Module:    $RCSfile: gdcmSegmentedPalette.h,v $
   Language:  C++
-  Date:      $Date: 2007/10/03 09:35:27 $
-  Version:   $Revision: 1.3 $
+  Date:      $Date: 2007/11/13 09:37:22 $
+  Version:   $Revision: 1.20 $
                                                                                 
   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
   l'Image). All rights reserved. See Doc/License.txt or
@@ -16,14 +16,29 @@
                                                                                 
 =========================================================================*/
 
-#include <gdcm.h>
-// Ref: 
+#ifndef _GDCMSEGMENTEDPALETTE_H_
+#define _GDCMSEGMENTEDPALETTE_H_
+
+#include "gdcmFile.h"
+#include "gdcmTagKey.h"
+#include "gdcmDataEntry.h"
+
+// Notepad from Satomi Takeo:
 // http://blog.goo.ne.jp/satomi_takeo/e/3643e5249b2a9650f9e10ef1c830e8b8
 // I bet the code was compiled on VS6. Make it compile on other platform:
 // * typedef are not inherited
 // * need to explicitely add typename keyword
 // * Uint8 / Uint16 are neither C nor C++
-// * replace all dcmtk code with identical gdcm code
+// * replace all dcmtk code with equivalent gdcm code
+// * Add extra parameter to ReadPaletteInto to save extracted info
+
+// MM: Over 50000 DICOM files I only found two that had a Segmented Palette LUT
+// And both were coming from a ALOKA SSD-4000 station
+//
+// JPRx :
+// It compiles fine under gcc 4.1.2, msvc 7 and DarwinG5-g++
+// It doesn't compile on msvc 6, borland and SunOS
+// Any fix welcome !
 
 #include <assert.h>
 #include <algorithm>
@@ -32,21 +47,57 @@
 #include <vector>
 #include <iterator>
 
-namespace {
+// Hack for VS6
+#if defined(_MSC_VER) && (_MSC_VER < 1310)
+#define GDCM_TYPENAME
+#else
+#define GDCM_TYPENAME typename
+#endif
+
+// Hack for Borland
+#if (defined(_MSC_VER) && (_MSC_VER < 1310)) || defined(__BORLANDC__)
+#define GDCM_TYPENAME2
+#else
+#define GDCM_TYPENAME2 typename
+#endif
+
+
+namespace GDCM_NAME_SPACE
+{
+// Long stody short: Sun compiler only provide the second interface of 
+// std::distance, since the implementation is so trivial, I'd rather redo it myself.
+// Ref:
+// http://www.sgi.com/tech/stl/distance.html#2
+// 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
+  template<typename InputIterator>
+    inline int32_t
+    mydistance(InputIterator first, InputIterator last)
+      {
+      int32_t n = 0;
+      while (first != last)
+        {
+        ++first;
+        ++n;
+        }
+      return n;
+      }
+
     // abstract class for segment.
     template <typename EntryType>
     class Segment {
     public:
-        typedef std::map<const EntryType*, const Segment*> SegmentMap;
+        typedef std::map<const EntryType* const, const Segment*> SegmentMap;
         virtual bool Expand(const SegmentMap& instances,
             std::vector<EntryType>& expanded) const = 0;
         const EntryType* First() const { return _first; }
-        const EntryType* Last() const { return _last; }
+        const EntryType* Last()  const { return _last;  }
         struct ToMap {
-            std::pair<
-                typename SegmentMap::key_type,
-                typename SegmentMap::mapped_type
-            >
+            typename SegmentMap::value_type
                 operator()(const Segment* segment) const
             { return std::make_pair(segment->First(), segment); }
         };
@@ -62,7 +113,9 @@ namespace {
     template <typename EntryType>
     class DiscreteSegment : public Segment<EntryType> {
     public:
+#if !defined(__sun__)
         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
+#endif
         DiscreteSegment(const EntryType* first)
             : Segment<EntryType>(first, first+2+*(first+1)) {}
         virtual bool Expand(const SegmentMap&,
@@ -77,7 +130,9 @@ namespace {
     template <typename EntryType>
     class LinearSegment : public Segment<EntryType> {
     public:
+#if !defined(__sun__)
         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
+#endif
         LinearSegment(const EntryType* first)
             : Segment<EntryType>(first, first+3) {}
         virtual bool Expand(const SegmentMap&,
@@ -106,7 +161,9 @@ namespace {
     template <typename EntryType>
     class IndirectSegment : public Segment<EntryType> {
     public:
+#if !defined(__sun__)
         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
+#endif
         IndirectSegment(const EntryType* first)
             : Segment<EntryType>(first, first+2+4/sizeof(EntryType)) {}
         virtual bool Expand(const SegmentMap& instances,
@@ -123,14 +180,15 @@ namespace {
                 = (*pOffset) | (static_cast<unsigned long>(*(pOffset + 1)) << 16);
             const EntryType* copied_part_head
                 = first_segment + offsetBytes / sizeof(EntryType);
-            typename SegmentMap::const_iterator ppHeadSeg = instances.find(copied_part_head);
+            GDCM_TYPENAME SegmentMap::const_iterator ppHeadSeg = instances.find(copied_part_head);
             if ( ppHeadSeg == instances.end() ) {
                 // referred segment not found
                 return false;
             }
             EntryType nNumCopies = *(this->_first + 1);
-            typename SegmentMap::const_iterator ppSeg = ppHeadSeg;
-            while ( std::distance(ppHeadSeg, ppSeg) <nNumCopies ) {
+            GDCM_TYPENAME SegmentMap::const_iterator ppSeg = ppHeadSeg;
+            while ( mydistance(ppHeadSeg, ppSeg) < nNumCopies ) {
+                // assert( mydistance(ppHeadSeg, ppSeg) == std::distance(ppHeadSeg, ppSeg) );
                 assert( ppSeg != instances.end() );
                 ppSeg->second->Expand(instances, expanded);
                 ++ppSeg;
@@ -146,7 +204,8 @@ namespace {
         typedef std::deque<Segment<EntryType>*> SegmentList;
         SegmentList segments;
         const EntryType* raw_seg = raw_values;
-        while ( (std::distance(raw_values, raw_seg) * sizeof(EntryType)) <length ) {
+        while ( (mydistance(raw_values, raw_seg) * sizeof(EntryType)) < length ) {
+            // assert( mydistance(raw_values, raw_seg) == std::distance(raw_values, raw_seg) );
             Segment<EntryType>* segment = NULL;
             if ( *raw_seg == 0 ) {
                 segment = new DiscreteSegment<EntryType>(raw_seg);
@@ -162,12 +221,13 @@ namespace {
                 // invalid opcode
                 break;
             }
+
         }
-        typename Segment<EntryType>::SegmentMap instances;
+        GDCM_TYPENAME Segment<EntryType>::SegmentMap instances;
         std::transform(segments.begin(), segments.end(),
-            std::inserter(instances, instances.end()), typename Segment<EntryType>::ToMap());
-        typename SegmentList::iterator ppSeg = segments.begin();
-        typename SegmentList::iterator endOfSegments = segments.end();
+            std::inserter(instances, instances.end()), GDCM_TYPENAME2 Segment<EntryType>::ToMap());
+        GDCM_TYPENAME SegmentList::iterator ppSeg = segments.begin();
+        GDCM_TYPENAME SegmentList::iterator endOfSegments = segments.end();
         for ( ; ppSeg != endOfSegments; ++ppSeg ) {
             (*ppSeg)->Expand(instances, palette);
         }
@@ -180,51 +240,60 @@ namespace {
     void ReadPaletteInto(GDCM_NAME_SPACE::File* pds, const GDCM_NAME_SPACE::TagKey& descriptor,
       const GDCM_NAME_SPACE::TagKey& segment, uint8_t* lut)
       {
-      int desc_values[3] = {};
+      unsigned int desc_values[3] = {0,0,0};
       unsigned long count = 0;
       //if ( pds->findAndGetUint16Array(descriptor, desc_values, &count).good() )
       std::string desc_values_str = pds->GetEntryString(descriptor.GetGroup(), descriptor.GetElement() );
-      count = sscanf( desc_values_str.c_str(), "%d\\%d\\%d", desc_values, desc_values+1, desc_values+2 );
+      count = sscanf( desc_values_str.c_str(), "%u\\%u\\%u", desc_values, desc_values+1, desc_values+2 );
         {
         assert( count == 3 );
         unsigned int num_entries = desc_values[0];
         if ( num_entries == 0 ) {
           num_entries = 0x10000;
         }
-        int min_pixel_value = desc_values[1];
+        unsigned int min_pixel_value = desc_values[1];
+        assert( min_pixel_value == 0 ); // FIXME
         unsigned int entry_size = desc_values[2];
         assert( entry_size == 8 || entry_size == 16 );
         //DcmElement* pe = NULL;
         GDCM_NAME_SPACE::DataEntry* pe = NULL;
 
-        pe = pds->GetDataEntry(segment.GetGroup(), segment.GetElement() ); {
+        pe = pds->GetDataEntry(segment.GetGroup(), segment.GetElement() );
+          {
           //if ( pds->findAndGetElement(segment, pe).good() )
           unsigned long length = pe->GetLength();
-          if ( entry_size == 8 ) {
+          if ( entry_size == 8 )
+            {
             uint8_t* segment_values = NULL;
             //if ( pe->getUint8Array(segment_values).good() )
-            segment_values = (uint8_t*)pe->GetBinArea(); {
+            segment_values = (uint8_t*)pe->GetBinArea();
+              {
               std::vector<uint8_t> palette;
               palette.reserve(num_entries);
               ExpandPalette(segment_values, length, palette);
               memcpy(lut, &palette[0], palette.size() );
-            }
-          } else if ( entry_size == 16 ) {
+              }
+            } 
+          else if ( entry_size == 16 ) 
+            {
             uint16_t* segment_values = NULL;
-            segment_values = (uint16_t*)pe->GetBinArea(); {
+            segment_values = (uint16_t*)pe->GetBinArea();
+              {
               //if ( pe->getUint16Array(segment_values).good() )
               std::vector<uint16_t> palette;
               palette.reserve(num_entries);
               ExpandPalette(segment_values, length, palette);
               memcpy(lut, &palette[0], palette.size()*2 );
-//              std::copy(palette.begin(), palette.end(), 
-//                std::ostream_iterator<uint16_t>(std::cout, "\n"));
 
+              }
             }
           }
         }
-        }
       }
-} // end namespace
+} // end namespace gdcm
+
 
+// do not pollute namespace:
+#undef GDCM_TYPENAME
 
+#endif