Program: gdcm
Module: $RCSfile: gdcmHeader.cxx,v $
Language: C++
- Date: $Date: 2004/10/12 04:35:46 $
- Version: $Revision: 1.193 $
+ Date: $Date: 2004/12/03 16:57:49 $
+ Version: $Revision: 1.211 $
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 <stdio.h> //sscanf
#include <vector>
namespace gdcm
{
-
//-----------------------------------------------------------------------------
// Constructor / Destructor
/**
// Note: this IS the right place for the code
// Image Location
- std::string imgLocation = GetEntryByNumber(0x0028, 0x0200);
+ const std::string &imgLocation = GetEntryByNumber(0x0028, 0x0200);
if ( imgLocation == GDCM_UNFOUND )
{
// default value
}
/**
- * \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
* @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)
+ {
+ dbg.Verbose(2, "Failed to open (write) File: " , fileName.c_str());
+ return false;
+ }
+
// Bits Allocated
if ( GetEntryByNumber(0x0028,0x0100) == "12")
{
if (i_lgPix != -2)
{
// no (GrPixel, NumPixel) element
- std::string s_lgPix;
- s_lgPix = Util::Format("%d", i_lgPix+12);
+ std::string s_lgPix = Util::Format("%d", i_lgPix+12);
+ s_lgPix = Util::DicomString( s_lgPix.c_str() );
ReplaceOrCreateByNumber(s_lgPix,GrPixel, 0x0000);
}
RemoveEntryNoDestroy(e);
}
}
- Document::Write(fp,filetype);
+ Document::WriteContent(fp,filetype);
+
+ fp->close();
+ delete fp;
+
+ return true;
}
//-----------------------------------------------------------------------------
return false;
}
- std::string res = GetEntryByNumber(0x0028, 0x0005);
+ const std::string &res = GetEntryByNumber(0x0028, 0x0005);
if ( res != GDCM_UNFOUND && atoi(res.c_str()) > 4 )
{
return false; // Image Dimensions
*/
int Header::GetXSize()
{
- std::string strSize;
- strSize = GetEntryByNumber(0x0028,0x0011);
+ const std::string &strSize = GetEntryByNumber(0x0028,0x0011);
if ( strSize == GDCM_UNFOUND )
{
return 0;
*/
int Header::GetYSize()
{
- std::string strSize = GetEntryByNumber(0x0028,0x0010);
+ const std::string &strSize = GetEntryByNumber(0x0028,0x0010);
if ( strSize != GDCM_UNFOUND )
{
return atoi( strSize.c_str() );
{
// Both DicomV3 and ACR/Nema consider the "Number of Frames"
// as the third dimension.
- std::string strSize = GetEntryByNumber(0x0028,0x0008);
+ const std::string &strSize = GetEntryByNumber(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 = GetEntryByNumber(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 = GetEntryByNumber(0x0028,0x0030);
if ( strSpacing == GDCM_UNFOUND )
{
// 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() );
+ return (float)atof( strSpacingBSlices.c_str() );
}
+ return 1.;
}
/**
// 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;
}
*/
int Header::GetSamplesPerPixel()
{
- std::string strSize = GetEntryByNumber(0x0028,0x0002);
+ const std::string& strSize = GetEntryByNumber(0x0028,0x0002);
if ( strSize == GDCM_UNFOUND )
{
dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
*/
bool Header::IsMonochrome()
{
- std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
- if ( PhotometricInterp == "MONOCHROME1 "
- || PhotometricInterp == "MONOCHROME2 " )
+ const std::string& PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
+ if ( Util::DicomStringEqual(PhotometricInterp, "MONOCHROME1")
+ || Util::DicomStringEqual(PhotometricInterp, "MONOCHROME2") )
{
return true;
}
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 "Uncompressed ACR-NEMA";
}
- while ( ! isdigit(transfertSyntax[transfertSyntax.length()-1]) )
+ while ( ! isdigit((unsigned char)transfertSyntax[transfertSyntax.length()-1]) )
{
transfertSyntax.erase(transfertSyntax.length()-1, 1);
}
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
}
else
{
- ReplaceOrCreateByNumber(std::string("anonymised"), 0x0010, 0x0010);
+ ReplaceOrCreateByNumber("anonymised", 0x0010, 0x0010);
}
}
}
}
+/**
+ * \brief Initialize a default DICOM header that should contain all the
+ * field require by other reader. DICOM standart does not
+ * explicitely defines thoses 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();
+
+ static DICOM_DEFAULT_VALUE defaultvalue[] = {
+ { "76", 0x0002, 0x0000}, // MetaElementGroup Length // FIXME: how to recompute ?
+ { "1.2.840.10008.5.1.4.1.1.2", 0x0002, 0x0002}, // MediaStorageSOPInstanceUID (CT Image Storage)
+ { uid.c_str(), 0x0002, 0x0012}, // META Implementation Class UID
+ { "ISO_IR 100",0x0008, 0x0005}, // Specific Character Set
+ { "DERIVED\\SECONDARY\\OTHER\\GDCM", 0x0008, 0x0008}, // Image Type
+ { "1.2.840.10008.5.1.4.1.1.2", 0x0008, 0x0016}, // SOP Class UID
+ { "", 0x0008, 0x0050}, // Accession Number
+ { "GDCM", 0x0008, 0x0070}, // Manufacturer
+ { "GDCM", 0x0008, 0x0080}, // Institution Name
+ { "http://www-creatis.insa-lyon.fr/Public/Gdcm/", 0x0008, 0x0081}, // Institution Address
+ { "", 0x0008, 0x0090}, // Refering Physician Name
+ { "", 0x0008, 0x1030}, // Study Description
+ { "", 0x0008, 0x1050}, // Performing Physician's Name
+ { "", 0x0008, 0x1060}, // Name of Physician(s) Reading Study
+ { "", 0x0010, 0x0040}, // Patient's Sex
+ { uid.c_str(), 0x0020, 0x000d}, // StudyInstanceUID
+ { uid.c_str(), 0x0020, 0x000e}, // SeriesInstanceUID
+ { "", 0x0020, 0x0011}, // AcquisitionNumber
+ { "1\\0\\0\\0\\1\\0", 0x0020, 0x0037}, // Image Orientation Patient
+ { "1", 0x0028, 0x0002}, // Samples per pixel 1 or 3
+ { "MONOCHROME2",0x0028, 0x0004}, // photochromatic interpretation
+
+// Date and timeG
+
+ { date.c_str(), 0x0008, 0x0012 } , // Instance Creation Date
+ { time.c_str(), 0x0008, 0x0013 } , // Instance Creation Time
+ { date.c_str(), 0x0008, 0x0020 } , // Study Date
+ { date.c_str(), 0x0008, 0x0022 } , // Acquisition Date
+ { date.c_str(), 0x0008, 0x0023 } , // Content Date
+ { time.c_str(), 0x0008, 0x0030 } , // Study Time
+ { "CT", 0x0008, 0x0060 } , // Modality
+ { "GDCM", 0x0010, 0x0010 } , // Patient's Name
+ { "GDCMID", 0x0010, 0x0020 } , // Patient ID
+ { "1", 0x0020, 0x0010 } , // StudyID
+ { "1", 0x0020, 0x0011 } , // SeriesNumber
+ { "1.0", 0x0018, 0x0050 } , // slice Thickness
+ { "1.0", 0x0018, 0x0088 } , // space between slices
+ { "1.0\\1.0", 0x0028, 0x0030 } , // pixelSpacing
+ { "64", 0x0028, 0x0010 } , // nbRows
+ { "64", 0x0028, 0x0011 } , // nbCols
+ { "16", 0x0028, 0x0100 } , // BitsAllocated 8 or 16
+ { "12", 0x0028, 0x0101 } , // BitsStored 8 or 12
+ { "11", 0x0028, 0x0102 } , // HighBit 7 or 11
+ { "0", 0x0028, 0x0103 } , // Pixel Representation 0(unsigned) or 1(signed)
+ { "1000.0", 0x0028, 0x1051 } , // Window Width
+ { "500.0", 0x0028, 0x1050 } , // Window Center
+ { 0, 0, 0 }
+ };
+
+ // default value
+ // Special case this is the image (not a string)
+ GrPixel = 0x7fe0;
+ NumPixel = 0x0010;
+ ReplaceOrCreateByNumber(0, 0, GrPixel, NumPixel);
+
+ // All remaining strings:
+ unsigned int i = 0;
+ DICOM_DEFAULT_VALUE current = defaultvalue[i];
+ while( current.value )
+ {
+ std::string value = Util::DicomString( current.value ); //pad the string properly
+ ReplaceOrCreateByNumber(value, current.group, current.elem);
+ current = defaultvalue[++i];
+ }
+}
+
//-----------------------------------------------------------------------------
// Private
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff