#include <fstream>
#include "gdcmDict.h"
#include "gdcmUtil.h"
-using namespace std;
/**
* \ingroup gdcmDict
from.getline(buff, 256, '\n');
name = buff;
gdcmDictEntry * newEntry = new gdcmDictEntry(group, element,
- vr, fourth, name);
+ vr, fourth, name);
// FIXME: use AddNewEntry
NameHt[name] = newEntry;
KeyHt[gdcmDictEntry::TranslateToKey(group, element)] = newEntry;
gdcmDictEntry::gdcmDictEntry(guint16 InGroup, guint16 InElement,
- std::string InVr, std::string InFourth,
- std::string InName) {
+ std::string InVr, std::string InFourth,
+ std::string InName) {
group = InGroup;
element = InElement;
vr = InVr;
#include <stdlib.h> // For getenv
#include "gdcmUtil.h"
#include "gdcmDictSet.h"
-using namespace std;
#define PUB_DICT_NAME "DicomV3Dict"
#ifndef PUB_DICT_PATH
* \sa gdcmDictSet::GetPubDictTagNamesByCategory
* @return A list of all entries of the public dicom dictionnary.
*/
-list<string> * gdcmDictSet::GetPubDictTagNames(void) {
- list<string> * Result = new list<string>;
+std::list<std::string> * gdcmDictSet::GetPubDictTagNames(void) {
+ std::list<std::string> * Result = new std::list<std::string>;
TagKeyHT entries = GetDefaultPubDict()->GetEntries();
for (TagKeyHT::iterator tag = entries.begin(); tag != entries.end(); ++tag){
* corresponding values are lists of all the dictionnary entries
* among that group.
*/
-map<string, list<string> > * gdcmDictSet::GetPubDictTagNamesByCategory(void) {
- map<string, list<string> > * Result = new map<string, list<string> >;
+std::map<std::string, std::list<std::string> > * gdcmDictSet::GetPubDictTagNamesByCategory(void) {
+ std::map<std::string, std::list<std::string> > * Result = new map<std::string, std::list<std::string> >;
TagKeyHT entries = GetDefaultPubDict()->GetEntries();
for (TagKeyHT::iterator tag = entries.begin(); tag != entries.end(); ++tag){
* the environnement variable is absent the path is defaulted
* to "../Dicts/".
*/
-string gdcmDictSet::BuildDictPath(void) {
- string ResultPath;
+std::string gdcmDictSet::BuildDictPath(void) {
+ std::string ResultPath;
const char* EnvPath = (char*)0;
EnvPath = getenv("GDCM_DICT_PATH");
if (EnvPath && (strlen(EnvPath) != 0)) {
*/
gdcmDictSet::gdcmDictSet(void) {
DictPath = BuildDictPath();
- string PubDictFile = DictPath + PUB_DICT_FILENAME;
+ std::string PubDictFile = DictPath + PUB_DICT_FILENAME;
Dicts[PUB_DICT_NAME] = new gdcmDict(PubDictFile);
}
* @param Name Symbolic name that be used as identifier of the newly
* created dictionary.
*/
-void gdcmDictSet::LoadDictFromFile(string FileName, DictKey Name) {
+void gdcmDictSet::LoadDictFromFile(std::string FileName, DictKey Name) {
gdcmDict *NewDict = new gdcmDict(FileName);
Dicts[Name] = NewDict;
}
#include "gdcmUtil.h"
#include "gdcmElValSet.h"
#include "gdcmTS.h"
-using namespace std;
gdcmElValSet::~gdcmElValSet() {
for (TagElValueHT::iterator tag = tagHt.begin(); tag != tagHt.end(); ++tag) {
* @return
*/
int gdcmElValSet::CheckIfExistByNumber(guint16 Group, guint16 Elem ) {
- string key = TranslateToKey(Group, Elem );
+ std::string key = TranslateToKey(Group, Elem );
return (tagHt.count(key));
}
size_t o;
short int g, e;
TSKey v;
- string d2;
+ std::string d2;
gdcmTS * ts = gdcmGlobal::GetTS();
for (TagElValueHT::iterator tag = tagHt.begin();
* \brief
* @return
*/
-gdcmElValue* gdcmElValSet::GetElementByName(string TagName) {
+gdcmElValue* gdcmElValSet::GetElementByName(std::string TagName) {
if ( ! NameHt.count(TagName))
return (gdcmElValue*)0;
return NameHt.find(TagName)->second;
* @param element
* @return
*/
-string gdcmElValSet::GetElValueByNumber(guint16 group, guint16 element) {
+std::string gdcmElValSet::GetElValueByNumber(guint16 group, guint16 element) {
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHt.count(key))
return GDCM_UNFOUND;
* \brief
* @return
*/
-string gdcmElValSet::GetElValueByName(string TagName) {
+std::string gdcmElValSet::GetElValueByName(std::string TagName) {
if ( ! NameHt.count(TagName))
return GDCM_UNFOUND;
return NameHt.find(TagName)->second->GetValue();
* @param element
* @return
*/
-int gdcmElValSet::SetElValueByNumber(string content,
+int gdcmElValSet::SetElValueByNumber(std::string content,
guint16 group, guint16 element) {
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHt.count(key))
return 0;
tagHt[key]->SetValue(content);
- string vr = tagHt[key]->GetVR();
+ std::string vr = tagHt[key]->GetVR();
guint32 lgr;
if( (vr == "US") || (vr == "SS") )
* @param TagName
* @return
*/
-int gdcmElValSet::SetElValueByName(string content, string TagName) {
+int gdcmElValSet::SetElValueByName(std::string content, std::string TagName) {
if ( ! NameHt.count(TagName))
return 0;
NameHt[TagName]->SetValue(content);
- string vr = NameHt[TagName]->GetVR();
+ std::string vr = NameHt[TagName]->GetVR();
guint32 lgr;
if( (vr == "US") || (vr == "SS") )
* @param TagName
* @return
*/
-int gdcmElValSet::SetElValueLengthByName(guint32 length, string TagName) {
+int gdcmElValSet::SetElValueLengthByName(guint32 length, std::string TagName) {
if ( ! NameHt.count(TagName))
return 0;
NameHt.find(TagName)->second->SetLength(length);
*/
void gdcmElValSet::UpdateGroupLength(bool SkipSequence, FileType type) {
guint16 gr, el;
- string vr;
+ std::string vr;
gdcmElValue *elem;
char trash[10];
- string str_trash;
+ std::string str_trash;
GroupKey key;
GroupHT groupHt; // to hold the length of each group
guint16 gr, el;
guint32 lgr;
const char * val;
- string vr;
+ std::string vr;
guint32 val_uint32;
guint16 val_uint16;
- vector<string> tokens;
+ vector<std::string> tokens;
void *ptr;
int gdcmElValSet::Write(FILE * _fp, FileType type) {
if (type == ImplicitVR) {
- string implicitVRTransfertSyntax = "1.2.840.10008.1.2";
+ std::string implicitVRTransfertSyntax = "1.2.840.10008.1.2";
SetElValueByNumber(implicitVRTransfertSyntax, 0x0002, 0x0010);
//FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
// no way
if (type == ExplicitVR) {
- string explicitVRTransfertSyntax = "1.2.840.10008.1.2.1";
+ std::string explicitVRTransfertSyntax = "1.2.840.10008.1.2.1";
SetElValueByNumber(explicitVRTransfertSyntax, 0x0002, 0x0010);
// See above comment
SetElValueLengthByNumber(20, 0x0002, 0x0010);
#include <typeinfo>
#include <stdio.h>
-using namespace std;
-
-gdcmException::gdcmException(const string &f, const string& msg) throw()
+gdcmException::gdcmException(const std::string &f, const std::string& msg) throw()
#ifdef __GNUC__
try
#endif
}
-string gdcmException::getName() const throw() {
+std::string gdcmException::getName() const throw() {
try {
#ifdef __GNUC__ // GNU C++ compiler class name demangling
unsigned int nested = 1, i, nb, offset;
- string one;
+ std::string one;
- string name;
- string iname = typeid(*this).name();
+ std::string name;
+ std::string iname = typeid(*this).name();
if(iname[0] == 'Q') {
nested = iname[1] - '0';
- iname = string(iname, 2, std::string::npos);
+ iname = std::string(iname, 2, std::string::npos);
}
for(i = 0; i < nested; i++) {
::sscanf(iname.c_str(), "%u%n", &nb, &offset);
- iname = string(iname, offset, std::string::npos);
- name += string(iname, 0, nb);
+ iname = std::string(iname, offset, std::string::npos);
+ name += std::string(iname, 0, nb);
if(i + 1 < nested) name += "::";
- iname = string(iname, nb, std::string::npos);
+ iname = std::string(iname, nb, std::string::npos);
}
return name;
#else // no class name demangling
#endif
}
catch(...) {
- fatal("Exception::getName(string &)");
+ fatal("Exception::getName(std::string &)");
return "";
}
}
#include "gdcmFile.h"
#include "gdcmUtil.h"
#include "iddcmjpeg.h" // for the 'LibIDO' Jpeg LossLess
-using namespace std;
#define str2num(str, typeNum) *((typeNum *)(str))
* @return
*/
-gdcmFile::gdcmFile(string & filename)
+gdcmFile::gdcmFile(std::string & filename)
:gdcmHeader(filename.c_str())
{
SetPixelDataSizeFromHeader();
*/
void gdcmFile::SetPixelDataSizeFromHeader(void) {
int nb;
- string str_nb;
+ std::string str_nb;
str_nb=gdcmHeader::GetPubElValByNumber(0x0028,0x0100);
if (str_nb == GDCM_UNFOUND ) {
}
lgrTotale = GetXSize() * GetYSize() * GetZSize() * (nb/8)* GetSamplesPerPixel();
- string str_PhotometricInterpretation = gdcmHeader::GetPubElValByNumber(0x0028,0x0004);
+ std::string str_PhotometricInterpretation = gdcmHeader::GetPubElValByNumber(0x0028,0x0004);
if ( str_PhotometricInterpretation == "PALETTE COLOR "
|| str_PhotometricInterpretation == "YBR_FULL") { // --> some more to be added !!
lgrTotale*=3;
/**
* \ingroup gdcmFile
* \brief Parse pixel data from disk and *prints* the result
- * \ For multi-fragment Jpeg files checking purpose *only*
+ * \ For multi-fragment Jpeg/Rle files checking purpose *only*
* \ Allows to 'see' if the file *does* conform
* \ (some of them do not)
- * \ with Dicom Part 3, Annex A (PS 3.5-2003, page 58)
+ * \ with Dicom Part 3, Annex A (PS 3.5-2003, page 58, page 85)
*
*/
bool gdcmFile::ParsePixelData(void) {
+
if ( !OpenFile())
return false;
IsExplicitVRBigEndianTransferSyntax() ||
IsDeflatedExplicitVRLittleEndianTransferSyntax() ) {
- printf ("gdcmFile::ParsePixelData : non JPEG File\n");
+ printf ("gdcmFile::ParsePixelData : non JPEG/RLE File\n");
return 0;
}
int nb;
- string str_nb=gdcmHeader::GetPubElValByNumber(0x0028,0x0100);
+ std::string str_nb=gdcmHeader::GetPubElValByNumber(0x0028,0x0100);
if (str_nb == GDCM_UNFOUND ) {
nb = 16;
} else {
printf ("Checking the Dicom-Jpeg/RLE Pixels\n");
- // ------------------------------- for Parsing : Position on begining of Jpeg Pixels
- guint16 ItemTagGr,ItemTagEl;
- int ln;
- long ftellRes;
- char * destination = NULL;
+ guint16 ItemTagGr,ItemTagEl;
+ int ln;
+ long ftellRes;
+ char * destination = NULL;
+
+ // ------------------------------- for Parsing : Position on begining of Jpeg/RLE Pixels
+
+ if( !IsRLELossLessTransferSyntax()) {
+
+ // JPEG Image
+
+ cout << "JPEG image" << endl;
ftellRes=ftell(fp);
fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Basic Offset Table Item Tag Gr
fread(&ItemTagEl,2,1,fp); // Reading (e000) : Basic Offset Table Item Tag El
printf(" at %x : fragment length %d x(%08x)\n",
ftellRes, ln,ln);
- destination += taille * nBytes; // location in user's memory
-
- printf (" Destination will be x(%x) = %d \n",
- destination,destination );
-
+ // destination += taille * nBytes; // location in user's memory
+ //printf (" Destination will be x(%x) = %d \n",
+ // destination,destination );
+
+ // ------------------------
fseek(fp,ln,SEEK_CUR); // skipping (not reading) fragment pixels
-
+ // ------------------------
+
ftellRes=ftell(fp);
fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr
fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El
}
printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n",
ftellRes,ItemTagGr,ItemTagEl );
-
+ }
+
+ } else {
+
+ // RLE Image
+
+ cout << "RLE image" << endl;
+ long RleSegmentLength[15],fragmentLength;
+ guint32 nbRleSegments;
+ guint32 RleSegmentOffsetTable[15];
+ ftellRes=ftell(fp);
+ // Basic Offset Table with Item Value
+ // Item Tag
+ fread(&ItemTagGr,2,1,fp); // Reading (fffe):Basic Offset Table Item Tag Gr
+ fread(&ItemTagEl,2,1,fp); // Reading (e000):Basic Offset Table Item Tag El
+ if(GetSwapCode()) {
+ ItemTagGr=SwapShort(ItemTagGr);
+ ItemTagEl=SwapShort(ItemTagEl);
+ }
+ printf ("at %x : ItemTag (should be fffe,e000): %04x,%04x\n",
+ ftellRes,ItemTagGr,ItemTagEl );
+ // Item Length
+ ftellRes=ftell(fp);
+ fread(&ln,4,1,fp);
+ if(GetSwapCode())
+ ln=SwapLong(ln); // Basic Offset Table Item Lentgh
+ printf("at %x : Basic Offset Table Item Lentgh (??) %d x(%08x)\n",
+ ftellRes,ln,ln);
+ if (ln != 0) {
+ // What is it used for ??
+ char * BasicOffsetTableItemValue= (char *)malloc(ln+1);
+ fread(BasicOffsetTableItemValue,ln,1,fp);
+ guint32 a;
+ for (int i=0;i<ln;i+=4){
+ a=str2num(&BasicOffsetTableItemValue[i],guint32);
+ printf(" x(%08x) %d\n",a,a);
+ }
+ }
+
+ ftellRes=ftell(fp);
+ fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr
+ fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El
+ if(GetSwapCode()) {
+ ItemTagGr=SwapShort(ItemTagGr);
+ ItemTagEl=SwapShort(ItemTagEl);
+ }
+ printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n",
+ ftellRes,ItemTagGr,ItemTagEl );
+
+ // while 'Sequence Delimiter Item' (fffe,e0dd) not found
+ while ( ( ItemTagGr == 0xfffe) && (ItemTagEl != 0xe0dd) ) {
+ // Parse fragments of the current Fragment (Frame)
+ ftellRes=ftell(fp);
+ fread(&fragmentLength,4,1,fp);
+ if(GetSwapCode())
+ fragmentLength=SwapLong(fragmentLength); // length
+ printf(" at %x : 'fragment' length %d x(%08x)\n",
+ ftellRes, fragmentLength,fragmentLength);
+
+// destination += taille * nBytes; // location in user's memory
+// printf (" Destination will be x(%x) = %d \n",
+// destination,destination );
+
+ //------------------ scanning (not reading) fragment pixels
+
+ fread(&nbRleSegments,4,1,fp); // Reading : Number of RLE Segments
+ if(GetSwapCode())
+ nbRleSegments=SwapLong(nbRleSegments);
+ printf(" Nb of RLE Segments : %d\n",nbRleSegments);
+
+ for(int k=1; k<=15; k++) { // Reading RLE Segments Offset Table
+ ftellRes=ftell(fp);
+ fread(&RleSegmentOffsetTable[k],4,1,fp);
+ if(GetSwapCode())
+ RleSegmentOffsetTable[k]=SwapLong(RleSegmentOffsetTable[k]);
+ printf(" at : %x Offset Segment %d : %d (%x)\n",
+ ftellRes,k,RleSegmentOffsetTable[k],RleSegmentOffsetTable[k]);
+ }
+ if (nbRleSegments>1) {
+ for(int k=1; k<=nbRleSegments-1; k++) { // skipping (not reading) RLE Segments
+ RleSegmentLength[k]=RleSegmentOffsetTable[k+1]-RleSegmentOffsetTable[k];
+ ftellRes=ftell(fp);
+ printf (" Segment %d : Length = %d Start at %x\n",
+ k,RleSegmentLength[k], ftellRes);
+ fseek(fp,RleSegmentLength[k],SEEK_CUR);
+ }
+ }
+ RleSegmentLength[nbRleSegments] = fragmentLength - RleSegmentOffsetTable[nbRleSegments] ;
+ // TODO : Check the value
+ ftellRes=ftell(fp);
+ printf (" Segment %d : Length = %d Start at %x\n",
+ nbRleSegments,RleSegmentLength[nbRleSegments],ftellRes);
+
+ fseek(fp,RleSegmentLength[nbRleSegments],SEEK_CUR);
+
+ // ------------------ end of scanning fragment pixels
+ ftellRes=ftell(fp);
+ fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr
+ fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El
+ if(GetSwapCode()) {
+ ItemTagGr=SwapShort(ItemTagGr);
+ ItemTagEl=SwapShort(ItemTagEl);
+ }
+ printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n",
+ ftellRes,ItemTagGr,ItemTagEl );
}
+ }
return 1;
}
return false;
}
-// ------------------------------- Uncompressed File
+// ------------------------- Uncompressed File
if ( !IsDicomV3() ||
IsImplicitVRLittleEndianTransferSyntax() ||
}
}
- // ----------------------------- JPEG Compressed File .
+ // ------------------------ Compressed File .
int nb;
- string str_nb=gdcmHeader::GetPubElValByNumber(0x0028,0x0100);
+ std::string str_nb=gdcmHeader::GetPubElValByNumber(0x0028,0x0100);
if (str_nb == GDCM_UNFOUND ) {
nb = 16;
} else {
}
_IdDcmJpegFree (jpg);
return true;
- }
+ }
+ // ------------------------------- RLE
+
+ if (gdcmHeader::IsRLELossLessTransferSyntax()) {
+ int res = (bool)gdcm_read_RLE_file (destination);
+ return res;
+ }
+
// ------------------------------- JPEG Lossy : call to IJG 6b
long fragmentBegining; // for ftell, fseek
-
- bool a=0, b=0;
-
- a = gdcmHeader::IsRLELossLessTransferSyntax();
- if (!a)
- bool b = gdcmHeader::IsJPEG2000();
+ bool b = gdcmHeader::IsJPEG2000();
bool res;
guint16 ItemTagGr,ItemTagEl;
// FIXME : multi fragments
fragmentBegining=ftell(fp);
- if (a)
- res = (bool)gdcm_read_RLE_file (destination); // Reading Fragment pixels
- else if (b)
+
+ if (b)
res = (bool)gdcm_read_JPEG2000_file (destination); // Reading Fragment pixels
else if (IsJPEGLossless()) { // ------------- call to LibIDO Jpeg for each Frame/fragment
size_t gdcmFile::GetImageDataIntoVector (void* destination, size_t MaxSize) {
int nb, nbu, highBit, signe;
- string str_nbFrames, str_nb, str_nbu, str_highBit, str_signe;
+ std::string str_nbFrames, str_nb, str_nbu, str_highBit, str_signe;
if ( lgrTotale > MaxSize ) {
dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: pixel data bigger"
// Try to deal with the color
// --------------------------
- string str_PhotometricInterpretation = gdcmHeader::GetPubElValByNumber(0x0028,0x0004);
+ std::string str_PhotometricInterpretation = gdcmHeader::GetPubElValByNumber(0x0028,0x0004);
if ( (str_PhotometricInterpretation == "MONOCHROME1 ")
|| (str_PhotometricInterpretation == "MONOCHROME2 ")
memmove(destination,newDest,lgrTotale);
free(newDest);
// now, it's an RGB image
- string spp = "3";
+ std::string spp = "3";
gdcmHeader::SetPubElValByNumber(spp,0x0028,0x0002);
- string rgb="RGB";
+ std::string rgb="RGB";
gdcmHeader::SetPubElValByNumber(rgb,0x0028,0x0004);
break;
}
free(newDest);
// now, it's an RGB image
- string spp = "3";
+ std::string spp = "3";
gdcmHeader::SetPubElValByNumber(spp,0x0028,0x0002);
- string rgb="RGB";
+ std::string rgb="RGB";
gdcmHeader::SetPubElValByNumber(rgb,0x0028,0x0004);
} else { // need to make RGB Pixels (?)
*/
void gdcmFile::SetImageDataSize(size_t ImageDataSize) {
- string content1;
+ std::string content1;
char car[20];
// Assumes ElValue (0x7fe0, 0x0010) exists ...
sprintf(car,"%d",ImageDataSize);
* @return
*/
-int gdcmFile::WriteRawData (string fileName) {
+int gdcmFile::WriteRawData (std::string fileName) {
FILE * fp1;
fp1 = fopen(fileName.c_str(),"wb");
if (fp1 == NULL) {
* @return int acts as a boolean
*/
-int gdcmFile::WriteDcmImplVR (string fileName) {
+int gdcmFile::WriteDcmImplVR (std::string fileName) {
return WriteBase(fileName, ImplicitVR);
}
*/
int gdcmFile::WriteDcmImplVR (const char* fileName) {
- return WriteDcmImplVR (string (fileName));
+ return WriteDcmImplVR (std::string (fileName));
}
/////////////////////////////////////////////////////////////////
* @return int acts as a boolean
*/
-int gdcmFile::WriteDcmExplVR (string fileName) {
+int gdcmFile::WriteDcmExplVR (std::string fileName) {
return WriteBase(fileName, ExplicitVR);
}
* @return int acts as a boolean
*/
-int gdcmFile::WriteAcr (string fileName) {
+int gdcmFile::WriteAcr (std::string fileName) {
return WriteBase(fileName, ACR);
}
*
* @return int acts as a boolean
*/
-int gdcmFile::WriteBase (string FileName, FileType type) {
+int gdcmFile::WriteBase (std::string FileName, FileType type) {
FILE * fp1;
fp1 = fopen(FileName.c_str(),"wb");
int gdcm_read_JPEG_file (void * image_buffer); // For JPEG 8 Bits
int gdcm_read_JPEG_file12 (void * image_buffer); // For JPEG 12 Bits
int gdcm_read_JPEG2000_file (void * image_buffer); // For JPEG 2000 (TODO)
- int gdcm_read_RLE_file (void * image_buffer); // For Run Length Encoding (TODO)
-
-
+
+// For Run Length Encoding (TOCHECK)
+ int gdcm_read_RLE_file (void * image_buffer);
+
+
protected:
int WriteBase(std::string FileName, FileType type);
public:
-// $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.84 2003/09/18 09:32:15 regrain Exp $
+// $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.85 2003/09/24 11:37:10 jpr Exp $
//This is needed when compiling in debug mode
#ifdef _MSC_VER
#include <sstream>
#include "gdcmUtil.h"
#include "gdcmHeader.h"
-using namespace std;
#include "gdcmTS.h"
-
-// TODO : remove DEBUG
-#define DEBUG 0
-
// Refer to gdcmHeader::CheckSwap()
#define HEADER_LENGTH_TO_READ 256
// Refer to gdcmHeader::SetMaxSizeLoadElementValue()
return;
char VR[3];
- string vr;
+ std::string vr;
int lgrLue;
char msg[100]; // for sprintf. Sorry
lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
VR[2]=0;
- vr = string(VR);
+ vr = std::string(VR);
// Assume we are reading a falsely explicit VR file i.e. we reached
// a tag where we expect reading a VR but are in fact we read the
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.1" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.1.99" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.2" ) //1.2.2 ??? A verifier !
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.4.50" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.4.51" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.4.52" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.4.53" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.5" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( (Transfer == "1.2.840.10008.1.2.4.90")
|| (Transfer == "1.2.840.10008.1.2.4.91") )
return true;
void gdcmHeader::FindLength (gdcmElValue * ElVal) {
guint16 element = ElVal->GetElement();
guint16 group = ElVal->GetGroup();
- string vr = ElVal->GetVR();
+ std::string vr = ElVal->GetVR();
guint16 length16;
if( (element == 0x0010) && (group == 0x7fe0) ) {
dbg.SetDebug(0);
void gdcmHeader::LoadElementValue(gdcmElValue * ElVal) {
size_t item_read;
guint16 group = ElVal->GetGroup();
- string vr = ElVal->GetVR();
+ std::string vr = ElVal->GetVR();
guint32 length = ElVal->GetLength();
bool SkipLoad = false;
* @param Elem
* \return integer acts as a boolean
*/
-int gdcmHeader::ReplaceOrCreateByNumber(string Value, guint16 Group, guint16 Elem ) {
+int gdcmHeader::ReplaceOrCreateByNumber(std::string Value, guint16 Group, guint16 Elem ) {
// TODO : FIXME JPRx
// curieux, non ?
gdcmElValue* nvElValue=NewElValueByNumber(Group, Elem);
PubElValSet.Add(nvElValue);
- string v = Value;
+ std::string v = Value;
PubElValSet.SetElValueByNumber(v, Group, Elem);
return(1);
}
int gdcmHeader::ReplaceIfExistByNumber(char* Value, guint16 Group, guint16 Elem ) {
gdcmElValue* elValue = PubElValSet.GetElementByNumber(Group, Elem);
- string v = Value;
+ std::string v = Value;
PubElValSet.SetElValueByNumber(v, Group, Elem);
return 1;
}
* a default one when absent.
* @param Name Name of the underlying DictEntry
*/
-gdcmElValue* gdcmHeader::NewElValueByName(string Name) {
+gdcmElValue* gdcmHeader::NewElValueByName(std::string Name) {
gdcmDictEntry * NewTag = GetDictEntryByName(Name);
if (!NewTag)
n = ReadInt16();
if ( (g==0x7fe0) && (n==0x0010) )
- if (DEBUG)
- printf("in gdcmHeader::ReadNextElement try to read 7fe0 0010 \n");
if (errno == 1)
// We reached the EOF (or an error occured) and header parsing
FindLength(NewElVal);
if (errno == 1) {
// Call it quits
- if (DEBUG) printf("in gdcmHeader::ReadNextElement : g %04x n %04x errno %d\n",g, n, errno);
return (gdcmElValue *)0;
}
NewElVal->SetOffset(ftell(fp));
if ( (g==0x7fe0) && (n==0x0010) )
- if (DEBUG)
- printf("sortie de gdcmHeader::ReadNextElement 7fe0 0010 \n");
return NewElVal;
}
bool gdcmHeader::IsAnInteger(gdcmElValue * ElVal) {
guint16 group = ElVal->GetGroup();
guint16 element = ElVal->GetElement();
- string vr = ElVal->GetVR();
+ std::string vr = ElVal->GetVR();
guint32 length = ElVal->GetLength();
// When we have some semantics on the element we just read, and if we
if (length == 4)
return true;
else {
- if (DEBUG) printf("Erroneous Group Length element length (%04x , %04x) : %d\n",
- group, element,length);
-
dbg.Error("gdcmHeader::IsAnInteger",
"Erroneous Group Length element length.");
}
// When the "Image Location" is absent we default to group 0x7fe0.
guint16 grPixel;
guint16 numPixel;
- string ImageLocation = GetPubElValByName("Image Location");
+ std::string ImageLocation = GetPubElValByName("Image Location");
if ( ImageLocation == GDCM_UNFOUND ) {
grPixel = 0x7fe0;
} else {
* @param Name name of the searched DictEntry
* @return Corresponding DictEntry when it exists, NULL otherwise.
*/
-gdcmDictEntry * gdcmHeader::GetDictEntryByName(string Name) {
+gdcmDictEntry * gdcmHeader::GetDictEntryByName(std::string Name) {
gdcmDictEntry * found = (gdcmDictEntry*)0;
if (!RefPubDict && !RefShaDict) {
dbg.Verbose(0, "gdcmHeader::GetDictEntry",
* @return Corresponding element value when it exists, and the string
* GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) {
+std::string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) {
return PubElValSet.GetElValueByNumber(group, element);
}
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
+std::string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
gdcmElValue* elem = PubElValSet.GetElementByNumber(group, element);
if ( !elem )
return GDCM_UNFOUND;
* @return Corresponding element value when it exists, and the string
* GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValByName(string TagName) {
+std::string gdcmHeader::GetPubElValByName(std::string TagName) {
return PubElValSet.GetElValueByName(TagName);
}
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValRepByName(string TagName) {
+std::string gdcmHeader::GetPubElValRepByName(std::string TagName) {
gdcmElValue* elem = PubElValSet.GetElementByName(TagName);
if ( !elem )
return GDCM_UNFOUND;
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) {
+std::string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) {
return ShaElValSet.GetElValueByNumber(group, element);
}
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
+std::string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
gdcmElValue* elem = ShaElValSet.GetElementByNumber(group, element);
if ( !elem )
return GDCM_UNFOUND;
* @return Corresponding element value when it exists, and the string
* GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValByName(string TagName) {
+std::string gdcmHeader::GetShaElValByName(std::string TagName) {
return ShaElValSet.GetElValueByName(TagName);
}
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValRepByName(string TagName) {
+std::string gdcmHeader::GetShaElValRepByName(std::string TagName) {
gdcmElValue* elem = ShaElValSet.GetElementByName(TagName);
if ( !elem )
return GDCM_UNFOUND;
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetElValByNumber(guint16 group, guint16 element) {
- string pub = GetPubElValByNumber(group, element);
+std::string gdcmHeader::GetElValByNumber(guint16 group, guint16 element) {
+ std::string pub = GetPubElValByNumber(group, element);
if (pub.length())
return pub;
return GetShaElValByNumber(group, element);
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetElValRepByNumber(guint16 group, guint16 element) {
- string pub = GetPubElValRepByNumber(group, element);
+std::string gdcmHeader::GetElValRepByNumber(guint16 group, guint16 element) {
+ std::string pub = GetPubElValRepByNumber(group, element);
if (pub.length())
return pub;
return GetShaElValRepByNumber(group, element);
* @return Corresponding element value when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetElValByName(string TagName) {
- string pub = GetPubElValByName(TagName);
+std::string gdcmHeader::GetElValByName(std::string TagName) {
+ std::string pub = GetPubElValByName(TagName);
if (pub.length())
return pub;
return GetShaElValByName(TagName);
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetElValRepByName(string TagName) {
- string pub = GetPubElValRepByName(TagName);
+std::string gdcmHeader::GetElValRepByName(std::string TagName) {
+ std::string pub = GetPubElValRepByName(TagName);
if (pub.length())
return pub;
return GetShaElValRepByName(TagName);
* @param group group of the ElVal to modify
* @param element element of the ElVal to modify
*/
-int gdcmHeader::SetPubElValByNumber(string content, guint16 group,
+int gdcmHeader::SetPubElValByNumber(std::string content, guint16 group,
guint16 element)
//TODO : homogeneiser les noms : SetPubElValByNumber qui appelle PubElValSet.SetElValueByNumber
* @param content new value to substitute with
* @param TagName name of the tag to be modified
*/
-int gdcmHeader::SetPubElValByName(string content, string TagName) {
+int gdcmHeader::SetPubElValByName(std::string content, std::string TagName) {
return ( PubElValSet.SetElValueByName (content, TagName) );
}
* @param element element of the ElVal to modify
* @return 1 on success, 0 otherwise.
*/
-int gdcmHeader::SetShaElValByNumber(string content,
+int gdcmHeader::SetShaElValByNumber(std::string content,
guint16 group, guint16 element) {
return ( ShaElValSet.SetElValueByNumber (content, group, element) );
}
* @param content new value to substitute with
* @param ShadowTagName name of the tag to be modified
*/
-int gdcmHeader::SetShaElValByName(string content, string ShadowTagName) {
+int gdcmHeader::SetShaElValByName(std::string content, std::string ShadowTagName) {
return ( ShaElValSet.SetElValueByName (content, ShadowTagName) );
}
* @param VR The Value Representation to be given to this new tag.
* @ return The newly hand crafted Element Value.
*/
-gdcmElValue* gdcmHeader::NewManualElValToPubDict(string NewTagName, string VR) {
+gdcmElValue* gdcmHeader::NewManualElValToPubDict(std::string NewTagName, std::string VR) {
gdcmElValue* NewElVal = (gdcmElValue*)0;
guint32 StuffGroup = 0xffff; // Group to be stuffed with additional info
guint32 FreeElem = 0;
rewind(fp);
// Load 'non string' values
- string PhotometricInterpretation = GetPubElValByNumber(0x0028,0x0004);
+ std::string PhotometricInterpretation = GetPubElValByNumber(0x0028,0x0004);
if( PhotometricInterpretation == "PALETTE COLOR " ){
LoadElementVoidArea(0x0028,0x1200); // gray LUT
LoadElementVoidArea(0x0028,0x1201); // R LUT
// if recognition code tells us we deal with a LibIDO image
// we switch lineNumber and columnNumber
//
- string RecCode;
+ std::string RecCode;
RecCode = GetPubElValByNumber(0x0008, 0x0010);
if (RecCode == "ACRNEMA_LIBIDO_1.1" ||
RecCode == "CANRME_AILIBOD1_1." ) {
int gdcmHeader::GetXSize(void) {
// We cannot check for "Columns" because the "Columns" tag is present
// both in IMG (0028,0011) and OLY (6000,0011) sections of the dictionary.
- string StrSize = GetPubElValByNumber(0x0028,0x0011);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0011);
if (StrSize == GDCM_UNFOUND)
return 0;
return atoi(StrSize.c_str());
int gdcmHeader::GetYSize(void) {
// We cannot check for "Rows" because the "Rows" tag is present
// both in IMG (0028,0010) and OLY (6000,0010) sections of the dictionary.
- string StrSize = GetPubElValByNumber(0x0028,0x0010);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0010);
if (StrSize != GDCM_UNFOUND)
return atoi(StrSize.c_str());
if ( IsDicomV3() )
int gdcmHeader::GetZSize(void) {
// Both in DicomV3 and ACR/Nema the consider the "Number of Frames"
// as the third dimension.
- string StrSize = GetPubElValByNumber(0x0028,0x0008);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0008);
if (StrSize != GDCM_UNFOUND)
return atoi(StrSize.c_str());
* @return The encountered number of Bits Stored, 0 by default.
*/
int gdcmHeader::GetBitsStored(void) {
- string StrSize = GetPubElValByNumber(0x0028,0x0101);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0101);
if (StrSize == GDCM_UNFOUND)
return 1;
return atoi(StrSize.c_str());
* @return The encountered number of Samples Per Pixel, 1 by default.
*/
int gdcmHeader::GetSamplesPerPixel(void) {
- string StrSize = GetPubElValByNumber(0x0028,0x0002);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0002);
if (StrSize == GDCM_UNFOUND)
return 1; // Well, it's supposed to be mandatory ...
return atoi(StrSize.c_str());
* @return The encountered Planar Configuration, 0 by default.
*/
int gdcmHeader::GetPlanarConfiguration(void) {
- string StrSize = GetPubElValByNumber(0x0028,0x0006);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0006);
if (StrSize == GDCM_UNFOUND)
return 0;
return atoi(StrSize.c_str());
*
*/
int gdcmHeader::GetPixelSize(void) {
- string PixelType = GetPixelType();
+ std::string PixelType = GetPixelType();
if (PixelType == "8U" || PixelType == "8S")
return 1;
if (PixelType == "16U" || PixelType == "16S")
* \warning 12 bit images appear as 16 bit.
* @return
*/
-string gdcmHeader::GetPixelType(void) {
- string BitsAlloc;
+std::string gdcmHeader::GetPixelType(void) {
+ std::string BitsAlloc;
BitsAlloc = GetElValByName("Bits Allocated");
if (BitsAlloc == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Bits Allocated");
- BitsAlloc = string("16");
+ BitsAlloc = std::string("16");
}
if (BitsAlloc == "12")
- BitsAlloc = string("16");
+ BitsAlloc = std::string("16");
- string Signed;
+ std::string Signed;
Signed = GetElValByName("Pixel Representation");
if (Signed == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Pixel Representation");
- BitsAlloc = string("0");
+ BitsAlloc = std::string("0");
}
if (Signed == "0")
- Signed = string("U");
+ Signed = std::string("U");
else
- Signed = string("S");
+ Signed = std::string("S");
return( BitsAlloc + Signed);
}
* \ else 1.
* @return Transfert Syntax Name (as oposite to Transfert Syntax UID)
*/
-string gdcmHeader::GetTransferSyntaxName(void) {
- string TransfertSyntax = GetPubElValByNumber(0x0002,0x0010);
+std::string gdcmHeader::GetTransferSyntaxName(void) {
+ std::string TransfertSyntax = GetPubElValByNumber(0x0002,0x0010);
if (TransfertSyntax == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetTransferSyntaxName: unfound Transfert Syntax (0002,0010)");
return "Uncompressed ACR-NEMA";
}
// we do it only when we need it
gdcmTS * ts = gdcmGlobal::GetTS();
- string tsName=ts->GetValue(TransfertSyntax);
+ std::string tsName=ts->GetValue(TransfertSyntax);
//delete ts; // Seg Fault when deleted ?!
return tsName;
}
*/
int gdcmHeader::GetLUTLength(void) {
- vector<string> tokens;
+ vector<std::string> tokens;
int LutLength;
//int LutDepth;
//int LutNbits;
// Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
- string LutDescriptionR = GetPubElValByNumber(0x0028,0x1101);
+ std::string LutDescriptionR = GetPubElValByNumber(0x0028,0x1101);
if (LutDescriptionR == GDCM_UNFOUND)
return 0;
- string LutDescriptionG = GetPubElValByNumber(0x0028,0x1102);
+ std::string LutDescriptionG = GetPubElValByNumber(0x0028,0x1102);
if (LutDescriptionG == GDCM_UNFOUND)
return 0;
- string LutDescriptionB = GetPubElValByNumber(0x0028,0x1103);
+ std::string LutDescriptionB = GetPubElValByNumber(0x0028,0x1103);
if (LutDescriptionB == GDCM_UNFOUND)
return 0;
if( (LutDescriptionR != LutDescriptionG) || (LutDescriptionR != LutDescriptionB) ) {
*/
int gdcmHeader::GetLUTNbits(void) {
- vector<string> tokens;
+ vector<std::string> tokens;
//int LutLength;
//int LutDepth;
int LutNbits;
// Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
// Consistency already checked in GetLUTLength
- string LutDescription = GetPubElValByNumber(0x0028,0x1101);
+ std::string LutDescription = GetPubElValByNumber(0x0028,0x1101);
if (LutDescription == GDCM_UNFOUND)
return 0;
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
-// $Header: /cvs/public/gdcm/src/Attic/gdcmHeaderHelper.cxx,v 1.5 2003/09/18 09:32:15 regrain Exp $
+// $Header: /cvs/public/gdcm/src/Attic/gdcmHeaderHelper.cxx,v 1.6 2003/09/24 11:37:10 jpr Exp $
//This is needed when compiling in debug mode
#ifdef _MSC_VER
#include <math.h>
#include <algorithm>
#include <string.h> //for bzero
-using namespace std;
//directory manipulation (os indep).
//cygwin ???? -> _WIN32 ??
#include "gdcmIdo.h"
#include "gdcmUtil.h"
-using namespace std;
gdcmHeaderIdo::gdcmHeaderIdo (char* InFilename)
: gdcmHeader(InFilename)
#include <stdio.h>
#include "gdcmFile.h"
-#include "jpeg/libijg8/cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
-#include "jpeg/libijg8/jversion.h" /* for version message */
#include <ctype.h> /* to declare isprint() */
-/* Create the add-on message string table. */
-#define JMESSAGE(code,string) string ,
+#define str2num(str, typeNum) *((typeNum *)(str))
-static const char * const cdjpeg_message_table[] = {
-#include "jpeg/libijg8/cderror.h"
- NULL
-};
-
- /* -------------------------------------------------------------------- */
- //
- // RLE LossLess Files
- //
- /* -------------------------------------------------------------------- */
+static int _gdcm_read_RLE_fragment (char ** image_buffer,
+ long lengthToDecode,
+ long uncompressedSegmentSize,
+ FILE* fp);
+// static because nothing but gdcm_read_RLE_file may call it
-int
-gdcmFile::gdcm_read_RLE_file (void * image_buffer) {
+// ------------------------------------------------------------------------------------
+/**
+ * \ingroup gdcmFile
+ * \brief Reads a 'Run Length Encoded' Dicom encapsulated file
+ * @param destination Address (in caller's memory space) at which the
+ * pixel data should be copied
+ * @return int acts as a Boolean
+ */
+// This is a debug version.
+// Forget the printf as they will be removed
+// as soon as the last Heuristics are checked
+int
+gdcmFile::gdcm_read_RLE_file (void * image_buffer) {
+ char * im = (char *)image_buffer;
+ cout << "RLE image" << endl;
+
+ long RleSegmentLength[15],fragmentLength,uncompressedSegmentSize;;
+ long ftellRes, ln;
+ guint32 nbRleSegments;
+ guint32 RleSegmentOffsetTable[15];
+ guint16 ItemTagGr,ItemTagEl;
+ uncompressedSegmentSize=GetXSize()*GetYSize();
+ printf("uncompressedSegmentSize %d\n",uncompressedSegmentSize);
+ ftellRes=ftell(fp);
+ // Basic Offset Table with Item Value
+ // Item Tag
+ fread(&ItemTagGr,2,1,fp); // Reading (fffe):Basic Offset Table Item Tag Gr
+ fread(&ItemTagEl,2,1,fp); // Reading (e000):Basic Offset Table Item Tag El
+ if(GetSwapCode()) {
+ ItemTagGr=SwapShort(ItemTagGr);
+ ItemTagEl=SwapShort(ItemTagEl);
+ }
+ printf ("at %x : ItemTag (should be fffe,e000): %04x,%04x\n",
+ ftellRes,ItemTagGr,ItemTagEl );
+ // Item Length
+ ftellRes=ftell(fp);
+ fread(&ln,4,1,fp);
+ if(GetSwapCode())
+ ln=SwapLong(ln); // Basic Offset Table Item Lentgh
+ printf("at %x : Basic Offset Table Item Lentgh (??) %d x(%08x)\n",
+ ftellRes,ln,ln);
+ if (ln != 0) {
+ // What is it used for ??
+ char * BasicOffsetTableItemValue= (char *)malloc(ln+1);
+ fread(BasicOffsetTableItemValue,ln,1,fp);
+ guint32 a;
+ for (int i=0;i<ln;i+=4){
+ a=str2num(&BasicOffsetTableItemValue[i],guint32);
+ printf(" x(%08x) %d\n",a,a);
+ }
+ }
+
+ ftellRes=ftell(fp);
+ fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr
+ fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El
+ if(GetSwapCode()) {
+ ItemTagGr=SwapShort(ItemTagGr);
+ ItemTagEl=SwapShort(ItemTagEl);
+ }
+ printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n",
+ ftellRes,ItemTagGr,ItemTagEl );
+
+ // while 'Sequence Delimiter Item' (fffe,e0dd) not found
+ while ( ( ItemTagGr == 0xfffe) && (ItemTagEl != 0xe0dd) ) {
+ // Parse fragments of the current Fragment (Frame)
+ ftellRes=ftell(fp);
+ fread(&fragmentLength,4,1,fp);
+ if(GetSwapCode())
+ fragmentLength=SwapLong(fragmentLength); // length
+ printf(" at %x : fragment length %d x(%08x)\n",
+ ftellRes, fragmentLength,fragmentLength);
+
+ // scanning fragment pixels
+
+ fread(&nbRleSegments,4,1,fp); // Reading : Number of RLE Segments
+ if(GetSwapCode())
+ nbRleSegments=SwapLong(nbRleSegments);
+ printf(" Nb of RLE Segments : %d\n",nbRleSegments);
+
+ for(int k=1; k<=15; k++) { // Reading RLE Segments Offset Table
+ ftellRes=ftell(fp);
+ fread(&RleSegmentOffsetTable[k],4,1,fp);
+ if(GetSwapCode())
+ RleSegmentOffsetTable[k]=SwapLong(RleSegmentOffsetTable[k]);
+ printf(" at : %x Offset Segment %d : %d (%x)\n",
+ ftellRes,k,RleSegmentOffsetTable[k],RleSegmentOffsetTable[k]);
+ }
+
+ if (nbRleSegments>1) {
+ for(int k=1; k<=nbRleSegments-1; k++) { // reading RLE Segments
+ RleSegmentLength[k]=RleSegmentOffsetTable[k+1]-RleSegmentOffsetTable[k];
+ ftellRes=ftell(fp);
+ printf (" Segment %d : Length = %d Start at %x\n",
+ k,RleSegmentLength[k], ftellRes);
+ _gdcm_read_RLE_fragment (&im, RleSegmentLength[k],uncompressedSegmentSize,fp);
+ //fseek(fp,RleSegmentLength[k],SEEK_CUR);
+
+ }
+ }
+ RleSegmentLength[nbRleSegments] = fragmentLength - RleSegmentOffsetTable[nbRleSegments]; // + 4;
+ // 4 : bytes for number of RLE Segments (WHY ???);
+ // TODO : Check the value
+ ftellRes=ftell(fp);
+ printf (" Segment %d : Length = %d Start at %x\n",
+ nbRleSegments,RleSegmentLength[nbRleSegments],ftellRes);
+ _gdcm_read_RLE_fragment (&im, RleSegmentLength[nbRleSegments],uncompressedSegmentSize, fp);
+ //fseek(fp,RleSegmentLength[nbRleSegments],SEEK_CUR);
+
+ // end of scanning fragment pixels
+
+ ftellRes=ftell(fp);
+ fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr
+ fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El
+ if(GetSwapCode()) {
+ ItemTagGr=SwapShort(ItemTagGr);
+ ItemTagEl=SwapShort(ItemTagEl);
+ }
+ printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n",
+ ftellRes,ItemTagGr,ItemTagEl );
+ }
+ return (1);
+}
+ /* -------------------------------------------------------------------- */
+ //
+ // RLE LossLess Fragment
+ //
+ /* -------------------------------------------------------------------- */
-
-
-
-
-
-
-
-
-
-
- printf("Sorry RLE LossLess File not yet taken into account\n");
- return 0;
+ // static because nothing but gdcm_read_RLE_file can call it
+ // DO NOT doxygen !
+
+static int
+_gdcm_read_RLE_fragment (char ** areaToRead,
+ long lengthToDecode,
+ long uncompressedSegmentSize,
+ FILE* fp) {
+ long ftellRes;
+ int count;
+ long numberOfOutputBytes=0;
+ char n, car;
+ ftellRes =ftell(fp);
+ printf ("Fragment begin : %x lengthToDecode %d\n",ftellRes,lengthToDecode);
+
+ while(numberOfOutputBytes<uncompressedSegmentSize) {
+
+ ftellRes =ftell(fp);
+ fread(&n,sizeof(char),1,fp);
+ count=n;
+ //printf (" Piece begin : %x count : %d x(%x)\n",ftellRes, count, count);
+ if (count >= 0 && count <= 127) {
+ fread(*areaToRead,(count+1)*sizeof(char),1,fp);
+ *areaToRead+=count+1;
+ numberOfOutputBytes+=count+1;
+ } else {
+ if (count <= -1 && count >= -127) {
+ fread(&car,sizeof(char),1,fp);
+ for(int i=0; i<-count+1; i++) {
+ (*areaToRead)[i]=car;
+ }
+ *areaToRead+=(-count+1);
+ numberOfOutputBytes+=(-count+1);
+ }
+ }
+ // if count = 128 output nothing (See : PS 3.5-2003 Page 86)
+ }
+ return 1;
}
-// $Header: /cvs/public/gdcm/src/gdcmUtil.cxx,v 1.18 2003/09/22 08:28:43 regrain Exp $
+// $Header: /cvs/public/gdcm/src/gdcmUtil.cxx,v 1.19 2003/09/24 11:37:10 jpr Exp $
//This is needed when compiling in debug mode
#ifdef _MSC_VER
#include <ctype.h> // For isspace
#include <string.h>
#include "gdcmUtil.h"
-using namespace std;
// Library globals.
gdcmDebug dbg;
projects / gdcm.git / commitdiff