orthanc: OrthancServer/FromDcmtkBridge.cpp comparison

comparison OrthancServer/FromDcmtkBridge.cpp @ 1737:ec66a16aa398

removal of DicomStringValue and DicomNullValue

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 22 Oct 2015 07:52:24 +0200
parents	b953c6eef28d
children	15a788a63846

comparison

equal deleted inserted replaced

-:b953c6eef28d
+:ec66a16aa398
 #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>
 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
 {
 case EVR_OB:  // other byte
 case EVR_OF:  // other float
 case EVR_OW:  // other word
 case EVR_UN:  // unknown value representation
-return new DicomNullValue;
+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_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,
 unsigned int maxStringLength)
 {
-std::string content = value.AsString();
 switch (format)
 {
 case DicomToJsonFormat_Short:
 case DicomToJsonFormat_Simple:
 {
 assert(target.type() == Json::nullValue);
 if (!value.IsNull() &&
 (maxStringLength == 0 ||
-content.size() <= maxStringLength))
+value.GetContent().size() <= maxStringLength))
 {
-target = content;
+target = value.GetContent();
 }
 break;
 }
 target["Value"] = Json::nullValue;
 }
 else
 {
 if (maxStringLength == 0 ||
-content.size() <= maxStringLength)
+value.GetContent().size() <= maxStringLength)
 {
 target["Type"] = "String";
-target["Value"] = content;
+target["Value"] = value.GetContent();
 }
 else
 {
 target["Type"] = "TooLong";
 target["Value"] = Json::nullValue;
 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;
 }
 }

Mercurial > hg > orthanc

comparison OrthancServer/FromDcmtkBridge.cpp @ 1737:ec66a16aa398