orthanc: OrthancServer/FromDcmtkBridge.cpp comparison

comparison OrthancServer/FromDcmtkBridge.cpp @ 1744:b3de74dec2d5 db-changes

integration mainline->db-changes

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 26 Oct 2015 12:30:34 +0100
parents	df331354cea2
children	57b9e6890482

comparison

equal deleted inserted replaced

-:54d78925cbb6
+:b3de74dec2d5
 #include "../Core/Logging.h"
 #include "../Core/Toolbox.h"
 #include "../Core/OrthancException.h"
 #include "../Core/Images/PngWriter.h"
 #include "../Core/Uuid.h"
-#include "../Core/DicomFormat/DicomString.h"
-#include "../Core/DicomFormat/DicomNullValue.h"
 #include "../Core/DicomFormat/DicomIntegerPixelAccessor.h"
 #include <list>
 #include <limits>
 DcmElement* element = dataset.getElement(i);
 if (element && element->isLeaf())
 {
 target.SetValue(element->getTag().getGTag(),
 element->getTag().getETag(),
-ConvertLeafElement(*element, encoding));
+ConvertLeafElement(*element, DicomToJsonFlags_Default, encoding));
 }
 }
 }
 #endif
 }
 DicomValue* FromDcmtkBridge::ConvertLeafElement(DcmElement& element,
+DicomToJsonFlags flags,
 Encoding encoding)
 {
 if (!element.isLeaf())
 {
 // This function is only applicable to leaf elements
 char *c;
 if (element.getString(c).good())
 {
 if (c == NULL)  // This case corresponds to the empty string
 {
-return new DicomString("");
+return new DicomValue("", false);
 }
 else
 {
 std::string s(c);
 std::string utf8 = Toolbox::ConvertToUtf8(s, encoding);
-return new DicomString(utf8);
+return new DicomValue(utf8, false);
 }
 }
 else
 {
-return new DicomNullValue;
+return new DicomValue;
 }
 }
 try
 {
 // http://support.dcmtk.org/docs/dcvr_8h-source.html
 switch (element.getVR())
 {
 /**
-* TODO.
+* Deal with binary data (including PixelData).
 **/
 case EVR_OB:  // other byte
 case EVR_OF:  // other float
 case EVR_OW:  // other word
 case EVR_UN:  // unknown value representation
-return new DicomNullValue;
+case EVR_ox:  // OB or OW depending on context
+{
+if (!(flags & DicomToJsonFlags_ConvertBinaryToNull))
+{
+Uint8* data = NULL;
+if (element.getUint8Array(data) == EC_Normal)
+{
+return new DicomValue(reinterpret_cast<const char*>(data), element.getLength(), true);
+}
+}
+return new DicomValue;
+}
 /**
 * String types, should never happen at this point because of
 * "element.isaString()".
 **/
 case EVR_ST:  // short text
 case EVR_LT:  // long text
 case EVR_UT:  // unlimited text
 case EVR_PN:  // person name
 case EVR_UI:  // unique identifier
-return new DicomNullValue;
+return new DicomValue;
 /**
 * Numberic types
 **/
 case EVR_SL:  // signed long
 {
 Sint32 f;
 if (dynamic_cast<DcmSignedLong&>(element).getSint32(f).good())
-return new DicomString(boost::lexical_cast<std::string>(f));
+return new DicomValue(boost::lexical_cast<std::string>(f), false);
 else
-return new DicomNullValue;
+return new DicomValue;
 }
 case EVR_SS:  // signed short
 {
 Sint16 f;
 if (dynamic_cast<DcmSignedShort&>(element).getSint16(f).good())
-return new DicomString(boost::lexical_cast<std::string>(f));
+return new DicomValue(boost::lexical_cast<std::string>(f), false);
 else
-return new DicomNullValue;
+return new DicomValue;
 }
 case EVR_UL:  // unsigned long
 {
 Uint32 f;
 if (dynamic_cast<DcmUnsignedLong&>(element).getUint32(f).good())
-return new DicomString(boost::lexical_cast<std::string>(f));
+return new DicomValue(boost::lexical_cast<std::string>(f), false);
 else
-return new DicomNullValue;
+return new DicomValue;
 }
 case EVR_US:  // unsigned short
 {
 Uint16 f;
 if (dynamic_cast<DcmUnsignedShort&>(element).getUint16(f).good())
-return new DicomString(boost::lexical_cast<std::string>(f));
+return new DicomValue(boost::lexical_cast<std::string>(f), false);
 else
-return new DicomNullValue;
+return new DicomValue;
 }
 case EVR_FL:  // float single-precision
 {
 Float32 f;
 if (dynamic_cast<DcmFloatingPointSingle&>(element).getFloat32(f).good())
-return new DicomString(boost::lexical_cast<std::string>(f));
+return new DicomValue(boost::lexical_cast<std::string>(f), false);
 else
-return new DicomNullValue;
+return new DicomValue;
 }
 case EVR_FD:  // float double-precision
 {
 Float64 f;
 if (dynamic_cast<DcmFloatingPointDouble&>(element).getFloat64(f).good())
-return new DicomString(boost::lexical_cast<std::string>(f));
+return new DicomValue(boost::lexical_cast<std::string>(f), false);
 else
-return new DicomNullValue;
+return new DicomValue;
 }
 /**
 * Attribute tag.
 {
 DcmTagKey tag;
 if (dynamic_cast<DcmAttributeTag&>(element).getTagVal(tag, 0).good())
 {
 DicomTag t(tag.getGroup(), tag.getElement());
-return new DicomString(t.Format());
+return new DicomValue(t.Format(), false);
 }
 else
 {
-return new DicomNullValue;
+return new DicomValue;
 }
 }
 /**
 * Sequence types, should never occur at this point because of
 * "element.isLeaf()".
 **/
 case EVR_SQ:  // sequence of items
-return new DicomNullValue;
+return new DicomValue;
 /**
 * Internal to DCMTK.
 **/
-case EVR_ox:  // OB or OW depending on context
 case EVR_xs:  // SS or US depending on context
 case EVR_lt:  // US, SS or OW depending on context, used for LUT Data (thus the name)
 case EVR_na:  // na="not applicable", for data which has no VR
 case EVR_up:  // up="unsigned pointer", used internally for DICOMDIR suppor
 case EVR_item:  // used internally for items
 case EVR_pixelItem:  // used internally for pixel items in a compressed image
 case EVR_UNKNOWN: // used internally for elements with unknown VR (encoded with 4-byte length field in explicit VR)
 case EVR_PixelData:  // used internally for uncompressed pixeld data
 case EVR_OverlayData:  // used internally for overlay data
 case EVR_UNKNOWN2B:  // used internally for elements with unknown VR with 2-byte length field in explicit VR
-return new DicomNullValue;
+return new DicomValue;
 /**
 * Default case.
 **/
 default:
-return new DicomNullValue;
+return new DicomValue;
 }
 }
 catch (boost::bad_lexical_cast)
 {
-return new DicomNullValue;
+return new DicomValue;
 }
 catch (std::bad_cast)
 {
-return new DicomNullValue;
+return new DicomValue;
 }
 }
 static Json::Value& PrepareNode(Json::Value& parent,
 static void LeafValueToJson(Json::Value& target,
 const DicomValue& value,
 DicomToJsonFormat format,
+DicomToJsonFlags flags,
 unsigned int maxStringLength)
 {
-std::string content = value.AsString();
+Json::Value* targetValue = NULL;
+Json::Value* targetType = NULL;
 switch (format)
 {
 case DicomToJsonFormat_Short:
 case DicomToJsonFormat_Simple:
 {
 assert(target.type() == Json::nullValue);
+targetValue = &target;
-if (!value.IsNull() &&
-(maxStringLength == 0 ||
-content.size() <= maxStringLength))
-{
-target = content;
-}
 break;
 }
 case DicomToJsonFormat_Full:
 {
 assert(target.type() == Json::objectValue);
+target["Value"] = Json::nullValue;
-if (value.IsNull())
+target["Type"] = Json::nullValue;
-{
+targetType = &target["Type"];
-target["Type"] = "Null";
+targetValue = &target["Value"];
-target["Value"] = Json::nullValue;
-}
-else
-{
-if (maxStringLength == 0 ||
-content.size() <= maxStringLength)
-{
-target["Type"] = "String";
-target["Value"] = content;
-}
-else
-{
-target["Type"] = "TooLong";
-target["Value"] = Json::nullValue;
-}
-}
 break;
 }
 default:
 throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+assert(targetValue != NULL);
+assert(targetValue->type() == Json::nullValue);
+assert(targetType == NULL || targetType->type() == Json::nullValue);
+if (value.IsNull())
+{
+if (targetType != NULL)
+{
+*targetType = "Null";
+}
+}
+else if (value.IsBinary())
+{
+if (flags & DicomToJsonFlags_ConvertBinaryToAscii)
+{
+*targetValue = Toolbox::ConvertToAscii(value.GetContent());
+}
+else
+{
+std::string s;
+value.FormatDataUriScheme(s);
+*targetValue = s;
+}
+if (targetType != NULL)
+{
+*targetType = "Binary";
+}
+}
+else if (maxStringLength == 0 ||
+value.GetContent().size() <= maxStringLength)
+{
+*targetValue = value.GetContent();
+if (targetType != NULL)
+{
+*targetType = "String";
+}
+}
+else
+{
+if (targetType != NULL)
+{
+*targetType = "TooLong";
+}
 }
 }
 static void DatasetToJson(Json::Value& parent,
 DcmItem& item,
 DicomToJsonFormat format,
+DicomToJsonFlags flags,
 unsigned int maxStringLength,
 Encoding encoding);
 void FromDcmtkBridge::ToJson(Json::Value& parent,
 DcmElement& element,
 DicomToJsonFormat format,
+DicomToJsonFlags flags,
 unsigned int maxStringLength,
 Encoding encoding)
 {
 if (parent.type() == Json::nullValue)
 {
 assert(parent.type() == Json::objectValue);
 Json::Value& target = PrepareNode(parent, element, format);
 if (element.isLeaf())
 {
-std::auto_ptr<DicomValue> v(FromDcmtkBridge::ConvertLeafElement(element, encoding));
+std::auto_ptr<DicomValue> v(FromDcmtkBridge::ConvertLeafElement(element, flags, encoding));
-LeafValueToJson(target, *v, format, maxStringLength);
+LeafValueToJson(target, *v, format, flags, maxStringLength);
 }
 else
 {
 assert(target.type() == Json::nullValue);
 target = Json::arrayValue;
 for (unsigned long i = 0; i < sequence.card(); i++)
 {
 DcmItem* child = sequence.getItem(i);
 Json::Value& v = target.append(Json::objectValue);
-DatasetToJson(v, *child, format, maxStringLength, encoding);
+DatasetToJson(v, *child, format, flags, maxStringLength, encoding);
 }
 }
 }
 static void DatasetToJson(Json::Value& parent,
 DcmItem& item,
 DicomToJsonFormat format,
+DicomToJsonFlags flags,
 unsigned int maxStringLength,
 Encoding encoding)
 {
 assert(parent.type() == Json::objectValue);
 for (unsigned long i = 0; i < item.card(); i++)
 {
 DcmElement* element = item.getElement(i);
-FromDcmtkBridge::ToJson(parent, *element, format, maxStringLength, encoding);
+if (element == NULL)
+{
+throw OrthancException(ErrorCode_InternalError);
+}
+if (!(flags & DicomToJsonFlags_IncludePrivateTags) &&
+element->getTag().isPrivate())
+{
+continue;
+}
+if (!(flags & DicomToJsonFlags_IncludeUnknownTags))
+{
+DictionaryLocker locker;
+if (locker->findEntry(element->getTag(), NULL) == NULL)
+{
+continue;
+}
+}
+DcmEVR evr = element->getTag().getEVR();
+if (evr == EVR_OB ||
+evr == EVR_OF ||
+evr == EVR_OW ||
+evr == EVR_UN ||
+evr == EVR_ox)
+{
+// This is a binary tag
+DicomTag tag(FromDcmtkBridge::Convert(element->getTag()));
+if ((tag == DICOM_TAG_PIXEL_DATA && !(flags & DicomToJsonFlags_IncludePixelData)) ||
+(tag != DICOM_TAG_PIXEL_DATA && !(flags & DicomToJsonFlags_IncludeBinary)))
+{
+continue;
+}
+}
+FromDcmtkBridge::ToJson(parent, *element, format, flags, maxStringLength, encoding);
 }
 }
 void FromDcmtkBridge::ToJson(Json::Value& target,
 DcmDataset& dataset,
 DicomToJsonFormat format,
+DicomToJsonFlags flags,
 unsigned int maxStringLength)
 {
 target = Json::objectValue;
-DatasetToJson(target, dataset, format, maxStringLength, DetectEncoding(dataset));
+DatasetToJson(target, dataset, format, flags, maxStringLength, DetectEncoding(dataset));
 }
 std::string FromDcmtkBridge::GetName(const DicomTag& t)
 {
 DcmTag tmp(tag.GetGroup(), tag.GetElement());
 return tmp.isUnknownVR();
 }
-void FromDcmtkBridge::Print(FILE* fp, const DicomMap& m)
-{
-for (DicomMap::Map::const_iterator
-it = m.map_.begin(); it != m.map_.end(); ++it)
-{
-DicomTag t = it->first;
-std::string s = it->second->AsString();
-fprintf(fp, "0x%04x 0x%04x (%s) [%s]\n", t.GetGroup(), t.GetElement(), GetName(t).c_str(), s.c_str());
-}
-}
 void FromDcmtkBridge::ToJson(Json::Value& result,
 const DicomMap& values,
 bool simplify)
 {
 if (result.type() != Json::objectValue)
 for (DicomMap::Map::const_iterator
 it = values.map_.begin(); it != values.map_.end(); ++it)
 {
 if (simplify)
 {
-result[GetName(it->first)] = it->second->AsString();
+if (it->second->IsNull())
+{
+result[GetName(it->first)] = Json::nullValue;
+}
+else
+{
+// TODO IsBinary
+result[GetName(it->first)] = it->second->GetContent();
+}
 }
 else
 {
 Json::Value value = Json::objectValue;
 value["Type"] = "Null";
 value["Value"] = Json::nullValue;
 }
 else
 {
+// TODO IsBinary
 value["Type"] = "String";
-value["Value"] = it->second->AsString();
+value["Value"] = it->second->GetContent();
 }
 result[it->first.Format()] = value;
 }
 }
 }
 static bool IsBinaryTag(const DcmTag& key)
 {
-return key.isPrivate() || key.isUnknownVR();
+return (key.isPrivate() ||
+key.isUnknownVR() ||
+key.getEVR() == EVR_OB ||
+key.getEVR() == EVR_OF ||
+key.getEVR() == EVR_OW ||
+key.getEVR() == EVR_UN ||
+key.getEVR() == EVR_ox);
 }
 DcmElement* FromDcmtkBridge::CreateElementForTag(const DicomTag& tag)
 {
 switch (key.getEVR())
 {
 // http://support.dcmtk.org/docs/dcvr_8h-source.html
 /**
-* TODO.
+* Binary types, handled above
 **/
 case EVR_OB:  // other byte
 case EVR_OF:  // other float
 case EVR_OW:  // other word
-case EVR_AT:  // attribute tag
-throw OrthancException(ErrorCode_NotImplemented);
 case EVR_UN:  // unknown value representation
-throw OrthancException(ErrorCode_ParameterOutOfRange);
+case EVR_ox:  // OB or OW depending on context
+throw OrthancException(ErrorCode_InternalError);
 /**
 * String types.
 * http://support.dcmtk.org/docs/classDcmByteString.html
 case EVR_SQ:  // sequence of items
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 /**
+* TODO
+**/
+case EVR_AT:  // attribute tag
+throw OrthancException(ErrorCode_NotImplemented);
+/**
 * Internal to DCMTK.
 **/
-case EVR_ox:  // OB or OW depending on context
 case EVR_xs:  // SS or US depending on context
 case EVR_lt:  // US, SS or OW depending on context, used for LUT Data (thus the name)
 case EVR_na:  // na="not applicable", for data which has no VR
 case EVR_up:  // up="unsigned pointer", used internally for DICOMDIR suppor
 case EVR_item:  // used internally for items

Mercurial > hg > orthanc

comparison OrthancServer/FromDcmtkBridge.cpp @ 1744:b3de74dec2d5 db-changes