Program: gdcm
Module: $RCSfile: gdcmHeader.cxx,v $
Language: C++
- Date: $Date: 2004/10/12 04:35:46 $
- Version: $Revision: 1.193 $
+ Date: $Date: 2005/01/17 11:13:21 $
+ Version: $Revision: 1.233 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include "gdcmDebug.h"
#include "gdcmTS.h"
#include "gdcmValEntry.h"
+#include "gdcmBinEntry.h"
+#include <stdio.h> //sscanf
#include <vector>
namespace gdcm
{
-
//-----------------------------------------------------------------------------
// Constructor / Destructor
/**
* \brief Constructor
* @param filename name of the file whose header we want to analyze
*/
-Header::Header( std::string const & filename ):
+Header::Header( std::string const &filename ):
Document( filename )
{
// for some ACR-NEMA images GrPixel, NumPixel is *not* 7fe0,0010
// is found by indirection through the "Image Location").
// Inside the group pointed by "Image Location" the searched element
// is conventionally the element 0x0010 (when the norm is respected).
- // When the "Image Location" is absent we default to group 0x7fe0.
+ // When the "Image Location" is Missing we default to group 0x7fe0.
// Note: this IS the right place for the code
// Image Location
- std::string imgLocation = GetEntryByNumber(0x0028, 0x0200);
+ const std::string &imgLocation = GetEntry(0x0028, 0x0200);
if ( imgLocation == GDCM_UNFOUND )
{
// default value
{
NumPixel = 0x0010;
}
+
+ // Now, we know GrPixel and NumPixel.
+ // Let's create a VirtualDictEntry to allow a further VR modification
+ // and force VR to match with BitsAllocated.
+
+ DocEntry *entry = GetDocEntry(GrPixel, NumPixel);
+ if ( entry != 0 )
+ {
+
+ std::string PixelVR;
+ // 8 bits allocated is a 'O Bytes' , as well as 24 (old ACR-NEMA RGB)
+ // more than 8 (i.e 12, 16) is a 'O Words'
+ if ( GetBitsAllocated() == 8 || GetBitsAllocated() == 24 )
+ PixelVR = "OB";
+ else
+ PixelVR = "OW";
+
+ DictEntry* newEntry = NewVirtualDictEntry(
+ GrPixel, NumPixel,
+ PixelVR, "PXL", "Pixel Data");
+
+ entry->SetDictEntry( newEntry );
+ }
}
/**
- * \brief Constructor
+ * \brief Constructor used when we want to generate dicom files from scratch
*/
Header::Header()
:Document()
{
+ InitializeDefaultHeader();
}
/**
{
}
-
/**
* \brief Performs some consistency checking on various 'File related'
* (as opposed to 'DicomDir related') entries
* then writes in a file all the (Dicom Elements) included the Pixels
- * @param fp file pointer on an already open file
+ * @param fileName file name to write to
* @param filetype Type of the File to be written
* (ACR-NEMA, ExplicitVR, ImplicitVR)
*/
-void Header::Write(FILE* fp,FileType filetype)
+bool Header::Write(std::string fileName, FileType filetype)
{
+ std::ofstream *fp = new std::ofstream(fileName.c_str(),
+ std::ios::out | std::ios::binary);
+ if (*fp == NULL)
+ {
+ gdcmVerboseMacro("Failed to open (write) File: " << fileName.c_str());
+ return false;
+ }
+
// Bits Allocated
- if ( GetEntryByNumber(0x0028,0x0100) == "12")
+ if ( GetEntry(0x0028,0x0100) == "12")
{
- SetEntryByNumber("16", 0x0028,0x0100);
+ SetEntry("16", 0x0028,0x0100);
}
/// \todo correct 'Pixel group' Length if necessary
- int i_lgPix = GetEntryLengthByNumber(GrPixel, NumPixel);
+ int i_lgPix = GetEntryLength(GrPixel, NumPixel);
if (i_lgPix != -2)
{
// no (GrPixel, NumPixel) element
- std::string s_lgPix;
- s_lgPix = Util::Format("%d", i_lgPix+12);
- ReplaceOrCreateByNumber(s_lgPix,GrPixel, 0x0000);
+ std::string s_lgPix = Util::Format("%d", i_lgPix+12);
+ s_lgPix = Util::DicomString( s_lgPix.c_str() );
+ ReplaceOrCreate(s_lgPix,GrPixel, 0x0000);
}
// FIXME : should be nice if we could move it to File
// Drop Palette Color, if necessary
- if ( GetEntryByNumber(0x0028,0x0002).c_str()[0] == '3' )
+ if ( GetEntry(0x0028,0x0002).c_str()[0] == '3' )
{
// if SamplesPerPixel = 3, sure we don't need any LUT !
// Drop 0028|1101, 0028|1102, 0028|1103
// Drop 0028|1201, 0028|1202, 0028|1203
- DocEntry* e = GetDocEntryByNumber(0x0028,0x01101);
+ DocEntry *e = GetDocEntry(0x0028,0x01101);
if (e)
{
RemoveEntryNoDestroy(e);
}
- e = GetDocEntryByNumber(0x0028,0x1102);
+ e = GetDocEntry(0x0028,0x1102);
if (e)
{
RemoveEntryNoDestroy(e);
}
- e = GetDocEntryByNumber(0x0028,0x1103);
+ e = GetDocEntry(0x0028,0x1103);
if (e)
{
RemoveEntryNoDestroy(e);
}
- e = GetDocEntryByNumber(0x0028,0x01201);
+ e = GetDocEntry(0x0028,0x01201);
if (e)
{
RemoveEntryNoDestroy(e);
}
- e = GetDocEntryByNumber(0x0028,0x1202);
+ e = GetDocEntry(0x0028,0x1202);
if (e)
{
RemoveEntryNoDestroy(e);
}
- e = GetDocEntryByNumber(0x0028,0x1203);
+ e = GetDocEntry(0x0028,0x1203);
if (e)
{
RemoveEntryNoDestroy(e);
}
}
- Document::Write(fp,filetype);
+
+/*
+#ifdef GDCM_WORDS_BIGENDIAN
+ // Super Super hack that will make gdcm a BOMB ! but should
+ // Fix temporarily the dashboard
+ BinEntry *b = GetBinEntry(GrPixel,NumPixel);
+ if ( GetPixelSize() == 16 )
+ {
+ uint16_t *im16 = (uint16_t*)b->GetBinArea();
+ int lgr = b->GetLength();
+ for( int i = 0; i < lgr / 2; i++ )
+ {
+ im16[i]= (im16[i] >> 8) | (im16[i] << 8 );
+ }
+ }
+#endif //GDCM_WORDS_BIGENDIAN
+*/
+
+ Document::WriteContent(fp,filetype);
+
+/*
+#ifdef GDCM_WORDS_BIGENDIAN
+ // Flip back the pixel ... I told you this is a hack
+ if ( GetPixelSize() == 16 )
+ {
+ uint16_t *im16 = (uint16_t*)b->GetBinArea();
+ int lgr = b->GetLength();
+ for( int i = 0; i < lgr / 2; i++ )
+ {
+ im16[i]= (im16[i] >> 8) | (im16[i] << 8 );
+ }
+ }
+#endif //GDCM_WORDS_BIGENDIAN
+*/
+
+ fp->close();
+ delete fp;
+
+ return true;
}
//-----------------------------------------------------------------------------
return false;
}
- std::string res = GetEntryByNumber(0x0028, 0x0005);
+ const std::string &res = GetEntry(0x0028, 0x0005);
if ( res != GDCM_UNFOUND && atoi(res.c_str()) > 4 )
{
return false; // Image Dimensions
}
- if ( !GetDocEntryByNumber(0x0028, 0x0100) )
+ if ( !GetDocEntry(0x0028, 0x0100) )
{
return false; // "Bits Allocated"
}
- if ( !GetDocEntryByNumber(0x0028, 0x0101) )
+ if ( !GetDocEntry(0x0028, 0x0101) )
{
return false; // "Bits Stored"
}
- if ( !GetDocEntryByNumber(0x0028, 0x0102) )
+ if ( !GetDocEntry(0x0028, 0x0102) )
{
return false; // "High Bit"
}
- if ( !GetDocEntryByNumber(0x0028, 0x0103) )
+ if ( !GetDocEntry(0x0028, 0x0103) )
{
return false; // "Pixel Representation" i.e. 'Sign'
}
*/
int Header::GetXSize()
{
- std::string strSize;
- strSize = GetEntryByNumber(0x0028,0x0011);
+ const std::string &strSize = GetEntry(0x0028,0x0011);
if ( strSize == GDCM_UNFOUND )
{
return 0;
*/
int Header::GetYSize()
{
- std::string strSize = GetEntryByNumber(0x0028,0x0010);
+ const std::string &strSize = GetEntry(0x0028,0x0010);
if ( strSize != GDCM_UNFOUND )
{
return atoi( strSize.c_str() );
}
// The Rows (0028,0010) entry was optional for ACR/NEMA. It might
- // hence be a signal (1d image). So we default to 1:
+ // hence be a signal (1D image). So we default to 1:
return 1;
}
* \brief Retrieve the number of planes of volume or the number
* of frames of a multiframe.
* \warning When present we consider the "Number of Frames" as the third
- * dimension. When absent we consider the third dimension as
+ * dimension. When Missing we consider the third dimension as
* being the ACR-NEMA "Planes" tag content.
* @return The encountered size when found, 1 by default (single image).
*/
{
// Both DicomV3 and ACR/Nema consider the "Number of Frames"
// as the third dimension.
- std::string strSize = GetEntryByNumber(0x0028,0x0008);
+ const std::string &strSize = GetEntry(0x0028,0x0008);
if ( strSize != GDCM_UNFOUND )
{
return atoi( strSize.c_str() );
}
// We then consider the "Planes" entry as the third dimension
- strSize = GetEntryByNumber(0x0028,0x0012);
- if ( strSize != GDCM_UNFOUND )
+ const std::string &strSize2 = GetEntry(0x0028,0x0012);
+ if ( strSize2 != GDCM_UNFOUND )
{
- return atoi( strSize.c_str() );
+ return atoi( strSize2.c_str() );
}
return 1;
float Header::GetXSpacing()
{
float xspacing, yspacing;
- std::string strSpacing = GetEntryByNumber(0x0028,0x0030);
+ const std::string &strSpacing = GetEntry(0x0028,0x0030);
if ( strSpacing == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetXSpacing: unfound Pixel Spacing (0028,0030)");
+ gdcmVerboseMacro( "Unfound Pixel Spacing (0028,0030)" );
return 1.;
}
// if single value is found, xspacing is defaulted to yspacing
if ( nbValues == 1 )
{
- return yspacing;
+ xspacing = yspacing;
}
+
+ if ( xspacing == 0.0 )
+ xspacing = 1.0;
+
+ return xspacing;
+
}
+
+ // to avoid troubles with David Clunie's-like images
+ if ( xspacing == 0. && yspacing == 0.)
+ return 1.;
+
if ( xspacing == 0.)
{
- dbg.Verbose(0, "Header::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
+ gdcmVerboseMacro("gdcmData/CT-MONO2-8-abdo.dcm problem");
// seems to be a bug in the header ...
- sscanf( strSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing);
+ nbValues = sscanf( strSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing);
+ gdcmAssertMacro( nbValues == 2 );
}
return xspacing;
*/
float Header::GetYSpacing()
{
- float yspacing = 0;
- std::string strSpacing = GetEntryByNumber(0x0028,0x0030);
+ float yspacing = 1.;
+ std::string strSpacing = GetEntry(0x0028,0x0030);
if ( strSpacing == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetYSpacing: unfound Pixel Spacing (0028,0030)");
+ gdcmVerboseMacro("Unfound Pixel Spacing (0028,0030)");
return 1.;
}
// if sscanf cannot read any float value, it won't affect yspacing
sscanf( strSpacing.c_str(), "%f", &yspacing);
+ if ( yspacing == 0.0 )
+ yspacing = 1.0;
+
return yspacing;
}
/**
* \brief gets the info from 0018,0088 : Space Between Slices
- * else from 0018,0050 : Slice Thickness
- * else 1.0
+ * else from 0018,0050 : Slice Thickness
+ * else 1.0
* @return Z dimension of a voxel-to be
*/
float Header::GetZSpacing()
// disjointes (Spacing between Slices > Slice Thickness)
// Slice Thickness : epaisseur de tissus sur laquelle est acquis le signal
// ca interesse le physicien de l'IRM, pas le visualisateur de volumes ...
- // Si le Spacing Between Slices est absent,
+ // Si le Spacing Between Slices est Missing,
// on suppose que les coupes sont jointives
- std::string strSpacingBSlices = GetEntryByNumber(0x0018,0x0088);
+ const std::string &strSpacingBSlices = GetEntry(0x0018,0x0088);
if ( strSpacingBSlices == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetZSpacing: unfound StrSpacingBSlices");
- std::string strSliceThickness = GetEntryByNumber(0x0018,0x0050);
+ gdcmVerboseMacro("Unfound Spacing Between Slices (0018,0088)");
+ const std::string &strSliceThickness = GetEntry(0x0018,0x0050);
if ( strSliceThickness == GDCM_UNFOUND )
{
+ gdcmVerboseMacro("Unfound Slice Thickness (0018,0050)");
return 1.;
}
else
// we assume slices join together
// (no overlapping, no interslice gap)
// if they don't, we're fucked up
- return atof( strSliceThickness.c_str() );
+ return (float)atof( strSliceThickness.c_str() );
}
}
- else
- {
- return atof( strSpacingBSlices.c_str() );
- }
+ //else
+ return (float)atof( strSpacingBSlices.c_str() );
}
/**
{
float resInter = 0.;
/// 0028 1052 DS IMG Rescale Intercept
- std::string strRescInter = GetEntryByNumber(0x0028,0x1052);
+ const std::string &strRescInter = GetEntry(0x0028,0x1052);
if ( strRescInter != GDCM_UNFOUND )
{
if( sscanf( strRescInter.c_str(), "%f", &resInter) != 1 )
{
// bug in the element 0x0028,0x1052
- dbg.Verbose(0, "Header::GetRescaleIntercept: Rescale Slope "
- "is empty");
+ gdcmVerboseMacro( "Rescale Intercept (0028,1052) is empty." );
}
}
{
float resSlope = 1.;
//0028 1053 DS IMG Rescale Slope
- std::string strRescSlope = GetEntryByNumber(0x0028,0x1053);
+ std::string strRescSlope = GetEntry(0x0028,0x1053);
if ( strRescSlope != GDCM_UNFOUND )
{
if( sscanf( strRescSlope.c_str(), "%f", &resSlope) != 1)
{
// bug in the element 0x0028,0x1053
- dbg.Verbose(0, "Header::GetRescaleSlope: Rescale Slope is empty");
+ gdcmVerboseMacro( "Rescale Slope (0028,1053) is empty.");
}
}
// 0028 0100 US IMG Bits Allocated
// (in order no to be messed up by old RGB images)
- if ( GetEntryByNumber(0x0028,0x0100) == "24" )
+ if ( GetEntry(0x0028,0x0100) == "24" )
{
return 3;
}
- std::string strPhotometricInterpretation = GetEntryByNumber(0x0028,0x0004);
+ std::string strPhotometricInterpretation = GetEntry(0x0028,0x0004);
if ( ( strPhotometricInterpretation == "PALETTE COLOR ") )
{
// beware of trailing space at end of string
// DICOM tags are never of odd length
if ( strPhotometricInterpretation == GDCM_UNFOUND ||
- strPhotometricInterpretation == "MONOCHROME1 " ||
- strPhotometricInterpretation == "MONOCHROME2 " )
+ Util::DicomStringEqual(strPhotometricInterpretation, "MONOCHROME1") ||
+ Util::DicomStringEqual(strPhotometricInterpretation, "MONOCHROME2") )
{
return 1;
}
{
// 0028 0100 US IMG Bits Allocated
// (in order no to be messed up by old RGB images)
- if ( Header::GetEntryByNumber(0x0028,0x0100) == "24" )
+ if ( Header::GetEntry(0x0028,0x0100) == "24" )
{
return 3;
}
float Header::GetXOrigin()
{
float xImPos, yImPos, zImPos;
- std::string strImPos = GetEntryByNumber(0x0020,0x0032);
+ std::string strImPos = GetEntry(0x0020,0x0032);
if ( strImPos == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetXImagePosition: unfound Image "
- "Position Patient (0020,0032)");
- strImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
+ gdcmVerboseMacro( "Unfound Image Position Patient (0020,0032)");
+ strImPos = GetEntry(0x0020,0x0030); // For ACR-NEMA images
if ( strImPos == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetXImagePosition: unfound Image "
- "Position (RET) (0020,0030)");
+ gdcmVerboseMacro( "Unfound Image Position (RET) (0020,0030)");
/// \todo How to tell the caller nothing was found ?
return 0.;
}
float Header::GetYOrigin()
{
float xImPos, yImPos, zImPos;
- std::string strImPos = GetEntryByNumber(0x0020,0x0032);
+ std::string strImPos = GetEntry(0x0020,0x0032);
if ( strImPos == GDCM_UNFOUND)
{
- dbg.Verbose(0, "Header::GetYImagePosition: unfound Image "
- "Position Patient (0020,0032)");
- strImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
+ gdcmVerboseMacro( "Unfound Image Position Patient (0020,0032)");
+ strImPos = GetEntry(0x0020,0x0030); // For ACR-NEMA images
if ( strImPos == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetYImagePosition: unfound Image "
- "Position (RET) (0020,0030)");
+ gdcmVerboseMacro( "Unfound Image Position (RET) (0020,0030)");
/// \todo How to tell the caller nothing was found ?
return 0.;
}
float Header::GetZOrigin()
{
float xImPos, yImPos, zImPos;
- std::string strImPos = GetEntryByNumber(0x0020,0x0032);
+ std::string strImPos = GetEntry(0x0020,0x0032);
if ( strImPos != GDCM_UNFOUND )
{
if( sscanf( strImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
{
- dbg.Verbose(0, "Header::GetZImagePosition: wrong Image "
- "Position Patient (0020,0032)");
+ gdcmVerboseMacro( "Wrong Image Position Patient (0020,0032)");
return 0.; // bug in the element 0x0020,0x0032
}
else
}
}
- strImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
+ strImPos = GetEntry(0x0020,0x0030); // For ACR-NEMA images
if ( strImPos != GDCM_UNFOUND )
{
if( sscanf( strImPos.c_str(),
"%f\\%f\\%f", &xImPos, &yImPos, &zImPos ) != 3 )
{
- dbg.Verbose(0, "Header::GetZImagePosition: wrong Image Position (RET) (0020,0030)");
+ gdcmVerboseMacro( "Wrong Image Position (RET) (0020,0030)");
return 0.; // bug in the element 0x0020,0x0032
}
else
}
}
- std::string strSliceLocation = GetEntryByNumber(0x0020,0x1041); // for *very* old ACR-NEMA images
+ std::string strSliceLocation = GetEntry(0x0020,0x1041); // for *very* old ACR-NEMA images
if ( strSliceLocation != GDCM_UNFOUND )
{
if( sscanf( strSliceLocation.c_str(), "%f", &zImPos) != 1)
{
- dbg.Verbose(0, "Header::GetZImagePosition: wrong Slice Location (0020,1041)");
+ gdcmVerboseMacro( "Wrong Slice Location (0020,1041)");
return 0.; // bug in the element 0x0020,0x1041
}
else
return zImPos;
}
}
- dbg.Verbose(0, "Header::GetZImagePosition: unfound Slice Location (0020,1041)");
+ gdcmVerboseMacro( "Unfound Slice Location (0020,1041)");
- std::string strLocation = GetEntryByNumber(0x0020,0x0050);
+ std::string strLocation = GetEntry(0x0020,0x0050);
if ( strLocation != GDCM_UNFOUND )
{
if( sscanf( strLocation.c_str(), "%f", &zImPos) != 1)
{
- dbg.Verbose(0, "Header::GetZImagePosition: wrong Location (0020,0050)");
+ gdcmVerboseMacro( "Wrong Location (0020,0050)");
return 0.; // bug in the element 0x0020,0x0050
}
else
return zImPos;
}
}
- dbg.Verbose(0, "Header::GetYImagePosition: unfound Location (0020,0050)");
+ gdcmVerboseMacro( "Unfound Location (0020,0050)");
return 0.; // Hopeless
}
// faster function. sscanf() can do all possible conversions whereas
// atoi() can only do single decimal integer conversions.
//0020 0013 IS REL Image Number
- std::string strImNumber = GetEntryByNumber(0x0020,0x0013);
+ std::string strImNumber = GetEntry(0x0020,0x0013);
if ( strImNumber != GDCM_UNFOUND )
{
return atoi( strImNumber.c_str() );
ModalityType Header::GetModality()
{
// 0008 0060 CS ID Modality
- std::string strModality = GetEntryByNumber(0x0008,0x0060);
+ std::string strModality = GetEntry(0x0008,0x0060);
if ( strModality != GDCM_UNFOUND )
{
if ( strModality.find("AU") < strModality.length()) return AU;
*/
int Header::GetBitsStored()
{
- std::string strSize = GetEntryByNumber( 0x0028, 0x0101 );
+ std::string strSize = GetEntry( 0x0028, 0x0101 );
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
- "be mandatory");
+ gdcmVerboseMacro("(0028,0101) is supposed to be mandatory");
return 0; // It's supposed to be mandatory
// the caller will have to check
}
/**
* \brief Retrieve the high bit position.
- * \warning The method defaults to 0 when information is absent.
+ * \warning The method defaults to 0 when information is Missing.
* The responsability of checking this value is left to the caller.
- * @return The high bit positin when present. 0 when absent.
+ * @return The high bit positin when present. 0 when Missing.
*/
int Header::GetHighBitPosition()
{
- std::string strSize = GetEntryByNumber( 0x0028, 0x0102 );
+ std::string strSize = GetEntry( 0x0028, 0x0102 );
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetHighBitPosition: this is supposed "
- "to be mandatory");
+ gdcmVerboseMacro( "(0028,0102) is supposed to be mandatory");
return 0;
}
return atoi( strSize.c_str() );
}
/**
- * \brief Check wether the pixels are signed or UNsigned data.
- * \warning The method defaults to false (UNsigned) when information is absent.
+ * \brief Check whether the pixels are signed or UNsigned data.
+ * \warning The method defaults to false (UNsigned) when information is Missing.
* The responsability of checking this value is left to the caller.
* @return True when signed, false when UNsigned
*/
bool Header::IsSignedPixelData()
{
- std::string strSize = GetEntryByNumber( 0x0028, 0x0103 );
+ std::string strSize = GetEntry( 0x0028, 0x0103 );
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::IsSignedPixelData: this is supposed "
- "to be mandatory");
+ gdcmVerboseMacro( "(0028,0103) is supposed to be mandatory");
return false;
}
int sign = atoi( strSize.c_str() );
*/
int Header::GetBitsAllocated()
{
- std::string strSize = GetEntryByNumber(0x0028,0x0100);
+ std::string strSize = GetEntry(0x0028,0x0100);
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
- "be mandatory");
+ gdcmVerboseMacro( "(0028,0100) is supposed to be mandatory");
return 0; // It's supposed to be mandatory
// the caller will have to check
}
*/
int Header::GetSamplesPerPixel()
{
- std::string strSize = GetEntryByNumber(0x0028,0x0002);
+ const std::string& strSize = GetEntry(0x0028,0x0002);
if ( strSize == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
- "be mandatory");
+ gdcmVerboseMacro( "(0028,0002) is supposed to be mandatory");
return 1; // Well, it's supposed to be mandatory ...
// but sometimes it's missing : *we* assume Gray pixels
}
}
/**
- * \brief Check wether this a monochrome picture or not by accessing
+ * \brief Check whether this a monochrome picture or not by accessing
* the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
* @return true when "MONOCHROME1" or "MONOCHROME2". False otherwise.
*/
bool Header::IsMonochrome()
{
- std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
- if ( PhotometricInterp == "MONOCHROME1 "
- || PhotometricInterp == "MONOCHROME2 " )
+ const std::string& PhotometricInterp = GetEntry( 0x0028, 0x0004 );
+ if ( Util::DicomStringEqual(PhotometricInterp, "MONOCHROME1")
+ || Util::DicomStringEqual(PhotometricInterp, "MONOCHROME2") )
{
return true;
}
if ( PhotometricInterp == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::IsMonochrome: absent Photometric "
- "Interpretation");
+ gdcmVerboseMacro( "Not found : Photometric Interpretation (0028,0004)");
}
return false;
}
/**
- * \brief Check wether this a "PALETTE COLOR" picture or not by accessing
+ * \brief Check whether this a "PALETTE COLOR" picture or not by accessing
* the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
* @return true when "PALETTE COLOR". False otherwise.
*/
bool Header::IsPaletteColor()
{
- std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
+ std::string PhotometricInterp = GetEntry( 0x0028, 0x0004 );
if ( PhotometricInterp == "PALETTE COLOR " )
{
return true;
}
if ( PhotometricInterp == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::IsPaletteColor: absent Photometric "
- "Interpretation");
+ gdcmVerboseMacro( "Not found : Palette color (0028,0004)");
}
return false;
}
/**
- * \brief Check wether this a "YBR_FULL" color picture or not by accessing
+ * \brief Check whether this a "YBR_FULL" color picture or not by accessing
* the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
* @return true when "YBR_FULL". False otherwise.
*/
bool Header::IsYBRFull()
{
- std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
+ std::string PhotometricInterp = GetEntry( 0x0028, 0x0004 );
if ( PhotometricInterp == "YBR_FULL" )
{
return true;
}
if ( PhotometricInterp == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::IsYBRFull: absent Photometric "
- "Interpretation");
+ gdcmVerboseMacro( "Not found : YBR Full (0028,0004)");
}
return false;
}
*/
int Header::GetPlanarConfiguration()
{
- std::string strSize = GetEntryByNumber(0x0028,0x0006);
+ std::string strSize = GetEntry(0x0028,0x0006);
if ( strSize == GDCM_UNFOUND )
{
+ gdcmVerboseMacro( "Not found : Planar Configuration (0028,0006)");
return 0;
}
return atoi( strSize.c_str() );
{
// 0028 0100 US IMG Bits Allocated
// (in order no to be messed up by old RGB images)
- // if (Header::GetEntryByNumber(0x0028,0x0100) == "24")
+ // if (Header::GetEntry(0x0028,0x0100) == "24")
// return 3;
std::string pixelType = GetPixelType();
{
return 8;
}
- dbg.Verbose(0, "Header::GetPixelSize: Unknown pixel type");
+ gdcmVerboseMacro( "Unknown pixel type");
return 0;
}
*/
std::string Header::GetPixelType()
{
- std::string bitsAlloc = GetEntryByNumber(0x0028, 0x0100); // Bits Allocated
+ std::string bitsAlloc = GetEntry(0x0028, 0x0100); // Bits Allocated
if ( bitsAlloc == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetPixelType: unfound Bits Allocated");
+ gdcmVerboseMacro( "Missing Bits Allocated (0028,0100)");
bitsAlloc = "16";
}
{
return "FD";
}
- if ( bitsAlloc == "12" )
+ else if ( bitsAlloc == "12" )
{
// It will be unpacked
bitsAlloc = "16";
bitsAlloc = "8"; // by old RGB images)
}
- std::string sign = GetEntryByNumber(0x0028, 0x0103);//"Pixel Representation"
+ std::string sign = GetEntry(0x0028, 0x0103);//"Pixel Representation"
if (sign == GDCM_UNFOUND )
{
- dbg.Verbose(0, "Header::GetPixelType: unfound Pixel Representation");
+ gdcmVerboseMacro( "Missing Pixel Representation (0028,0103)");
bitsAlloc = "0";
}
- if ( sign == "0" )
+ else if ( sign == "0" )
{
sign = "U";
}
*/
size_t Header::GetPixelOffset()
{
- DocEntry* pxlElement = GetDocEntryByNumber(GrPixel,NumPixel);
+ DocEntry* pxlElement = GetDocEntry(GrPixel,NumPixel);
if ( pxlElement )
{
return pxlElement->GetOffset();
*/
size_t Header::GetPixelAreaLength()
{
- DocEntry* pxlElement = GetDocEntryByNumber(GrPixel,NumPixel);
+ DocEntry* pxlElement = GetDocEntry(GrPixel,NumPixel);
if ( pxlElement )
{
return pxlElement->GetLength();
{
// Check the presence of the LUT Descriptors, and LUT Tables
// LutDescriptorRed
- if ( !GetDocEntryByNumber(0x0028,0x1101) )
+ if ( !GetDocEntry(0x0028,0x1101) )
{
return false;
}
// LutDescriptorGreen
- if ( !GetDocEntryByNumber(0x0028,0x1102) )
+ if ( !GetDocEntry(0x0028,0x1102) )
{
return false;
}
// LutDescriptorBlue
- if ( !GetDocEntryByNumber(0x0028,0x1103) )
+ if ( !GetDocEntry(0x0028,0x1103) )
{
return false;
}
// Red Palette Color Lookup Table Data
- if ( !GetDocEntryByNumber(0x0028,0x1201) )
+ if ( !GetDocEntry(0x0028,0x1201) )
{
return false;
}
// Green Palette Color Lookup Table Data
- if ( !GetDocEntryByNumber(0x0028,0x1202) )
+ if ( !GetDocEntry(0x0028,0x1202) )
{
return false;
}
// Blue Palette Color Lookup Table Data
- if ( !GetDocEntryByNumber(0x0028,0x1203) )
+ if ( !GetDocEntry(0x0028,0x1203) )
{
return false;
}
//Just hope Lookup Table Desc-Red = Lookup Table Desc-Red
// = Lookup Table Desc-Blue
// Consistency already checked in GetLUTLength
- std::string lutDescription = GetEntryByNumber(0x0028,0x1101);
+ std::string lutDescription = GetEntry(0x0028,0x1101);
if ( lutDescription == GDCM_UNFOUND )
{
return 0;
return lutNbits;
}
-/**
- * \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* Header::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, "Header::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, "Header::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, "Header::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, "Header::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 TS
- * else 1.
- * @return The full Transfert Syntax Name (as opposed to Transfert Syntax UID)
- */
-std::string Header::GetTransfertSyntaxName()
-{
- // use the TS (TS : Transfert Syntax)
- std::string transfertSyntax = GetEntryByNumber(0x0002,0x0010);
-
- if ( transfertSyntax == GDCM_NOTLOADED )
- {
- std::cout << "Transfert Syntax not loaded. " << std::endl
- << "Better you increase MAX_SIZE_LOAD_ELEMENT_VALUE"
- << std::endl;
- return "Uncompressed ACR-NEMA";
- }
- if ( transfertSyntax == GDCM_UNFOUND )
- {
- dbg.Verbose(0, "Header::GetTransfertSyntaxName:"
- " unfound Transfert Syntax (0002,0010)");
- return "Uncompressed ACR-NEMA";
- }
-
- while ( ! isdigit(transfertSyntax[transfertSyntax.length()-1]) )
- {
- transfertSyntax.erase(transfertSyntax.length()-1, 1);
- }
- // we do it only when we need it
- TS* ts = Global::GetTS();
- std::string tsName = ts->GetValue( transfertSyntax );
-
- //delete ts; /// \todo Seg Fault when deleted ?!
- return tsName;
-}
-
-/**
- * \brief Sets the Pixel Area size in the Header
- * --> not-for-rats function
- * @param ImageDataSize new Pixel Area Size
- * warning : nothing else is checked
- */
-void Header::SetImageDataSize(size_t ImageDataSize)
-{
- ///FIXME I don't understand this code wh ydo we set two times 'car' ?
- std::string car = Util::Format("%d", ImageDataSize);
-
- DocEntry *a = GetDocEntryByNumber(GrPixel, NumPixel);
- a->SetLength(ImageDataSize);
-
- ImageDataSize += 8;
- car = Util::Format("%d", ImageDataSize);
-
- SetEntryByNumber(car, GrPixel, NumPixel);
-}
//-----------------------------------------------------------------------------
// Protected
bool Header::AnonymizeHeader()
{
// If exist, replace by spaces
- SetEntryByNumber (" ",0x0010, 0x2154); // Telephone
- SetEntryByNumber (" ",0x0010, 0x1040); // Adress
- SetEntryByNumber (" ",0x0010, 0x0020); // Patient ID
+ SetEntry (" ",0x0010, 0x2154); // Telephone
+ SetEntry (" ",0x0010, 0x1040); // Adress
+ SetEntry (" ",0x0010, 0x0020); // Patient ID
- DocEntry* patientNameHE = GetDocEntryByNumber (0x0010, 0x0010);
+ DocEntry* patientNameHE = GetDocEntry (0x0010, 0x0010);
if ( patientNameHE ) // we replace it by Study Instance UID (why not)
{
- std::string studyInstanceUID = GetEntryByNumber (0x0020, 0x000d);
+ std::string studyInstanceUID = GetEntry (0x0020, 0x000d);
if ( studyInstanceUID != GDCM_UNFOUND )
{
- ReplaceOrCreateByNumber(studyInstanceUID, 0x0010, 0x0010);
+ ReplaceOrCreate(studyInstanceUID, 0x0010, 0x0010);
}
else
{
- ReplaceOrCreateByNumber(std::string("anonymised"), 0x0010, 0x0010);
+ ReplaceOrCreate("anonymised", 0x0010, 0x0010);
}
}
iop[0] = iop[1] = iop[2] = iop[3] = iop[4] = iop[5] = 0.;
// 0020 0037 DS REL Image Orientation (Patient)
- if ( (strImOriPat = GetEntryByNumber(0x0020,0x0037)) != GDCM_UNFOUND )
+ if ( (strImOriPat = GetEntry(0x0020,0x0037)) != GDCM_UNFOUND )
{
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, "Header::GetImageOrientationPatient: "
- "wrong Image Orientation Patient (0020,0037)");
+ gdcmVerboseMacro( "Wrong Image Orientation Patient (0020,0037). Less than 6 values were found." );
}
}
//For ACR-NEMA
// 0020 0035 DS REL Image Orientation (RET)
- else if ( (strImOriPat = GetEntryByNumber(0x0020,0x0035)) != GDCM_UNFOUND )
+ else if ( (strImOriPat = GetEntry(0x0020,0x0035)) != GDCM_UNFOUND )
{
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, "Header::GetImageOrientationPatient: "
- "wrong Image Orientation Patient (0020,0035)");
+ gdcmVerboseMacro( "wrong Image Orientation Patient (0020,0035). Less than 6 values were found." );
}
}
}
+/**
+ * \brief Initialize a default DICOM header that should contain all the
+ * field require by other reader. DICOM standard does not
+ * explicitely defines those fields, heuristic has been choosen.
+ * This is not perfect as we are writting a CT image...
+ */
+void Header::InitializeDefaultHeader()
+{
+ typedef struct
+ {
+ const char *value;
+ uint16_t group;
+ uint16_t elem;
+ } DICOM_DEFAULT_VALUE;
+
+ std::string date = Util::GetCurrentDate();
+ std::string time = Util::GetCurrentTime();
+ std::string uid = Util::CreateUniqueUID();
+ std::string uidMedia = uid;
+ std::string uidClass = uid + ".1";
+ std::string uidInst = uid + ".10";
+ std::string uidStudy = uid + ".100";
+ std::string uidSerie = uid + ".1000";
+
+ static DICOM_DEFAULT_VALUE defaultvalue[] = {
+ { "146 ", 0x0002, 0x0000}, // Meta Element Group Length // FIXME: how to recompute ?
+ { "1.2.840.10008.5.1.4.1.1.2", 0x0002, 0x0002}, // Media Storage SOP Class UID (CT Image Storage)
+ { uidClass.c_str(), 0x0002, 0x0003}, // Media Storage SOP Instance UID
+ { uidClass.c_str(), 0x0002, 0x0012}, // META Implementation Class UID
+ { "GDCM", 0x0002, 0x0016}, // Source Application Entity Title
+
+ { date.c_str(), 0x0008, 0x0012}, // Instance Creation Date
+ { time.c_str(), 0x0008, 0x0013}, // Instance Creation Time
+ { "1.2.840.10008.5.1.4.1.1.2", 0x0008, 0x0016}, // SOP Class UID
+ { uidInst.c_str(), 0x0008, 0x0018}, // SOP Instance UID
+ { "CT", 0x0008, 0x0060}, // Modality
+ { "GDCM", 0x0008, 0x0070}, // Manufacturer
+ { "GDCM", 0x0008, 0x0080}, // Institution Name
+ { "http://www-creatis.insa-lyon.fr/Public/Gdcm", 0x0008, 0x0081}, // Institution Address
+
+ { "GDCM", 0x0010, 0x0010}, // Patient's Name
+ { "GDCMID", 0x0010, 0x0020}, // Patient ID
+
+ { uidStudy.c_str(), 0x0020, 0x000d}, // Study Instance UID
+ { uidSerie.c_str(), 0x0020, 0x000e}, // Series Instance UID
+ { "1", 0x0020, 0x0010}, // StudyID
+ { "1", 0x0020, 0x0011}, // SeriesNumber
+
+ { "1", 0x0028, 0x0002}, // Samples per pixel 1 or 3
+ { "MONOCHROME1", 0x0028, 0x0004}, // photochromatic interpretation
+ { "0", 0x0028, 0x0010}, // nbRows
+ { "0", 0x0028, 0x0011}, // nbCols
+ { "8", 0x0028, 0x0100}, // BitsAllocated 8 or 12 or 16
+ { "8", 0x0028, 0x0101}, // BitsStored <= BitsAllocated
+ { "7", 0x0028, 0x0102}, // HighBit <= BitsAllocated - 1
+ { "0", 0x0028, 0x0103}, // Pixel Representation 0(unsigned) or 1(signed)
+ { 0, 0, 0 }
+ };
+
+ // default value
+ // Special case this is the image (not a string)
+ GrPixel = 0x7fe0;
+ NumPixel = 0x0010;
+ ReplaceOrCreate(0, 0, GrPixel, NumPixel);
+
+ // All remaining strings:
+ unsigned int i = 0;
+ DICOM_DEFAULT_VALUE current = defaultvalue[i];
+ while( current.value )
+ {
+ ReplaceOrCreate(current.value, current.group, current.elem);
+ current = defaultvalue[++i];
+ }
+}
+
+
//-----------------------------------------------------------------------------
// Private
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff