Program: gdcm
Module: $RCSfile: gdcmHeader.cxx,v $
Language: C++
- Date: $Date: 2004/09/29 17:33:17 $
- Version: $Revision: 1.190 $
+ Date: $Date: 2004/10/18 12:49:22 $
+ Version: $Revision: 1.194 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include <vector>
+namespace gdcm
+{
+
//-----------------------------------------------------------------------------
// Constructor / Destructor
/**
* \brief Constructor
* @param filename name of the file whose header we want to analyze
*/
-gdcmHeader::gdcmHeader( std::string const & filename ):
- gdcmDocument( filename )
+Header::Header( std::string const & filename ):
+ Document( filename )
{
// for some ACR-NEMA images GrPixel, NumPixel is *not* 7fe0,0010
// We may encounter the 'RETired' (0x0028, 0x0200) tag
/**
* \brief Constructor
*/
-gdcmHeader::gdcmHeader()
- :gdcmDocument()
+Header::Header()
+ :Document()
{
}
/**
* \brief Canonical destructor.
*/
-gdcmHeader::~gdcmHeader ()
+Header::~Header ()
{
}
* @param filetype Type of the File to be written
* (ACR-NEMA, ExplicitVR, ImplicitVR)
*/
-void gdcmHeader::Write(FILE* fp,FileType filetype)
+void Header::Write(FILE* fp,FileType filetype)
{
// Bits Allocated
if ( GetEntryByNumber(0x0028,0x0100) == "12")
if (i_lgPix != -2)
{
// no (GrPixel, NumPixel) element
- char* dumm = new char[20];
- sprintf(dumm ,"%d", i_lgPix+12);
- std::string s_lgPix = dumm;
- delete[] dumm;
+ std::string s_lgPix;
+ s_lgPix = Util::Format("%d", i_lgPix+12);
ReplaceOrCreateByNumber(s_lgPix,GrPixel, 0x0000);
}
- // FIXME : should be nice if we could move it to gdcmFile
+ // FIXME : should be nice if we could move it to File
// (or in future gdcmPixelData class)
// Drop Palette Color, if necessary
// Drop 0028|1101, 0028|1102, 0028|1103
// Drop 0028|1201, 0028|1202, 0028|1203
- gdcmDocEntry* e = GetDocEntryByNumber(0x0028,0x01101);
+ DocEntry* e = GetDocEntryByNumber(0x0028,0x01101);
if (e)
{
RemoveEntryNoDestroy(e);
RemoveEntryNoDestroy(e);
}
}
- gdcmDocument::Write(fp,filetype);
+ Document::Write(fp,filetype);
}
//-----------------------------------------------------------------------------
/**
* \brief This predicate, based on hopefully reasonable heuristics,
- * decides whether or not the current gdcmHeader was properly parsed
+ * decides whether or not the current Header was properly parsed
* and contains the mandatory information for being considered as
* a well formed and usable Dicom/Acr File.
- * @return true when gdcmHeader is the one of a reasonable Dicom/Acr file,
+ * @return true when Header is the one of a reasonable Dicom/Acr file,
* false otherwise.
*/
-bool gdcmHeader::IsReadable()
+bool Header::IsReadable()
{
- if( !gdcmDocument::IsReadable() )
+ if( !Document::IsReadable() )
{
return false;
}
* @return The encountered size when found, 0 by default.
* 0 means the file is NOT USABLE. The caller will have to check
*/
-int gdcmHeader::GetXSize()
+int Header::GetXSize()
{
std::string strSize;
strSize = GetEntryByNumber(0x0028,0x0011);
/**
* \brief Retrieve the number of lines of image.
- * \warning The defaulted value is 1 as opposed to gdcmHeader::GetXSize()
+ * \warning The defaulted value is 1 as opposed to Header::GetXSize()
* @return The encountered size when found, 1 by default
* (The ACR-NEMA file contains a Signal, not an Image).
*/
-int gdcmHeader::GetYSize()
+int Header::GetYSize()
{
std::string strSize = GetEntryByNumber(0x0028,0x0010);
if ( strSize != GDCM_UNFOUND )
* being the ACR-NEMA "Planes" tag content.
* @return The encountered size when found, 1 by default (single image).
*/
-int gdcmHeader::GetZSize()
+int Header::GetZSize()
{
// Both DicomV3 and ACR/Nema consider the "Number of Frames"
// as the third dimension.
* else 1.0
* @return X dimension of a pixel
*/
-float gdcmHeader::GetXSpacing()
+float Header::GetXSpacing()
{
float xspacing, yspacing;
std::string strSpacing = GetEntryByNumber(0x0028,0x0030);
if ( strSpacing == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetXSpacing: unfound Pixel Spacing (0028,0030)");
+ dbg.Verbose(0, "Header::GetXSpacing: unfound Pixel Spacing (0028,0030)");
return 1.;
}
}
if ( xspacing == 0.)
{
- dbg.Verbose(0, "gdcmHeader::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
+ dbg.Verbose(0, "Header::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
// seems to be a bug in the header ...
sscanf( strSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing);
}
* else 1.0
* @return Y dimension of a pixel
*/
-float gdcmHeader::GetYSpacing()
+float Header::GetYSpacing()
{
float yspacing = 0;
std::string strSpacing = GetEntryByNumber(0x0028,0x0030);
if ( strSpacing == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetYSpacing: unfound Pixel Spacing (0028,0030)");
+ dbg.Verbose(0, "Header::GetYSpacing: unfound Pixel Spacing (0028,0030)");
return 1.;
}
* else 1.0
* @return Z dimension of a voxel-to be
*/
-float gdcmHeader::GetZSpacing()
+float Header::GetZSpacing()
{
// Spacing Between Slices : distance entre le milieu de chaque coupe
// Les coupes peuvent etre :
if ( strSpacingBSlices == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetZSpacing: unfound StrSpacingBSlices");
+ dbg.Verbose(0, "Header::GetZSpacing: unfound StrSpacingBSlices");
std::string strSliceThickness = GetEntryByNumber(0x0018,0x0050);
if ( strSliceThickness == GDCM_UNFOUND )
{
*\brief gets the info from 0028,1052 : Rescale Intercept
* @return Rescale Intercept
*/
-float gdcmHeader::GetRescaleIntercept()
+float Header::GetRescaleIntercept()
{
float resInter = 0.;
/// 0028 1052 DS IMG Rescale Intercept
if( sscanf( strRescInter.c_str(), "%f", &resInter) != 1 )
{
// bug in the element 0x0028,0x1052
- dbg.Verbose(0, "gdcmHeader::GetRescaleIntercept: Rescale Slope "
+ dbg.Verbose(0, "Header::GetRescaleIntercept: Rescale Slope "
"is empty");
}
}
*\brief gets the info from 0028,1053 : Rescale Slope
* @return Rescale Slope
*/
-float gdcmHeader::GetRescaleSlope()
+float Header::GetRescaleSlope()
{
float resSlope = 1.;
//0028 1053 DS IMG Rescale Slope
if( sscanf( strRescSlope.c_str(), "%f", &resSlope) != 1)
{
// bug in the element 0x0028,0x1053
- dbg.Verbose(0, "gdcmHeader::GetRescaleSlope: Rescale Slope is empty");
+ dbg.Verbose(0, "Header::GetRescaleSlope: Rescale Slope is empty");
}
}
* \warning to be used with GetImagePixels()
* @return 1 if Gray level, 3 if Color (RGB, YBR or PALETTE COLOR)
*/
-int gdcmHeader::GetNumberOfScalarComponents()
+int Header::GetNumberOfScalarComponents()
{
if ( GetSamplesPerPixel() == 3 )
{
* \warning to be used with GetImagePixelsRaw()
* @return 1 if Gray level, 3 if Color (RGB or YBR - NOT 'PALETTE COLOR' -)
*/
-int gdcmHeader::GetNumberOfScalarComponentsRaw()
+int Header::GetNumberOfScalarComponentsRaw()
{
// 0028 0100 US IMG Bits Allocated
// (in order no to be messed up by old RGB images)
- if ( gdcmHeader::GetEntryByNumber(0x0028,0x0100) == "24" )
+ if ( Header::GetEntryByNumber(0x0028,0x0100) == "24" )
{
return 3;
}
* else 0.
* @return up-left image corner X position
*/
-float gdcmHeader::GetXOrigin()
+float Header::GetXOrigin()
{
float xImPos, yImPos, zImPos;
std::string strImPos = GetEntryByNumber(0x0020,0x0032);
if ( strImPos == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image "
+ dbg.Verbose(0, "Header::GetXImagePosition: unfound Image "
"Position Patient (0020,0032)");
strImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
if ( strImPos == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image "
+ dbg.Verbose(0, "Header::GetXImagePosition: unfound Image "
"Position (RET) (0020,0030)");
/// \todo How to tell the caller nothing was found ?
return 0.;
* else 0.
* @return up-left image corner Y position
*/
-float gdcmHeader::GetYOrigin()
+float Header::GetYOrigin()
{
float xImPos, yImPos, zImPos;
std::string strImPos = GetEntryByNumber(0x0020,0x0032);
if ( strImPos == GDCM_UNFOUND)
{
- dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image "
+ dbg.Verbose(0, "Header::GetYImagePosition: unfound Image "
"Position Patient (0020,0032)");
strImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
if ( strImPos == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image "
+ dbg.Verbose(0, "Header::GetYImagePosition: unfound Image "
"Position (RET) (0020,0030)");
/// \todo How to tell the caller nothing was found ?
return 0.;
* else 0.
* @return up-left image corner Z position
*/
-float gdcmHeader::GetZOrigin()
+float Header::GetZOrigin()
{
float xImPos, yImPos, zImPos;
std::string strImPos = GetEntryByNumber(0x0020,0x0032);
{
if( sscanf( strImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
{
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Image "
+ dbg.Verbose(0, "Header::GetZImagePosition: wrong Image "
"Position Patient (0020,0032)");
return 0.; // bug in the element 0x0020,0x0032
}
if( sscanf( strImPos.c_str(),
"%f\\%f\\%f", &xImPos, &yImPos, &zImPos ) != 3 )
{
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Image Position (RET) (0020,0030)");
+ dbg.Verbose(0, "Header::GetZImagePosition: wrong Image Position (RET) (0020,0030)");
return 0.; // bug in the element 0x0020,0x0032
}
else
{
if( sscanf( strSliceLocation.c_str(), "%f", &zImPos) != 1)
{
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Slice Location (0020,1041)");
+ dbg.Verbose(0, "Header::GetZImagePosition: wrong Slice Location (0020,1041)");
return 0.; // bug in the element 0x0020,0x1041
}
else
return zImPos;
}
}
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: unfound Slice Location (0020,1041)");
+ dbg.Verbose(0, "Header::GetZImagePosition: unfound Slice Location (0020,1041)");
std::string strLocation = GetEntryByNumber(0x0020,0x0050);
if ( strLocation != GDCM_UNFOUND )
{
if( sscanf( strLocation.c_str(), "%f", &zImPos) != 1)
{
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Location (0020,0050)");
+ dbg.Verbose(0, "Header::GetZImagePosition: wrong Location (0020,0050)");
return 0.; // bug in the element 0x0020,0x0050
}
else
return zImPos;
}
}
- dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Location (0020,0050)");
+ dbg.Verbose(0, "Header::GetYImagePosition: unfound Location (0020,0050)");
return 0.; // Hopeless
}
* \brief gets the info from 0020,0013 : Image Number else 0.
* @return image number
*/
-int gdcmHeader::GetImageNumber()
+int Header::GetImageNumber()
{
// The function i atoi() takes the address of an area of memory as
// parameter and converts the string stored at that location to an integer
* \brief gets the info from 0008,0060 : Modality
* @return Modality Type
*/
-ModalityType gdcmHeader::GetModality()
+ModalityType Header::GetModality()
{
// 0008 0060 CS ID Modality
std::string strModality = GetEntryByNumber(0x0008,0x0060);
* @return The encountered number of Bits Stored, 0 by default.
* 0 means the file is NOT USABLE. The caller has to check it !
*/
-int gdcmHeader::GetBitsStored()
+int Header::GetBitsStored()
{
std::string strSize = GetEntryByNumber( 0x0028, 0x0101 );
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetBitsStored: this is supposed to "
+ dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
"be mandatory");
return 0; // It's supposed to be mandatory
// the caller will have to check
* The responsability of checking this value is left to the caller.
* @return The high bit positin when present. 0 when absent.
*/
-int gdcmHeader::GetHighBitPosition()
+int Header::GetHighBitPosition()
{
std::string strSize = GetEntryByNumber( 0x0028, 0x0102 );
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetHighBitPosition: this is supposed "
+ dbg.Verbose(0, "Header::GetHighBitPosition: this is supposed "
"to be mandatory");
return 0;
}
* The responsability of checking this value is left to the caller.
* @return True when signed, false when UNsigned
*/
-bool gdcmHeader::IsSignedPixelData()
+bool Header::IsSignedPixelData()
{
std::string strSize = GetEntryByNumber( 0x0028, 0x0103 );
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::IsSignedPixelData: this is supposed "
+ dbg.Verbose(0, "Header::IsSignedPixelData: this is supposed "
"to be mandatory");
return false;
}
* @return The encountered number of Bits Allocated, 0 by default.
* 0 means the file is NOT USABLE. The caller has to check it !
*/
-int gdcmHeader::GetBitsAllocated()
+int Header::GetBitsAllocated()
{
std::string strSize = GetEntryByNumber(0x0028,0x0100);
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetBitsStored: this is supposed to "
+ dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
"be mandatory");
return 0; // It's supposed to be mandatory
// the caller will have to check
* @return The encountered number of Samples Per Pixel, 1 by default.
* (Gray level Pixels)
*/
-int gdcmHeader::GetSamplesPerPixel()
+int Header::GetSamplesPerPixel()
{
std::string strSize = GetEntryByNumber(0x0028,0x0002);
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetBitsStored: this is supposed to "
+ dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
"be mandatory");
return 1; // Well, it's supposed to be mandatory ...
// but sometimes it's missing : *we* assume Gray pixels
* the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
* @return true when "MONOCHROME1" or "MONOCHROME2". False otherwise.
*/
-bool gdcmHeader::IsMonochrome()
+bool Header::IsMonochrome()
{
std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
if ( PhotometricInterp == "MONOCHROME1 "
}
if ( PhotometricInterp == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::IsMonochrome: absent Photometric "
+ dbg.Verbose(0, "Header::IsMonochrome: absent Photometric "
"Interpretation");
}
return false;
* the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
* @return true when "PALETTE COLOR". False otherwise.
*/
-bool gdcmHeader::IsPaletteColor()
+bool Header::IsPaletteColor()
{
std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
if ( PhotometricInterp == "PALETTE COLOR " )
}
if ( PhotometricInterp == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::IsPaletteColor: absent Photometric "
+ dbg.Verbose(0, "Header::IsPaletteColor: absent Photometric "
"Interpretation");
}
return false;
* the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
* @return true when "YBR_FULL". False otherwise.
*/
-bool gdcmHeader::IsYBRFull()
+bool Header::IsYBRFull()
{
std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
if ( PhotometricInterp == "YBR_FULL" )
}
if ( PhotometricInterp == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::IsYBRFull: absent Photometric "
+ dbg.Verbose(0, "Header::IsYBRFull: absent Photometric "
"Interpretation");
}
return false;
* (0 : RGB Pixels , 1 : R Plane + G Plane + B Plane)
* @return The encountered Planar Configuration, 0 by default.
*/
-int gdcmHeader::GetPlanarConfiguration()
+int Header::GetPlanarConfiguration()
{
std::string strSize = GetEntryByNumber(0x0028,0x0006);
if ( strSize == GDCM_UNFOUND )
* @return The size in bytes of a single pixel of data; 0 by default
* 0 means the file is NOT USABLE; the caller will have to check
*/
-int gdcmHeader::GetPixelSize()
+int Header::GetPixelSize()
{
// 0028 0100 US IMG Bits Allocated
// (in order no to be messed up by old RGB images)
- // if (gdcmHeader::GetEntryByNumber(0x0028,0x0100) == "24")
+ // if (Header::GetEntryByNumber(0x0028,0x0100) == "24")
// return 3;
std::string pixelType = GetPixelType();
{
return 8;
}
- dbg.Verbose(0, "gdcmHeader::GetPixelSize: Unknown pixel type");
+ dbg.Verbose(0, "Header::GetPixelSize: Unknown pixel type");
return 0;
}
* 24 bit images appear as 8 bit
* @return 0S if nothing found. NOT USABLE file. The caller has to check
*/
-std::string gdcmHeader::GetPixelType()
+std::string Header::GetPixelType()
{
std::string bitsAlloc = GetEntryByNumber(0x0028, 0x0100); // Bits Allocated
if ( bitsAlloc == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Bits Allocated");
+ dbg.Verbose(0, "Header::GetPixelType: unfound Bits Allocated");
bitsAlloc = "16";
}
if (sign == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Pixel Representation");
+ dbg.Verbose(0, "Header::GetPixelType: unfound Pixel Representation");
bitsAlloc = "0";
}
if ( sign == "0" )
* of *image* pixels (not *icone image* pixels, if any !)
* @return Pixel Offset
*/
-size_t gdcmHeader::GetPixelOffset()
+size_t Header::GetPixelOffset()
{
- gdcmDocEntry* pxlElement = GetDocEntryByNumber(GrPixel,NumPixel);
+ DocEntry* pxlElement = GetDocEntryByNumber(GrPixel,NumPixel);
if ( pxlElement )
{
return pxlElement->GetOffset();
* -in case of embeded compressed image-)
* 0 : NOT USABLE file. The caller has to check.
*/
-size_t gdcmHeader::GetPixelAreaLength()
+size_t Header::GetPixelAreaLength()
{
- gdcmDocEntry* pxlElement = GetDocEntryByNumber(GrPixel,NumPixel);
+ DocEntry* pxlElement = GetDocEntryByNumber(GrPixel,NumPixel);
if ( pxlElement )
{
return pxlElement->GetLength();
* Please warn me if you know sbdy that *does* know ... jprx
* @return true if LUT Descriptors and LUT Tables were found
*/
-bool gdcmHeader::HasLUT()
+bool Header::HasLUT()
{
// Check the presence of the LUT Descriptors, and LUT Tables
// LutDescriptorRed
* when (0028,0004),Photometric Interpretation = [PALETTE COLOR ]
* @ return bit number of each LUT item
*/
-int gdcmHeader::GetLUTNbits()
+int Header::GetLUTNbits()
{
std::vector<std::string> tokens;
int lutNbits;
}
tokens.clear(); // clean any previous value
- Tokenize ( lutDescription, tokens, "\\" );
+ Util::Tokenize ( lutDescription, tokens, "\\" );
//LutLength=atoi(tokens[0].c_str());
//LutDepth=atoi(tokens[1].c_str());
}
/**
- * \brief builts Red/Green/Blue/Alpha LUT from Header
- * when (0028,0004),Photometric Interpretation = [PALETTE COLOR ]
- * and (0028,1101),(0028,1102),(0028,1102)
- * - xxx Palette Color Lookup Table Descriptor - are found
- * and (0028,1201),(0028,1202),(0028,1202)
- * - xxx Palette Color Lookup Table Data - are found
- * \warning does NOT deal with :
- * 0028 1100 Gray Lookup Table Descriptor (Retired)
- * 0028 1221 Segmented Red Palette Color Lookup Table Data
- * 0028 1222 Segmented Green Palette Color Lookup Table Data
- * 0028 1223 Segmented Blue Palette Color Lookup Table Data
- * no known Dicom reader deals with them :-(
- * @return a RGBA Lookup Table
- */
-uint8_t* gdcmHeader::GetLUTRGBA()
-{
- // Not so easy : see
- // http://www.barre.nom.fr/medical/dicom2/limitations.html#Color%20Lookup%20Tables
-
-// if Photometric Interpretation # PALETTE COLOR, no LUT to be done
- if ( GetEntryByNumber(0x0028,0x0004) != "PALETTE COLOR " )
- {
- return NULL;
- }
-
- int lengthR, debR, nbitsR;
- int lengthG, debG, nbitsG;
- int lengthB, debB, nbitsB;
-
- // Get info from Lut Descriptors
- // (the 3 LUT descriptors may be different)
- std::string lutDescriptionR = GetEntryByNumber(0x0028,0x1101);
- if ( lutDescriptionR == GDCM_UNFOUND )
- {
- return NULL;
- }
-
- std::string lutDescriptionG = GetEntryByNumber(0x0028,0x1102);
- if ( lutDescriptionG == GDCM_UNFOUND )
- {
- return NULL;
- }
-
- std::string lutDescriptionB = GetEntryByNumber(0x0028,0x1103);
- if ( lutDescriptionB == GDCM_UNFOUND )
- {
- return NULL;
- }
-
- // lengthR: Red LUT length in Bytes
- // debR: subscript of the first Lut Value
- // nbitsR: Lut item size (in Bits)
- int nbRead = sscanf( lutDescriptionR.c_str(), "%d\\%d\\%d",
- &lengthR, &debR, &nbitsR );
- if( nbRead != 3 )
- {
- dbg.Verbose(0, "gdcmHeader::GetLUTRGBA: trouble reading red LUT");
- }
-
- // lengthG: Green LUT length in Bytes
- // debG: subscript of the first Lut Value
- // nbitsG: Lut item size (in Bits)
- nbRead = sscanf( lutDescriptionG.c_str(), "%d\\%d\\%d",
- &lengthG, &debG, &nbitsG );
- if( nbRead != 3 )
- {
- dbg.Verbose(0, "gdcmHeader::GetLUTRGBA: trouble reading green LUT");
- }
-
- // lengthB: Blue LUT length in Bytes
- // debB: subscript of the first Lut Value
- // nbitsB: Lut item size (in Bits)
- nbRead = sscanf( lutDescriptionB.c_str(), "%d\\%d\\%d",
- &lengthB, &debB, &nbitsB );
- if( nbRead != 3 )
- {
- dbg.Verbose(0, "gdcmHeader::GetLUTRGBA: trouble reading blue LUT");
- }
-
- // Load LUTs into memory, (as they were stored on disk)
- uint8_t* lutR = (uint8_t*) GetEntryBinAreaByNumber(0x0028,0x1201);
- uint8_t* lutG = (uint8_t*) GetEntryBinAreaByNumber(0x0028,0x1202);
- uint8_t* lutB = (uint8_t*) GetEntryBinAreaByNumber(0x0028,0x1203);
-
- if ( !lutR || !lutG || !lutB )
- {
- dbg.Verbose(0, "gdcmHeader::GetLUTRGBA: trouble with one of the LUT");
- return NULL;
- }
- // forge the 4 * 8 Bits Red/Green/Blue/Alpha LUT
-
- uint8_t* LUTRGBA = new uint8_t[1024]; // 256 * 4 (R, G, B, Alpha)
- if ( !LUTRGBA )
- {
- return NULL;
- }
- memset(LUTRGBA, 0, 1024);
-
- // Bits Allocated
- int nb;
- std::string str_nb = GetEntryByNumber(0x0028,0x0100);
- if ( str_nb == GDCM_UNFOUND )
- {
- nb = 16;
- }
- else
- {
- nb = atoi( str_nb.c_str() );
- }
- int mult;
-
- if ( nbitsR == 16 && nb == 8)
- {
- // when LUT item size is different than pixel size
- mult = 2; // high byte must be = low byte
- }
- else
- {
- // See PS 3.3-2003 C.11.1.1.2 p 619
- mult = 1;
- }
-
- // if we get a black image, let's just remove the '+1'
- // from 'i*mult+1' and check again
- // if it works, we shall have to check the 3 Palettes
- // to see which byte is ==0 (first one, or second one)
- // and fix the code
- // We give up the checking to avoid some (useless ?)overhead
- // (optimistic asumption)
- uint8_t* a;
- int i;
-
- a = LUTRGBA + 0;
- for( i=0; i < lengthR; ++i)
- {
- *a = lutR[i*mult+1];
- a += 4;
- }
-
- a = LUTRGBA + 1;
- for( i=0; i < lengthG; ++i)
- {
- *a = lutG[i*mult+1];
- a += 4;
- }
-
- a = LUTRGBA + 2;
- for(i=0; i < lengthB; ++i)
- {
- *a = lutB[i*mult+1];
- a += 4;
- }
-
- a = LUTRGBA + 3;
- for(i=0; i < 256; ++i)
- {
- *a = 1; // Alpha component
- a += 4;
- }
- return LUTRGBA;
-}
-
-/**
- * \brief Accesses the info from 0002,0010 : Transfert Syntax and gdcmTS
+ * \brief Accesses the info from 0002,0010 : Transfert Syntax and TS
* else 1.
* @return The full Transfert Syntax Name (as opposed to Transfert Syntax UID)
*/
-std::string gdcmHeader::GetTransfertSyntaxName()
+std::string Header::GetTransfertSyntaxName()
{
- // use the gdcmTS (TS : Transfert Syntax)
+ // use the TS (TS : Transfert Syntax)
std::string transfertSyntax = GetEntryByNumber(0x0002,0x0010);
if ( transfertSyntax == GDCM_NOTLOADED )
}
if ( transfertSyntax == GDCM_UNFOUND )
{
- dbg.Verbose(0, "gdcmHeader::GetTransfertSyntaxName:"
+ dbg.Verbose(0, "Header::GetTransfertSyntaxName:"
" unfound Transfert Syntax (0002,0010)");
return "Uncompressed ACR-NEMA";
}
transfertSyntax.erase(transfertSyntax.length()-1, 1);
}
// we do it only when we need it
- gdcmTS* ts = gdcmGlobal::GetTS();
+ TS* ts = Global::GetTS();
std::string tsName = ts->GetValue( transfertSyntax );
//delete ts; /// \todo Seg Fault when deleted ?!
* @param ImageDataSize new Pixel Area Size
* warning : nothing else is checked
*/
-void gdcmHeader::SetImageDataSize(size_t ImageDataSize)
+void Header::SetImageDataSize(size_t ImageDataSize)
{
- char car[20];
- sprintf(car,"%d",ImageDataSize);
+ ///FIXME I don't understand this code wh ydo we set two times 'car' ?
+ std::string car = Util::Format("%d", ImageDataSize);
- gdcmDocEntry *a = GetDocEntryByNumber(GrPixel, NumPixel);
+ DocEntry *a = GetDocEntryByNumber(GrPixel, NumPixel);
a->SetLength(ImageDataSize);
ImageDataSize += 8;
- sprintf(car,"%d",ImageDataSize);
+ car = Util::Format("%d", ImageDataSize);
- const std::string content1 = car;
- SetEntryByNumber(content1, GrPixel, NumPixel);
+ SetEntryByNumber(car, GrPixel, NumPixel);
}
//-----------------------------------------------------------------------------
* \brief anonymize a Header (removes Patient's personal info)
* (read the code to see which ones ...)
*/
-bool gdcmHeader::AnonymizeHeader()
+bool Header::AnonymizeHeader()
{
// If exist, replace by spaces
SetEntryByNumber (" ",0x0010, 0x2154); // Telephone
SetEntryByNumber (" ",0x0010, 0x1040); // Adress
SetEntryByNumber (" ",0x0010, 0x0020); // Patient ID
- gdcmDocEntry* patientNameHE = GetDocEntryByNumber (0x0010, 0x0010);
+ DocEntry* patientNameHE = GetDocEntryByNumber (0x0010, 0x0010);
if ( patientNameHE ) // we replace it by Study Instance UID (why not)
{
* @param iop adress of the (6)float aray to receive values
* @return cosines of image orientation patient
*/
-void gdcmHeader::GetImageOrientationPatient( float iop[6] )
+void Header::GetImageOrientationPatient( float iop[6] )
{
std::string strImOriPat;
//iop is supposed to be float[6]
if( sscanf( strImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f",
&iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6 )
{
- dbg.Verbose(0, "gdcmHeader::GetImageOrientationPatient: "
+ dbg.Verbose(0, "Header::GetImageOrientationPatient: "
"wrong Image Orientation Patient (0020,0037)");
}
}
if( sscanf( strImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f",
&iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6 )
{
- dbg.Verbose(0, "gdcmHeader::GetImageOrientationPatient: "
+ dbg.Verbose(0, "Header::GetImageOrientationPatient: "
"wrong Image Orientation Patient (0020,0035)");
}
}
// Private
//-----------------------------------------------------------------------------
+
+} // end namespace gdcm
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff