if ( !OpenFile(exception_on_error))
return;
- if (ParseHeader())
+ if (ParseHeader()) {
LoadHeaderEntries();
+ }
CloseFile();
wasUpdated = 0; // will be set to 1 if user adds an entry
* false otherwise.
*/
bool gdcmParser::IsReadable(void) {
- if(filetype==Unknown)
+ if(filetype==Unknown) {
return(false);
- if(listEntries.size()<=0)
+ }
+ if(listEntries.size()<=0) {
return(false);
+ }
return(true);
}
return(fp);
fclose(fp);
- dbg.Verbose(0, "gdcmParser::gdcmParser not DICOM/ACR", filename.c_str());
+ dbg.Verbose(0, "gdcmParser::OpenFile not DICOM/ACR", filename.c_str());
}
else {
- dbg.Verbose(0, "gdcmParser::gdcmParser cannot open file", filename.c_str());
+ dbg.Verbose(0, "gdcmParser::OpenFile cannot open file", filename.c_str());
}
return(NULL);
}
*/
bool gdcmParser::Write(FILE *fp, FileType type) {
// ==============
-// TODO The stuff has been rewritten using the chained list instead
+// TODO The stuff was rewritten using the chained list instead
// of the H table
// so we could remove the GroupHT from the gdcmParser
// To be checked
UpdateGroupLength(true,ACR);
*/
- WriteEntries(type, fp);
+ WriteEntries(fp,type);
return(true);
}
free(a);
return NULL;
}
+
return a;
}
* (ACR-NEMA, ExplicitVR, ImplicitVR)
* @param _fp already open file pointer
*/
-void gdcmParser::WriteEntries(FileType type, FILE * _fp)
+void gdcmParser::WriteEntries(FILE *_fp,FileType type)
{
guint16 gr, el;
guint32 lgr;
guint32 val_uint32;
guint16 val_uint16;
guint16 valZero =0;
+ void *voidArea;
std::vector<std::string> tokens;
// TODO : function CheckHeaderCoherence to be written
// TODO : find a trick (in STL?) to do it, at low cost !
void *ptr;
-
- // TODO : get grPixel and numPixel
- guint16 grPixel =0x7fe0;
- guint16 numPixel=0x0010;
- //IterHT it = GetHeaderEntrySameNumber(grPixel,numPixel);
-
-
+
// TODO (?) tester les echecs en ecriture (apres chaque fwrite)
-
+ int compte =0;
+
for (ListTag::iterator tag2=listEntries.begin();
tag2 != listEntries.end();
++tag2)
lgr = (*tag2)->GetReadLength();
val = (*tag2)->GetValue().c_str();
vr = (*tag2)->GetVR();
- cout << hex << gr << " " << el << " " << vr <<" lgr " << lgr << endl;
+ voidArea = (*tag2)->GetVoidArea();
+
if ( type == ACR )
{
if (gr < 0x0008) continue; // ignore pure DICOM V3 groups
{
// EXPLICIT VR
guint16 z=0, shortLgr;
- if (vr == "Unknown") { // Unknown was 'written'
+ if (vr == "unkn") { // Unknown was 'written'
shortLgr=lgr;
fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp);
} else {
if (gr != 0xfffe) { // NO value for 'delimiters'
- if (vr == "Unknown") // Unknown was 'written'
+ if (vr == "unkn") // Unknown was 'written'
fwrite(&z,(size_t)2 ,(size_t)1 ,_fp);
else
fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp);
}
- if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") || gr == 0xfffe) // JPR
+ if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") || gr == 0xfffe)
{
if (gr != 0xfffe)
fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp);
if (vr == "SQ") continue; // no "value" to write for the SEQuences
if (gr == 0xfffe)continue;
+ if (voidArea != NULL) { // there is a 'non string' LUT, overlay, etc
+ fwrite ( voidArea,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
+ continue;
+ }
+
if (vr == "US" || vr == "SS")
{
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
}
tokens.clear();
continue;
- }
+ }
+
// Pixels are never loaded in the element !
-
- // TODO : FIX --> doesn't work when ICONE is found !!!
-
- if ((gr == grPixel) && (el == numPixel) )
- break;
-
+ // we stop writting when Pixel are processed
+ // FIX : we loose trailing elements (RAB, right now)
+
+ if ((gr == GrPixel) && (el == NumPixel) ) {
+ compte++;
+ if (compte == countGrPixel) // we passed *all* the GrPixel,NumPixel
+ break;
+ }
fwrite ( val,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
}
}
LoadEntryVoidArea(0x0028,0x1221); // Segmented Red Palette Color LUT Data
LoadEntryVoidArea(0x0028,0x1222); // Segmented Green Palette Color LUT Data
LoadEntryVoidArea(0x0028,0x1223); // Segmented Blue Palette Color LUT Data
- }
-
+ }
+ //FIXME : how to use it?
+ LoadEntryVoidArea(0x0028,0x3006); //LUT Data (CTX dependent)
+
// --------------------------------------------------------------
// Special Patch to allow gdcm to read ACR-LibIDO formated images
//
guint16 group = Entry->GetGroup();
std::string vr = Entry->GetVR();
guint16 length16;
- if( (element == 0x0010) && (group == 0x7fe0) )
+ if( (element == NumPixel) && (group == GrPixel) )
{
dbg.SetDebug(-1);
dbg.Verbose(2, "gdcmParser::FindLength: ",
- "we reached 7fe0 0010");
+ "we reached (GrPixel,NumPixel)");
}
if ( (filetype == ExplicitVR) && (! Entry->IsImplicitVR()) )
return;
char VR[3];
- int lgrLue;
long PositionOnEntry = ftell(fp);
// Warning: we believe this is explicit VR (Value Representation) because
// is in explicit VR and try to fix things if it happens not to be
// the case.
- lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
+ int lgrLue=fread (&VR, (size_t)2,(size_t)1, fp); // lgrLue not used
VR[2]=0;
if(!CheckHeaderEntryVR(Entry,VR))
{
sprintf(msg,"Falsely explicit vr file (%04x,%04x)\n",
Entry->GetGroup(),Entry->GetElement());
dbg.Verbose(1, "gdcmParser::FindVR: ",msg);
-
+ if (Entry->GetGroup()%2 && Entry->GetElement() == 0x0000) { // Group length is UL !
+ gdcmDictEntry* NewEntry = NewVirtualDictEntry(
+ Entry->GetGroup(),Entry->GetElement(),
+ "UL","FIXME","Group Length");
+ Entry->SetDictEntry(NewEntry);
+ }
return(false);
}
if ( Entry->IsVRUnknown() )
{
// When not a dictionary entry, we can safely overwrite the VR.
- Entry->SetVR(vr);
+ if (Entry->GetElement() == 0x0000) { // Group length is UL !
+ Entry->SetVR("UL");
+ } else {
+ Entry->SetVR(vr);
+ }
}
else if ( Entry->GetVR() != vr )
{
s << NewInt32;
}
}
-
#ifdef GDCM_NO_ANSI_STRING_STREAM
s << std::ends; // to avoid oddities on Solaris
#endif //GDCM_NO_ANSI_STRING_STREAM
{
Entry->SetReadLength(FoundLength); // will be updated only if a bug is found
- if ( FoundLength == 0xffffffff)
- {
+ if ( FoundLength == 0xffffffff) {
FoundLength = 0;
}
+
+ guint16 gr =Entry->GetGroup();
+ guint16 el =Entry->GetElement();
+
+ if (FoundLength%2) {
+ std::cout << "Warning : Tag with uneven length " << FoundLength
+ << " in x(" << std::hex << gr << "," << el <<")" << std::dec << std::endl;
+ }
// Sorry for the patch!
// XMedCom did the trick to read some nasty GE images ...
- else if (FoundLength == 13)
- {
+ if (FoundLength == 13) {
// The following 'if' will be removed when there is no more
// images on Creatis HDs with a 13 length for Manufacturer...
if ( (Entry->GetGroup() != 0x0008) ||
- ( (Entry->GetElement() != 0x0070) && (Entry->GetElement() != 0x0080) ) ) {
+ ( (Entry->GetElement() != 0x0070) && (Entry->GetElement() != 0x0080) ) ){
// end of remove area
FoundLength =10;
Entry->SetReadLength(10); // a bug is to be fixed
// to fix some garbage 'Leonardo' Siemens images
// May be commented out to avoid overhead
else if ( (Entry->GetGroup() == 0x0009) &&
- ( (Entry->GetElement() == 0x1113) || (Entry->GetElement() == 0x1114) ) )
- {
+ ( (Entry->GetElement() == 0x1113) || (Entry->GetElement() == 0x1114) ) ){
FoundLength =4;
Entry->SetReadLength(4); // a bug is to be fixed
}
// For *regular* headers, the test is useless..
// lets's print a warning message and go on,
// instead of giving up with an error message
- std::cout << s.str().c_str() << std::endl;
+
+ //std::cout << s.str().c_str() << std::endl;
+
// dbg.Error("gdcmParser::IsHeaderEntryAnInteger",
// s.str().c_str());
}
// * the 4 bytes of the first tag (0002, 0000),or (0002, 0001)
// i.e. a total of 136 bytes.
entCur = deb + 136;
- // FIXME
- // Use gdcmParser::dicom_vr to test all the possibilities
- // instead of just checking for UL, OB and UI !?
+
+ // FIXME : FIXME:
+ // Sometimes (see : gdcmData/icone.dcm) group 0x0002 *is* Explicit VR,
+ // but elem 0002,0010 (Transfert Syntax) tells us the file is *Implicit* VR.
+ // -and it is !-
+
if( (memcmp(entCur, "UL", (size_t)2) == 0) ||
(memcmp(entCur, "OB", (size_t)2) == 0) ||
- (memcmp(entCur, "UI", (size_t)2) == 0) )
+ (memcmp(entCur, "UI", (size_t)2) == 0) ||
+ (memcmp(entCur, "CS", (size_t)2) == 0) ) // CS, to remove later
+ // when Write DCM *adds*
+ // FIXME
+ // Use gdcmParser::dicom_vr to test all the possibilities
+ // instead of just checking for UL, OB and UI !? // group 0000
+
{
filetype = ExplicitVR;
dbg.Verbose(1, "gdcmParser::CheckSwap:",
dbg.Verbose(1, "gdcmParser::CheckSwap:",
"not an explicit Value Representation");
}
+
if (net2host)
{
sw = 4321;
return NULL;
}
NewEntry->SetOffset(ftell(fp));
- //if ( (g==0x7fe0) && (n==0x0010) )
return NewEntry;
}
{
gdcmDictEntry *NewTag = GetDictEntryByName(Name);
if (!NewTag)
- NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "Unknown", Name);
+ NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "unkn", Name);
gdcmHeaderEntry* NewEntry = new gdcmHeaderEntry(NewTag);
if (!NewEntry)
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff