Program: gdcm
Module: $RCSfile: gdcmFile.cxx,v $
Language: C++
- Date: $Date: 2004/06/28 14:12:03 $
- Version: $Revision: 1.112 $
+ Date: $Date: 2004/08/26 15:29:53 $
+ Version: $Revision: 1.121 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
typedef std::pair<TagDocEntryHT::iterator,TagDocEntryHT::iterator> IterHT;
-//-----------------------------------------------------------------------------
+//-------------------------------------------------------------------------
// Constructor / Destructor
/**
* \ingroup gdcmFile
* one sets an a posteriori shadow dictionary (efficiency can be
* seen as a side effect).
* @param filename file to be opened for parsing
- * @param exception_on_error whether we throw an exception or not
- * @param enable_sequences = true to allow the header
- * to be parsed *inside* the SeQuences,
- * when they have an actual length
- * \warning enable_sequences *has to be* true for reading PAPYRUS 3.0 files
- * @param ignore_shadow to allow skipping the shadow elements,
- * to save memory space.
- * \warning The TRUE value for this param has to be used
- * with a FALSE value for the 'enable_sequence' param.
- * ('public elements' may be embedded in 'shadow Sequences')
*/
-gdcmFile::gdcmFile(std::string const & filename,
- bool exception_on_error,
- bool enable_sequences,
- bool ignore_shadow)
+gdcmFile::gdcmFile(std::string const & filename )
{
- Header = new gdcmHeader( filename,
- exception_on_error,
- enable_sequences,
- ignore_shadow );
+ Header = new gdcmHeader( filename );
SelfHeader = true;
PixelRead = -1; // no ImageData read yet.
std::string str_PhotometricInterpretation =
Header->GetEntryByNumber(0x0028,0x0004);
- /*if ( str_PhotometricInterpretation == "PALETTE COLOR " )*/
+ // if ( str_PhotometricInterpretation == "PALETTE COLOR " )
// pb when undealt Segmented Palette Color
if ( Header->HasLUT() )
*
* @param destination Address (in caller's memory space) at which the
* pixel data should be copied
- * @param MaxSize Maximum number of bytes to be copied. When MaxSize
+ * @param maxSize Maximum number of bytes to be copied. When MaxSize
* is not sufficient to hold the pixel data the copy is not
* executed (i.e. no partial copy).
* @return On success, the number of bytes actually copied. Zero on
// from Lut R + Lut G + Lut B
uint8_t *newDest = new uint8_t[ImageDataSize];
uint8_t *a = (uint8_t *)destination;
- uint8_t *lutRGBA = Header->GetLUTRGBA();
+ uint8_t *lutRGBA = Header->GetLUTRGBA();
if ( lutRGBA )
{
std::string spp = "3"; // Samples Per Pixel
Header->SetEntryByNumber(spp,0x0028,0x0002);
- std::string rgb= "RGB "; // Photometric Interpretation
+ std::string rgb = "RGB "; // Photometric Interpretation
Header->SetEntryByNumber(rgb,0x0028,0x0004);
std::string planConfig = "0"; // Planar Configuration
Header->SetEntryByNumber(planConfig,0x0028,0x0006);
if ( Header->HasLUT() )
{
/// \todo Let gdcmHeader user a chance to get the right value
- // ImageDataSize /= 3; //dangerous
imgDataSize = ImageDataSizeRaw;
}
*
* @param destination Address (in caller's memory space) at which the
* pixel data should be copied
- * @param MaxSize Maximum number of bytes to be copied. When MaxSize
+ * @param maxSize Maximum number of bytes to be copied. When MaxSize
* is not sufficient to hold the pixel data the copy is not
* executed (i.e. no partial copy).
* @return On success, the number of bytes actually copied. Zero on
}
else if ( nb == 32 )
{
- guint32 mask = 0xffffffff;
+ uint32_t mask = 0xffffffff;
mask = mask >> (nb - nbu);
- guint32 *deb = (guint32 *)destination;
+ uint32_t *deb = (uint32_t *)destination;
for(int i = 0; i<l; i++)
{
*deb = (*deb >> (nbu - highBit - 1)) & mask;
* 'volume'Pixels are presented as C-like 3D arrays : lane per plane
* \warning user is kindly requested NOT TO 'free' the Pixel area
* @param inData user supplied pixel area
- * @param ExpectedSize total image size, in Bytes
+ * @param expectedSize total image size, in Bytes
*
* @return boolean
*/
bool gdcmFile::WriteRawData(std::string const & fileName)
{
- FILE *fp1;
- fp1 = fopen(fileName.c_str(), "wb");
+ FILE *fp1 = fopen(fileName.c_str(), "wb");
if (fp1 == NULL)
{
printf("Fail to open (write) file [%s] \n", fileName.c_str());
return false;
}
- fwrite (PixelData,ImageDataSize, 1, fp1);
+ fwrite (PixelData, ImageDataSize, 1, fp1);
fclose (fp1);
return true;
*/
bool gdcmFile::WriteBase (std::string const & fileName, FileType type)
{
- FILE *fp1;
-
if ( PixelRead == -1 && type != gdcmExplicitVR)
{
return false;
}
- fp1 = fopen(fileName.c_str(), "wb");
+ FILE *fp1 = fopen(fileName.c_str(), "wb");
if (fp1 == NULL)
{
printf("Failed to open (write) File [%s] \n", fileName.c_str());
Header->SetEntryByNumber(rows , 0x0028, 0x0011);
}
// ----------------- End of Special Patch ----------------
-
- /// \todo get the grPixel, numPixel values (for some ACR-NEMA images only)
-
+
uint16_t grPixel = Header->GetGrPixel();
uint16_t numPixel = Header->GetNumPixel();;
-
- // Update Pixel Data Length
- // the *last* of the (GrPixel, NumPixel), if many.
- TagKey key = gdcmDictEntry::TranslateToKey(grPixel, numPixel);
- TagDocEntryHT::iterator p2;
- gdcmDocEntry* PixelElement;
-
- IterHT it = Header->GetEntry().equal_range(key); // get a pair of iterators first-last synonym
-
- if ( Header->GetEntry().count(key) == 1 ) // only the first is significant
- {
- p2 = it.first; // iterator on the first (unique) synonym
- }
- else
- {
- p2 = it.second;// iterator on the last synonym
- }
-
- PixelElement = p2->second; // H Table target column (2-nd col)
- // PixelElement->SetPrintLevel(2);
- // PixelElement->Print();
+ gdcmDocEntry* PixelElement =
+ GetHeader()->GetDocEntryByNumber(grPixel, numPixel);
if ( PixelRead == 1 )
{
+ // we read pixel 'as is' (no tranformation LUT -> RGB)
PixelElement->SetLength( ImageDataSizeRaw );
}
else if ( PixelRead == 0 )
{
+ // we tranformed GrayLevel pixels + LUT into RGB Pixel
PixelElement->SetLength( ImageDataSize );
}
-
- //PixelElement->SetPrintLevel(2);
- //PixelElement->Print();
+
Header->Write(fp1, type);
// --------------------------------------------------------------
case 4321:
for(i=0; i < lgr/2; i++)
{
- im16[i]= (im16[i] >> 8) | (im16[i] << 8 );
+ im16[i]= (im16[i] >> 8) | (im16[i] << 8 );
}
break;
default:
// ---------------------- Run Length Encoding
if ( Header->IsRLELossLessTransferSyntax() )
{
- bool res = (bool)gdcm_read_RLE_file (fp,destination);
+ bool res = gdcm_read_RLE_file (fp,destination);
Header->CloseFile();
return res;
}
if ( jpg2000 )
{
// JPEG 2000 : call to ???
- res = (bool)gdcm_read_JPEG2000_file (fp,destination); // Not Yet written
+ res = gdcm_read_JPEG2000_file (fp,destination); // Not Yet written
// ------------------------------------- endif (JPEG2000)
}
else if (jpgLossless)
if ( Header->GetBitsStored() == 8)
{
// Reading Fragment pixels
- res = (bool)gdcm_read_JPEG_file (fp,destination);
+ res = gdcm_read_JPEG_file (fp,destination);
}
else
{
// Reading Fragment pixels
- res = (bool)gdcm_read_JPEG_file12 (fp,destination);
+ res = gdcm_read_JPEG_file12 (fp,destination);
}
// ------------------------------------- endif (JPEGLossy)
}