PM/DYT
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
1c07e198c9
DYT/Tool/3rdParty_x64/include/dcmtk/dcmimgle/dimoimg.h

1156 lines
46 KiB
C
Raw Normal View History

添加tool
2024-11-22 15:19:31 +00:00
/*
*
* Copyright (C) 1996-2016, OFFIS e.V.
* All rights reserved. See COPYRIGHT file for details.
*
* This software and supporting documentation were developed by
*
* OFFIS e.V.
* R&D Division Health
* Escherweg 2
* D-26121 Oldenburg, Germany
*
*
* Module: dcmimgle
*
* Author: Joerg Riesmeier
*
* Purpose: DicomMonochromeImage (Header)
*
*/
#ifndef DIMOIMG_H
#define DIMOIMG_H
#include "dcmtk/config/osconfig.h"
#include "dcmtk/ofstd/ofcast.h"
#include "dcmtk/dcmimgle/diimage.h"
#include "dcmtk/dcmimgle/dimopx.h"
#include "dcmtk/dcmimgle/dimoopx.h"
#include "dcmtk/dcmimgle/didispfn.h"
/*------------------------*
* forward declarations *
*------------------------*/
class DiColorImage;
/*---------------------*
* class declaration *
*---------------------*/
/** Base class for monochrome images
*/
class DCMTK_DCMIMGLE_EXPORT DiMonoImage
: public DiImage
{
public:
/** constructor
*
** @param docu pointer to the DICOM document
* @param status status of the image object
*/
DiMonoImage(const DiDocument *docu,
const EI_Status status);
/** constructor, rescale
*
** @param docu pointer to the DICOM document
* @param status status of the image object
* @param slope rescale slope
* @param intercept rescale intercept
*/
DiMonoImage(const DiDocument *docu,
const EI_Status status,
const double slope,
const double intercept);
/** constructor, modality LUT
*
** @param docu pointer to the DICOM document
* @param status status of the image object
* @param data element containing the modality LUT data
* @param descriptor element containing the modality LUT descriptor
* @param explanation element containing the modality LUT explanation (optional)
*/
DiMonoImage(const DiDocument *docu,
const EI_Status status,
const DcmUnsignedShort &data,
const DcmUnsignedShort &descriptor,
const DcmLongString *explanation);
/** destructor
*/
virtual ~DiMonoImage();
/** process next couple of frames
*
** @param fcount number of frames to be processed (0 = same number as before)
*
** @return status, true if successful, false otherwise
*/
virtual int processNextFrames(const unsigned long fcount);
/** get minimum and maximum pixel values.
* the resulting pixel values are stored in 'double' variables to avoid problems
* with different number ranges, limited to monochrome images
*
** @param min minimum pixel value (reference parameter)
* @param max maximum pixel value (reference parameter)
* @param mode 0 = min/max 'used' pixel values,
* 1 = min/max 'possible' pixel values (absolute min/max)
*
** @return status code (true if successful)
*/
int getMinMaxValues(double &min,
double &max,
const int mode) const;
/** get display function
*
** @return pointer to current display function, NULL if absent
*/
DiDisplayFunction *getDisplayFunction() const
{
return DisplayFunction;
}
/** set display function
*
** @param display object describing the output device characteristic (only referenced!)
*
** @return true if successful, false otherwise
*/
int setDisplayFunction(DiDisplayFunction *display);
/** set no display function.
* disables display function transformation, object is not deleted!
*
** @return true if successful (1 = disabled current function,
* 2 = there was no function to disable)
* false otherwise
*/
int setNoDisplayFunction();
/** unset all VOI transformations (windows and LUTs).
* only applicable for monochrome images
*
** @return true if successful (1 = previous window/LUT has been valid,
* 2 = otherwise),
* false otherwise (image is invalid or not monochrome)
*/
int setNoVoiTransformation();
/** delete specified display LUT(s)
*
** @param bits parameter of LUT to be deleted (0 = all)
*
** @return true if successful, false otherwise
*/
inline int deleteDisplayLUT(const int bits)
{
return (DisplayFunction != NULL) ? DisplayFunction->deleteLookupTable(bits) : 0;
}
/** check whether given output value is unused
*
** @param value output value to be checked
*
** @return status, true if unused (1 = within output range, 2 = out of range), false otherwise
*/
inline int isValueUnused(const unsigned long value)
{
return (OutputData != NULL) ? OutputData->isUnused(value) : 0;
}
/** convert P-value to DDL.
* conversion uses display LUT if present, linear scaling otherwise.
*
** @param pvalue P-value to be converted (0..65535)
* @param ddl reference to resulting DDL
* @param bits number of bits for output
*
** @return true if successful (1 = display function transformation,
* 2 = linear scaling),
* false otherwise
*/
int convertPValueToDDL(const Uint16 pvalue,
Uint16 &ddl,
const int bits);
/** set automatically calculated minimum/maximum window.
* possibly active VOI LUT is implicitly disabled.
*
** @param idx ignore global min/max values if false (0)
*
** @return true if successful (1 = window has changed,
* 2 = new window is the same as previous one),
* false otherwise
*/
int setMinMaxWindow(const int idx = 1);
/** set automatically calculated VOI window for the specified Region of Interest (ROI).
* The ROI is specified by means of a rectangle (left_pos, top_pos, width, height).
* Possibly active VOI LUT is implicitly disabled.
*
** @param left_pos x-coordinate of the top left-hand corner of the ROI (starting from 0)
* @param top_pos y-coordinate of the top left-hand corner of the ROI (starting from 0)
* @param width width in pixels of the rectangular ROI (minimum: 1)
* @param height height in pixels of the rectangular ROI (minimum: 1)
* @param frame index of the frame to be used for the calculation
*
** @return true if successful (1 = window has changed,
* 2 = new window is the same as previous one),
* false otherwise
*/
int setRoiWindow(const unsigned long left_pos,
const unsigned long top_pos,
const unsigned long width,
const unsigned long height,
const unsigned long frame);
/** set automatically calculated histogram window.
* possibly active VOI LUT is implicitly disabled.
*
** @param thresh threshold value specifying percentage of histogram border which shall be ignored
*
** @return true if successful, false otherwise
*/
int setHistogramWindow(const double thresh);
/** set specified window (given by index to window width/center sequence stored in image file).
* possibly active VOI LUT is implicitly disabled.
*
** @param pos index to window width/center sequence
*
** @return true if successful, false otherwise
*/
int setWindow(const unsigned long pos = 0);
/** set specified window (given by window width and center).
* possibly active VOI LUT is implicitly disabled.
*
** @param center center of specified window
* @param width width of specified window
* @param explanation window explanation (optional)
*
** @return true if successful (1 = window has changed,
* 2 = new window is the same as previous one),
* false otherwise
*/
int setWindow(const double center,
const double width,
const char *explanation = NULL);
/** get current window center and width values
*
** @param center return current window center value
* @param width return current window width value
*
** @return true if successful, false otherwise
*/
int getWindow(double &center,
double &width);
/** get number of VOI windows (stored in image file)
*
** @return number of VOI windows
*/
inline unsigned long getWindowCount() const
{
return WindowCount;
}
/** get VOI LUT function.
* possible values are: EFV_Default, EFV_Linear, EFV_Sigmoid.
*
** @return currently active VOI LUT function
*/
EF_VoiLutFunction getVoiLutFunction() const;
/** set VOI LUT function
*
** @param function type of VOI LUT function (default, linear or sigmoid).
* 'default' basically means the same as 'linear'.
*
** @return true if successful (1 = function has changed,
* 2 = function has not changed)
* false otherwise
*/
int setVoiLutFunction(const EF_VoiLutFunction function);
/** set VOI LUT (given by dcmdata elements).
* possibly active window/center is implicitly disabled.
*
** @param data contains LUT data
* @param descriptor describes LUT structure
* @param explanation free form description of VOI LUT (optional)
* @param descripMode mode specifying the use of the bits per table entry value
*
** @return true if successful, false otherwise
*/
int setVoiLut(const DcmUnsignedShort &data,
const DcmUnsignedShort &descriptor,
const DcmLongString *explanation,
const EL_BitsPerTableEntry descripMode = ELM_UseValue);
/** set VOI LUT (given by index to VOI LUT sequence stored in image file).
* possibly active window/center is implicitly disabled.
*
** @param pos index to VOI LUT sequence
* @param descripMode mode specifying the use of the bits per table entry value
*
** @return true if successful, false otherwise
*/
int setVoiLut(const unsigned long pos,
const EL_BitsPerTableEntry descripMode = ELM_UseValue);
/** get number of VOI LUTs (stored in image file)
*
** @return number of VOI LUTs
*/
inline unsigned long getVoiLutCount() const
{
return VoiLutCount;
}
/** get description of active VOI transformation
*
** @return pointer to description text (NULL if absent)
*/
inline const char *getVoiTransformationExplanation() const
{
return VoiExplanation.c_str();
}
/** get description of specified VOI window (stored in the image file)
*
** @param pos index of the stored VOI window (0..n-1)
* @param explanation variable in which the result text is stored
*
** @return pointer to description text (NULL if absent or index invalid)
*/
const char *getVoiWindowExplanation(const unsigned long pos,
OFString &explanation) const;
/** get description of specified VOI LUT (stored in the image file)
*
** @param pos index of the stored VOI LUT (0..n-1)
* @param explanation variable in which the result text is stored
*
** @return pointer to description text (NULL if absent or index invalid)
*/
const char *getVoiLutExplanation(const unsigned long pos,
OFString &explanation) const;
/** get description of performed modality LUT transformation
*
** @return pointer to description text (NULL if absent)
*/
inline const char *getModalityLutExplanation() const
{
return (InterData != NULL) ? InterData->getModalityLutExplanation() : OFstatic_cast(const char *, NULL);
}
/** set hardcopy parameters. (used to display LinOD images)
*
** @param min minimum density of the print-out (in hundreds of Optical Density, e.g. 150 means 1.5 OD)
* @param max maximum density of the print-out (ditto)
* @param reflect reflected ambient light (in candela per square meter - cd/m^2)
* @param illumin illumination (ditto)
*
** @return true if successful (1 = at least one of the parameters has changed,
* 2 = no parameter has changed)
* false otherwise
*/
int setHardcopyParameters(const unsigned int min,
const unsigned int max,
const unsigned int reflect,
const unsigned int illumin);
/** get shape for presentation transformation.
* possible values are: ESP_Default, ESP_Identity, ESP_Inverse, ESP_LinOD
* If a presentation LUT is currently active ESP_Default is always returned.
*
** @return currently active presentation LUT shape
*/
ES_PresentationLut getPresentationLutShape() const;
/** set shape for presentation transformation.
* possibly active presentation LUT is implicitly disabled.
*
** @param shape presentation LUT shape (default, identity or inverse).
* 'default' means that the output data is always created with 0 for black
* and maxvalue for white (i.e. monochrome2 data is created for output).
*
** @return true if successful (1 = shape has changed,
* 2 = shape has not changed)
* false otherwise
*/
int setPresentationLutShape(const ES_PresentationLut shape);
/** set LUT for presentation transformation.
* possibly active presentation LUT is implicitly disabled.
*
** @param data contains LUT data
* @param descriptor describes LUT structure
* @param explanation free form description of presentation LUT (optional)
* @param descripMode mode specifying the use of the bits per table entry value
*
** @return true if successful, false otherwise
*/
int setPresentationLut(const DcmUnsignedShort &data,
const DcmUnsignedShort &descriptor,
const DcmLongString *explanation = NULL,
const EL_BitsPerTableEntry descripMode = ELM_UseValue);
/** set inverse LUT for presentation transformation.
* this LUT transform is e.g. used for DICOM print (12->8, 8->12 bit)
* possibly active presentation LUT will not be considered !
*
** @param data contains LUT data
* @param descriptor describes LUT structure
* @param descripMode mode specifying the use of the bits per table entry value
*
** @return true if successful, false otherwise
*/
int setInversePresentationLut(const DcmUnsignedShort &data,
const DcmUnsignedShort &descriptor,
const EL_BitsPerTableEntry descripMode = ELM_UseValue);
/** get description of active presentation LUT
*
** @return pointer to description text (NULL if absent)
*/
inline const char *getPresentationLutExplanation() const
{
return (PresLutData != NULL) ? PresLutData->getExplanation() : OFstatic_cast(const char *, NULL);
}
/** add specified plane to group of additional overlay planes.
* replaces old overlay plane if group number already exists.
*
** @param group group number (0x60nn) of overlay plane
* @param left_pos x coordinate of plane orgin (referring to image origin)
* @param top_pos y coordinate of plane origin
* @param columns width of overlay plane (in pixels)
* @param rows height of overlay plane (in pixels)
* @param data overlay plane data (dcmdata element)
* @param label overlay plane label
* @param description overlay plane description
* @param mode display mode (see 'diutils.h')
*
** @return false (0) if an error occurred, true otherwise (1 = added new plane,
* 2 = replaced existing plane)
*/
int addOverlay(const unsigned int group,
const signed int left_pos,
const signed int top_pos,
const unsigned int columns,
const unsigned int rows,
const DcmOverlayData &data,
const DcmLongString &label,
const DcmLongString &description,
const EM_Overlay mode);
/** remove all additional overlay planes
*
** @return false (0) if an error occurred, true otherwise
*/
int removeAllOverlays();
/** get pointer to specified overlay managing object
*
** @param idx index of overlay group (0 = dataset, 1 = additional)
*
** @return pointer to overlay managing object (NULL if absent or invalid)
*/
inline DiOverlay *getOverlayPtr(const unsigned int idx)
{
return (idx < 2) ? Overlays[idx] : OFstatic_cast(DiOverlay *, NULL);
}
/** get pointer to current monochrome image (this)
*
** @return pointer to this object
*/
inline DiMonoImage *getMonoImagePtr()
{
return this;
}
/** flip current image (horizontally and/or vertically)
*
** @param horz flip horizontally if true
* @param vert flip vertically if true
*
** @return true if successful (1 = flipped at least direction,
* 2 = not flipped, because of image resolution - width and/or height equal to 1),
* false otherwise
*/
int flip(const int horz,
const int vert);
/** rotate current image (by steps of 90 degrees)
*
** @param degree angle by which the image shall be rotated (-360, -270, -180, -90, 0, 90, 180, 270, 360)
*
** @return true if successful (1 = rotated by at least 90 degrees,
* 2 = not rotated, because of image resolution or angle),
* false otherwise
*/
int rotate(const int degree);
/** get number of bits per sample.
* If the optional parameter is specified the value will be checked and in any case
* a valid value will be returned.
*
** @param bits value to be returned (if less than 1 or greater than the maximum (32)
* the default value will be used which is equal to the bits per sample
* value stored in the DICOM dataset)
*
** @return status, true if successful, false otherwise
*/
virtual int getBits(const int bits = 0) const
{
return (((bits < 1) || (bits > MAX_BITS)) && (bits != MI_PastelColor)) ? BitsPerSample : bits;
}
/** get number of bytes required for the rendered output of a single frame
*
* @param bits number of bits for the output pixel data (depth)
*
** @return number of bytes if successful, 0 otherwise
*/
virtual unsigned long getOutputDataSize(const int bits = 0) const;
/** get pixel data with specified format.
* (memory is handled internally)
*
** @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param planar flag, only useful for multi-planar images (color)
*
** @return untyped pointer to the pixel data if successful, NULL otherwise
*/
virtual const void *getOutputData(const unsigned long frame,
const int bits,
const int planar = 0) = 0;
/** get pixel data with specified format.
* (memory is handled externally)
*
** @param buffer untyped pointer to the externally allocated memory buffer
* @param size size of the memory buffer in bytes (will be checked)
* @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param planar flag, only useful for multi-planar images (color)
*
** @return status, true if successful, false otherwise
*/
virtual int getOutputData(void *buffer,
const unsigned long size,
const unsigned long frame,
const int bits,
const int planar = 0) = 0;
/** get pixel data of specified plane.
* (memory is handled internally)
*
** @param dummy (not used)
*
** @return untyped pointer to the pixel data if successful, NULL otherwise
*/
const void *getOutputPlane(const int dummy) const;
/** delete internally handled output memory buffer
* Save memory if data is no longer needed.
*/
void deleteOutputData();
/** create bitmap for specified overlay plane.
* (up to 16 bits per pixel with two values: fore and back)
*
** @param frame index of frame used for output
* @param plane number (0..15) or group number (0x60nn) of overlay plane
* @param left_pos returns x coordinate of plane's origin
* @param top_pos returns y coordinate of plane's origin
* @param width returns width of overlay plane (in pixels)
* @param height returns height of overlay plane (in pixels)
* @param mode return display mode (see 'diutils.h')
* @param idx index of overlay group (0 = dataset, 1 = additional, 2 = '1' plane hides '0' plane)
* @param bits number of bits (stored) in the resulting array, default: 8
* @param fore foreground color to be set in bitmap, default: 255
* @param back background color to be set in bitmap (transparent), default: 0
*
** @return pointer to overlay plane data (internal memory buffer)
*/
const void *getOverlayData(const unsigned long frame,
const unsigned int plane,
unsigned int &left_pos,
unsigned int &top_pos,
unsigned int &width,
unsigned int &height,
EM_Overlay &mode,
const unsigned int idx,
const int bits = 8,
const Uint16 fore = 0xff,
const Uint16 back = 0x0);
/** create bitmap for specified overlay plane.
* (up to 16 bits per pixel with two values: fore and back)
*
** @param frame index of frame used for output
* @param plane number (0..15) or group number (0x60nn) of overlay plane
* @param width returns width of overlay plane (in pixels)
* @param height returns height of overlay plane (in pixels)
* @param idx index of overlay group (0 = dataset, 1 = additional, 2 = '1' plane hides '0' plane)
* @param bits number of bits (stored) in the resulting array, default: 8
* @param fore foreground color to be set in bitmap, default: 255
* @param back background color to be set in bitmap (transparent), default: 0
*
** @return pointer to overlay plane data (internal memory buffer)
*/
const void *getFullOverlayData(const unsigned long frame,
const unsigned int plane,
unsigned int &width,
unsigned int &height,
const unsigned int idx,
const int bits = 8,
const Uint16 fore = 0xff,
const Uint16 back = 0x0);
/** delete buffer for overlay plane data.
* Save memory if data is no longer needed.
*/
void deleteOverlayData();
/** create bitmap for specified overlay plane and store it in (6xxx,3000) format.
* (1 bit allocated and stored, foreground color is 1, background color is 0,
* data is 16 bit padded - even length)
* memory is not handled internally - must be deleted from calling program.
*
** @param buffer stores pointer to overlay data (memory is allocated internally)
* @param plane number (0..15) or group number (0x60nn) of overlay plane
* @param width returns width of overlay plane (in pixels)
* @param height returns height of overlay plane (in pixels)
* @param frames returns number of frames (multiple overlay frames possible!)
* @param idx index of overlay group (0 = dataset, planes stored in the image dataset;
* 1 = additional, planes added by addOverlay()),
* default: 0
*
** @return number of bytes allocated for the 'buffer' if successful, 0 otherwise
*/
unsigned long create6xxx3000OverlayData(Uint8 *&buffer,
const unsigned int plane,
unsigned int &width,
unsigned int &height,
unsigned long &frames,
const unsigned int idx = 0);
/** get pointer to intermediate pixel data representation
*
** @return pointer to intermediate pixel data
*/
const DiPixel *getInterData() const
{
return InterData;
}
/** get pointer to intermediate pixel data representation
*
** @return pointer to intermediate pixel data
*/
const DiMonoPixel *getMonoInterData() const
{
return InterData;
}
/** create true color (24/32 bit) or palette (8 bit) bitmap for MS Windows.
* memory is not handled internally - must be deleted from calling program.
*
** @param data untyped pointer memory buffer (set to NULL if not allocated externally)
* @param size size of the memory buffer in bytes (if 0 'data' is set to NULL)
* @param frame index of frame to be converted (starting from 0)
* @param bits number of bits per pixel used for the output bitmap (8, 24 or 32)
* @param upsideDown specifies the order of lines in the images (0 = top-down, bottom-up otherwise)
* @param padding align each line to a 32-bit address if true (default)
*
** @return number of bytes allocated by the bitmap, or 0 if an error occurred
*/
unsigned long createDIB(void *&data,
const unsigned long size,
const unsigned long frame,
const int bits,
const int upsideDown,
const int padding = 1);
/** create true color (32 bit) or palette (8 bit) bitmap for Java (AWT default format).
* Memory is not handled internally - must be deleted from calling program.
*
** @param data resulting pointer to bitmap data (set to NULL if an error occurred)
* @param frame index of frame to be converted (starting from 0)
* @param bits number of bits per pixel used for the output bitmap (8 or 32)
*
** @return number of bytes allocated by the bitmap, or 0 if an error occurred
*/
unsigned long createAWTBitmap(void *&data,
const unsigned long frame,
const int bits);
/** create packed bitmap (e.g. 12/16 bit -> 12/12 bit for DICOM printers).
* Memory is not handled internally - must be deleted from calling program.
*
** @param buffer pointer to input memory buffer
* @param size size of memory buffer (will be checked whether it is sufficient)
* @param count number of entries (pixels) in input buffer
* @param alloc number of bits allocated for the pixels stored in the buffer (e.g. 16)
* @param stored number of bits stored for the pixels stored in the buffer (e.g. 12)
*
** @return pointer to memory buffer containing the packed output bitmap data (NULL if an error occurred)
*/
static void *createPackedBitmap(const void *buffer,
const unsigned long size,
const unsigned long count,
const int alloc,
const int stored);
/** create new single frame DiImage with applied grayscale transformations.
* The method getOutputData() is used internally for the new bitmap.
*
** @param frame index of frame to be converted
* @param bits number of bits per pixel used for the output bitmap
*
** @return pointer to new DiImage object (NULL if an error occurred)
*/
DiImage *createOutputImage(const unsigned long frame,
const int bits);
/** write current image and related attributes to DICOM dataset.
*
** @param dataset reference to DICOM dataset where the image attributes are stored
* @param mode 0 = determine value of BitsStored from 'used' pixel values,
* 1 = determine value of BitsStored from 'possible' pixel values
* @param planar dummy parameter (only used for color images)
*
** @return true if successful, false otherwise
*/
int writeImageToDataset(DcmItem &dataset,
const int mode,
const int planar);
/** write pixel data to PPM file.
* pixel data is written in ASCII format.
*
** @param stream open C++ output stream
* @param frame index of frame used for output
* @param bits number of bits used for output of pixel data
*
** @return true if successful, false otherwise
*/
int writePPM(STD_NAMESPACE ostream& stream,
const unsigned long frame,
const int bits);
/** write pixel data to PPM file.
* pixel data is written in ASCII format.
*
** @param stream open C output stream
* @param frame index of frame used for output
* @param bits number of bits used for output of pixel data
*
** @return true if successful, false otherwise
*/
int writePPM(FILE *stream,
const unsigned long frame,
const int bits);
/** write pixel data to raw PPM file
*
** @param stream open C output stream
* @param frame index of frame used for output
* @param bits number of bits used for output of pixel data
*
** @return true if successful, false otherwise
*/
int writeRawPPM(FILE *stream,
const unsigned long frame,
const int bits);
/** write pixel data to BMP file
*
** @param stream open C output stream
* @param frame index of frame used for output (default: first frame = 0)
* @param bits number of bits used for output of pixel data (8, 24 or 32, default (0) = 8)
*
** @return true if successful, false otherwise
*/
int writeBMP(FILE *stream,
const unsigned long frame,
const int bits);
protected:
/** constructor
*
** @param image pointer to dataset (encapsulated)
* @param status current image status
* @param dummy (necessary to be different from another constructor)
*/
DiMonoImage(const DiDocument *image,
const EI_Status status,
const char dummy);
/** constructor, copy
*
** @param image pointer to reference image
* @param fstart first frame to be processed
* @param fcount number of frames
*/
DiMonoImage(const DiMonoImage *image,
const unsigned long fstart,
const unsigned long fcount);
/** constructor, convert color images to monochrome
*
** @param image pointer to reference image
* @param red coefficient by which the red component is weighted
* @param green coefficient by which the green component is weighted
* @param blue coefficient by which the blue component is weighted
*
** @return pointer to new DiImage object (NULL if an error occurred)
*/
DiMonoImage(const DiColorImage *image,
const double red,
const double green,
const double blue);
/** constructor, scale/clip
*
** @param image pointer to reference image
* @param left_pos x coordinate of top left corner of area to be scaled
* (referring to image origin, negative values create a border around the image)
* @param top_pos y coordinate of top left corner of area to be scaled
* @param src_cols width of area to be scaled
* @param src_rows height of area to be scaled
* @param dest_cols width of scaled image (in pixels)
* @param dest_rows height of scaled image (in pixels)
* @param interpolate specifies whether scaling algorithm should use interpolation (if necessary).
* default: no interpolation (0), preferred interpolation algorithm (if applicable):
* 1 = pbmplus algorithm, 2 = c't algorithm, 3 = bilinear magnification,
* 4 = bicubic magnification
* @param aspect specifies whether pixel aspect ratio should be taken into consideration
* (if true, width OR height should be 0, i.e. this component will be calculated
* automatically)
* @param pvalue P-value used for the border outside the image (0..65535)
*/
DiMonoImage(const DiMonoImage *image,
const signed long left_pos,
const signed long top_pos,
const Uint16 src_cols,
const Uint16 src_rows,
const Uint16 dest_cols,
const Uint16 dest_rows,
const int interpolate,
const int aspect,
const Uint16 pvalue);
/** constructor, flip
*
** @param image pointer to reference image
** @param horz flip horizontally if true
* @param vert flip vertically if true
*/
DiMonoImage(const DiMonoImage *image,
const int horz,
const int vert);
/** constructor, rotate
*
** @param image pointer to reference image
* @param degree angle by which the image shall be rotated
*/
DiMonoImage(const DiMonoImage *image,
const int degree);
/** constructor, createMonoOutput
*
** @param image pointer to reference image
* @param pixel pointer to output pixel data used for the new image
* @param frame number of frame stored in the new image object
* @param stored number of bits stored
* @param alloc number of bits allocated
*/
DiMonoImage(const DiMonoImage *image,
DiMonoOutputPixel *pixel,
const unsigned long frame,
const int stored,
const int alloc);
/** initialize internal data structures and member variables
*
** @param modality pointer to object handling the modality transform
* @param reuse reuse particular information determined in a previous call
*/
void Init(DiMonoModality *modality,
const OFBool reuse = OFFalse);
/** initialize internal data structures (for Uint8)
*
** @param modality pointer to object handling the modality transform
*/
void InitUint8(DiMonoModality *modality);
/** initialize internal data structures (for Sint8)
*
** @param modality pointer to object handling the modality transform
*/
void InitSint8(DiMonoModality *modality);
/** initialize internal data structures (for Uint16)
*
** @param modality pointer to object handling the modality transform
*/
void InitUint16(DiMonoModality *modality);
/** initialize internal data structures (for Sint16)
*
** @param modality pointer to object handling the modality transform
*/
void InitSint16(DiMonoModality *modality);
/** initialize internal data structures (for Uint32)
*
** @param modality pointer to object handling the modality transform
*/
void InitUint32(DiMonoModality *modality);
/** initialize internal data structures (for Sint32)
*
** @param modality pointer to object handling the modality transform
*/
void InitSint32(DiMonoModality *modality);
/** check intermediate pixel representation for consistency
*
** @param mode check number of pixels stored in the dataset if true
*/
int checkInterData(const int mode = 1);
/** update Image Pixel Module attributes in the given dataset.
* Removes possibly existing embedded overlay planes and replaces any
* present modality transformation by a linear rescale/slope.
* Used in writeXXXToDataset() routines.
*
** @param dataset reference to DICOM image dataset
*/
virtual void updateImagePixelModuleAttributes(DcmItem &dataset);
/** get pixel data with specified format.
* (memory is handled externally)
*
** @param buffer untyped pointer to the externally allocated memory buffer
* @param size size of the memory buffer in bytes (will be checked)
* @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param planar flag, only useful for multi-planar images (color)
* @param negative invert pixel data if true
*
** @return untyped pointer to the pixel data if successful, NULL otherwise
*/
const void *getData(void *buffer,
const unsigned long size,
const unsigned long frame,
int bits,
const int planar,
const int negative);
/** get pixel data with specified format for Uint8 input (helper function).
* (memory is handled externally)
*
** @param buffer untyped pointer to the externally allocated memory buffer
* @param disp pointer to current display function object
* @param samples number of samples per pixel
* @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param low output pixel value to which 0 is mapped (min)
* @param high output pixel value to which 2^bits-1 is mapped (max)
*/
void getDataUint8(void *buffer,
DiDisplayFunction *disp,
const int samples,
const unsigned long frame,
const int bits,
const Uint32 low,
const Uint32 high);
/** get pixel data with specified format for Sint8 input (helper function).
* (memory is handled externally)
*
** @param buffer untyped pointer to the externally allocated memory buffer
* @param disp pointer to current display function object
* @param samples number of samples per pixel
* @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param low output pixel value to which 0 is mapped (min)
* @param high output pixel value to which 2^bits-1 is mapped (max)
*/
void getDataSint8(void *buffer,
DiDisplayFunction *disp,
const int samples,
const unsigned long frame,
const int bits,
const Uint32 low,
const Uint32 high);
/** get pixel data with specified format for Uint16 input (helper function).
* (memory is handled externally)
*
** @param buffer untyped pointer to the externally allocated memory buffer
* @param disp pointer to current display function object
* @param samples number of samples per pixel
* @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param low output pixel value to which 0 is mapped (min)
* @param high output pixel value to which 2^bits-1 is mapped (max)
*/
void getDataUint16(void *buffer,
DiDisplayFunction *disp,
const int samples,
const unsigned long frame,
const int bits,
const Uint32 low,
const Uint32 high);
/** get pixel data with specified format for Sint16 input (helper function).
* (memory is handled externally)
*
** @param buffer untyped pointer to the externally allocated memory buffer
* @param disp pointer to current display function object
* @param samples number of samples per pixel
* @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param low output pixel value to which 0 is mapped (min)
* @param high output pixel value to which 2^bits-1 is mapped (max)
*/
void getDataSint16(void *buffer,
DiDisplayFunction *disp,
const int samples,
const unsigned long frame,
const int bits,
const Uint32 low,
const Uint32 high);
/** get pixel data with specified format for Uint32 input (helper function).
* (memory is handled externally)
*
** @param buffer untyped pointer to the externally allocated memory buffer
* @param disp pointer to current display function object
* @param samples number of samples per pixel
* @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param low output pixel value to which 0 is mapped (min)
* @param high output pixel value to which 2^bits-1 is mapped (max)
*/
void getDataUint32(void *buffer,
DiDisplayFunction *disp,
const int samples,
const unsigned long frame,
const int bits,
const Uint32 low,
const Uint32 high);
/** get pixel data with specified format for Sint32 input (helper function).
* (memory is handled externally)
*
** @param buffer untyped pointer to the externally allocated memory buffer
* @param disp pointer to current display function object
* @param samples number of samples per pixel
* @param frame number of frame to be rendered
* @param bits number of bits for the output pixel data (depth)
* @param low output pixel value to which 0 is mapped (min)
* @param high output pixel value to which 2^bits-1 is mapped (max)
*/
void getDataSint32(void *buffer,
DiDisplayFunction *disp,
const int samples,
const unsigned long frame,
const int bits,
const Uint32 low,
const Uint32 high);
/** create a presentation look-up table converting the pixel data which is linear to
* Optical Density to DDLs of the softcopy device (used to display print images on screen).
*
** @param count number of LUT entries
* @param bits number of bits per entry
*
** @return true if successful, false otherwise
*/
int createLinODPresentationLut(const unsigned long count, const int bits);
/// center of current VOI-window
double WindowCenter;
/// width of current VOI-window
double WindowWidth;
/// number of stored VOI-windows
unsigned long WindowCount;
/// number of stored VOU-LUTs
unsigned long VoiLutCount;
/// true, if current VOI-window is valid
int ValidWindow;
/// free text explanation of current VOI transformation
OFString VoiExplanation;
/// VOI LUT function (linear or sigmoid)
EF_VoiLutFunction VoiLutFunction;
/// presentation LUT shape (identity, inverse or lin od)
ES_PresentationLut PresLutShape;
/// minimum density of a print-out (in hundreds of Optical Density)
unsigned int MinDensity;
/// maximum density of a print-out (ditto)
unsigned int MaxDensity;
/// reflected ambient light (in candela per square meter)
unsigned int Reflection;
/// illumination (ditto)
unsigned int Illumination;
/// points to associated overlay-objects ([0] = built-in, [1] = additional)
DiOverlay *Overlays[2];
/// points to associated VOI-LUT-object
DiLookupTable *VoiLutData;
/// points to associated presentation-LUT-object
DiLookupTable *PresLutData;
/// points to intermediate pixel data representation (object)
DiMonoPixel *InterData;
/// points to grayscale standard display function (only referenced!)
DiDisplayFunction *DisplayFunction;
private:
/// points to current output data (object)
DiMonoOutputPixel *OutputData;
/// points to current overlay plane data (pixel array)
void *OverlayData;
// --- declarations to avoid compiler warnings
DiMonoImage(const DiMonoImage &);
DiMonoImage &operator=(const DiMonoImage &);
};
#endif
Reference in New Issue Copy Permalink