COMP: Fix a bunch of warnings. Try to get template to compile on the pseudo VS6 so...

[gdcm.git] / src / gdcmSegmentedPalette.h

diff --git a/src/gdcmSegmentedPalette.h b/src/gdcmSegmentedPalette.h
index 27c6dabe69279bdc29018a4446ff69ab58a9365d..2f2c57c99d9045c92f2eb58e03898207ba52c38c 100644 (file)
--- 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:46:09 $
-  Version:   $Revision: 1.4 $
+  Date:      $Date: 2007/10/08 15:20:17 $
+  Version:   $Revision: 1.9 $
                                                                                 
   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
   l'Image). All rights reserved. See Doc/License.txt or
@@ -16,7 +16,13 @@
                                                                                 
 =========================================================================*/
 
-#include <gdcm.h>
+#ifndef _GDCMSEGMENTEDPALETTE_H_
+#define _GDCMSEGMENTEDPALETTE_H_
+
+#include "gdcmFile.h"
+#include "gdcmTagKey.h"
+#include "gdcmDataEntry.h"
+
 // Ref: 
 // http://blog.goo.ne.jp/satomi_takeo/e/3643e5249b2a9650f9e10ef1c830e8b8
 // I bet the code was compiled on VS6. Make it compile on other platform:
@@ -26,6 +32,8 @@
 // * 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
 #include <assert.h>
 #include <algorithm>
 #include <deque>
@@ -33,9 +41,17 @@
 #include <vector>
 #include <iterator>
 
-namespace gdcm {
+// Hack for VS6
+#if defined(_MSC_VER) && (_MSC_VER < 1310)
+#define GDCM_TYPENAME class
+#else
+#define GDCM_TYPENAME typename
+#endif
+
+namespace GDCM_NAME_SPACE
+{
     // abstract class for segment.
-    template <typename EntryType>
+    template <GDCM_TYPENAME EntryType>
     class Segment {
     public:
         typedef std::map<const EntryType*, const Segment*> SegmentMap;
@@ -60,7 +76,7 @@ namespace gdcm {
     };
 
     // discrete segment (opcode = 0)
-    template <typename EntryType>
+    template <GDCM_TYPENAME EntryType>
     class DiscreteSegment : public Segment<EntryType> {
     public:
         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
@@ -75,7 +91,7 @@ namespace gdcm {
     };
 
     // linear segment (opcode = 1)
-    template <typename EntryType>
+    template <GDCM_TYPENAME EntryType>
     class LinearSegment : public Segment<EntryType> {
     public:
         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
@@ -104,7 +120,7 @@ namespace gdcm {
     };
 
     // indirect segment (opcode = 2)
-    template <typename EntryType>
+    template <GDCM_TYPENAME EntryType>
     class IndirectSegment : public Segment<EntryType> {
     public:
         typedef typename Segment<EntryType>::SegmentMap SegmentMap;
@@ -131,7 +147,7 @@ namespace gdcm {
             }
             EntryType nNumCopies = *(this->_first + 1);
             typename SegmentMap::const_iterator ppSeg = ppHeadSeg;
-            while ( std::distance(ppHeadSeg, ppSeg) <nNumCopies ) {
+            while ( std::distance(ppHeadSeg, ppSeg) < nNumCopies ) {
                 assert( ppSeg != instances.end() );
                 ppSeg->second->Expand(instances, expanded);
                 ++ppSeg;
@@ -140,7 +156,7 @@ namespace gdcm {
         }
     };
 
-    template <typename EntryType>
+    template <GDCM_TYPENAME EntryType>
     void ExpandPalette(const EntryType* raw_values, uint32_t length,
         std::vector<EntryType>& palette)
     {
@@ -181,51 +197,60 @@ namespace gdcm {
     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] = {};
       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