Program: gdcm
Module: $RCSfile: gdcmFile.cxx,v $
Language: C++
- Date: $Date: 2004/06/21 04:52:08 $
- Version: $Revision: 1.104 $
+ Date: $Date: 2004/06/23 16:22:21 $
+ Version: $Revision: 1.109 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
* one sets an a posteriori shadow dictionary (efficiency can be
* seen as a side effect).
* @param header file to be opened for reading datas
- * @return
+ * @return
*/
gdcmFile::gdcmFile(gdcmHeader *header) {
Header=header;
* \note If the gdcmHeader is created by the gdcmFile, it is destroyed
* by the gdcmFile
*/
-gdcmFile::~gdcmFile(void) {
+gdcmFile::~gdcmFile() {
if(SelfHeader)
delete Header;
Header=NULL;
//-----------------------------------------------------------------------------
// Public
-/**
- * \ingroup gdcmFile
- * \brief returns the gdcmHeader *Header
- * @return
- */
-gdcmHeader *gdcmFile::GetHeader(void) {
- return(Header);
-}
/**
* \ingroup gdcmFile
* \brief computes the length (in bytes) to ALLOCATE to receive the
- * image(s) pixels (multiframes taken into account)
+ * image(s) pixels (multiframes taken into account)
* \warning : it is NOT the group 7FE0 length
* (no interest for compressed images).
* @return length to allocate
*/
-void gdcmFile::SetPixelDataSizeFromHeader(void) {
+void gdcmFile::SetPixelDataSizeFromHeader() {
// see PS 3.3-2003 : C.7.6.3.2.1
//
// MONOCHROME1
* Header->GetZSize() * (nb/8)* Header->GetSamplesPerPixel();
std::string str_PhotometricInterpretation =
Header->GetEntryByNumber(0x0028,0x0004);
-
+
/*if ( str_PhotometricInterpretation == "PALETTE COLOR " )*/
// pb when undealt Segmented Palette Color
* the pixel data represented in this file.
* @return The size of pixel data in bytes.
*/
-size_t gdcmFile::GetImageDataSize(void) {
- return (lgrTotale);
+size_t gdcmFile::GetImageDataSize() {
+ return lgrTotale;
}
/**
* \warning to be used with GetImagePixelsRaw()
* @return The size of pixel data in bytes.
*/
-size_t gdcmFile::GetImageDataSizeRaw(void) {
- return (lgrTotaleRaw);
+size_t gdcmFile::GetImageDataSizeRaw() {
+ return lgrTotaleRaw;
}
/**
* @return Pointer to newly allocated pixel data.
* NULL if alloc fails
*/
-void * gdcmFile::GetImageData (void) {
- PixelData = new char[lgrTotale];
+void * gdcmFile::GetImageData () {
+ PixelData = new unsigned char[lgrTotale]; //consistant with GetImageDataIntoVector
if (PixelData) {
GetImageDataIntoVector(PixelData, lgrTotale);
- GetHeader()->SetEntryVoidAreaByNumber(PixelData,
+ GetHeader()->SetEntryVoidAreaByNumber(PixelData,
GetHeader()->GetGrPixel(),
GetHeader()->GetNumPixel());
}
PixelRead=0; // no PixelRaw
-
- return(PixelData);
+
+ return PixelData;
}
/**
*/
size_t gdcmFile::GetImageDataIntoVector (void* destination, size_t MaxSize) {
//size_t l = GetImageDataIntoVectorRaw (destination, MaxSize);
- GetImageDataIntoVectorRaw (destination, MaxSize);
+ GetImageDataIntoVectorRaw (destination, MaxSize);
PixelRead=0 ; // no PixelRaw
if (!Header->HasLUT())
return lgrTotale;
// from Lut R + Lut G + Lut B
unsigned char *newDest = new unsigned char[lgrTotale];
- unsigned char *a = (unsigned char *)destination;
- unsigned char *lutRGBA = Header->GetLUTRGBA();
- if (lutRGBA) {
+ unsigned char *a = (unsigned char *)destination;
+ unsigned char *lutRGBA = Header->GetLUTRGBA();
+
+ if (lutRGBA) {
int l = lgrTotaleRaw;
- memmove(newDest, destination, l);// move Gray pixels to temp area
- int j;
+ memmove(newDest, destination, l);// move Gray pixels to temp area
+ int j;
for (int i=0;i<l; i++) { // Build RGB Pixels
j=newDest[i]*4;
*a++ = lutRGBA[j];
// Lets's write it in the Header
// CreateOrReplaceIfExist ?
-
+
std::string spp = "3"; // Samples Per Pixel
Header->SetEntryByNumber(spp,0x0028,0x0002);
std::string rgb= "RGB "; // Photometric Interpretation
Header->SetEntryByNumber(planConfig,0x0028,0x0006);
} else {
- // need to make RGB Pixels (?)
- // from grey Pixels (?!)
- // and Gray Lut (!?!)
- // or Segmented xxx Palette Color Lookup Table Data and so on
-
+ // need to make RGB Pixels (?)
+ // from grey Pixels (?!)
+ // and Gray Lut (!?!)
+ // or Segmented xxx Palette Color Lookup Table Data and so on
+
// Oops! I get one (gdcm-US-ALOKA-16.dcm)
// No idea how to manage such an image
// It seems that *no Dicom Viewer* has any idea :-(
// Segmented xxx Palette Color are *more* than 65535 long ?!?
-
+
std::string rgb= "MONOCHROME1 "; // Photometric Interpretation
- Header->SetEntryByNumber(rgb,0x0028,0x0004);
- }
- /// \todo Drop Palette Color out of the Header?
+ Header->SetEntryByNumber(rgb,0x0028,0x0004);
+ }
+ /// \todo Drop Palette Color out of the Header?
return lgrTotale;
}
* (image[s]/volume[s]) to newly allocated zone.
* Transforms YBR pixels into RGB pixels if any
* Transforms 3 planes R, G, B into a single RGB Plane
- * DOES NOT transform Grey plane + 3 Palettes into a RGB Plane
+ * DOES NOT transform Grey plane + 3 Palettes into a RGB Plane
* @return Pointer to newly allocated pixel data.
* \ NULL if alloc fails
*/
-void * gdcmFile::GetImageDataRaw (void) {
+void * gdcmFile::GetImageDataRaw () {
if (Header->HasLUT())
/// \todo Let gdcmHeadar user a chance to get the right value
- /// Create a member lgrTotaleRaw ???
+ /// Create a member lgrTotaleRaw ???
lgrTotale /= 3;
- PixelData = new char[lgrTotale];
-
+ PixelData = new unsigned char[lgrTotale];
+
if (PixelData) {
GetImageDataIntoVectorRaw(PixelData, lgrTotale);
- GetHeader()->SetEntryVoidAreaByNumber(PixelData,
- GetHeader()->GetGrPixel(),
- GetHeader()->GetNumPixel());
- }
+ GetHeader()->SetEntryVoidAreaByNumber(PixelData,
+ GetHeader()->GetGrPixel(),
+ GetHeader()->GetNumPixel());
+ }
PixelRead=1; // PixelRaw
- return(PixelData);
+
+ return PixelData;
}
/**
"than caller's expected MaxSize");
return (size_t)0;
}
-
- (void)ReadPixelData(destination);
-
- // Number of Bits Allocated for storing a Pixel
+
+ ReadPixelData(destination);
+
+ // Number of Bits Allocated for storing a Pixel
str_nb = Header->GetEntryByNumber(0x0028,0x0100);
if (str_nb == GDCM_UNFOUND ) {
nb = 16;
} else {
nb = atoi(str_nb.c_str() );
- }
- // Number of Bits actually used
+ }
+ // Number of Bits actually used
str_nbu=Header->GetEntryByNumber(0x0028,0x0101);
if (str_nbu == GDCM_UNFOUND ) {
nbu = nb;
} else {
nbu = atoi(str_nbu.c_str() );
- }
- // High Bit Position
+ }
+ // High Bit Position
str_highBit=Header->GetEntryByNumber(0x0028,0x0102);
if (str_highBit == GDCM_UNFOUND ) {
highBit = nb - 1;
} else {
highBit = atoi(str_highBit.c_str() );
- }
- // Pixel sign
- // 0 = Unsigned
- // 1 = Signed
+ }
+ // Pixel sign
+ // 0 = Unsigned
+ // 1 = Signed
str_signe=Header->GetEntryByNumber(0x0028,0x0103);
if (str_signe == GDCM_UNFOUND ) {
signe = 0; // default is unsigned
guint16 *deb = (guint16 *)destination;
for(int i = 0; i<l; i++) {
if(*deb == 0xffff)
- *deb=0;
- deb++;
+ *deb=0;
+ deb++;
}
}
// re arange bits inside the bytes
deb ++;
}
} else {
- dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: wierd image");
- return (size_t)0;
+ dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: weird image");
+ return 0;
}
}
// DO NOT remove this commented out code .
std::string str_PhotometricInterpretation =
Header->GetEntryByNumber(0x0028,0x0004);
-
+
if ( (str_PhotometricInterpretation == "MONOCHROME1 ")
|| (str_PhotometricInterpretation == "MONOCHROME2 ") ) {
return lgrTotale;
{
if (str_PhotometricInterpretation == "YBR_FULL") {
-
+
// Warning : YBR_FULL_422 acts as RGB
// : we need to make RGB Pixels from Planes Y,cB,cR
-
- // to see the tricks about YBR_FULL, YBR_FULL_422,
- // YBR_PARTIAL_422, YBR_ICT, YBR_RCT have a look at :
- // ftp://medical.nema.org/medical/dicom/final/sup61_ft.pdf
- // and be *very* affraid
- //
+
+ // to see the tricks about YBR_FULL, YBR_FULL_422,
+ // YBR_PARTIAL_422, YBR_ICT, YBR_RCT have a look at :
+ // ftp://medical.nema.org/medical/dicom/final/sup61_ft.pdf
+ // and be *very* affraid
+ //
int l = Header->GetXSize()*Header->GetYSize();
int nbFrames = Header->GetZSize();
/// \todo : Replace by the 'well known' integer computation
/// counterpart
- /// see http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
+ /// see http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
/// for code optimisation
-
+
for (int i=0;i<nbFrames;i++) {
for (int j=0;j<l; j++) {
R= 1.164 *(*a-16) + 1.596 *(*c -128) + 0.5;
}
memmove(destination,newDest,lgrTotale);
delete[] newDest;
- }
+ }
break;
}
case 2:
std::string planConfig = "0"; // Planar Configuration
Header->SetEntryByNumber(planConfig,0x0028,0x0006);
-
- /// \todo Drop Palette Color out of the Header?
+
+ /// \todo Drop Palette Color out of the Header?
return lgrTotale;
}
/**
* \ingroup gdcmFile
- * \brief performs a shadow copy (not a deep copy) of the user given
+ * \brief performs a shalow copy (not a deep copy) of the user given
* pixel area.
* 'image' Pixels are presented as C-like 2D arrays : line per line.
* 'volume'Pixels are presented as C-like 3D arrays : lane per plane
* @param inData user supplied pixel area
* @param ExpectedSize total image size, in Bytes
*
- * @return boolean
+ * @return boolean
*/
bool gdcmFile::SetImageData(void *inData, size_t ExpectedSize) {
Header->SetImageDataSize(ExpectedSize);
PixelData = inData;
lgrTotale = ExpectedSize;
PixelRead = 1;
- return(true);
+
+ return true;
}
/**
* It's up to the user to call his Reader properly
* @param fileName name of the file to be created
* (any already existing file is over written)
- * @return false if write fails
+ * @return false if write fails
*/
-bool gdcmFile::WriteRawData (std::string fileName) {
+bool gdcmFile::WriteRawData (std::string const & fileName) {
FILE *fp1;
fp1 = fopen(fileName.c_str(),"wb");
if (fp1 == NULL) {
printf("Fail to open (write) file [%s] \n",fileName.c_str());
- return (false);
- }
+ return false;
+ }
fwrite (PixelData,lgrTotale, 1, fp1);
fclose (fp1);
- return(true);
+
+ return true;
}
/**
* NO test is performed on processor "Endiannity".
* @param fileName name of the file to be created
* (any already existing file is overwritten)
- * @return false if write fails
+ * @return false if write fails
*/
-bool gdcmFile::WriteDcmImplVR (std::string fileName) {
+bool gdcmFile::WriteDcmImplVR (std::string const & fileName) {
return WriteBase(fileName, gdcmImplicitVR);
}
-/**
- * \ingroup gdcmFile
- * \brief Writes on disk A SINGLE Dicom file,
- * using the Implicit Value Representation convention
- * NO test is performed on processor "Endiannity". * @param fileName name of the file to be created
- * (any already existing file is overwritten)
- * @return false if write fails
- */
-
-bool gdcmFile::WriteDcmImplVR (const char *fileName) {
- return WriteDcmImplVR (std::string (fileName));
-}
-
/**
* \ingroup gdcmFile
* \brief Writes on disk A SINGLE Dicom file,
* using the Explicit Value Representation convention
* NO test is performed on processor "Endiannity". * @param fileName name of the file to be created
* (any already existing file is overwritten)
- * @return false if write fails
+ * @return false if write fails
*/
-bool gdcmFile::WriteDcmExplVR (std::string fileName) {
+bool gdcmFile::WriteDcmExplVR (std::string const & fileName) {
return WriteBase(fileName, gdcmExplicitVR);
}
-
+
/**
* \ingroup gdcmFile
* \brief Writes on disk A SINGLE Dicom file,
* \warning NO TEST is performed on processor "Endiannity".
* @param fileName name of the file to be created
* (any already existing file is overwritten)
- * @return false if write fails
+ * @return false if write fails
*/
-bool gdcmFile::WriteAcr (std::string fileName) {
+bool gdcmFile::WriteAcr (std::string const & fileName) {
return WriteBase(fileName, gdcmACR);
}
* @param fileName name of the file to be created
* (any already existing file is overwritten)
* @param type file type (ExplicitVR, ImplicitVR, ...)
- * @return false if write fails
+ * @return false if write fails
*/
-bool gdcmFile::WriteBase (std::string fileName, FileType type) {
+bool gdcmFile::WriteBase (std::string const & fileName, FileType type) {
FILE *fp1;
if (PixelRead==-1 && type != gdcmExplicitVR) {
- return false;
+ return false;
}
fp1 = fopen(fileName.c_str(),"wb");
columns = Header->GetEntryByNumber(0x0028, 0x0011);
Header->SetEntryByNumber(columns, 0x0028, 0x0010);
Header->SetEntryByNumber(rows , 0x0028, 0x0011);
- }
+ }
// ----------------- End of Special Patch ----------------
/// \todo get the grPixel, numPixel values (for some ACR-NEMA images only)
if (Header->GetFileType() == gdcmACR_LIBIDO){
Header->SetEntryByNumber(rows , 0x0028, 0x0010);
Header->SetEntryByNumber(columns, 0x0028, 0x0011);
- }
+ }
// ----------------- End of Special Patch ----------------
// fwrite(PixelData, lgrTotale, 1, fp1); // should be useless, now
fclose (fp1);
- return(true);
+
+ return true;
}
//-----------------------------------------------------------------------------
* @param nb Pixels Bit number
*/
void gdcmFile::SwapZone(void *im, int swap, int lgr, int nb) {
-guint32 s32;
-guint16 fort,faible;
-int i;
+ guint32 s32;
+ guint16 fort,faible;
+ int i;
-if(nb == 16)
- switch(swap) {
+ if(nb == 16)
+ switch(swap) {
case 0:
case 12:
case 1234:
break;
-
+
case 21:
case 3412:
case 2143:
for(i=0;i<lgr/2;i++) {
((unsigned short int *)im)[i]= ((((unsigned short int *)im)[i])>>8)
| ((((unsigned short int *)im)[i])<<8);
- }
+ }
break;
-
+
default:
- printf("SWAP value (16 bits) not allowed : %d\n", swap);
+ std::cout << "SWAP value (16 bits) not allowed :i" << swap << std::endl;
}
-if( nb == 32 )
- switch (swap) {
+ if( nb == 32 )
+ switch (swap) {
case 0:
case 1234:
break;
((unsigned long int *)im)[i]=(s32<<16)|fort;
}
break;
-
+
default:
- printf("SWAP value (32 bits) not allowed : %d\n", swap);
+ std::cout << "SWAP value (32 bits) not allowed : " << swap << std::endl;
}
-return;
}
/**
/* A */ /* B */ /* D */
*pdestination++ = ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4);
/* F */ /* C */ /* E */
-
- // Troubles expected on Big-Endian processors ?
+
+ // Troubles expected on Big-Endian processors ?
}
Header->CloseFile();
- return(true);
+ return true;
}
// ---------------------- Uncompressed File
bool jpg2000 = Header->IsJPEG2000();
bool jpgLossless = Header->IsJPEGLossless();
-
+
bool res = true;
guint16 ItemTagGr,ItemTagEl;
int ln;
res = (bool)gdcm_read_JPEG2000_file (fp,destination); // Not Yet written
} // ------------------------------------- endif (JPEG2000)
-
+
else if (jpgLossless) { // JPEG LossLess : call to xmedcom JPEG
-
JPEGLosslessDecodeImage (fp, // Reading Fragment pixels
- (unsigned short *)destination,
- Header->GetPixelSize() * 8 * Header->GetSamplesPerPixel(),
- ln);
+ (unsigned short *)destination,
+ Header->GetPixelSize() * 8 * Header->GetSamplesPerPixel(),
+ ln);
res=1; // in order not to break the loop
} // ------------------------------------- endif (JPEGLossless)