// gdcmFile.cxx
//-----------------------------------------------------------------------------
#include "gdcmFile.h"
-#include "gdcmUtil.h"
+#include "gdcmDebug.h"
#include "jpeg/ljpg/jpegless.h"
+typedef std::pair<TagHeaderEntryHT::iterator,TagHeaderEntryHT::iterator> IterHT;
+
//-----------------------------------------------------------------------------
// Constructor / Destructor
/**
* file (see SetFileName, SetDcmTag and Write)
* Opens (in read only and when possible) an existing file and checks
* for DICOM compliance. Returns NULL on failure.
- * \Note the in-memory representation of all available tags found in
+ * \note the in-memory representation of all available tags found in
* the DICOM header is post-poned to first header information access.
* This avoid a double parsing of public part of the header when
* 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
*/
-
gdcmFile::gdcmFile(gdcmHeader *header) {
Header=header;
SelfHeader=false;
+ PixelRead=-1; // no ImageData read yet.
if (Header->IsReadable())
SetPixelDataSizeFromHeader();
* file (see SetFileName, SetDcmTag and Write)
* Opens (in read only and when possible) an existing file and checks
* for DICOM compliance. Returns NULL on failure.
- * \Note the in-memory representation of all available tags found in
+ * \note the in-memory representation of all available tags found in
* the DICOM header is post-poned to first header information access.
* This avoid a double parsing of public part of the header when
* one sets an a posteriori shadow dictionary (efficiency can be
* seen as a side effect).
* @param filename file to be opened for parsing
- * @return
+ * @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 & filename) {
- Header=new gdcmHeader(filename.c_str());
+gdcmFile::gdcmFile(std::string & filename,
+ bool exception_on_error,
+ bool enable_sequences,
+ bool ignore_shadow) {
+ Header=new gdcmHeader(filename.c_str(),
+ exception_on_error,
+ enable_sequences,
+ ignore_shadow);
SelfHeader=true;
+ PixelRead=-1; // no ImageData read yet.
if (Header->IsReadable())
SetPixelDataSizeFromHeader();
}
-gdcmFile::gdcmFile(const char * filename) {
- Header=new gdcmHeader(filename);
+/**
+ * \ingroup gdcmFile
+ * \brief Constructor dedicated to writing a new DICOMV3 part10 compliant
+ * file (see SetFileName, SetDcmTag and Write)
+ * Opens (in read only and when possible) an existing file and checks
+ * for DICOM compliance. Returns NULL on failure.
+ * \note the in-memory representation of all available tags found in
+ * the DICOM header is post-poned to first header information access.
+ * This avoid a double parsing of public part of the header when
+ * 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(const char * filename,
+ bool exception_on_error,
+ bool enable_sequences,
+ bool ignore_shadow) {
+ Header=new gdcmHeader(filename,
+ exception_on_error,
+ enable_sequences,
+ ignore_shadow);
SelfHeader=true;
+ PixelRead=-1; // no ImageData read yet.
if (Header->IsReadable())
SetPixelDataSizeFromHeader();
/**
* \ingroup gdcmFile
* \brief canonical destructor
- * \Note If the gdcmHeader is created by the gdcmFile, it is destroyed
+ * \note If the gdcmHeader is created by the gdcmFile, it is destroyed
* by the gdcmFile
*/
gdcmFile::~gdcmFile(void) {
// Public
/**
* \ingroup gdcmFile
- * \brief
+ * \brief returns the gdcmHeader *Header
* @return
*/
gdcmHeader *gdcmFile::GetHeader(void) {
int nb;
std::string str_nb;
- str_nb=Header->GetPubEntryByNumber(0x0028,0x0100);
+ str_nb=Header->GetEntryByNumber(0x0028,0x0100);
if (str_nb == GDCM_UNFOUND ) {
nb = 16;
} else {
lgrTotale = lgrTotaleRaw = Header->GetXSize() * Header->GetYSize()
* Header->GetZSize() * (nb/8)* Header->GetSamplesPerPixel();
std::string str_PhotometricInterpretation =
- Header->GetPubEntryByNumber(0x0028,0x0004);
+ Header->GetEntryByNumber(0x0028,0x0004);
/*if ( str_PhotometricInterpretation == "PALETTE COLOR " )*/
// pb when undealt Segmented Palette Color
/**
* \ingroup gdcmFile
* \brief Returns the size (in bytes) of required memory to hold
- * \ the pixel data represented in this file, when user DOESN'T want
- * \ to get RGB pixels image when it's stored as a PALETTE COLOR image
- * \ - the (vtk) user is supposed to know how deal with LUTs -
+ * the pixel data represented in this file, when user DOESN'T want
+ * to get RGB pixels image when it's stored as a PALETTE COLOR image
+ * -the (vtk) user is supposed to know how deal with LUTs-
* \warning to be used with GetImagePixelsRaw()
* @return The size of pixel data in bytes.
*/
* \brief Allocates necessary memory, copies the pixel data
* (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
- Transforms single Grey plane + 3 Palettes into a RGB Plane
+ * Transforms 3 planes R, G, B into a single RGB Plane
+ * Transforms single Grey plane + 3 Palettes into a RGB Plane
* @return Pointer to newly allocated pixel data.
- * \ NULL if alloc fails
+ * NULL if alloc fails
*/
void * gdcmFile::GetImageData (void) {
- PixelData = (void *) malloc(lgrTotale);
+ PixelData = new char[lgrTotale];
if (PixelData)
GetImageDataIntoVector(PixelData, lgrTotale);
+
+ PixelRead=0; // no PixelRaw
return(PixelData);
}
* failure e.g. MaxSize is lower than necessary.
*/
size_t gdcmFile::GetImageDataIntoVector (void* destination, size_t MaxSize) {
- size_t l = GetImageDataIntoVectorRaw (destination, MaxSize);
-
+ //size_t l = 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 = (unsigned char *)malloc(lgrTotale);
+ unsigned char * newDest = new (unsigned char)[lgrTotale];
unsigned char * a = (unsigned char *)destination;
unsigned char * lutRGBA = Header->GetLUTRGBA();
if (lutRGBA) {
*a++ = lutRGBA[j+1];
*a++ = lutRGBA[j+2];
}
- free(newDest);
+ delete[] newDest;
// now, it's an RGB image
// Lets's write it in the Header
// CreateOrReplaceIfExist ?
std::string spp = "3"; // Samples Per Pixel
- Header->SetPubEntryByNumber(spp,0x0028,0x0002);
+ Header->SetEntryByNumber(spp,0x0028,0x0002);
std::string rgb= "RGB "; // Photometric Interpretation
- Header->SetPubEntryByNumber(rgb,0x0028,0x0004);
+ Header->SetEntryByNumber(rgb,0x0028,0x0004);
std::string planConfig = "0"; // Planar Configuration
- Header->SetPubEntryByNumber(planConfig,0x0028,0x0006);
+ Header->SetEntryByNumber(planConfig,0x0028,0x0006);
} else {
// need to make RGB Pixels (?)
// Segmented xxx Palette Color are *more* than 65535 long ?!?
std::string rgb= "MONOCHROME1 "; // Photometric Interpretation
- Header->SetPubEntryByNumber(rgb,0x0028,0x0004);
+ Header->SetEntryByNumber(rgb,0x0028,0x0004);
}
- // TODO : Drop Palette Color out of the Header?
+ /// \todo Drop Palette Color out of the Header?
return lgrTotale;
}
* \brief Allocates necessary memory, copies the pixel data
* (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
+ * Transforms 3 planes R, G, B into a single 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) {
if (Header->HasLUT())
- lgrTotale /= 3; // TODO Let gdcmHeadar user a chance
- // to get the right value
- // Create a member lgrTotaleRaw ???
- PixelData = (void *) malloc(lgrTotale);
+ /// \todo Let gdcmHeadar user a chance to get the right value
+ /// Create a member lgrTotaleRaw ???
+ lgrTotale /= 3;
+ PixelData = new char[lgrTotale];
if (PixelData)
GetImageDataIntoVectorRaw(PixelData, lgrTotale);
+ PixelRead=1; // PixelRaw
return(PixelData);
}
int nb, nbu, highBit, signe;
std::string str_nbFrames, str_nb, str_nbu, str_highBit, str_signe;
+ PixelRead=1 ; // PixelRaw
if ( lgrTotale > MaxSize ) {
dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: pixel data bigger"
}
(void)ReadPixelData(destination);
-
+
// Number of Bits Allocated for storing a Pixel
- str_nb = Header->GetPubEntryByNumber(0x0028,0x0100);
+ 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
- str_nbu=Header->GetPubEntryByNumber(0x0028,0x0101);
+ str_nbu=Header->GetEntryByNumber(0x0028,0x0101);
if (str_nbu == GDCM_UNFOUND ) {
nbu = nb;
} else {
nbu = atoi(str_nbu.c_str() );
}
// High Bit Position
- str_highBit=Header->GetPubEntryByNumber(0x0028,0x0102);
+ str_highBit=Header->GetEntryByNumber(0x0028,0x0102);
if (str_highBit == GDCM_UNFOUND ) {
highBit = nb - 1;
} else {
// Pixel sign
// 0 = Unsigned
// 1 = Signed
- str_signe=Header->GetPubEntryByNumber(0x0028,0x0103);
+ str_signe=Header->GetEntryByNumber(0x0028,0x0103);
if (str_signe == GDCM_UNFOUND ) {
signe = 0; // default is unsigned
} else {
deb++;
}
}
-
// re arange bits inside the bytes
if (nbu != nb){
int l = (int)lgrTotale / (nb/8);
return (size_t)0;
}
}
-// DO NOT remove this code commented out.
+// DO NOT remove this commented out code .
// Nobody knows what's expecting you ...
// Just to 'see' what was actually read on disk :-(
+
// FILE * f2;
-// f2 = fopen("SpuriousFile.raw","wb");
+// f2 = fopen("SpuriousFile.RAW","wb");
// fwrite(destination,lgrTotale,1,f2);
// fclose(f2);
// -------------------
std::string str_PhotometricInterpretation =
- Header->GetPubEntryByNumber(0x0028,0x0004);
+ Header->GetEntryByNumber(0x0028,0x0004);
if ( (str_PhotometricInterpretation == "MONOCHROME1 ")
|| (str_PhotometricInterpretation == "MONOCHROME2 ") ) {
int l = Header->GetXSize()*Header->GetYSize();
int nbFrames = Header->GetZSize();
- unsigned char * newDest = (unsigned char*) malloc(lgrTotale);
+ unsigned char * newDest = new (unsigned char)[lgrTotale];
unsigned char *x = newDest;
unsigned char * a = (unsigned char *)destination;
unsigned char * b = a + l;
unsigned char * c = b + l;
double R,G,B;
- // TODO : Replace by the 'well known'
- // integer computation counterpart
- // see http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
- // for code optimisation
+ /// \todo : Replace by the 'well known' integer computation
+ /// counterpart
+ /// 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++) {
}
}
memmove(destination,newDest,lgrTotale);
- free(newDest);
+ delete[] newDest;
} else {
int l = Header->GetXSize()*Header->GetYSize()*Header->GetZSize();
- char * newDest = (char*) malloc(lgrTotale);
+ char * newDest = new char[lgrTotale];
char * x = newDest;
char * a = (char *)destination;
char * b = a + l;
*(x++) = *(c++);
}
memmove(destination,newDest,lgrTotale);
- free(newDest);
+ delete[] newDest;
}
break;
}
// CreateOrReplaceIfExist ?
std::string spp = "3"; // Samples Per Pixel
- Header->SetPubEntryByNumber(spp,0x0028,0x0002);
+ Header->SetEntryByNumber(spp,0x0028,0x0002);
std::string rgb="RGB "; // Photometric Interpretation
- Header->SetPubEntryByNumber(rgb,0x0028,0x0004);
+ Header->SetEntryByNumber(rgb,0x0028,0x0004);
std::string planConfig = "0"; // Planar Configuration
- Header->SetPubEntryByNumber(planConfig,0x0028,0x0006);
+ 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 TODO JPR
- * \warning doit-etre etre publique ?
- * TODO : y a-t-il un inconvenient à fusioner ces 2 fonctions
- *
- * @param inData
- * @param ExpectedSize
+ * \brief performs a shadow 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
+ * \warning user is kindly requested NOT TO 'free' the Pixel area
+ * @param inData user supplied pixel area
+ * @param ExpectedSize total image size, in Bytes
*
* @return boolean
*/
/**
* \ingroup gdcmFile
- * \brief Ecrit sur disque les pixels d'UNE image
- * Aucun test n'est fait sur l'"Endiannerie" du processeur.
- * Ca sera à l'utilisateur d'appeler son Reader correctement
- * (Equivalent a IdImaWriteRawFile)
- *
+ * \brief Writes on disk A SINGLE Dicom file
+ * NO test is performed on processor "Endiannity".
+ * 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
FILE * fp1;
fp1 = fopen(fileName.c_str(),"wb");
if (fp1 == NULL) {
- printf("Echec ouverture (ecriture) Fichier [%s] \n",fileName.c_str());
+ printf("Fail to open (write) file [%s] \n",fileName.c_str());
return (false);
}
fwrite (PixelData,lgrTotale, 1, fp1);
/**
* \ingroup gdcmFile
- * \brief Ecrit sur disque UNE image Dicom
- * Aucun test n'est fait sur l'"Endiannerie" du processeur.
- * Ca fonctionnera correctement (?) sur processeur Intel
- * (Equivalent a IdDcmWrite)
- *
+ * \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
/**
* \ingroup gdcmFile
- * \brief
- * @param fileName name of the file to be created
+ * \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
*/
/**
* \ingroup gdcmFile
- * \brief
- * @param fileName name of the file to be created
- * (any already existing file is over written)
+* \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
*/
/**
* \ingroup gdcmFile
- * \brief Ecrit au format ACR-NEMA sur disque l'entete et les pixels
+ * \brief Writes on disk A SINGLE Dicom file,
+ * using the ACR-NEMA convention
+ * NO test is performed on processor "Endiannity".
* (a l'attention des logiciels cliniques
* qui ne prennent en entrée QUE des images ACR ...
* \warning if a DICOM_V3 header is supplied,
- * groups < 0x0008 and shadow groups are ignored)
- * \warning NO TEST is performed on processor "Endiannerie".
- * Ca fonctionnera correctement (?) sur processeur Intel
- * (Equivalent a IdDcmWrite)
- *
+ * groups < 0x0008 and shadow groups are ignored
+ * \warning NO TEST is performed on processor "Endiannity".
* @param fileName name of the file to be created
- * (any already existing file is over written)
+ * (any already existing file is overwritten)
* @return false if write fails
*/
// Protected
/**
* \ingroup gdcmFile
- *
-* @param fileName name of the file to be created
- * (any already existing file is over written)
+ * \brief NOT a end user inteded function
+ * (used by WriteDcmExplVR, WriteDcmImplVR, WriteAcr, etc)
+ * @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
*/
-bool gdcmFile::WriteBase (std::string FileName, FileType type) {
+bool gdcmFile::WriteBase (std::string fileName, FileType type) {
FILE * fp1;
- fp1 = fopen(FileName.c_str(),"wb");
+
+ if (PixelRead==-1 && type != ExplicitVR) {
+ return false;
+ }
+
+ fp1 = fopen(fileName.c_str(),"wb");
if (fp1 == NULL) {
- printf("Echec ouverture (ecriture) Fichier [%s] \n",FileName.c_str());
+ printf("Failed to open (write) File [%s] \n",fileName.c_str());
return (false);
}
if ( (type == ImplicitVR) || (type == ExplicitVR) ) {
char * filePreamble;
// writing Dicom File Preamble
- filePreamble=(char*)calloc(128,1);
+ filePreamble=new char[128];
fwrite(filePreamble,128,1,fp1);
fwrite("DICM",4,1,fp1);
+ delete[] filePreamble;
}
// --------------------------------------------------------------
// if recognition code tells us we dealt with a LibIDO image
// we reproduce on disk the switch between lineNumber and columnNumber
// just before writting ...
+
+ /// \todo the best trick would be *change* the recognition code
+ /// but pb expected if user deals with, e.g. COMPLEX images
std::string rows, columns;
if ( Header->GetFileType() == ACR_LIBIDO){
- rows = Header->GetPubEntryByNumber(0x0028, 0x0010);
- columns = Header->GetPubEntryByNumber(0x0028, 0x0011);
- Header->SetPubEntryByNumber(columns, 0x0028, 0x0010);
- Header->SetPubEntryByNumber(rows , 0x0028, 0x0011);
+ rows = Header->GetEntryByNumber(0x0028, 0x0010);
+ 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)
+
+ guint16 grPixel =Header->GetGrPixel();
+ guint16 numPixel=Header->GetNumPixel();;
+
+ // Update Pixel Data Length
+ // the *last* of the (GrPixel, NumPixel), if many.
+
+ TagKey key = gdcmDictEntry::TranslateToKey(grPixel, numPixel);
+ TagHeaderEntryHT::iterator p2;
+ gdcmHeaderEntry * 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();
+
+ if (PixelRead==1)
+ PixelElement->SetLength(lgrTotaleRaw);
+ else if (PixelRead==0)
+ PixelElement->SetLength(lgrTotale);
+
+ //PixelElement->SetPrintLevel(2);
+ //PixelElement->Print();
Header->Write(fp1, type);
// --------------------------------------------------------------
// just after writting
if (Header->GetFileType() == ACR_LIBIDO){
- Header->SetPubEntryByNumber(rows , 0x0028, 0x0010);
- Header->SetPubEntryByNumber(columns, 0x0028, 0x0011);
+ Header->SetEntryByNumber(rows , 0x0028, 0x0010);
+ Header->SetEntryByNumber(columns, 0x0028, 0x0011);
}
// ----------------- End of Special Patch ----------------
-
+
fwrite(PixelData, lgrTotale, 1, fp1);
fclose (fp1);
return(true);
case 2143:
case 4321:
- for(i=0;i<lgr;i++)
+ 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:
break;
case 4321:
- for(i=0;i<lgr;i++) {
+ for(i=0;i<lgr/4;i++) {
faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 4321 */
fort =((unsigned long int*)im)[i]>>16;
fort= (fort>>8) | (fort<<8);
break;
case 2143:
- for(i=0;i<lgr;i++) {
+ for(i=0;i<lgr/4;i++) {
faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 2143 */
fort=((unsigned long int*)im)[i]>>16;
fort= (fort>>8) | (fort<<8);
break;
case 3412:
- for(i=0;i<lgr;i++) {
+ for(i=0;i<lgr/4;i++) {
faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 3412 */
fort=((unsigned long int*)im)[i]>>16;
s32=faible;
if ( !(fp=Header->OpenFile()))
return false;
-
if ( fseek(fp, Header->GetPixelOffset(), SEEK_SET) == -1 ) {
Header->CloseFile();
return false;
}
-
-
// ---------------------- Compacted File (12 Bits Per Pixel)
/* unpack 12 Bits pixels into 16 Bits pixels */
/* 2 pixels 12bit = [0xABCDEF] */
/* 2 pixels 16bit = [0x0ABD] + [0x0FCE] */
+
if (Header->GetBitsAllocated()==12) {
int nbPixels = Header->GetXSize() * Header->GetYSize();
unsigned char b0, b1, b2;
fread(&b2,1,1,fp);
//Two steps is necessary to please VC++
*pdestination++ = ((b0 >> 4) << 8) + ((b0 & 0x0f) << 4) + (b1 & 0x0f);
- /* A */ /* B */ /* D */
+ /* A */ /* B */ /* D */
*pdestination++ = ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4);
- /* F */ /* C */ /* E */
+ /* F */ /* C */ /* E */
// Troubles expected on Big-Endian processors ?
}
+
+ Header->CloseFile();
return(true);
}
Header->IsDeflatedExplicitVRLittleEndianTransferSyntax() ) {
size_t ItemRead = fread(destination, Header->GetPixelAreaLength(), 1, fp);
-
if ( ItemRead != 1 ) {
Header->CloseFile();
return false;
// ---------------------- Run Length Encoding
if (Header->IsRLELossLessTransferSyntax()) {
- bool res = (bool)gdcm_read_RLE_file (fp,destination);
- return res;
+ bool res = (bool)gdcm_read_RLE_file (fp,destination);
+ Header->CloseFile();
+ return res;
}
// --------------- SingleFrame/Multiframe JPEG Lossless/Lossy/2000
int nb;
- std::string str_nb=Header->GetPubEntryByNumber(0x0028,0x0100);
+ std::string str_nb=Header->GetEntryByNumber(0x0028,0x0100);
if (str_nb == GDCM_UNFOUND ) {
nb = 16;
} else {
int taille = Header->GetXSize() * Header->GetYSize()
* Header->GetSamplesPerPixel();
long fragmentBegining; // for ftell, fseek
-
+
bool jpg2000 = Header->IsJPEG2000();
bool jpgLossless = Header->IsJPEGLossless();
guint16 ItemTagGr,ItemTagEl;
int ln;
- // Position on begining of Jpeg Pixels
+ // Position on begining of Jpeg Pixels
fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr
fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El
if (ln != 0) {
// What is it used for ?!?
- char *BasicOffsetTableItemValue = (char *)malloc(ln+1);
+ char *BasicOffsetTableItemValue = new char[ln+1];
fread(BasicOffsetTableItemValue,ln,1,fp);
}
}
// parsing fragments until Sequence Delim. Tag found
- while ( ( ItemTagGr == 0xfffe) && (ItemTagEl != 0xe0dd) ) {
+ while ( ( ItemTagGr == 0xfffe) && (ItemTagEl != 0xe0dd) ) {
// --- for each Fragment
fread(&ln,4,1,fp);
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff