dcmpstat/include/dvpssp.h

/*
 *
 *  Copyright (C) 1999-2004, OFFIS
 *
 *  This software and supporting documentation were developed by
 *
 *    Kuratorium OFFIS e.V.
 *    Healthcare Information and Communication Systems
 *    Escherweg 2
 *    D-26121 Oldenburg, Germany
 *
 *  THIS SOFTWARE IS MADE AVAILABLE,  AS IS,  AND OFFIS MAKES NO  WARRANTY
 *  REGARDING  THE  SOFTWARE,  ITS  PERFORMANCE,  ITS  MERCHANTABILITY  OR
 *  FITNESS FOR ANY PARTICULAR USE, FREEDOM FROM ANY COMPUTER DISEASES  OR
 *  ITS CONFORMITY TO ANY SPECIFICATION. THE ENTIRE RISK AS TO QUALITY AND
 *  PERFORMANCE OF THE SOFTWARE IS WITH THE USER.
 *
 *  Module: dcmpstat
 *
 *  Author: Marco Eichelberg
 *
 *  Purpose:
 *    classes: DVPSStoredPrint
 *
 *  Last Update:      $Author: joergr $
 *  Update Date:      $Date: 2004/02/04 15:49:09 $
 *  CVS/RCS Revision: $Revision: 1.37 $
 *  Status:           $State: Exp $
 *
 *  CVS/RCS Log at end of file
 *
 */


#ifndef DVPSSP_H
#define DVPSSP_H

#include "osconfig.h"    /* make sure OS specific configuration is included first */

#include "ofstream.h"
#include "ofstring.h"
#include "dctk.h"
#include "dvpstyp.h"         /* for enum types */
#include "dvpspll.h"         /* for class DVPSPresentationLUT_PList */
#include "dvpsibl.h"         /* for class DVPSImageBoxContent_PList */
#include "dvpsabl.h"         /* for class DVPSAnnotationContent_PList */
#include "dvpstat.h"         /* for class DVPresentationState */
#include "dvpspr.h"          /* for class DVPrintMessageHandler */

class DicomImage;
class DVPSPresentationLUT;
class DVConfiguration;
class DVPSStoredPrint
{
 public:
  DVPSStoredPrint(Uint16 illumin, Uint16 reflection, const char *aetitle = NULL);

  DVPSStoredPrint(const DVPSStoredPrint& copy);

  DVPSStoredPrint *clone() { return new DVPSStoredPrint(*this); }

  virtual ~DVPSStoredPrint();

  void clear();

  OFCondition read(DcmItem &dset);

  OFCondition write(
    DcmItem &dset,
    OFBool writeRequestedImageSize,
    OFBool limitImages,
    OFBool updateDecimateCrop,
    OFBool ignoreEmptyImages);

  OFCondition setOriginator(const char *aetitle);

  OFCondition setDestination(const char *aetitle);

  OFCondition setPrinterName(const char *name);

  OFCondition setImageDisplayFormat(unsigned long columns, unsigned long rows);

  OFCondition setFilmSizeID(const char *value);

  OFCondition setMagnificationType(const char *value);

  OFCondition setSmoothingType(const char *value);

  OFCondition setConfigurationInformation(const char *value);

  OFCondition setResolutionID(const char *value);

  OFCondition setFilmOrientation(DVPSFilmOrientation value);

  OFCondition setTrim(DVPSTrimMode value);

  OFCondition setRequestedDecimateCropBehaviour(DVPSDecimateCropBehaviour value);

  OFCondition setBorderDensity(const char *value);

  OFCondition setEmtpyImageDensity(const char *value);

  OFCondition setMaxDensity(const char *value);

  OFCondition setMinDensity(const char *value);

  OFCondition newPrinter(const char *name = NULL, const char *destinationAE = NULL); // short cut, delete all optional settings

  const char *getOriginator();
  const char *getDestination();
  const char *getPrinterName();

  unsigned long getImageDisplayFormatColumns();

  unsigned long getImageDisplayFormatRows();

  DVPSFilmOrientation getFilmOrientation();

  DVPSTrimMode getTrim();

  DVPSDecimateCropBehaviour getRequestedDecimateCropBehaviour()
  {
    return decimateCropBehaviour;
  }

  const char *getStudyInstanceUID();

  const char *getSeriesInstanceUID();

  const char *getSOPInstanceUID();

  const char *getFilmSizeID();

  const char *getMagnificationType();

  const char *getSmoothingType();

  const char *getConfigurationInformation();

  const char *getResolutionID();

  const char *getBorderDensity();

  const char *getEmtpyImageDensity();

  const char *getMaxDensity();

  const char *getMinDensity();

  Uint16 getMaxDensityValue();

  Uint16 getMinDensityValue();

  size_t getNumberOfImages()
  {
    return imageBoxContentList.size();
  }

  size_t getNumberOfAnnotations()
  {
    return annotationContentList.size();
  }

  OFCondition deleteImage(size_t idx);

  OFCondition deleteMultipleImages(size_t number);

  OFCondition deleteSpooledImages();

  OFBool imageHasAdditionalSettings(size_t idx)
  {
    return imageBoxContentList.imageHasAdditionalSettings(idx);
  }

  OFCondition setImagePolarity(size_t idx, const char *value)
  {
    return imageBoxContentList.setImagePolarity(idx, value);
  }

  OFCondition setImageRequestedSize(size_t idx, const char *value)
  {
    return imageBoxContentList.setImageRequestedSize(idx, value);
  }

  OFCondition setImageMagnificationType(size_t idx, const char *value)
  {
    return imageBoxContentList.setImageMagnificationType(idx, value);
  }

  OFCondition setImageSmoothingType(size_t idx, const char *value)
  {
    return imageBoxContentList.setImageSmoothingType(idx, value);
  }

  OFCondition setImageConfigurationInformation(size_t idx, const char *value)
  {
    return imageBoxContentList.setImageConfigurationInformation(idx, value);
  }

  const char *getImagePolarity(size_t idx)
  {
    return imageBoxContentList.getImagePolarity(idx);
  }

  const char *getImageRequestedSize(size_t idx)
  {
    return imageBoxContentList.getImageRequestedSize(idx);
  }

  const char *getImageMagnificationType(size_t idx)
  {
    return imageBoxContentList.getImageMagnificationType(idx);
  }

  const char *getImageSmoothingType(size_t idx)
  {
    return imageBoxContentList.getImageSmoothingType(idx);
  }

  const char *getImageConfigurationInformation(size_t idx)
  {
    return imageBoxContentList.getImageConfigurationInformation(idx);
  }

  DVPSPresentationLUT *getImagePresentationLUT(size_t idx);

  DVPSPresentationLUT *getPresentationLUT();

  OFCondition setDefaultPresentationLUT();

  OFCondition setPresentationLUTShape(DVPSPresentationLUTType shape);

  OFCondition setPresentationLookupTable(DcmItem &dset);

  Sint32 convertODtoPValue(Uint16 density, unsigned int bits = 8);

  OFCondition writeHardcopyImageAttributes(DcmItem &dset);

  OFCondition addImageBox(
    const char *retrieveaetitle,
    const char *refstudyuid,
    const char *refseriesuid,
    const char *refsopclassuid,
    const char *refsopinstanceuid,
    const char *requestedimagesize,
    const char *patientid,
    DVPSPresentationLUT *presentationlut,
    OFBool inversePLUT);

  OFCondition addImageBox(
    const char *retrieveaetitle,
    const char *refsopinstanceuid,
    const char *requestedimagesize=NULL,
    const char *patientid=NULL,
    DVPSPresentationLUT *presentationlut=NULL,
    OFBool inversePLUT=OFFalse);

  OFCondition setSingleAnnotation(
    const char *displayformat,
    const char *text,
    Uint16 position);

  void deleteAnnotations();

  OFCondition setInstanceUID(const char *uid);

  void clearInstanceUID() { sOPInstanceUID.clear(); }

  OFCondition getImageReference(size_t idx, const char *&studyUID, const char *&seriesUID, const char *&instanceUID)
  {
    return imageBoxContentList.getImageReference(idx, studyUID, seriesUID, instanceUID);
  }

  DVPSPrintPresentationLUTAlignment getReferencedPresentationLUTAlignment() { return referencedPresentationLUTAlignment; }

  OFCondition printSCUgetPrinterInstance(DVPSPrintMessageHandler& printHandler);

  OFCondition printSCUpreparePresentationLUT(
     DVPSPrintMessageHandler& printHandler,
     OFBool printerRequiresMatchingLUT,
     OFBool printerLUTRenderingPreferred,
     OFBool printerSupports12Bit);

  OFCondition printSCUcreateBasicFilmSession(
    DVPSPrintMessageHandler& printHandler,
    DcmDataset& dset,
    OFBool plutInSession);

  OFCondition printSCUcreateBasicFilmBox(DVPSPrintMessageHandler& printHandler, OFBool plutInSession);

  OFCondition printSCUsetBasicImageBox(
    DVPSPrintMessageHandler& printHandler,
    size_t idx,
    DicomImage& image,
    OFBool useMonochrome1=OFFalse);

  OFCondition printSCUsetBasicAnnotationBox(
    DVPSPrintMessageHandler& printHandler,
    size_t idx);

  OFCondition printSCUprintBasicFilmBox(DVPSPrintMessageHandler& printHandler);

  OFCondition printSCUprintBasicFilmSession(DVPSPrintMessageHandler& printHandler);

  OFCondition printSCUdelete(DVPSPrintMessageHandler& printHandler);

  OFCondition setPrintIllumination(Uint16 value);

  Uint16 getPrintIllumination();

  OFCondition setPrintReflectedAmbientLight(Uint16 value);

  Uint16 getPrintReflectedAmbientLight();

  OFBool printSCPCreate(
    DVConfiguration& cfg,
    const char *cfgname,
    DcmDataset *rqDataset,
    T_DIMSE_Message& rsp,
    DcmDataset *& rspDataset,
    OFBool presentationLUTnegotiated,
    DVPSPresentationLUT_PList& globalPresentationLUTList,
    const char *filmSessionUID,
    DcmUniqueIdentifier& study,
    DcmUniqueIdentifier& psSeries,
    DcmUniqueIdentifier& imgSeries);

  OFBool printSCPSet(
    DVConfiguration& cfg,
    const char *cfgname,
    DcmDataset *rqDataset,
    T_DIMSE_Message& rsp,
    DcmDataset *& rspDataset,
    OFBool presentationLUTnegotiated,
    DVPSPresentationLUT_PList& globalPresentationLUTList);

  OFBool isFilmBoxInstance(const char *c) { if (c && (filmBoxInstanceUID == c)) return OFTrue; else return OFFalse; }

  OFBool usesPresentationLUT(const char *c);

  DVPSImageBoxContent *duplicateImageBox(const char *uid) { return imageBoxContentList.duplicateImageBox(uid); }

  OFBool haveImagePositionClash(const char *uid, Uint16 position)  { return imageBoxContentList.haveImagePositionClash(uid, position); }

  void replaceImageBox(DVPSImageBoxContent *newImageBox) { imageBoxContentList.replace(newImageBox); }

  void updatePresentationLUTList(DVPSPresentationLUT_PList& globalPresentationLUTList);

  void setLog(OFConsole *stream, OFBool verbMode, OFBool dbgMode);

  OFBool matchesPresentationLUT(DVPSPrintPresentationLUTAlignment align) const
  {
    return imageBoxContentList.matchesPresentationLUT(align);
  }

  void overridePresentationLUTSettings(
      DcmUnsignedShort& newIllumination,
      DcmUnsignedShort& newReflectedAmbientLight,
      DcmUniqueIdentifier& newReferencedPLUT,
      DVPSPrintPresentationLUTAlignment newAlignment);

  OFBool emptyPageWarning() { return imageBoxContentList.emptyPageWarning(); }

 private:

  DVPSStoredPrint& operator=(const DVPSStoredPrint&);

  /* checks if given SOP class UID is an image storage SOP class
   * @return OFTrue if image SOP class, OFFalse otherwise.
   */
  OFBool isImageStorageSOPClass(OFString& sopclassuid);

  OFCondition createDefaultValues();

  OFCondition addReferencedPLUTSQ(DcmItem &dset);

  OFCondition addPresentationLUTReference(DcmItem& dset);

  void invalidateCache();

  void updateCache();

  /* Module: Patient (M)
   */
  DcmPersonName            patientName;
  DcmLongString            patientID;
  DcmDate                  patientBirthDate;
  DcmCodeString            patientSex;

  /* Module: General Study (M)
   */
  DcmUniqueIdentifier      studyInstanceUID;
  DcmDate                  studyDate;
  DcmTime                  studyTime;
  DcmPersonName            referringPhysiciansName;
  DcmShortString           studyID;
  DcmShortString           accessionNumber;

  /* Module: General Series (M)
   */
  DcmUniqueIdentifier      seriesInstanceUID;
  DcmIntegerString         seriesNumber;

  /* Module: General Equipment (M)
   */
  DcmLongString            manufacturer;

  /* Module: Printer Characteristics (M)
   */
  // the PrintManagementCapabilitiesSequence is only created/checked on the fly

  // PrinterCharacteristicsSequence
  DcmApplicationEntity     originator;
  DcmApplicationEntity     destination;
  DcmLongString            printerName;

  /* Module: Film Box (M)
   */
  DcmIntegerString         instanceNumber;
  /* the following attributes belong to the Film Box Content SQ (Type 1) */
  DcmShortText             imageDisplayFormat;
  DcmCodeString            annotationDisplayFormatID;
  DcmCodeString            filmOrientation;
  DcmCodeString            filmSizeID;
  DcmCodeString            magnificationType;
  DcmCodeString            smoothingType;
  DcmCodeString            borderDensity;
  DcmCodeString            emptyImageDensity;
  DcmUnsignedShort         minDensity;
  DcmUnsignedShort         maxDensity;
  DcmCodeString            trim;
  DcmShortText             configurationInformation;
  DcmUnsignedShort         illumination;
  DcmUnsignedShort         reflectedAmbientLight;
  DcmCodeString            requestedResolutionID;
  DcmUniqueIdentifier      referencedPresentationLUTInstanceUID;

  DVPSPrintPresentationLUTAlignment referencedPresentationLUTAlignment;

  /* Module: Image Box List (M)
   */
  DVPSImageBoxContent_PList imageBoxContentList;

  /* Module: Annotation List (U)
   */
  DVPSAnnotationContent_PList annotationContentList;

  /* Module: Presentation LUT List (U)
   */
  DVPSPresentationLUT_PList presentationLUTList;

  /* Module: SOP Common (M)
   * we don't store the SOP Class UID because it is well known.
   */
  DcmUniqueIdentifier      sOPInstanceUID;
  DcmCodeString            specificCharacterSet;
  DcmDate                  instanceCreationDate;
  DcmTime                  instanceCreationTime;

  DcmUniqueIdentifier      imageSeriesInstanceUID;

  OFBool currentValuesValid;
  unsigned long currentNumCols;
  unsigned long currentNumRows;

  DVPSDecimateCropBehaviour decimateCropBehaviour;

  OFString filmSessionInstanceUID;

  OFString filmBoxInstanceUID;

  OFString presentationLUTInstanceUID;

  DVPSPresentationLUT globalPresentationLUT;

  OFBool globalPresentationLUTValid;

  OFBool transmitImagesIn12Bit;

  OFBool renderPresentationLUTinSCP;

  OFString tempDensity;

  OFConsole *logstream;

  OFBool verboseMode;

  OFBool debugMode;

};

#endif

/*
 *  $Log: dvpssp.h,v $
 *  Revision 1.37  2004/02/04 15:49:09  joergr
 *  Removed acknowledgements with e-mail addresses from CVS log. Removed leading
 *  underscore characters from preprocessor symbols (reserved symbols).
 *
 *  Revision 1.36  2002/04/16 14:02:03  joergr
 *  Added configurable support for C++ ANSI standard includes (e.g. streams).
 *
 *  Revision 1.35  2001/09/26 15:36:15  meichel
 *  Adapted dcmpstat to class OFCondition
 *
 *  Revision 1.34  2001/06/01 15:50:21  meichel
 *  Updated copyright header
 *
 *  Revision 1.33  2000/07/18 16:03:44  joergr
 *  Moved method convertODtoLum/PValue from class DVInterface to DVPSStoredPrint
 *  and corrected implementation.
 *  Changed behaviour of methods getMin/MaxDensityValue (return default value if
 *  attribute empty/absent).
 *
 *  Revision 1.32  2000/07/07 14:14:24  joergr
 *  Added support for LIN OD presentation LUT shape.
 *
 *  Revision 1.31  2000/07/05 12:33:29  joergr
 *  Corrected documentation of one method.
 *
 *  Revision 1.30  2000/07/04 15:58:03  joergr
 *  Added support for overriding the presentation LUT settings made for the
 *  image boxes.
 *
 *  Revision 1.29  2000/06/20 14:50:08  meichel
 *  Added monochrome1 printing mode.
 *
 *  Revision 1.28  2000/06/19 16:29:07  meichel
 *  Added options for session printing and LIN OD to print tools, fixed
 *    pixel aspect ratio related bug.
 *
 *  Revision 1.27  2000/06/14 11:28:15  joergr
 *  Added methods to access the attributes Polarity and Requested Image Size.
 *
 *  Revision 1.26  2000/06/08 10:44:29  meichel
 *  Implemented Referenced Presentation LUT Sequence on Basic Film Session level.
 *    Empty film boxes (pages) are not written to file anymore.
 *
 *  Revision 1.25  2000/06/07 14:23:09  joergr
 *  Added methods to access the image polarity attribute.
 *  Added missing transformations (polarity, GSDF, presentation LUT, aspect
 *  ratio) to print preview rendering.
 *
 *  Revision 1.24  2000/06/07 13:17:46  meichel
 *  added binary and textual log facilities to Print SCP.
 *
 *  Revision 1.23  2000/06/02 16:00:51  meichel
 *  Adapted all dcmpstat classes to use OFConsole for log and error output
 *
 *  Revision 1.22  2000/05/31 12:56:39  meichel
 *  Added initial Print SCP support
 *
 *  Revision 1.21  2000/05/31 07:54:24  joergr
 *  Added support for Stored Print attributes Originator and Destination
 *  application entity title.
 *
 *  Revision 1.20  2000/05/30 13:42:09  joergr
 *  Added methods to set, get and store the printer name in the stored print
 *  object (PrinterCharacteristicsSequence).
 *
 *  Revision 1.19  2000/03/08 16:28:56  meichel
 *  Updated copyright header.
 *
 *  Revision 1.18  2000/03/03 14:13:55  meichel
 *  Implemented library support for redirecting error messages into memory
 *    instead of printing them to stdout/stderr for GUI applications.
 *
 *  Revision 1.17  2000/02/29 12:16:16  meichel
 *  Fixed bug in dcmpstat library that caused Monochrome1 images
 *    to be printed inverse if a Presentation LUT was applied.
 *
 *  Revision 1.16  1999/10/19 14:46:04  meichel
 *  added support for the Basic Annotation Box SOP Class
 *    as well as access methods for Max Density and Min Density.
 *
 *  Revision 1.15  1999/10/13 14:11:12  meichel
 *  Fixed bug in routine that renders P-LUTs into a print bitmap
 *    before sending an image to the printer
 *
 *  Revision 1.14  1999/10/07 17:21:50  meichel
 *  Reworked management of Presentation LUTs in order to create tighter
 *    coupling between Softcopy and Print.
 *
 *  Revision 1.13  1999/09/24 15:24:30  meichel
 *  Added support for CP 173 (Presentation LUT clarifications)
 *
 *  Revision 1.12  1999/09/17 14:33:59  meichel
 *  Completed print spool functionality including Supplement 22 support
 *
 *  Revision 1.11  1999/09/15 17:43:29  meichel
 *  Implemented print job dispatcher code for dcmpstat, adapted dcmprtsv
 *    and dcmpsprt applications.
 *
 *  Revision 1.10  1999/09/13 15:19:10  meichel
 *  Added implementations for a number of further print API methods.
 *
 *  Revision 1.9  1999/09/10 12:46:47  meichel
 *  Added implementations for a number of print API methods.
 *
 *  Revision 1.8  1999/09/09 14:57:33  thiel
 *  Added methods for print spooler
 *
 *  Revision 1.7  1999/09/09 12:20:47  meichel
 *  Added print API method declarations and implementations (empty for now).
 *
 *  Revision 1.6  1999/09/08 16:46:44  meichel
 *  Added print API method declarations
 *
 *  Revision 1.5  1999/09/01 16:14:41  meichel
 *  Added support for requested image size to print routines
 *
 *  Revision 1.4  1999/08/31 14:09:12  meichel
 *  Added get/set methods for stored print attributes
 *
 *  Revision 1.3  1999/08/27 15:57:57  meichel
 *  Added methods for saving hardcopy images and stored print objects
 *    either in file or in the local database.
 *
 *  Revision 1.2  1999/08/26 09:31:00  thiel
 *  Add extensions for the usage of the StoredPrint
 *
 *  Revision 1.1  1999/07/30 13:34:50  meichel
 *  Added new classes managing Stored Print objects
 *
 *
 */

---

Generated on 4 Nov 2004 for OFFIS DCMTK Version 3.5.3 by Doxygen 1.3.8