#include "gdcmUtil.h"
#include "gdcmHeader.h"
+#include <iddcmjpeg.h>
+
// Refer to gdcmHeader::CheckSwap()
#define HEADER_LENGTH_TO_READ 256
// Refer to gdcmHeader::SetMaxSizeLoadElementValue()
else
dbg.Error(!fp, "gdcmHeader::gdcmHeader cannot open file", InFilename);
ParseHeader();
+ LoadElements();
AddAndDefaultElements();
}
if(filetype == TrueDicom) {
// Next, determine the value representation (VR). Let's skip to the
- // first element (0002, 0000) and check there if we find "UL", in
- // which case we (almost) know it is explicit VR.
+ // first element (0002, 0000) and check there if we find "UL"
+ // - or "OB" if the 1st one is (0002,0001) -,
+ // in which case we (almost) know it is explicit VR.
// WARNING: if it happens to be implicit VR then what we will read
// is the length of the group. If this ascii representation of this
// length happens to be "UL" then we shall believe it is explicit VR.
// We need to skip :
// * the 128 bytes of File Preamble (often padded with zeroes),
// * the 4 bytes of "DICM" string,
- // * the 4 bytes of the first tag (0002, 0000),
+ // * the 4 bytes of the first tag (0002, 0000),or (0002, 0001)
// i.e. a total of 136 bytes.
entCur = deb + 136;
- if(memcmp(entCur, "UL", (size_t)2) == 0) {
+ if( (memcmp(entCur, "UL", (size_t)2) == 0) ||
+ (memcmp(entCur, "OB", (size_t)2) == 0) )
+ {
filetype = ExplicitVR;
dbg.Verbose(1, "gdcmHeader::CheckSwap:",
"explicit Value Representation");
size_t pixelsOffset;
pixelsOffset = GetPixelOffset();
fseek(fp, pixelsOffset, SEEK_SET);
- fread(_Pixels, 1, lgrTotale, fp);
+ if (IsJPEGLossless()) {
+ _Pixels=_IdDcmJpegRead(fp);
+ } else {
+ fread(_Pixels, 1, lgrTotale, fp);
+ }
}
* \ingroup gdcmHeader
* \brief Find the value representation of the current tag.
*/
-void gdcmHeader::FindVR( ElValue *ElVal) {
+void gdcmHeader::FindVR( gdcmElValue *ElVal) {
if (filetype != ExplicitVR)
return;
// PostPone this test in an optional integrity check at the end
// of parsing or only in debug mode.
if ( RealExplicit && !dicom_vr->count(vr) )
- RealExplicit = false;
+ RealExplicit= false;
if ( RealExplicit ) {
if ( ElVal->IsVrUnknown() ) {
* @return True when ImplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmHeader::IsImplicitVRLittleEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when ExplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmHeader::IsExplicitVRLittleEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when DeflatedExplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmHeader::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when big endian found. False in all other cases.
*/
bool gdcmHeader::IsExplicitVRBigEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
string Transfer = Element->GetValue();
- if ( Transfer == "1.2.840.10008.1.2.2" )
+ if ( Transfer == "1.2.840.10008.1.2.2" ) //1.2.2 ??? A verifier !
return true;
return false;
}
* @return True when JPEGBaseLineProcess1found. False in all other cases.
*/
bool gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
return false;
}
+// faire qq chose d'intelligent a la place de ça
+
+bool gdcmHeader::IsJPEGLossless(void) {
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ if ( !Element )
+ return false;
+ LoadElementValueSafe(Element);
+ const char * Transfert = Element->GetValue().c_str();
+ if ( memcmp(Transfert+strlen(Transfert)-2 ,"70",2)==0) return true;
+ if ( memcmp(Transfert+strlen(Transfert)-2 ,"55",2)==0) return true;
+ return false;
+}
+
+
/**
* \ingroup gdcmHeader
* \brief Determines if the Transfer Syntax was allready encountered
* @return True when JPEGExtendedProcess2-4 found. False in all other cases.
*/
bool gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when JPEGExtendedProcess3-5 found. False in all other cases.
*/
bool gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* other cases.
*/
bool gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* the parser went Jabberwocky) one can hope improving things by
* applying this heuristic.
*/
-void gdcmHeader::FixFoundLength(ElValue * ElVal, guint32 FoundLength) {
+void gdcmHeader::FixFoundLength(gdcmElValue * ElVal, guint32 FoundLength) {
if ( FoundLength == 0xffffffff)
FoundLength = 0;
ElVal->SetLength(FoundLength);
return TotalLength;
}
-void gdcmHeader::FindLength(ElValue * ElVal) {
+void gdcmHeader::FindLength(gdcmElValue * ElVal) {
guint16 element = ElVal->GetElement();
string vr = ElVal->GetVR();
guint16 length16;
(void)fseek(fp, (long)NBytes, SEEK_CUR);
}
-void gdcmHeader::SkipElementValue(ElValue * ElVal) {
+void gdcmHeader::SkipElementValue(gdcmElValue * ElVal) {
SkipBytes(ElVal->GetLength());
}
* than the value specified with
* gdcmHeader::SetMaxSizeLoadElementValue()
*/
-void gdcmHeader::LoadElementValue(ElValue * ElVal) {
+void gdcmHeader::LoadElementValue(gdcmElValue * ElVal) {
size_t item_read;
guint16 group = ElVal->GetGroup();
guint16 elem = ElVal->GetElement();
// The group length doesn't represent data to be loaded in memory, since
// each element of the group shall be loaded individualy.
if( elem == 0 )
- //SkipLoad = true; // modif sauvage JPR
- // On charge la longueur du groupe
- // quand l'element 0x0000 est présent !
+ //SkipLoad = true; // modif sauvage JPR
+ // On charge la longueur du groupe
+ // quand l'element 0x0000 est présent !
if ( SkipLoad ) {
// FIXME the following skip is not necessary
// When an integer is expected, read and convert the following two or
// four bytes properly i.e. as an integer as opposed to a string.
- if ( IsAnInteger(ElVal) ) {
- guint32 NewInt;
- if( length == 2 ) {
- NewInt = ReadInt16();
- } else if( length == 4 ) {
- NewInt = ReadInt32();
- } else
- dbg.Error(true, "LoadElementValue: Inconsistency when reading Int.");
-
- //FIXME: make the following an util fonction
- ostringstream s;
- s << NewInt;
- ElVal->SetValue(s.str());
- return;
- }
+
+ // pour les elements de Value Multiplicity > 1
+ // on aura en fait une serie d'entiers
+
+ // on devrait pouvoir faire + compact (?)
+
+ if ( IsAnInteger(ElVal) ) {
+ guint32 NewInt;
+ ostringstream s;
+ int nbInt;
+ if (vr == "US" || vr == "SS") {
+ nbInt = length / 2;
+ NewInt = ReadInt16();
+ s << NewInt;
+ if (nbInt > 1) {
+ for (int i=1; i < nbInt; i++) {
+ s << '\\';
+ NewInt = ReadInt16();
+ s << NewInt;
+ //printf("%s\n", s.str().c_str());
+ }
+ }
+
+ } else if (vr == "UL" || vr == "SL") {
+ nbInt = length / 4;
+ NewInt = ReadInt32();
+ s << NewInt;
+ if (nbInt > 1) {
+ for (int i=1; i < nbInt; i++) {
+ s << '\\';
+ NewInt = ReadInt32();
+ s << NewInt;
+ }
+ }
+ }
+ ElVal->SetValue(s.str());
+ return;
+ }
// FIXME The exact size should be length if we move to strings or whatever
char* NewValue = (char*)malloc(length+1);
* @param ElVal Element whose value shall be loaded.
* @return
*/
-void gdcmHeader::LoadElementValueSafe(ElValue * ElVal) {
+void gdcmHeader::LoadElementValueSafe(gdcmElValue * ElVal) {
long PositionOnEntry = ftell(fp);
LoadElementValue(ElVal);
fseek(fp, PositionOnEntry, SEEK_SET);
* @param Group group of the underlying DictEntry
* @param Elem element of the underlying DictEntry
*/
-ElValue* gdcmHeader::NewElValueByKey(guint16 Group, guint16 Elem) {
+gdcmElValue* gdcmHeader::NewElValueByKey(guint16 Group, guint16 Elem) {
// Find out if the tag we encountered is in the dictionaries:
gdcmDictEntry * NewTag = GetDictEntryByKey(Group, Elem);
if (!NewTag)
NewTag = new gdcmDictEntry(Group, Elem);
- ElValue* NewElVal = new ElValue(NewTag);
+ gdcmElValue* NewElVal = new gdcmElValue(NewTag);
if (!NewElVal) {
dbg.Verbose(1, "gdcmHeader::NewElValueByKey",
- "failed to allocate ElValue");
- return (ElValue*)0;
+ "failed to allocate gdcmElValue");
+ return (gdcmElValue*)0;
}
return NewElVal;
}
* a default one when absent.
* @param Name Name of the underlying DictEntry
*/
-ElValue* gdcmHeader::NewElValueByName(string Name) {
+gdcmElValue* gdcmHeader::NewElValueByName(string Name) {
gdcmDictEntry * NewTag = GetDictEntryByName(Name);
if (!NewTag)
NewTag = new gdcmDictEntry(0xffff, 0xffff, "LO", "Unknown", Name);
- ElValue* NewElVal = new ElValue(NewTag);
+ gdcmElValue* NewElVal = new gdcmElValue(NewTag);
if (!NewElVal) {
dbg.Verbose(1, "gdcmHeader::ObtainElValueByName",
- "failed to allocate ElValue");
- return (ElValue*)0;
+ "failed to allocate gdcmElValue");
+ return (gdcmElValue*)0;
}
return NewElVal;
}
* \brief Read the next tag but WITHOUT loading it's value
* @return On succes the newly created ElValue, NULL on failure.
*/
-ElValue * gdcmHeader::ReadNextElement(void) {
+gdcmElValue * gdcmHeader::ReadNextElement(void) {
guint16 g;
guint16 n;
- ElValue * NewElVal;
+ gdcmElValue * NewElVal;
g = ReadInt16();
n = ReadInt16();
if (errno == 1)
// We reached the EOF (or an error occured) and header parsing
// has to be considered as finished.
- return (ElValue *)0;
+ return (gdcmElValue *)0;
NewElVal = NewElValueByKey(g, n);
FindVR(NewElVal);
FindLength(NewElVal);
if (errno == 1)
// Call it quits
- return (ElValue *)0;
+ return (gdcmElValue *)0;
NewElVal->SetOffset(ftell(fp));
return NewElVal;
}
* @param ElVal The element value on which to apply the predicate.
* @return The result of the heuristical predicate.
*/
-bool gdcmHeader::IsAnInteger(ElValue * ElVal) {
+bool gdcmHeader::IsAnInteger(gdcmElValue * ElVal) {
guint16 group = ElVal->GetGroup();
guint16 element = ElVal->GetElement();
string vr = ElVal->GetVR();
dbg.Error("gdcmHeader::IsAnInteger",
"Erroneous Group Length element length.");
}
-
+
+ /*
+ // on le traite tt de même (VR peut donner l'info)
+ // faire qq chose + ruse (pas de test si pas de VR)
if ( group % 2 != 0 )
// We only have some semantics on documented elements, which are
// the even ones.
- return false;
+ return false;
+ */
+ /*
if ( (length != 4) && ( length != 2) )
// Swapping only make sense on integers which are 2 or 4 bytes long.
+
+ // En fait, pour les entiers de 'Value Multiplicity' supérieur a 1
+ // la longueur n'est pas forcement 2 ou 4
+ // ET il faudra swapper.
return false;
+ */
if ( (vr == "UL") || (vr == "US") || (vr == "SL") || (vr == "SS") )
return true;
+
+ // est-ce encore utile?
+ // mieux vaut modifier le source du Dicom Dictionnaty
+ // et remplacer pour ces 2 cas RET par US
+
if ( (group == 0x0028) && (element == 0x0005) )
// The "Image Dimensions" tag is retained from ACR/NEMA and contains
// the number of dimensions of the contained object (1 for Signal,
numPixel = 0x1010;
else
numPixel = 0x0010;
- ElValue* PixelElement = PubElVals.GetElementByNumber(grPixel, numPixel);
+ gdcmElValue* PixelElement = PubElVals.GetElementByNumber(grPixel, numPixel);
if (PixelElement)
return PixelElement->GetOffset();
else
* and the string "gdcm::Unfound" otherwise.
*/
string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
- ElValue* elem = PubElVals.GetElementByNumber(group, element);
+ gdcmElValue* elem = PubElVals.GetElementByNumber(group, element);
if ( !elem )
return "gdcm::Unfound";
return elem->GetVR();
* and the string "gdcm::Unfound" otherwise.
*/
string gdcmHeader::GetPubElValRepByName(string TagName) {
- ElValue* elem = PubElVals.GetElementByName(TagName);
+ gdcmElValue* elem = PubElVals.GetElementByName(TagName);
if ( !elem )
return "gdcm::Unfound";
return elem->GetVR();
* and the string "gdcm::Unfound" otherwise.
*/
string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
- ElValue* elem = ShaElVals.GetElementByNumber(group, element);
+ gdcmElValue* elem = ShaElVals.GetElementByNumber(group, element);
if ( !elem )
return "gdcm::Unfound";
return elem->GetVR();
* and the string "gdcm::Unfound" otherwise.
*/
string gdcmHeader::GetShaElValRepByName(string TagName) {
- ElValue* elem = ShaElVals.GetElementByName(TagName);
+ gdcmElValue* elem = ShaElVals.GetElementByName(TagName);
if ( !elem )
return "gdcm::Unfound";
return elem->GetVR();
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the PubElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the PubElVals of this instance
* through it's (group, element) and modifies it's content with
* the given value.
* @param content new value to substitute with
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the PubElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the PubElVals of this instance
* through tag name and modifies it's content with the given value.
* @param content new value to substitute with
* @param TagName name of the tag to be modified
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the ShaElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the PubElVals of this instance
+ * through it's (group, element) and modifies it's length with
+ * the given value.
+ * NOT FOR BOZOs !
+ * @param contents new length to substitute with
+ * @param group group of the ElVal to modify
+ * @param element element of the ElVal to modify
+ */
+int gdcmHeader::SetPubElValLengthByNumber(guint32 lgr, guint16 group,
+ guint16 element)
+{
+ return ( PubElVals.SetElValueLengthByNumber (lgr, group, element) );
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Accesses an existing gdcmElValue in the ShaElVals of this instance
* through it's (group, element) and modifies it's content with
* the given value.
* @param content new value to substitute with
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the ShaElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the ShaElVals of this instance
* through tag name and modifies it's content with the given value.
* @param content new value to substitute with
* @param TagName name of the tag to be modified
* \brief Parses the header of the file but WITHOUT loading element values.
*/
void gdcmHeader::ParseHeader(bool exception_on_error) throw(gdcmFormatError) {
- ElValue * newElValue = (ElValue *)0;
+ gdcmElValue * newElValue = (gdcmElValue *)0;
rewind(fp);
CheckSwap();
/**
* \ingroup gdcmHeader
* \brief Once the header is parsed add some gdcm convenience/helper elements
- * in the ElValSet. For example add:
+ * in the gdcmElValSet. For example add:
* - gdcmImageType which is an entry containing a short for the
* type of image and whose value ranges in
* I8 (unsigned 8 bit image)
* the ones of the official DICOM fields Rows, Columns and Planes.
*/
void gdcmHeader::AddAndDefaultElements(void) {
- ElValue* NewEntry = (ElValue*)0;
+ gdcmElValue* NewElVal = (gdcmElValue*)0;
+ string NewVal;
+
+ NewElVal = NewManualElValToPubDict("gdcmXSize", "US");
+ if (!NewElVal) return;
+ NewVal = GetElValByName("Rows");
+ if (NewVal != "gdcm::Unfound")
+ NewElVal->SetValue(NewVal);
+ else
+ NewElVal->SetValue("0");
+
+
+ NewElVal = NewManualElValToPubDict("gdcmYSize", "US");
+ if (!NewElVal) return;
+ NewVal = GetElValByName("Columns");
+ if (NewVal != "gdcm::Unfound")
+ NewElVal->SetValue(NewVal);
+ else
+ NewElVal->SetValue("0");
- NewEntry = NewElValueByName("gdcmXSize");
- NewEntry->SetValue(GetElValByName("Rows"));
- PubElVals.Add(NewEntry);
- NewEntry = NewElValueByName("gdcmYSize");
- NewEntry->SetValue(GetElValByName("Columns"));
- PubElVals.Add(NewEntry);
+ NewElVal = NewManualElValToPubDict("gdcmZSize", "US");
+ if (!NewElVal) return;
+ NewVal = GetElValByName("Planes");
+ if (NewVal != "gdcm::Unfound")
+ NewElVal->SetValue(NewVal);
+ else
+ NewElVal->SetValue("0");
+}
- NewEntry = NewElValueByName("gdcmZSize");
- NewEntry->SetValue(GetElValByName("Planes"));
- PubElVals.Add(NewEntry);
+/**
+ * \ingroup gdcmHeader
+ * \brief Small utility function that creates a new manually crafted
+ * (as opposed as read from the file) gdcmElValue with user
+ * specified name and adds it to the public tag hash table.
+ * Refer to gdcmHeader::AddAndDefaultElements for a typical usage.
+ * \note A fake TagKey is generated so the PubDict can keep it's coherence.
+ * @param NewTagName The name to be given to this new tag.
+ * @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* NewElVal = (gdcmElValue*)0;
+ guint32 StuffGroup = 0xffff; // Group to be stuffed with additional info
+ guint32 FreeElem = 0;
+ gdcmDictEntry* NewEntry = (gdcmDictEntry*)0;
+
+ FreeElem = PubElVals.GenerateFreeTagKeyInGroup(StuffGroup);
+ if (FreeElem == UINT32_MAX) {
+ dbg.Verbose(1, "gdcmHeader::NewManualElValToPubDict",
+ "Group 0xffff in Public Dict is full");
+ return (gdcmElValue*)0;
+ }
+ NewEntry = new gdcmDictEntry(StuffGroup, FreeElem,
+ VR, "GDCM", NewTagName);
+ NewElVal = new gdcmElValue(NewEntry);
+ PubElVals.Add(NewElVal);
+ return NewElVal;
}
/**
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff