-// gdcmFile.cxx
-//-----------------------------------------------------------------------------
+/*=========================================================================
+
+ Program: gdcm
+ Module: $RCSfile: gdcmFile.cxx,v $
+ Language: C++
+ Date: $Date: 2004/06/22 14:14:01 $
+ Version: $Revision: 1.106 $
+
+ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
+ l'Image). All rights reserved. See Doc/License.txt or
+ http://www.creatis.insa-lyon.fr/Public/Gdcm/License.htm for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+
#include "gdcmFile.h"
#include "gdcmDebug.h"
#include "jpeg/ljpg/jpegless.h"
-typedef std::pair<TagHeaderEntryHT::iterator,TagHeaderEntryHT::iterator> IterHT;
+typedef std::pair<TagDocEntryHT::iterator,TagDocEntryHT::iterator> IterHT;
//-----------------------------------------------------------------------------
// Constructor / Destructor
* 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;
* with a FALSE value for the 'enable_sequence' param.
* ('public elements' may be embedded in 'shadow Sequences')
*/
-gdcmFile::gdcmFile(std::string & filename,
+gdcmFile::gdcmFile(std::string const & filename,
bool exception_on_error,
bool enable_sequences,
bool ignore_shadow) {
SetPixelDataSizeFromHeader();
}
-/**
- * \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
//-----------------------------------------------------------------------------
// 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
* 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
*/
void * gdcmFile::GetImageData (void) {
PixelData = new char[lgrTotale];
- if (PixelData)
+ if (PixelData) {
GetImageDataIntoVector(PixelData, lgrTotale);
-
+ GetHeader()->SetEntryVoidAreaByNumber(PixelData,
+ GetHeader()->GetGrPixel(),
+ GetHeader()->GetNumPixel());
+ }
PixelRead=0; // no PixelRaw
+
return(PixelData);
}
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();
+ unsigned char *newDest = new unsigned char[lgrTotale];
+ 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
/// Create a member lgrTotaleRaw ???
lgrTotale /= 3;
PixelData = new char[lgrTotale];
- if (PixelData)
+
+ if (PixelData) {
GetImageDataIntoVectorRaw(PixelData, lgrTotale);
+ GetHeader()->SetEntryVoidAreaByNumber(PixelData,
+ GetHeader()->GetGrPixel(),
+ GetHeader()->GetNumPixel());
+ }
PixelRead=1; // PixelRaw
return(PixelData);
}
* @return On success, the number of bytes actually copied. Zero on
* failure e.g. MaxSize is lower than necessary.
*/
-size_t gdcmFile::GetImageDataIntoVectorRaw (void* destination, size_t MaxSize) {
+size_t gdcmFile::GetImageDataIntoVectorRaw (void *destination, size_t MaxSize) {
int nb, nbu, highBit, signe;
std::string str_nbFrames, str_nb, str_nbu, str_highBit, str_signe;
int l = Header->GetXSize()*Header->GetYSize();
int nbFrames = Header->GetZSize();
- 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;
+ 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
int l = Header->GetXSize()*Header->GetYSize()*Header->GetZSize();
- char * newDest = new char[lgrTotale];
- char * x = newDest;
- char * a = (char *)destination;
- char * b = a + l;
- char * c = b + l;
+ char *newDest = new char[lgrTotale];
+ char *x = newDest;
+ char *a = (char *)destination;
+ char *b = a + l;
+ char *c = b + l;
for (int j=0;j<l; j++) {
*(x++) = *(a++);
*
* @return boolean
*/
-bool gdcmFile::SetImageData(void * inData, size_t ExpectedSize) {
+bool gdcmFile::SetImageData(void *inData, size_t ExpectedSize) {
Header->SetImageDataSize(ExpectedSize);
PixelData = inData;
lgrTotale = ExpectedSize;
+ PixelRead = 1;
return(true);
}
*/
bool gdcmFile::WriteRawData (std::string fileName) {
- FILE * fp1;
+ FILE *fp1;
fp1 = fopen(fileName.c_str(),"wb");
if (fp1 == NULL) {
printf("Fail to open (write) file [%s] \n",fileName.c_str());
*/
bool gdcmFile::WriteDcmImplVR (std::string fileName) {
- return WriteBase(fileName, ImplicitVR);
+ return WriteBase(fileName, gdcmImplicitVR);
}
/**
* @return false if write fails
*/
-bool gdcmFile::WriteDcmImplVR (const char* fileName) {
+bool gdcmFile::WriteDcmImplVR (const char *fileName) {
return WriteDcmImplVR (std::string (fileName));
}
*/
bool gdcmFile::WriteDcmExplVR (std::string fileName) {
- return WriteBase(fileName, ExplicitVR);
+ return WriteBase(fileName, gdcmExplicitVR);
}
/**
*/
bool gdcmFile::WriteAcr (std::string fileName) {
- return WriteBase(fileName, ACR);
+ return WriteBase(fileName, gdcmACR);
}
//-----------------------------------------------------------------------------
*/
bool gdcmFile::WriteBase (std::string fileName, FileType type) {
- FILE * fp1;
+ FILE *fp1;
- if (PixelRead==-1 && type != ExplicitVR) {
+ if (PixelRead==-1 && type != gdcmExplicitVR) {
return false;
}
return (false);
}
- if ( (type == ImplicitVR) || (type == ExplicitVR) ) {
- char * filePreamble;
+ if ( (type == gdcmImplicitVR) || (type == gdcmExplicitVR) ) {
+ char *filePreamble;
// writing Dicom File Preamble
filePreamble=new char[128];
memset(filePreamble,0,128);
/// but pb expected if user deals with, e.g. COMPLEX images
std::string rows, columns;
- if ( Header->GetFileType() == ACR_LIBIDO){
+ if ( Header->GetFileType() == gdcmACR_LIBIDO){
rows = Header->GetEntryByNumber(0x0028, 0x0010);
columns = Header->GetEntryByNumber(0x0028, 0x0011);
Header->SetEntryByNumber(columns, 0x0028, 0x0010);
// the *last* of the (GrPixel, NumPixel), if many.
TagKey key = gdcmDictEntry::TranslateToKey(grPixel, numPixel);
- TagHeaderEntryHT::iterator p2;
- gdcmHeaderEntry * PixelElement;
+ TagDocEntryHT::iterator p2;
+ gdcmDocEntry *PixelElement;
IterHT it= Header->GetEntry().equal_range(key); // get a pair of iterators first-last synonym
// ...and we restore the Header to be Dicom Compliant again
// just after writting
- if (Header->GetFileType() == ACR_LIBIDO){
+ if (Header->GetFileType() == gdcmACR_LIBIDO){
Header->SetEntryByNumber(rows , 0x0028, 0x0010);
Header->SetEntryByNumber(columns, 0x0028, 0x0011);
}
// ----------------- End of Special Patch ----------------
- fwrite(PixelData, lgrTotale, 1, fp1);
+ // fwrite(PixelData, lgrTotale, 1, fp1); // should be useless, now
fclose (fp1);
return(true);
}
* @param lgr Area Length
* @param nb Pixels Bit number
*/
-void gdcmFile::SwapZone(void* im, int swap, int lgr, int nb) {
+void gdcmFile::SwapZone(void *im, int swap, int lgr, int nb) {
guint32 s32;
guint16 fort,faible;
int i;
case 4321:
for(i=0;i<lgr/2;i++) {
- ((unsigned short int*)im)[i]= ((((unsigned short int*)im)[i])>>8)
- | ((((unsigned short int*)im)[i])<<8);
+ ((unsigned short int *)im)[i]= ((((unsigned short int *)im)[i])>>8)
+ | ((((unsigned short int *)im)[i])<<8);
}
break;
case 4321:
for(i=0;i<lgr/4;i++) {
- faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 4321 */
- fort =((unsigned long int*)im)[i]>>16;
+ faible= ((unsigned long int *)im)[i]&0x0000ffff; /* 4321 */
+ fort =((unsigned long int *)im)[i]>>16;
fort= (fort>>8) | (fort<<8);
faible=(faible>>8) | (faible<<8);
s32=faible;
- ((unsigned long int*)im)[i]=(s32<<16)|fort;
+ ((unsigned long int *)im)[i]=(s32<<16)|fort;
}
break;
case 2143:
for(i=0;i<lgr/4;i++) {
- faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 2143 */
- fort=((unsigned long int*)im)[i]>>16;
+ faible= ((unsigned long int *)im)[i]&0x0000ffff; /* 2143 */
+ fort=((unsigned long int *)im)[i]>>16;
fort= (fort>>8) | (fort<<8);
faible=(faible>>8) | (faible<<8);
s32=fort;
- ((unsigned long int*)im)[i]=(s32<<16)|faible;
+ ((unsigned long int *)im)[i]=(s32<<16)|faible;
}
break;
case 3412:
for(i=0;i<lgr/4;i++) {
- faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 3412 */
- fort=((unsigned long int*)im)[i]>>16;
+ faible= ((unsigned long int *)im)[i]&0x0000ffff; /* 3412 */
+ fort=((unsigned long int *)im)[i]>>16;
s32=faible;
- ((unsigned long int*)im)[i]=(s32<<16)|fort;
+ ((unsigned long int *)im)[i]=(s32<<16)|fort;
}
break;
* @param destination where the pixel data should be stored.
*
*/
-bool gdcmFile::ReadPixelData(void* destination) {
+bool gdcmFile::ReadPixelData(void *destination) {
FILE *fp;
int nbPixels = Header->GetXSize() * Header->GetYSize();
unsigned char b0, b1, b2;
- unsigned short int* pdestination = (unsigned short int*)destination;
+ unsigned short int *pdestination = (unsigned short int*)destination;
for(int p=0;p<nbPixels;p+=2) {
fread(&b0,1,1,fp);
fread(&b1,1,1,fp);
JPEGLosslessDecodeImage (fp, // Reading Fragment pixels
(unsigned short *)destination,
- Header->GetPixelSize()*8* Header->GetSamplesPerPixel(),
+ Header->GetPixelSize() * 8 * Header->GetSamplesPerPixel(),
ln);
res=1; // in order not to break the loop
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff