Category

Development Platform
Home > SourceCode/Document > Graph program > Picture Viewer > View Code
dcmpschk.cxx
Package: dcmtk-3.5.3.zip　[view]
Upload User: jinxing
Upload Date: 2016-11-26
Package Size: 5101k
Code Size: 37k
Category:

Picture Viewer

Development Platform:

Visual C++

dcmpschk.cxx：Code Content
  1. /*
  2.  *
  3.  *  Copyright (C) 2000-2004, OFFIS
  4.  *
  5.  *  This software and supporting documentation were developed by
  6.  *
  7.  *    Kuratorium OFFIS e.V.
  8.  *    Healthcare Information and Communication Systems
  9.  *    Escherweg 2
  10.  *    D-26121 Oldenburg, Germany
  11.  *
  12.  *  THIS SOFTWARE IS MADE AVAILABLE,  AS IS,  AND OFFIS MAKES NO  WARRANTY
  13.  *  REGARDING  THE  SOFTWARE,  ITS  PERFORMANCE,  ITS  MERCHANTABILITY  OR
  14.  *  FITNESS FOR ANY PARTICULAR USE, FREEDOM FROM ANY COMPUTER DISEASES  OR
  15.  *  ITS CONFORMITY TO ANY SPECIFICATION. THE ENTIRE RISK AS TO QUALITY AND
  16.  *  PERFORMANCE OF THE SOFTWARE IS WITH THE USER.
  17.  *
  18.  *  Module: dcmpstat
  19.  *
  20.  *  Author: Andrew Hewett/Marco Eichelberg
  21.  *
  22.  *  Purpose:
  23.  *    VR and IOD checker for Presentation States
  24.  *
  25.  *
  26.  *  Last Update:      $Author: joergr $
  27.  *  Update Date:      $Date: 2004/02/04 15:44:38 $
  28.  *  CVS/RCS Revision: $Revision: 1.16 $
  29.  *  Status:           $State: Exp $
  30.  *
  31.  *  CVS/RCS Log at end of file
  32.  *
  33.  */
  35. #include "osconfig.h"    /* make sure OS specific configuration is included first */
  37. #define INCLUDE_CSTDLIB
  38. #include "ofstdinc.h"
  40. #ifdef HAVE_WINDOWS_H
  41. #include <windows.h>     /* this includes either winsock.h or winsock2.h */
  42. #endif
  44. #ifdef HAVE_GUSI_H
  45.     /* needed for Macintosh */
  46. #include <GUSI.h>
  47. #include <SIOUX.h>
  48. #endif
  50. #include "ofstream.h"
  51. #include "dctk.h"        /* for class DcmDataset */
  52. #include "ofstring.h"    /* for class OFString */
  53. #include "vrscan.h"
  54. #include "ofconapp.h"    /* for OFConsoleApplication */
  55. #include "dcmpstat.h"    /* for DcmPresentationState */
  57. #ifdef WITH_ZLIB
  58. #include <zlib.h>        /* for zlibVersion() */
  59. #endif
  61. #define OFFIS_CONSOLE_APPLICATION "dcmpschk"
  63. static char rcsid[] = "$dcmtk: " OFFIS_CONSOLE_APPLICATION " v"
  64.   OFFIS_DCMTK_VERSION " " OFFIS_DCMTK_RELEASEDATE " $";
  66. /* command line options */
  67. static OFBool           opt_verbose         = OFFalse;             /* default: not verbose */
  68. static const char *     opt_logfilename     = NULL;
  69. static const char *     opt_filename        = NULL;
  70. static int              opt_debugMode       = 0;
  72. static ostream *        logstream           = &COUT;
  74. // ********************************************
  76. enum ErrorMode
  77. {
  78.   EM_ok,
  79.   EM_informational,
  80.   EM_warning,
  81.   EM_error
  82. };
  84. #define MSG_invalidVR      "Error: Unsupported Value Representation."
  85. #define MSG_lengthtoolarge "Error: Value Length too large."
  86. #define MSG_lengthtoosmall "Error: Value Length too small."
  87. #define MSG_unexpectedVR   "Error: Unexpected Value Representation."
  88. #define MSG_vmtoolarge     "Error: Value Multiplicity too large."
  89. #define MSG_vmtoosmall     "Error: Value Multiplicity too small."
  90. #define MSGe_mhxferError   "Error: Meta-header encoded using invalid transfer syntax."
  91. #define MSGe_missingAtt    "Error: Attribute is missing."
  92. #define MSGe_wrongAtt      "Error: Attribute is incorrect."
  93. #define MSGe_wrongDType    "Error: Attribute value does not conform to data type definition."
  94. #define MSGi_wrongDType    "Informational: Attribute value does not conform to data type definition."
  95. #define MSGw_wrongDType    "Warning: Attribute value uses retired form."
  97. void printVRError(
  98.   ostream& out,
  99.   ErrorMode mode,
  100.   const char *elementDescription,
  101.   const DcmDictEntry* dictRef,
  102.   const char *format)
  103. {
  104.   if (mode == EM_error)              out << MSGe_wrongDType << endl;
  105.   else if (mode == EM_warning)       out << MSGw_wrongDType << endl;
  106.   else if (mode == EM_informational) out << MSGi_wrongDType << endl;
  107.   out << "   Affected attribute: ";
  108.   if (dictRef)
  109.   {
  110.      out << dictRef->getTagName();
  111.      out << " " << dictRef->getKey();
  112.      out << ", Type " << dictRef->getVR().getVRName() << endl;
  113.   } else out << "(unnamed)" << endl;
  114.   out << "   Attribute value   : ";
  115.   if (elementDescription) out << "[" << elementDescription << "]" << endl;
  116.   else out << "(empty)" << endl;
  117.   if (mode == EM_error)
  118.   {
  119.     out << "   Expected format for each value: ";
  120.     if (format)
  121.     {
  122.       out << format << endl;
  123.     } else out << "(undefined)" << endl;
  124.   }
  125.   out << endl;
  126. }
  128. void printResult(ostream& out, DcmStack& stack, OFBool showFullData)
  129. {
  130.     unsigned long n = stack.card();
  131.     if (n == 0) {
  132.         return;
  133.     }
  135.     /* print the path leading up to the top stack elem */
  136.     for (unsigned long i=n-1; i>=1; i--)
  137.     {
  138.         DcmObject *dobj = stack.elem(i);
  139.         /* do not print if a DCM_Item as this is not
  140.          * very helpful to distinguish instances.
  141.          */
  142.         if (dobj != NULL && dobj->getTag().getXTag() != DCM_Item)
  143.         {
  144.             char buf[128];
  145.             sprintf(buf, "(%04x,%04x).",
  146.                     (unsigned)dobj->getGTag(),
  147.                     (unsigned)dobj->getETag());
  148.             out << buf;
  149.         }
  150.     }
  152.     /* print the tag and its value */
  153.     DcmObject *dobj = stack.top();
  154.     dobj->print(out, (showFullData ? 0 : DCMTypes::PF_shortenLongTagValues));
  156. }
  158. OFBool isaStringVR(DcmVR& vr)
  159. {
  160.     OFBool isaString = OFFalse;
  161.     switch(vr.getEVR())
  162.     {
  163.     case EVR_AE:
  164.     case EVR_AS:
  165.     case EVR_CS:
  166.     case EVR_DA:
  167.     case EVR_DS:
  168.     case EVR_DT:
  169.     case EVR_IS:
  170.     case EVR_LO:
  171.     case EVR_LT:
  172.     case EVR_PN:
  173.     case EVR_SH:
  174.     case EVR_ST:
  175.     case EVR_TM:
  176.     case EVR_UI:
  177.         isaString = OFTrue;
  178.         break;
  179.     default:
  180.         isaString = OFFalse;
  181.         break;
  182.     }
  183.     return isaString;
  184. }
  186. const char* streamvm(const DcmDictEntry *e)
  187. {
  188.     static char buf[256];
  189.     if (e->isFixedSingleVM()) {
  190.         sprintf(buf, "%d", e->getVMMax());
  191.     } else if (e->isVariableRangeVM()) {
  192.         sprintf(buf, "%d-n", e->getVMMin());
  193.     } else if (e->isFixedRangeVM()){
  194.         sprintf(buf, "%d-%d", e->getVMMin(), e->getVMMax());
  195.     } else {
  196.         sprintf(buf, "?(%d-%d)?", e->getVMMin(), e->getVMMax());
  197.     }
  198.     return buf;
  199. }
  201. const char* streamLengthOfValue(DcmVR& vr)
  202. {
  203.     static char buf[256];
  204.     Uint32 min = vr.getMinValueLength();
  205.     Uint32 max = vr.getMaxValueLength();
  206.     Uint32 undefLen = DCM_UndefinedLength;
  208.     if (min==max) {
  209.         sprintf(buf, "%d bytes fixed length", (int)min);
  210.     } else if (min==0) {
  211.         if (max==undefLen) {
  212.             sprintf(buf, "unrestricted length");
  213.         } else {
  214.             sprintf(buf, "%d bytes maximum", (int)max);
  215.         }
  216.     } else {
  217.         sprintf(buf, "range %d-%d bytes length", (int)min, (int)max);
  218.     }
  219.     return buf;
  220. }
  222. int
  223. splitFields(char* line, char* fields[], Uint32 maxFields, char splitChar)
  224. {
  225.     char* p;
  226.     Uint32 foundFields = 0;
  227.     int len;
  229.     do {
  230.         p = strchr(line, splitChar);
  231.         if (p == NULL) {
  232.             len = strlen(line);
  233.         } else {
  234.             len = p - line;
  235.         }
  236.         fields[foundFields] = new char[len+1];
  237.         strncpy(fields[foundFields], line, len);
  238.         fields[foundFields][len] = '';
  240.         foundFields++;
  241.         line = p + 1;
  242.     } while ((foundFields < maxFields) && (p != NULL));
  244.     return foundFields;
  245. }
  247. OFBool isaKnownPointer(DcmTag& t)
  248. {
  249.     /*
  250.     ** The DICOMDIR code automatically converts any pointers
  251.     ** to have VR=up even if when the data has an explicit VR encoding.
  252.     ** If this attribute is a known pointer then it is ok for it to
  253.     ** have the internal VR=up.
  254.     */
  256.     OFBool result = OFFalse;
  257.     const DcmDataDictionary& globalDataDict = dcmDataDict.rdlock();
  258.     const DcmDictEntry *dictRef = globalDataDict.findEntry(t, NULL);
  260.     if (dictRef && (t.getEVR() == EVR_up) && (t.getEVR() == dictRef->getEVR())) result = OFTrue;
  262.     dcmDataDict.unlock();
  263.     return result;
  264. }
  266. int scanValue(istream& scannerInput)
  267. {
  268.    vrscan valueScanner;
  269.    valueScanner.yyin = &scannerInput;
  270.    int firstResult = valueScanner.yylex();
  271.    if (valueScanner.yylex())
  272.       return 16;
  273.    return firstResult;
  274. }
  276. int checkelem(ostream & out, DcmElement *elem,  DcmXfer& oxfer,
  277.         DcmStack& stack, OFBool showFullData,
  278.         int& dderrors, OFBool /* verbose */)
  279. {
  280.     DcmVR vr(elem->getVR());
  281.     Uint32 len = elem->getLength();
  282.     DcmTag tag(elem->getTag());
  283.     Uint32 vm = elem->getVM();
  284.     const DcmDataDictionary& globalDataDict = dcmDataDict.rdlock();
  285.     const DcmDictEntry *dictRef = globalDataDict.findEntry(tag, NULL);
  286.     int i = 0;
  288.     /*
  289.     ** if the data was encoded in explicit VR then check that the given VR matches
  290.     ** the value in the data dictionary.
  291.     */
  292.     if (oxfer.isExplicitVR()) {
  293.         if (!vr.isStandard() && !isaKnownPointer(tag)) {
  294.             out << MSG_invalidVR << endl
  295.                 << "   Affected VR       : [" << vr.getVRName() << "]";
  296.             if (dictRef) out << ", should be ["
  297.                 << dictRef->getVR().getVRName() << "] according to data dictionary.";
  298.             out << endl << "   Affected attribute: ";
  299.             printResult(out, stack, showFullData);
  300.             out << endl;
  301.             dderrors++;
  302.         } else if (dictRef && !vr.isEquivalent(dictRef->getVR())) {
  303.             out << MSG_unexpectedVR << endl
  304.                 << "   Affected VR       : [" << vr.getVRName() << "], should be ["
  305.                 << dictRef->getVR().getVRName() << "] according to data dictionary." << endl
  306.                 << "   Affected attribute: ";
  307.             printResult(out, stack, showFullData);
  308.             out << endl;
  309.             dderrors++;
  310.         }
  311.     }
  313.     if (len) /* type 2 attributes can be empty. */
  314.     {
  316.        /*
  317.        ** Check value multiplicity
  318.        */
  319.        if ((dictRef)&&(vm < (Uint32)dictRef->getVMMin()))
  320.        {
  321.            out << MSG_vmtoosmall << endl
  322.                << "   Affected VM       : " << vm << ", should be "
  323.                << streamvm(dictRef) << " according to data dictionary."
  324.                << endl << "   Affected attribute: ";
  325.            printResult(out, stack, showFullData);
  326.            out << endl;
  327.            dderrors++;
  328.        }
  330.        if ((dictRef)&&(vm > (Uint32)dictRef->getVMMax()))
  331.        {
  332.            out << MSG_vmtoolarge << endl
  333.                << "   Affected VM       : " << vm << ", should be "
  334.                << streamvm(dictRef) << " according to data dictionary."
  335.                << endl << "   Affected attribute: ";
  336.            printResult(out, stack, showFullData);
  337.            out << endl;
  338.            dderrors++;
  339.        }
  341.        /*
  342.        ** Check length of attribute
  343.        */
  344.        /* Need to split the value into its components if VM>1 */
  345.        if (isaStringVR(vr)) {
  346.            /* only strings have variable length components */
  347.            char* value = NULL;
  348.         ((DcmByteString*)elem)->getString(value);
  350.            char **fields = new char*[vm+1];
  351.            if (fields == NULL) {
  352.                printResult(out, stack, showFullData);
  353.                out << "Internal error: out of memory (value multiplicity too large)" << endl;
  354.            } else {
  355.                int nfields = splitFields(value, fields, vm, '\');
  356.                if ((Uint32)nfields != vm) {
  357.                    printResult(out, stack, showFullData);
  358.                    out << "Internal error: splitFields inconsistency ("
  359.                        << nfields << "!=" << vm << ")" << endl;
  360.                    exit(1);
  361.                }
  362.                for (i=0; (Uint32)i<vm; i++) {
  363.                    char* s = fields[i];
  364.                    int slen = strlen(s);
  365.                    if ((Uint32)slen > vr.getMaxValueLength()) {
  366.                        out << MSG_lengthtoolarge << endl
  367.                            << "   Affected length   : " << slen << " bytes, should be "
  368.                            << streamLengthOfValue(vr) << " for " << vr.getVRName() << "." << endl;
  369.                     if (vm > 1) out << "   Affected value [" << i << "]: "" << s << """ << endl;
  370.                        out << "   Affected attribute: ";
  371.                        printResult(out, stack, showFullData);
  372.                     dderrors++;
  373.                     out << endl;
  374.                    }
  375.                    if ((Uint32)slen < vr.getMinValueLength()) {
  376.                        out << MSG_lengthtoosmall << endl
  377.                            << "   Affected length   : " << slen << " bytes, should be "
  378.                            << streamLengthOfValue(vr) << " for " << vr.getVRName() << "." << endl;
  379.                     if (vm > 1) out << "   Affected value [" << i << "]: "" << s << """ << endl;
  380.                        out << "   Affected attribute: ";
  381.                        printResult(out, stack, showFullData);
  382.                     dderrors++;
  383.                     out << endl;
  384.                    }
  386.                    delete[] fields[i];
  387.                    fields[i] = NULL;
  388.                }
  389.                delete[] fields;
  390.            }
  391.        } else {
  392.            Uint32 componentSize = len; /* vm is 0 if value field is too short, e.g. < 8 bytes for FD */
  393.            if (vm>0) componentSize = len/vm;
  394.            if (componentSize > vr.getMaxValueLength()) {
  395.                out << MSG_lengthtoolarge << endl
  396.                    << "   Affected length   : " << componentSize << " bytes, should be "
  397.                    << streamLengthOfValue(vr) << " for " << vr.getVRName() << "." << endl
  398.                    << "   Affected attribute: ";
  399.                printResult(out, stack, showFullData);
  400.             dderrors++;
  401.             out << endl;
  402.         }
  403.            if (componentSize < vr.getMinValueLength()) {
  404.                out << MSG_lengthtoosmall << endl
  405.                    << "   Affected length   : " << componentSize << " bytes, should be "
  406.                    << streamLengthOfValue(vr) << " for " << vr.getVRName() << "." << endl
  407.                    << "   Affected attribute: ";
  408.                printResult(out, stack, showFullData);
  409.             dderrors++;
  410.             out << endl;
  411.            }
  412.        }
  414.       /*
  415.       **  check, wether the value of the element is suitable to the data type.
  416.       */
  419.       /*** differenciate all value representations */
  420.        if (isaStringVR(vr))
  421.        {
  422.          char* value = NULL;
  423.          if (EC_Normal == ((DcmByteString*)elem)->getString(value) && value) switch (vr.getEVR())
  424.          {
  425.            case EVR_AE:
  426.               {
  427.                 OFString vrAndValue("ae");
  428.                 vrAndValue += value;
  429.                 OFIStringStream input((char*)(vrAndValue.c_str()));
  430.                 int realVR = scanValue(input);
  431.                 if (realVR != 13)
  432.                 {
  433.                    printVRError(out, EM_error, value, dictRef, "all but control characters");
  434.                    dderrors++;
  435.                 }
  436.               }
  437.              break;
  438.            case EVR_AS:
  439.               {
  440.                 OFString vrAndValue("as");
  441.                 vrAndValue += value;
  442.                 OFIStringStream input((char*)(vrAndValue.c_str()));
  443.                 int realVR = scanValue(input);
  444.                 if (realVR != 1)
  445.                 {
  446.                    printVRError(out, EM_error, value, dictRef, "[0-9]{3}[DWMY]");
  447.                    dderrors++;
  448.                 }
  449.               }
  450.               break;
  451.            case EVR_CS:
  452.               {
  453.                 OFString vrAndValue("cs");
  454.                 vrAndValue += value;
  455.                 OFIStringStream input((char*)(vrAndValue.c_str()));
  456.                 int realVR = scanValue(input);
  457.                 if (realVR != 10)
  458.                 {
  459.                    printVRError(out, EM_error, value, dictRef, "[0-9A-Z _]+");
  460.                    dderrors++;
  461.                 }
  462.              }
  463.              break;
  464.            case EVR_DA:
  465.               {
  466.                 OFString vrAndValue("da");
  467.                 vrAndValue += value;
  468.                 OFIStringStream input((char*)(vrAndValue.c_str()));
  469.                 int realVR = scanValue(input);
  470.                 if (realVR != 2 )
  471.                 {
  472.                    if (realVR == 3)
  473.                    {
  474.                       printVRError(out, EM_warning, value, dictRef, NULL);
  475.                       dderrors++;
  476.                    } else {
  477.                      printVRError(out, EM_error, value, dictRef, "[0-9]{8} with valid values for year, month and day");
  478.                      dderrors++;
  479.                    }
  480.                 }
  481.               }
  482.               break;
  483.            case EVR_DS:
  484.               {
  485.                 OFString vrAndValue("ds");
  486.                 vrAndValue += value;
  487.                 OFIStringStream input((char*)(vrAndValue.c_str()));
  488.                 int realVR = scanValue(input);
  489.                 if (realVR != 6)
  490.                 {
  491.                    printVRError(out, EM_error, value, dictRef, "([\-\+]?[0-9]*[\.]?[0-9]+)|([\-\+]?[0-9][\.]?[0-9]+[Ee][\+\-][0-9]+)");
  492.                    dderrors++;
  493.                 }
  494.            }
  495.            break;
  496.         case EVR_DT:
  497.            {
  498.              OFString vrAndValue("dt");
  499.              vrAndValue += value;
  500.              OFIStringStream input((char*)(vrAndValue.c_str()));
  501.              int realVR = scanValue(input);
  502.              if (realVR != 7)
  503.              {
  504.                 printVRError(out, EM_error, value, dictRef, "[0-9]{8}[0-9]{2}([0-9]{2}([0-9]{2}(\.[0-9]{1,6})?)?)?([\+\-][0-9]{4})?");
  505.                 dderrors++;
  506.              }
  507.            }
  508.            break;
  509.         case EVR_IS:
  510.            {
  511.              OFString vrAndValue("is");
  512.              vrAndValue += value;
  513.              OFIStringStream input((char*)(vrAndValue.c_str()));
  514.              int realVR = scanValue(input);
  515.              if (realVR != 8)
  516.              {
  517.                 printVRError(out, EM_error, value, dictRef, "[\+\-]?[0-9]+ in the range -2^31 .. 2^31-1");
  518.                 dderrors++;
  519.              }
  520.            }
  521.            break;
  522.         case EVR_SH:
  523.         case EVR_LO:
  524.            {
  525.              OFString vrAndValue("lo");
  526.              vrAndValue += value;
  527.              OFIStringStream input((char*)(vrAndValue.c_str()));
  528.              int realVR = scanValue(input);
  529.              if (realVR != 12)
  530.              {
  531.                 printVRError(out, EM_error, value, dictRef, "all but '\' and control characters");
  532.                 dderrors++;
  533.              }
  534.            }
  535.            break;
  536.         case EVR_ST:
  537.         case EVR_LT:
  538.            {
  539.              OFString vrAndValue("lt");
  540.              vrAndValue += value;
  541.              OFIStringStream input((char*)(vrAndValue.c_str()));
  542.              int realVR = scanValue(input);
  543.              if (realVR != 14)
  544.              {
  545.                 printVRError(out, EM_error, value, dictRef, "all");
  546.                 dderrors++;
  547.              }
  548.            }
  549.            break;
  550.         case EVR_PN:
  551.            {
  552.              OFString vrAndValue("pn");
  553.              vrAndValue += value;
  554.              OFIStringStream input((char*)(vrAndValue.c_str()));
  555.              int realVR = scanValue(input);
  556.              if (realVR != 11)
  557.              {
  558.                 if (realVR == 15) /* OLD_PN */
  559.                 {
  560.                   printVRError(out, EM_warning, value, dictRef, NULL);
  561.                   dderrors++;
  562.                 } else {
  563.                   printVRError(out, EM_error, value, dictRef, "{all}*([\^]{all}*([\^]{all}*([\^]{all}*(\^{all}*)?)?)?)?");
  564.                   dderrors++;
  565.                 }
  566.              }
  567.            }
  568.            break;
  569.         case EVR_TM:
  570.            {
  571.              OFString vrAndValue("tm");
  572.              vrAndValue += value;
  573.              OFIStringStream input((char*)(vrAndValue.c_str()));
  574.              int realVR = scanValue(input);
  575.              if (realVR != 4)
  576.              {
  577.                 if (realVR == 5)
  578.                 {
  579.                   printVRError(out, EM_warning, value, dictRef, NULL);
  580.                   dderrors++;
  581.                 } else {
  582.                   printVRError(out, EM_error, value, dictRef, "[0-9]{2}([0-9]{2}([0-9]{2}(\.[0-9]{1,6})?)?)? with valid values for hour, minute and second");
  583.                   dderrors++;
  584.                 }
  585.              }
  586.            }
  587.            break;
  588.         case EVR_UI:
  589.            {
  590.              OFString vrAndValue("ui");
  591.              vrAndValue += value;
  592.              OFIStringStream input((char*)(vrAndValue.c_str()));
  593.              int realVR = scanValue(input);
  594.              if (realVR != 9)
  595.              {
  596.                 printVRError(out, EM_error, value, dictRef, "([0-9]+\.)*[0-9]+ without any leading zeroes");
  597.                 dderrors++;
  598.              }
  599.            }
  600.            break;
  601.         default:
  602.            break;
  603.         }
  605.       } //end of if (isaStringVR(vr))
  607.     }
  608.     dcmDataDict.unlock();
  609.     return 0;
  610. }
  612. int checkitem(ostream & out, DcmItem *item,  DcmXfer& oxfer,
  613.         DcmStack& stack, OFBool showFullData, int& dderrors, OFBool verbose)
  614. {
  616.     if (item == NULL) {
  617.         return 0;
  618.     }
  619.     /*
  620.     ** Step through each attribute and check it.
  621.     */
  623.     unsigned long count = item->card();
  624.     for (unsigned long i=0; i<count; i++) {
  625.         DcmElement *elem = item->getElement(i);
  627.         stack.push(elem);
  628.         checkelem(out, elem, oxfer, stack, showFullData, dderrors, verbose);
  629.         stack.pop();
  631.         if (elem->ident() == EVR_SQ) {
  632.             DcmSequenceOfItems *seq = (DcmSequenceOfItems*)elem;
  633.             unsigned long nitems = seq->card();
  634.             for (unsigned long j=0; j<nitems; j++) {
  635.                 /* check each item.  an item is just another dataset */
  636.                 stack.push(seq);
  637.                 checkitem(out, seq->getItem(j), oxfer, stack, showFullData, dderrors, verbose);
  638.                 stack.pop();
  639.             }
  640.         }
  641.     }
  642.     return 0;
  643. }
  645. int dcmchk(
  646.   ostream & out,
  647.   const char* ifname,
  648.   OFBool isDataset,
  649.   E_TransferSyntax xfer,
  650.   OFBool showFullData,
  651.   OFBool loadAllDataInMemory,
  652.   int& dderrors,
  653.   OFBool verbose)
  654. {
  655.     DcmFileFormat *ds = new DcmFileFormat();
  657.     OFCondition cond = ds->loadFile(ifname, xfer, EGL_noChange, DCM_MaxReadLength, isDataset);
  658.     if (! cond.good())
  659.     {
  660.       out << "Error: " << cond.text() << " reading file: " << ifname << endl;
  661.     }
  663.     if (loadAllDataInMemory) {
  664.         ds->loadAllDataIntoMemory();
  665.         if (ds->error() != EC_Normal)
  666.         {
  667.            out << "Error: " << ds->error().text()
  668.                 << " reading file: " << ifname << endl;
  669.             return 1;
  670.         }
  671.     }
  673.     DcmStack stack;
  674.     DcmXfer oxfer(META_HEADER_DEFAULT_TRANSFERSYNTAX);
  676.     DcmMetaInfo *mi = ds->getMetaInfo();
  677.     if (mi->card() > 0)
  678.     {
  679.       // we only check the meta-header if there is something to check
  680.       checkitem(out, mi, oxfer, stack, showFullData, dderrors, verbose);
  681.     }
  683.     oxfer = ds->getDataset()->getOriginalXfer();
  684.     checkitem(out, ds->getDataset(),  oxfer, stack, showFullData, dderrors, verbose);
  686.     delete ds;
  688.     return 0;
  689. }
  691. //*********************************************************
  693. static void
  694. printAttribute(ostream& out, DcmItem* dset,
  695.                const DcmTagKey& key)
  696. {
  697.     DcmElement *elem = NULL;
  698.     DcmStack stack;
  699.     OFCondition ec = EC_Normal;
  701.     ec = dset->search(key, stack, ESM_fromHere, OFFalse);
  702.     elem = (DcmElement*) stack.top();
  703.     elem->print(out, DCMTypes::PF_shortenLongTagValues);
  704. }
  706. static OFBool
  707. chkType1AttributeExistance(ostream& out, DcmItem* dset,
  708.                       const DcmTagKey& key)
  709. {
  710.     OFBool found = OFTrue;
  711.     if (!dset->tagExistsWithValue(key)) {
  712.         DcmTag t(key);
  713.         out << MSGe_missingAtt << endl
  714.             << "   Affected attribute: " << t.getXTag()
  715.             << " " << t.getTagName() << endl;
  716.         out << endl;
  717.         found = OFFalse;
  718.     }
  719.     return found;
  720. }
  722. int dcmchkMetaHeader(ostream& out, DcmMetaInfo* meta, DcmDataset* dset)
  723. {
  725.     if (meta == NULL || meta->card() == 0) {
  726.         /* no meta-header so no errors */
  727.         return 0;
  728.     }
  730.     int nErrs = 0;
  732.     /*
  733.     ** The meta-header should use the LittleEndianExplicit transfer syntax
  734.     */
  735.     if (meta->getOriginalXfer() != EXS_LittleEndianExplicit) {
  736.         DcmXfer used(meta->getOriginalXfer());
  737.         DcmXfer expected(EXS_LittleEndianExplicit);
  738.         out << MSGe_mhxferError << endl
  739.             << "    Expected: " << expected.getXferName() << endl
  740.             << "    Used:     " << used.getXferName() << endl << endl;
  741.         nErrs++;
  742.     }
  744.     /*
  745.     ** Check the meta-header contents
  746.     */
  748.     // examine the FileMetaInformationVersion
  749.     DcmTagKey fmiv(DCM_FileMetaInformationVersion);
  750.     if (chkType1AttributeExistance(out, meta, fmiv)) {
  751.         Uint8 b0 = 0xff;
  752.         Uint8 b1 = 0xff;
  753.         // get bytes
  754.         meta->findAndGetUint8(fmiv, b0, 0);
  755.         meta->findAndGetUint8(fmiv, b1, 1);
  756.         // we expect 0x00/0x01 for the version
  757.         if ((b0 != 0x00) || (b1 != 0x01)) {
  758.             out << MSGe_wrongAtt << endl
  759.                 << "   Invalid FileMetaInformationVersion (expected: 00\01)"
  760.                 << endl << "   Affected attribute: " << endl << "      ";
  761.             printAttribute(out, meta, fmiv);
  762.             out << endl;
  763.             nErrs++;
  764.         }
  765.     } else {
  766.         nErrs++;
  767.     }
  769.     // examine the MediaStorageSOPClassUID
  770.     DcmTagKey msscuid(DCM_MediaStorageSOPClassUID);
  771.     if (chkType1AttributeExistance(out, meta, msscuid)) {
  772.         OFString metaHeaderClassUID;
  773.         meta->findAndGetOFStringArray(msscuid, metaHeaderClassUID);
  774.         // should be the same as SOPClassUID in the dataset
  775.         if (dset && dset->tagExistsWithValue(DCM_SOPClassUID)) {
  776.             OFString datasetClassUID;
  777.             dset->findAndGetOFStringArray(DCM_SOPClassUID, datasetClassUID);
  778.             if (metaHeaderClassUID != datasetClassUID) {
  779.                 out << MSGe_wrongAtt << endl
  780.                     << "   Inconsistant SOP class information"
  781.                 << endl << "   Affected attributes: " << endl << "      ";
  782.                 printAttribute(out, meta, msscuid);
  783.                 out << "      ";
  784.                 printAttribute(out, dset, DCM_SOPClassUID);
  785.                 out << endl;
  786.                 nErrs++;
  787.             }
  788.         }
  789.         if (!dcmFindNameOfUID(metaHeaderClassUID.c_str())) {
  790.             out << MSGe_wrongAtt << endl
  791.                 << "   Unknown SOP Class"
  792.                 << endl << "   Affected attribute: " << endl << "      ";
  793.             printAttribute(out, meta, msscuid);
  794.             out << endl;
  795.             nErrs++;
  796.         }
  797.     } else {
  798.         nErrs++;
  799.     }
  801.     // Examine MediaStorageSOPInstanceUID
  802.     DcmTagKey mssiuid(DCM_MediaStorageSOPInstanceUID);
  803.     if (chkType1AttributeExistance(out, meta, mssiuid)) {
  804.         OFString metaHeaderInstanceUID;
  805.         meta->findAndGetOFStringArray(mssiuid, metaHeaderInstanceUID);
  806.         // should be the same as SOPInstanceUID in the dataset
  807.         if (dset && dset->tagExistsWithValue(DCM_SOPInstanceUID)) {
  808.             OFString datasetInstanceUID;
  809.             dset->findAndGetOFStringArray(DCM_SOPInstanceUID, datasetInstanceUID);
  810.             if (metaHeaderInstanceUID != datasetInstanceUID) {
  811.                 out << MSGe_wrongAtt << endl
  812.                     << "   Inconsistant SOP instance information"
  813.                 << endl << "   Affected attributes: " << endl << "      ";
  814.                 printAttribute(out, meta, mssiuid);
  815.                 out << "      ";
  816.                 printAttribute(out, dset, DCM_SOPInstanceUID);
  817.                 out << endl;
  818.                 nErrs++;
  819.             }
  820.         }
  821.     } else {
  822.         nErrs++;
  823.     }
  825.     // examine the TransferSyntaxUID
  826.     DcmTagKey tsuid(DCM_TransferSyntaxUID);
  827.     if (chkType1AttributeExistance(out, meta, tsuid)) {
  828.         OFString transferSyntaxUID;
  829.         meta->findAndGetOFStringArray(tsuid, transferSyntaxUID);
  830.         // is this transfer syntax known ?
  831.         DcmXfer expected(transferSyntaxUID.c_str());
  832.         if (expected.getXfer() == EXS_Unknown) {
  833.             out << MSGe_wrongAtt << endl
  834.                 << "   Unknown Transfer Syntax"
  835.                 << endl << "   Affected attribute: " << endl << "      ";
  836.             printAttribute(out, meta, tsuid);
  837.             out << endl;
  838.             nErrs++;
  839.         }
  841.         // should be the same as transfer syntax used to read the dataset
  842.         if (dset && (dset->getOriginalXfer() != EXS_LittleEndianExplicit)) {
  843.             DcmXfer used(dset->getOriginalXfer());
  844.             OFString usedTransferSyntaxUID(used.getXferID());
  845.             if (transferSyntaxUID != usedTransferSyntaxUID) {
  846.                 out << MSGe_wrongAtt << endl
  847.                     << "   Dataset not encoded using specified transfer syntax"
  848.                     << endl << "   Affected attribute: " << endl << "      ";
  849.                 printAttribute(out, meta, tsuid);
  850.                 out << "   Dataset encoded using: " << used.getXferName()
  851.                     << endl << endl;
  852.                 nErrs++;
  853.             }
  855.         }
  856.     } else {
  857.         nErrs++;
  858.     }
  860.     // Check the group length information
  861.     DcmTagKey gltag(DCM_MetaElementGroupLength);
  862.     if (chkType1AttributeExistance(out, meta, gltag)) {
  863.         Uint32 len = 0;
  864.         meta->findAndGetUint32(gltag, len, 0);
  865.         // Compute how large the Meta-Header should be
  866.         Uint32 expectedLength = meta->getLength(EXS_LittleEndianExplicit,
  867.                                                 EET_ExplicitLength);
  868.         expectedLength -= 12; // less length of group length element itself
  870.         if (len != expectedLength) {
  871.             out << MSGe_wrongAtt << endl
  872.                 << "   Invalid meta-header group length (expected: "
  873.                 <<  expectedLength  << ")"
  874.                 << endl << "   Affected attribute: " << endl << "      ";
  875.             printAttribute(out, meta, gltag);
  876.             out << endl;
  877.             nErrs++;
  878.         }
  879.     } else {
  880.         nErrs++;
  881.     }
  883.     return nErrs;
  884. }
  886. int checkfile(const char *filename, OFBool verbose, ostream& out, OFConsole *outconsole, OFBool opt_debug)
  887. {
  888.     DcmFileFormat *dfile = new DcmFileFormat();
  889.     if (dfile == NULL)
  890.     {
  891.       out << "Error: out of memory." << endl;
  892.       return -1;
  893.     }
  895.     OFCondition cond = dfile->loadFile(filename);
  896.     if (! cond.good())
  897.     {
  898.       out << "Error: " << cond.text() << " reading file: " << filename << endl;
  899.       delete dfile;
  900.       return -1;
  901.     }
  903.     int numberOfErrors = 0;
  904.     OFBool test_passed = OFTrue;
  906.     DcmDataset *DataSet = dfile->getDataset();
  907.     DcmMetaInfo *MetaInfo = dfile->getMetaInfo();
  909.     if (verbose)
  910.     {
  911.       out << "=========================================================" << endl;
  912.     }
  913.     out << "Testing: " << filename << endl;
  914.     if (verbose)
  915.     {
  916.       out << "=========================================================" << endl << endl;
  917.     } else out << endl;
  919.     if (MetaInfo)
  920.     {
  921.       if (verbose)
  922.       {
  923.         out << "---------------------------------------------------------" << endl
  924.             << "Pass 1 - Inconsistencies between Meta-header and Data Set" << endl
  925.             << "---------------------------------------------------------" << endl << endl;
  926.       }
  927.       numberOfErrors += dcmchkMetaHeader(out, MetaInfo, DataSet);
  928.     }
  930.     if (verbose)
  931.     {
  932.       out << "-------------------------------------------------------------" << endl
  933.           << "Pass 2 - Inconsistencies between Data Dictionary and Data Set" << endl
  934.           << "-------------------------------------------------------------" << endl << endl;
  935.     }
  937.     dcmchk(out, opt_filename, OFFalse, EXS_Unknown,
  938.           OFFalse /* showFullData */, OFTrue /* loadAllDataInMemory */,
  939.           numberOfErrors, verbose);
  941.     if (verbose)
  942.     {
  943.       out << "-------------------------------------------------------------" << endl
  944.           << "Pass 3 - Semantic Check of Presentation State Object         " << endl
  945.           << "-------------------------------------------------------------" << endl << endl;
  946.     }
  949.     DcmUniqueIdentifier sopclassuid(DCM_SOPClassUID);
  950.     DcmStack stack;
  951.     if (EC_Normal == DataSet->search(DCM_SOPClassUID, stack, ESM_fromHere, OFFalse))
  952.     {
  953.       sopclassuid = *((DcmUniqueIdentifier *)(stack.top()));
  954.     }
  955.     OFString aString;
  956.     sopclassuid.getOFString(aString,0);
  957.     if (aString == UID_GrayscaleSoftcopyPresentationStateStorage)
  958.     {
  959.       DcmPresentationState pState;
  960.       pState.setLog(outconsole, OFTrue, opt_debug);
  961.       if (pState.read(*DataSet).bad())
  962.       {
  963.         test_passed = OFFalse;
  964.         out << endl;
  965.       }
  966.     } else {
  967.       if (verbose) out << "Not a Grayscale Softcopy Presentation State, skipping pass 3." << endl <<endl;
  968.     }
  969.     if (numberOfErrors > 0) test_passed = OFFalse;
  971.     if (test_passed) out << "Test passed." << endl << endl;
  972.     else out << "Test failed - one or more errors." << endl << endl;
  974.     if (dfile) delete dfile;
  975.     return numberOfErrors;
  976. }
  979. void closeLog()
  980. {
  981.   ofConsole.setCout();
  982.   ofConsole.split();
  983.   if (logstream != &COUT)
  984.   {
  985.     delete logstream;
  986.     logstream = &COUT;
  987.   }
  988. }
  990. #define SHORTCOL 2
  991. #define LONGCOL 14
  993. int main(int argc, char *argv[])
  994. {
  996. #ifdef HAVE_GUSI_H
  997.     GUSISetup(GUSIwithSIOUXSockets);
  998.     GUSISetup(GUSIwithInternetSockets);
  999. #endif
  1001. #ifdef HAVE_WINSOCK_H
  1002.     WSAData winSockData;
  1003.     /* we need at least version 1.1 */
  1004.     WORD winSockVersionNeeded = MAKEWORD( 1, 1 );
  1005.     WSAStartup(winSockVersionNeeded, &winSockData);
  1006. #endif
  1008.     SetDebugLevel((0));
  1010.     OFConsoleApplication app(OFFIS_CONSOLE_APPLICATION , "Checking tool for presentation states", rcsid);
  1011.     OFCommandLine cmd;
  1012.     cmd.setOptionColumns(LONGCOL, SHORTCOL);
  1013.     cmd.setParamColumn(LONGCOL + SHORTCOL + 2);
  1015.     cmd.addParam("filename_in",   "presentation state file(s) to be checked", OFCmdParam::PM_MultiMandatory);
  1017.     cmd.addGroup("general options:");
  1018.      cmd.addOption("--help",        "-h",    "print this help text and exit");
  1019.      cmd.addOption("--version",              "print version information and exit", OFTrue /* exclusive */);
  1020.      cmd.addOption("--verbose",     "-v",    "verbose mode, print actions");
  1021.      cmd.addOption("--debug",       "-d",    "debug mode, print debug information");
  1023.      cmd.addOption("--logfile",     "-l", 1, "[f]ilename: string",
  1024.                                              "write output to logfile f");
  1026.     /* evaluate command line */
  1027.     prepareCmdLineArgs(argc, argv, OFFIS_CONSOLE_APPLICATION);
  1028.     if (app.parseCommandLine(cmd, argc, argv, OFCommandLine::ExpandWildcards))
  1029.     {
  1030.       /* check exclusive options first */
  1031.       if (cmd.getParamCount() == 0)
  1032.       {
  1033.         if (cmd.findOption("--version"))
  1034.         {
  1035.             app.printHeader(OFTrue /*print host identifier*/);          // uses ofConsole.lockCerr()
  1036.             CERR << endl << "External libraries used:";
  1037. #ifdef WITH_ZLIB
  1038.             CERR << endl << "- ZLIB, Version " << zlibVersion() << endl;
  1039. #else
  1040.             CERR << " none" << endl;
  1041. #endif
  1042.             return 0;
  1043.          }
  1044.       }
  1046.       /* options */
  1047.       if (cmd.findOption("--verbose")) opt_verbose = OFTrue;
  1048.       if (cmd.findOption("--debug"))   opt_debugMode = 3;
  1049.       if (cmd.findOption("--logfile"))
  1050.       {
  1051.         app.checkValue(cmd.getValue(opt_logfilename));
  1052.       }
  1053.     }
  1054.     SetDebugLevel((opt_debugMode));
  1056.     if (opt_logfilename)
  1057.     {
  1058.       ofstream *newstream = new ofstream(opt_logfilename);
  1059.       if (newstream && (newstream->good()))
  1060.       {
  1061.         logstream=newstream;
  1062.         ofConsole.setCout(logstream);
  1063.         ofConsole.join();
  1064.       }
  1065.       else
  1066.       {
  1067.        delete newstream;
  1068.       }
  1069.     }
  1071.     int paramCount = cmd.getParamCount();
  1072.     for (int param=1; param <= paramCount; param++)
  1073.     {
  1074.       cmd.getParam(param, opt_filename);
  1075.       checkfile(opt_filename, opt_verbose, *logstream, &ofConsole, ((opt_debugMode>0) ? OFTrue : OFFalse));
  1076.     }
  1078.     closeLog();
  1080. #ifdef DEBUG
  1081.     dcmDataDict.clear();  /* useful for debugging with dmalloc */
  1082. #endif
  1083.     return 0;
  1084. }
  1086. /*
  1087.  * CVS/RCS Log:
  1088.  * $Log: dcmpschk.cc,v $
  1089.  * Revision 1.16  2004/02/04 15:44:38  joergr
  1090.  * Removed acknowledgements with e-mail addresses from CVS log.
  1091.  *
  1092.  * Revision 1.15  2003/09/05 09:00:49  meichel
  1093.  * Updated presentation state checker to use class DcmPresentationState
  1094.  *   instead of DVPresentationState. Imported updated VR checking code
  1095.  *   from module dcmcheck.
  1096.  *
  1097.  * Revision 1.14  2003/09/01 12:58:58  wilkens
  1098.  * Added #include to file to be able to compile again under Win32.
  1099.  *
  1100.  * Revision 1.13  2003/03/12 17:34:20  meichel
  1101.  * Updated DcmObject::print() flags
  1102.  *
  1103.  * Revision 1.12  2002/11/27 15:47:52  meichel
  1104.  * Adapted module dcmpstat to use of new header file ofstdinc.h
  1105.  *
  1106.  * Revision 1.11  2002/11/26 08:44:27  meichel
  1107.  * Replaced all includes for "zlib.h" with <zlib.h>
  1108.  *   to avoid inclusion of zlib.h in the makefile dependencies.
  1109.  *
  1110.  * Revision 1.10  2002/09/23 18:26:07  joergr
  1111.  * Added new command line option "--version" which prints the name and version
  1112.  * number of external libraries used (incl. preparation for future support of
  1113.  * 'config.guess' host identifiers).
  1114.  *
  1115.  * Revision 1.9  2002/08/20 12:21:53  meichel
  1116.  * Adapted code to new loadFile and saveFile methods, thus removing direct
  1117.  *   use of the DICOM stream classes.
  1118.  *
  1119.  * Revision 1.8  2002/06/14 10:44:18  meichel
  1120.  * Adapted log file handling to ofConsole singleton
  1121.  *
  1122.  * Revision 1.7  2002/05/02 14:10:04  joergr
  1123.  * Added support for standard and non-standard string streams (which one is
  1124.  * supported is detected automatically via the configure mechanism).
  1125.  *
  1126.  * Revision 1.6  2002/04/16 14:01:27  joergr
  1127.  * Added configurable support for C++ ANSI standard includes (e.g. streams).
  1128.  *
  1129.  * Revision 1.5  2001/11/09 16:04:51  joergr
  1130.  * Changed type of variable to avoid compiler warnings (comparison of signed
  1131.  * and unsigned data).
  1132.  *
  1133.  * Revision 1.4  2001/10/02 11:51:59  joergr
  1134.  * Introduced new general purpose functions to get/put DICOM element values
  1135.  * from/to an item/dataset - removed some old and rarely used functions.
  1136.  *
  1137.  * Revision 1.3  2001/09/26 15:36:02  meichel
  1138.  * Adapted dcmpstat to class OFCondition
  1139.  *
  1140.  * Revision 1.2  2001/06/01 15:50:08  meichel
  1141.  * Updated copyright header
  1142.  *
  1143.  * Revision 1.1  2000/06/21 15:40:32  meichel
  1144.  * Added initial version of Presentation State Checker.
  1145.  *
  1146.  *
  1147.  */