mlDICOMSetAddTagTools.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
#pragma once
 
#include "MLDICOMTagsSystem.h"
 
#include <FMEThirdPartyWarningsDisable.h>
#include <string>
#include <FMEThirdPartyWarningsRestore.h>
 
#include <mlLinearAlgebra.h>
 
// DICOM Tree prototypes.
#include <DCMTree_Lib.h>
 
ML_START_NAMESPACE
 
// Forwards
class DicomMessageCollector;
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
namespace DICOMTagTools {

MLDICOMTags_EXPORT DCMTree::TagPtr addTagToTree(DCMTree::TreePtr     dcmTree, 
                                                const DCMTree::TagId &tagId, 
                                                unsigned int         numValues=1,
                                                const DCMTree::Vr    *vr=nullptr,
                                                unsigned int         numSQValues=1);

MLDICOMTags_EXPORT void setTagValue(DCMTree::TagPtr tag, unsigned int v0, unsigned int v1, unsigned int v2);

MLDICOMTags_EXPORT void setTagValue(DCMTree::TagPtr tag, double v0, double v1, double v2);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, const std::string &str);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, float val);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, MLuint16 val);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, int val);

MLDICOMTags_EXPORT  std::string toDblStrLimited(double      val,
                                                signed char maxSize);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, double val);

MLDICOMTags_EXPORT void setSplitTagStringValue(DCMTree::TagPtr   tag, 
                                               const std::string &str);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr   tag, 
                                          const std::string &str,
                                          bool                  ,
                                          signed char           );

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, 
                                          double          v0, 
                                          double          v1, 
                                          bool            doMultValueAdd,
                                          signed char     maxSize=-1);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, 
                                          MLint           v0, 
                                          MLint           v1, 
                                          MLint           v2,
                                          bool            doMultValueAdd);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr   tag, 
                                          const ImageVector &vec,
                                          bool              doMultValueAdd);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, 
                                          const Vector2   &vec,
                                          bool            doMultValueAdd,
                                          signed char     maxSize=-1);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, 
                                          const Vector3   &vec,
                                          bool            doMultValueAdd,
                                          signed char     maxSize=-1);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, 
                                          const Vector6   &vec,
                                          bool            doMultValueAdd,
                                          signed char     maxSize=-1);

MLDICOMTags_EXPORT void setTagStringValue(DCMTree::TagPtr tag, 
                                          const Matrix4   &mat,
                                          bool            doMultValueAdd,
                                          signed char     maxSize=-1);

template <typename TAG_VAL_TYPE>
  DCMTree::TagPtr addStringTagToTree(DCMTree::TreePtr     dcmTree, 
                                     const DCMTree::TagId &tagId, 
                                     const TAG_VAL_TYPE   &vec,
                                     bool                 doMultValueAdd,
                                     signed char          maxSize=-1)
{
  DCMTree::TagPtr retTag;
  if (dcmTree){
    retTag = addTagToTree(dcmTree, tagId);
    setTagStringValue(retTag, vec, doMultValueAdd, maxSize);
  }
  return retTag;
}

template <typename TAG_VAL_TYPE>
  DCMTree::TagPtr addStringTagToTree(DCMTree::TreePtr     dcmTree, 
                                     const DCMTree::TagId &tagId, 
                                     const TAG_VAL_TYPE   &vec)
{
  DCMTree::TagPtr retTag;
  if (dcmTree){
    retTag = addTagToTree(dcmTree, tagId);
    setTagStringValue(retTag, vec);
  }
  return retTag;
}

template <typename TAG_VAL_TYPE>
  DCMTree::TagPtr addTagToTree(DCMTree::TreePtr     dcmTree, 
                               const DCMTree::TagId &tagId, 
                               TAG_VAL_TYPE         val0,
                               TAG_VAL_TYPE         val1,
                               TAG_VAL_TYPE         val2)
{
  DCMTree::TagPtr retTag = addTagToTree(dcmTree, tagId);
  setTagValue(retTag, val0, val1, val2);
  return retTag;
}

MLDICOMTags_EXPORT DCMTree::TagPtr addTag(DCMTree::TreePtr  dcmTree, 
                                          std::string       *errStr,
                                          DCMTree::TagId    tagId,
                                          const std::string &tagStrValue,
                                          bool              setValue,
                                          MLuint32          numVals=1,
                                          const DCMTree::Vr *vr=nullptr,
                                          bool              splitValue=false);
 

enum ValueModifyModes { 
  Replace=0,          
  DoNotModify,        
  Prepend,            
  Append              
}; 

enum { NumValueModifyModes = Append+1 };  

extern MLDICOMTags_EXPORT const char * const ValueModifyModesStrings[NumValueModifyModes];

MLDICOMTags_EXPORT void setTagValue(DCMTree::TreePtr       dcmTree,
                                    std::string            *errStr,
                                    DCMTree::TagId         tagId,
                                    const std::string      &tagStrValue,
                                    const ValueModifyModes modMode,
                                    bool                   splitValue=false);

MLDICOMTags_EXPORT std::string setOrAddCreatorAndTag(DCMTree::TreePtr   dcmTree,
                                                     const std::string  &privateCreatorString,
                                                     MLuint16           privateGroupId,
                                                     MLuint8            privateElementGroupId,
                                                     MLuint8            privateTagIdLowerByte,
                                                     const std::string  &privateTagValue,
                                                     DCMTree::Vr        privateVR,
                                                     bool               splitValue);

MLDICOMTags_EXPORT void appendSequenceEntries(DCMTree::TagPtr tag,
                                              MLint           numEntries,
                                              std::string     &errStr);

MLDICOMTags_EXPORT void insertOneSequenceEntry(DCMTree::TagPtr tag,
                                               MLint           posIdx,
                                               std::string     &errStr);
 
}
 
ML_END_NAMESPACE