###############################################################################
#  FILE:
#  IPConfig - Imaging Services customization file for 11.5 ISG distribution
#
#  DESCRIPTION:
#		Imaging Services customization file
#		Includes two sections
#			1. The definitions of the IP Presentation customizable data types
#			2. The definitions of the IP factory defaults
# USAGE:
#		This file should not be modified by any means by the service personnel
#		without a review within Imaging Services Group
#		Please forward any internal inquiries related to this file
#		to "*MIG Image Quality Service"
###############################################################################
#		Update history
###############################################################################
#		AG: September 2006
#		Added image orientation skew tolerance
#		CB: September 2006
#		Set the default m_dImageOrientationSkewTolerance to 0.01
#		(CRDB00042589)
###############################################################################
#		CB: September 2006
#		Changed "Hurter & Driffield" LUT function shape name to "H & D"
#		and "Gain" into "Gamma" for the gamma LUT function shape parameter
#		(CRDB00029903)
###############################################################################
#		CB,	December 15 2006:
#		Added default orientation rules for Breast MRs
#		and Hand CR and DX studies (CRDB00046838)
###############################################################################
#		CB,	March 19 2007:
#		Disabled orientation correction for all images with
#		image type "Screen Save"(CRDB00048056)
##############################################################################
#		JSun,	July 17 2008:
#		STRQ10634,modified calibration selection options and
#               calibration selection options to support ERMF
###############################################################################
#		MM,	September 13 2007:
#		added static types for multilanguage support
#		added french translations for IP's UI components
###############################################################################
#		WLR,	Jan 2008:
#		"Sharp" and "Smooth" should be translated as "Accentuée" and
#		"Lisse" respectively (CR 59318)
###############################################################################
#		JSun,	Aug 2008:
#		Added calibration type to annotation type "TLocalizedUIText"
###############################################################################
#       MM, July 2009:
#       added configuration for scoped, annotations-based queries
#       added new types to control appearance of CAD mark overlays
#       added default merge policies for multiple CAD SR scenarios
###############################################################################
#       SL, 22 July 2009:
#       CR 72941 Default configuration setting for DICOM Sigmoid VOI LUT Function
###############################################################################
#        Ari Telias, 28 August 2014:
#       CRDB00122165	DBT images are not correctly positioned after Disk Exported
###############################################################################

###############################################################################
###############################################################################
###############################################################################
##     SECTION 1 Type definitions for IP customization variables          #####
##	  WARNING: THIS SECTION SHOULD NOT BE EVER MODIFIED ouside MIG R&D    #####
###############################################################################
###############################################################################
###############################################################################

###############################################################################
# Basic IP type definitions and enumerations
###############################################################################

#------------------------------------------------------------------------------
# Definition of a TLangString language string / value pair type
#------------------------------------------------------------------------------
TLangString.type = type
TLangString.EntryNames = ( m_Language, m_Value )
TLangString.EntryTypes = ( string, string )
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the multistring type ( DO NOT ALTER NAME ) [ for multilanguage ]
#------------------------------------------------------------------------------
multistring.type = type
multistring.EntryNames = ( m_MLString )
multistring.EntryTypes = ( vector TLangString )
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of a point in 2D space
#------------------------------------------------------------------------------
TPoint.type = type
TPoint.EntryNames = ( m_X, m_Y )
TPoint.EntryTypes = ( double, double )
#------------------------------------------------------------------------------
# m_X, m_Y values define the coordinates of a point in the 2D (image) space
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of a rectangle in 2D space
#------------------------------------------------------------------------------
TRectangle.type = type
TRectangle.EntryNames = ( m_Left,m_Right,m_Top, m_Bottom )
TRectangle.EntryTypes = ( double, double, double, double )
#------------------------------------------------------------------------------
# m_Left,m_Right,m_Top,m_Bottom values define the boundaries of a rectangle
# in the 2D (image) space
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of a GUID
#------------------------------------------------------------------------------
TGuid.type = type
TGuid.EntryNames = ( m_Data1, m_Data2, m_Data3, m_Data4 )
TGuid.EntryTypes = ( huint, hushort, hushort, vector hubyte )
#------------------------------------------------------------------------------
# global unique identifier used for distinguish between entities having the
# same type at client app level (e.g. for LUT function definitions)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of a generic parameter
#------------------------------------------------------------------------------
TParameter.type = type
TParameter.EntryNames = ( m_DisplayName, m_Name, m_MinRange, m_MaxRange, \
						  m_ActualValue, m_DefaultValue, m_bHidden, \
			  m_ForbiddenValues, m_DisplayName@ML )

TParameter.EntryTypes = ( string, string, double, double, \
						  double, double, bool, \
			  vector double, multistring )
#------------------------------------------------------------------------------
# m_DisplayName: the name of the parameter to be displayed by the client app UI
# m_Name: the internal name of the parameter
# m_MinRange, m_MaxRange: the interval of allowed values of the parameter
# m_ActualValue: the value within the allowed interval used for the instance
# of the parameter (should be equal to m_DefaultValue in the context defined)
# in this customization file
# m_DefaultValue: the value within the allowed interval that can be used
# as default for the parameter
# m_bHidden: when it is true, the parameter is not modifiable through the client app
# UI means; when it is false, the parameter will be displayed and modified through the
# client app UI
# m_ForbiddenValues: the vector of values that cannot be applied as
# actual values within the allowed interval (e.g. for preventing division by zero)
#------------------------------------------------------------------------------

###############################################################################
# Type definitions for scopes
###############################################################################

#------------------------------------------------------------------------------
# DICOM element identifier (the DICOM tag)
#------------------------------------------------------------------------------
TDicomID.type = type
TDicomID.EntryNames = (m_GroupID, m_ElementID)
TDicomID.EntryTypes = (hushort, hushort)
#------------------------------------------------------------------------------
# m_GroupID, m_ElementID: the DICOM group ID and the DICOM element ID as
# specified in the DICOM standard (four digits hexadecimal values required)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The specification of a DICOM element value identifier
#------------------------------------------------------------------------------
TDicomElementID.type = type
TDicomElementID.EntryNames = (m_GroupID, m_ElementID, m_ValueIndex, m_IndexInValue)
TDicomElementID.EntryTypes = (hushort, hushort, int default -1, int default -1)
#------------------------------------------------------------------------------
# m_GroupID, m_ElementID: the DICOM group ID and the DICOM element ID as
# specified in the DICOM standard (four digits hexadecimal values required)
# m_ValueIndex, m_IndexInValue: specify which part of the data matrix associated
# whith the element is used (generally the DICOM element data is a matrix of values)
# a -1 m_ValueIndex means all the values and a -1 m_IndexInValue means all the
# items of the value.
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The association between a DICOM element value identifier and the value itself
#------------------------------------------------------------------------------
TDicomElement.type = type
TDicomElement.EntryNames = ( m_ID, m_Value )
TDicomElement.EntryTypes = ( TDicomElementID, variant )
#------------------------------------------------------------------------------
# m_ID: the DICOM element value identifier
# m_Value: the value associated with the DICOM element value.
# The type of the value is only known at run-time, not at bind time
# The variant built in type supports strings and vector of strings, doubles,
# vectors and matrices of doubles and integers, vectors and matrices of integers
# as converted from the DICOM header by the IP Dicom Services
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Scope Entry defined as a vector of DICOM element values
#------------------------------------------------------------------------------
TScopeEntry.type = type
TScopeEntry.EntryNames = ( m_Elements, m_MatchWeight )
TScopeEntry.EntryTypes = ( vector TDicomElement, int default 1 )
#------------------------------------------------------------------------------
# m_Elements: the vector of DICOM elements that should be searched for
# when the scope entry is evaluated
# m_MatchWeight: is the weight to be produced by a successful match of at least one
# of the DICOM elements from m_Elements (matching by OR logic)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Scope defined as a vector of scope entries
#------------------------------------------------------------------------------
TScope.type = type
TScope.EntryNames = ( m_Entries )
TScope.EntryTypes = ( vector TScopeEntry )
#------------------------------------------------------------------------------
# m_Entries: is the vector of scope entries that should be searched for
# when the scope is evaluated.
# NB: The result of the evaluation of a scope is
# the sum of all the matching weights associated with the entries in the
# vector that produced a successful match (matching by weighted AND logic)
#------------------------------------------------------------------------------

###############################################################################
# IP default scope variable (meaning all images)
###############################################################################

#------------------------------------------------------------------------------
# the definition of a default scope meaning all images for scoped variables
#------------------------------------------------------------------------------
vDefaultScopeEntry.type = TScopeEntry
vDefaultScopeEntry.m_MatchWeight = 1
#------------------------------------------------------------------------------
vDefaultScope.type = TScope
vDefaultScope.m_Entries.1 = vDefaultScopeEntry
#------------------------------------------------------------------------------
# has the smallest defined scope weight
# NB: narrower scopes should have larger weights when competing with wider scopes
#------------------------------------------------------------------------------

###############################################################################
###############################################################################
# Predefined IP scope variables for modalities and image types
###############################################################################
###############################################################################

#------------------------------------------------------------------------------
#  DICOM element values that identify specific image modalities
#  Defined Terms for Modality DICOM element (0008,0060) are given
#  in the DICOM Standard Part 3 Section C.7.1.1.1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the modality element ID
#------------------------------------------------------------------------------
vModalityElementID.type				= TDicomElementID
vModalityElementID.m_GroupID		= 0008
vModalityElementID.m_ElementID		= 0060
vModalityElementID.m_ValueIndex		= 0
vModalityElementID.m_IndexInValue	= -1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Computed Radiography
#------------------------------------------------------------------------------
vCRModalityElement.type		= TDicomElement
vCRModalityElement.m_ID		= vModalityElementID
vCRModalityElement.m_Value	= "CR"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Digital Radiography
#------------------------------------------------------------------------------
vDXModalityElement.type	= TDicomElement
vDXModalityElement.m_ID	= vModalityElementID
vDXModalityElement.m_value = "DX"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Computed Tomography
#------------------------------------------------------------------------------
vCTModalityElement.type	= TDicomElement
vCTModalityElement.m_ID	= vModalityElementID
vCTModalityElement.m_value = "CT"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Magnetic Resonance
#------------------------------------------------------------------------------
vMRModalityElement.type	= TDicomElement
vMRModalityElement.m_ID	= vModalityElementID
vMRModalityElement.m_value = "MR"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Nuclear Medicine
#------------------------------------------------------------------------------
vNMModalityElement.type	= TDicomElement
vNMModalityElement.m_ID	= vModalityElementID
vNMModalityElement.m_value = "NM"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Ultrasound
#------------------------------------------------------------------------------
vUSModalityElement.type	= TDicomElement
vUSModalityElement.m_ID	= vModalityElementID
vUSModalityElement.m_value = "US"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Endoscopy
#------------------------------------------------------------------------------
vESModalityElement.type	= TDicomElement
vESModalityElement.m_ID	= vModalityElementID
vESModalityElement.m_value = "ES"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Magnetic Resonance Angiography
#------------------------------------------------------------------------------
vMAModalityElement.type	= TDicomElement
vMAModalityElement.m_ID	= vModalityElementID
vMAModalityElement.m_value = "MA"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Positron Emission Tomography (PET)
#------------------------------------------------------------------------------
vPTModalityElement.type	= TDicomElement
vPTModalityElement.m_ID	= vModalityElementID
vPTModalityElement.m_value = "PT"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Single-Photon Emission Computed Tomography (SPECT)
#------------------------------------------------------------------------------
vSTModalityElement.type	= TDicomElement
vSTModalityElement.m_ID	= vModalityElementID
vSTModalityElement.m_value = "ST"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# X-Ray Angiography
#------------------------------------------------------------------------------
vXAModalityElement.type	= TDicomElement
vXAModalityElement.m_ID	= vModalityElementID
vXAModalityElement.m_value = "XA"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# X-Ray Radiofluoroscopy
#------------------------------------------------------------------------------
vRFModalityElement.type	= TDicomElement
vRFModalityElement.m_ID	= vModalityElementID
vRFModalityElement.m_value = "RF"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Radiotherapy Image
#------------------------------------------------------------------------------
vRTIMAGEModalityElement.type	= TDicomElement
vRTIMAGEModalityElement.m_ID	= vModalityElementID
vRTIMAGEModalityElement.m_value = "RTIMAGE"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Mammography
#------------------------------------------------------------------------------
vMGModalityElement.type	= TDicomElement
vMGModalityElement.m_ID	= vModalityElementID
vMGModalityElement.m_value = "MG"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Other
#------------------------------------------------------------------------------
vOTModalityElement.type	= TDicomElement
vOTModalityElement.m_ID	= vModalityElementID
vOTModalityElement.m_value = "OT"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Structured Report
#------------------------------------------------------------------------------
vSRModalityElement.type	= TDicomElement
vSRModalityElement.m_ID	= vModalityElementID
vSRModalityElement.m_value = "SR"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the Media Storage SOP Class UID element ID
#------------------------------------------------------------------------------
vMediaStorageSOPClassElementID.type				= TDicomElementID
vMediaStorageSOPClassElementID.m_GroupID		= 0008
vMediaStorageSOPClassElementID.m_ElementID		= 0016
vMediaStorageSOPClassElementID.m_ValueIndex		= 0
vMediaStorageSOPClassElementID.m_IndexInValue	= -1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Mammography CAD SR SOP Class
#------------------------------------------------------------------------------
vMammoCadSRSopClassElement.type = TDicomElement
vMammoCadSRSopClassElement.m_ID = vMediaStorageSOPClassElementID
vMammoCadSRSopClassElement.m_value = "1.2.840.10008.5.1.4.1.1.88.50"

#------------------------------------------------------------------------------
# Dicom Elements that identify specific photometric interpretations
# Defined terms for Photometric Interpretation DICOM element (0028,0004)
# are given in the DICOM Standard Part 3 Section C.7.6.3.1.2
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the image type element ID
#------------------------------------------------------------------------------
vImageTypeElementID.type			= TDicomElementID
vImageTypeElementID.m_GroupID		= 0028
vImageTypeElementID.m_ElementID		= 0004
vImageTypeElementID.m_ValueIndex	= 0
vImageTypeElementID.m_IndexInValue	= -1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# min is white images
#------------------------------------------------------------------------------
vMonochromeOneElement.type		= TDicomElement
vMonochromeOneElement.m_ID		= vImageTypeElementID
vMonochromeOneElement.m_Value	= "MONOCHROME1"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# min is black images
#------------------------------------------------------------------------------
vMonochromeTwoElement.type		= TDicomElement
vMonochromeTwoElement.m_ID		= vImageTypeElementID
vMonochromeTwoElement.m_Value	= "MONOCHROME2"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# color RGB image
#------------------------------------------------------------------------------
vRGBElement.type     = TDicomElement
vRGBElement.m_ID 	 = vImageTypeElementID
vRGBElement.m_Value  = "RGB"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Pallete color RGB image
#------------------------------------------------------------------------------
vPaletteColorElement.type		= TDicomElement
vPaletteColorElement.m_ID		= vImageTypeElementID
vPaletteColorElement.m_Value	= "PALETTE COLOR"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
#  Dicom Element to identify specific bits allocated values,
#  based on the DICOM element (0028,0100). See DICOM Standard
#  Part 3 Section C.7.6.3
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the image allocated bits ID
#------------------------------------------------------------------------------
vBitsAllocatedElementID.type			= TDicomElementID
vBitsAllocatedElementID.m_GroupID		= 0028
vBitsAllocatedElementID.m_ElementID		= 0100
vBitsAllocatedElementID.m_ValueIndex	= 0
vBitsAllocatedElementID.m_IndexInValue	= 0
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
v8BitAllocatedElement.type      = TDicomElement
v8BitAllocatedElement.m_ID      = vBitsAllocatedElementID
v8BitAllocatedElement.m_Value	= 8
#------------------------------------------------------------------------------
v16BitAllocatedElement.type     = TDicomElement
v16BitAllocatedElement.m_ID      = vBitsAllocatedElementID
v16BitAllocatedElement.m_Value	= 16
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the Manufacturer Name ID
#------------------------------------------------------------------------------
vManufacturerNameElementID.type             = TDicomElementID
vManufacturerNameElementID.m_GroupID        = 0008
vManufacturerNameElementID.m_ElementID      = 0070
vManufacturerNameElementID.m_ValueIndex     = 0
vManufacturerNameElementID.m_IndexInValue   = -1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the Manufacturer Model Name ID
#------------------------------------------------------------------------------
vManufacturerModelNameElementID.type             = TDicomElementID
vManufacturerModelNameElementID.m_GroupID        = 0008
vManufacturerModelNameElementID.m_ElementID      = 1090
vManufacturerModelNameElementID.m_ValueIndex     = 0
vManufacturerModelNameElementID.m_IndexInValue   = -1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the Body Region Property ID
#------------------------------------------------------------------------------
vBodyRegionPropertyElementID.type             = TDicomElementID
vBodyRegionPropertyElementID.m_GroupID        = 3711
vBodyRegionPropertyElementID.m_ElementID      = 1104
vBodyRegionPropertyElementID.m_ValueIndex     = 0
vBodyRegionPropertyElementID.m_IndexInValue   = -1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the Projection Property Element ID
#------------------------------------------------------------------------------
vProjectionPropertyElementID.type             = TDicomElementID
vProjectionPropertyElementID.m_GroupID        = 3711
vProjectionPropertyElementID.m_ElementID      = 110B
vProjectionPropertyElementID.m_ValueIndex     = 0
vProjectionPropertyElementID.m_IndexInValue   = -1
#------------------------------------------------------------------------------

#-----------------------------------------------------------------------
# placeholder for Overlay Description ID
#-----------------------------------------------------------------------
vOverlayDescriptionElementID.type             = TDicomElementID
vOverlayDescriptionElementID.m_GroupID        = 6000
vOverlayDescriptionElementID.m_ElementID      = 0022
vOverlayDescriptionElementID.m_ValueIndex     = 0
vOverlayDescriptionElementID.m_IndexInValue   = -1
#-----------------------------------------------------------------------

#------------------------------------------------------------------------------
# placeholder for the Software Version Elment ID
#------------------------------------------------------------------------------
vCadSRVersionElementID.type             = TDicomElementID
vCadSRVersionElementID.m_GroupID        = 0018
vCadSRVersionElementID.m_ElementID      = 1020
vCadSRVersionElementID.m_ValueIndex     = 0
vCadSRVersionElementID.m_IndexInValue   = -1

#------------------------------------------------------------------------------
#   Modality-Specific Scope Entries (weight 2)
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
vCRImageScopeEntry.type				= TScopeEntry
vCRImageScopeEntry.m_MatchWeight	= 2
vCRImageScopeEntry.m_Elements.1		= vCRModalityElement
#------------------------------------------------------------------------------
vDXImageScopeEntry.type				= TScopeEntry
vDXImageScopeEntry.m_MatchWeight	= 2
vDXImageScopeEntry.m_Elements.1		= vDXModalityElement
#------------------------------------------------------------------------------
vCTImageScopeEntry.type				= TScopeEntry
vCTImageScopeEntry.m_MatchWeight	= 2
vCTImageScopeEntry.m_Elements.1		= vCTModalityElement
#------------------------------------------------------------------------------
vMRImageScopeEntry.type				= TScopeEntry
vMRImageScopeEntry.m_MatchWeight	= 2
vMRImageScopeEntry.m_Elements.1		= vMRModalityElement
#------------------------------------------------------------------------------
vNMImageScopeEntry.type				= TScopeEntry
vNMImageScopeEntry.m_MatchWeight	= 2
vNMImageScopeEntry.m_Elements.1		= vNMModalityElement
#------------------------------------------------------------------------------
vUSImageScopeEntry.type				= TScopeEntry
vUSImageScopeEntry.m_MatchWeight	= 2
vUSImageScopeEntry.m_Elements.1		= vUSModalityElement
#------------------------------------------------------------------------------
vOTImageScopeEntry.type				= TScopeEntry
vOTImageScopeEntry.m_MatchWeight	= 2
vOTImageScopeEntry.m_Elements.1		= vOTModalityElement
#------------------------------------------------------------------------------
vESImageScopeEntry.type				= TScopeEntry
vESImageScopeEntry.m_MatchWeight	= 2
vESImageScopeEntry.m_Elements.1		= vESModalityElement
#------------------------------------------------------------------------------
vMAImageScopeEntry.type				= TScopeEntry
vMAImageScopeEntry.m_MatchWeight	= 2
vMAImageScopeEntry.m_Elements.1		= vMAModalityElement
#------------------------------------------------------------------------------
vPTImageScopeEntry.type				= TScopeEntry
vPTImageScopeEntry.m_MatchWeight	= 2
vPTImageScopeEntry.m_Elements.1		= vPTModalityElement
#------------------------------------------------------------------------------
vSTImageScopeEntry.type				= TScopeEntry
vSTImageScopeEntry.m_MatchWeight	= 2
vSTImageScopeEntry.m_Elements.1		= vSTModalityElement
#------------------------------------------------------------------------------
vXAImageScopeEntry.type				= TScopeEntry
vXAImageScopeEntry.m_MatchWeight	= 2
vXAImageScopeEntry.m_Elements.1		= vXAModalityElement
#------------------------------------------------------------------------------
vRFImageScopeEntry.type				= TScopeEntry
vRFImageScopeEntry.m_MatchWeight	= 2
vRFImageScopeEntry.m_Elements.1		= vRFModalityElement
#------------------------------------------------------------------------------
vRTImageScopeEntry.type				= TScopeEntry
vRTImageScopeEntry.m_MatchWeight	= 2
vRTImageScopeEntry.m_Elements.1		= vRTIMAGEModalityElement
#------------------------------------------------------------------------------
vMGImageScopeEntry.type				= TScopeEntry
vMGImageScopeEntry.m_MatchWeight	= 2
vMGImageScopeEntry.m_Elements.1		= vMGModalityElement
#------------------------------------------------------------------------------
vSRImageScopeEntry.type				= TScopeEntry
vSRImageScopeEntry.m_MatchWeight	= 2
vSRImageScopeEntry.m_Elements.1		= vMammoCadSRSopClassElement
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
#   Photometric Interpretation-Specific Scope Entries
#------------------------------------------------------------------------------
vMonochromeOneScopeEntry.type			= TScopeEntry
vMonochromeOneScopeEntry.m_MatchWeight	= 3
vMonochromeOneScopeEntry.m_Elements.1	= vMonochromeOneElement
#------------------------------------------------------------------------------
vMonochromeTwoScopeEntry.type			= TScopeEntry
vMonochromeTwoScopeEntry.m_MatchWeight	= 3
vMonochromeTwoScopeEntry.m_Elements.1	= vMonochromeTwoElement
#------------------------------------------------------------------------------
vRGBScopeEntry.type						= TScopeEntry
vRGBScopeEntry.m_MatchWeight			= 3
vRGBScopeEntry.m_Elements.1				= vRGBElement
#------------------------------------------------------------------------------
vPaletteColorScopeEntry.type			= TScopeEntry
vPaletteColorScopeEntry.m_MatchWeight	= 3
vPaletteColorScopeEntry.m_Elements.1	= vPaletteColorElement
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
#    Bits Allocated Scope Entries
#------------------------------------------------------------------------------
v8BitAllocatedScopeEntry.type			= TScopeEntry
v8BitAllocatedScopeEntry.m_MatchWeight	= 30
v8BitAllocatedScopeEntry.m_Elements.1	= v8BitAllocatedElement
#------------------------------------------------------------------------------
v16BitAllocatedScopeEntry.type			= TScopeEntry
v16BitAllocatedScopeEntry.m_MatchWeight	= 30
v16BitAllocatedScopeEntry.m_Elements.1	= v16BitAllocatedElement
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Scopes based on image characteristics
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# CR Images
#------------------------------------------------------------------------------
vCRImageScope.type						= TScope
vCRImageScope.m_Entries.1				= vCRImageScopeEntry

#------------------------------------------------------------------------------
# CT Images
#------------------------------------------------------------------------------
vCTImageScope.type						= TScope
vCTImageScope.m_Entries.1				= vCTImageScopeEntry

#------------------------------------------------------------------------------
# MR Images
#------------------------------------------------------------------------------
vMRImageScope.type						= TScope
vMRImageScope.m_Entries.1				= vMRImageScopeEntry

#------------------------------------------------------------------------------
# Nuclear Medicine Images
#------------------------------------------------------------------------------
vNMImageScope.type						= TScope
vNMImageScope.m_Entries.1				= vNMImageScopeEntry

#------------------------------------------------------------------------------
# Ultrasound Images
#------------------------------------------------------------------------------
vUSImageScope.type						= TScope
vUSImageScope.m_Entries.1				= vUSImageScopeEntry

#------------------------------------------------------------------------------
# Other Images
#------------------------------------------------------------------------------
vOTImageScope.type						= TScope
vOTImageScope.m_Entries.1				= vOTImageScopeEntry

#------------------------------------------------------------------------------
# ES Images
#------------------------------------------------------------------------------
vESImageScope.type						= TScope
vESImageScope.m_Entries.1				= vESImageScopeEntry

#------------------------------------------------------------------------------
# MA Images
#------------------------------------------------------------------------------
vMAImageScope.type						= TScope
vMAImageScope.m_Entries.1				= vMAImageScopeEntry

#------------------------------------------------------------------------------
# PET Images
#------------------------------------------------------------------------------
vPTImageScope.type						= TScope
vPTImageScope.m_Entries.1				= vPTImageScopeEntry

#------------------------------------------------------------------------------
# ST Images
#------------------------------------------------------------------------------
vSTImageScope.type						= TScope
vSTImageScope.m_Entries.1				= vSTImageScopeEntry

#------------------------------------------------------------------------------
# XA Images
#------------------------------------------------------------------------------
vXAImageScope.type						= TScope
vXAImageScope.m_Entries.1				= vXAImageScopeEntry

#------------------------------------------------------------------------------
# RF Images
#------------------------------------------------------------------------------
vRFImageScope.type						= TScope
vRFImageScope.m_Entries.1				= vRFImageScopeEntry

#------------------------------------------------------------------------------
# RT Images
#------------------------------------------------------------------------------
vRTImageScope.type						= TScope
vRTImageScope.m_Entries.1				= vRTImageScopeEntry

#------------------------------------------------------------------------------
# DX Images
#------------------------------------------------------------------------------
vDXImageScope.type						= TScope
vDXImageScope.m_Entries.1				= vDXImageScopeEntry

#------------------------------------------------------------------------------
# Mammography Images
#------------------------------------------------------------------------------
vMGImageScope.type						= TScope
vMGImageScope.m_Entries.1				= vMGImageScopeEntry

#------------------------------------------------------------------------------
# Monochrome 1 Mammography Images
#------------------------------------------------------------------------------
vMonochromeOneMGImageScope.type			= TScope
vMonochromeOneMGImageScope.m_Entries.1	= vMonochromeOneScopeEntry
vMonochromeOneMGImageScope.m_Entries.2	= vMGImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 2 Mammography Images
#------------------------------------------------------------------------------
vMonochromeTwoMGImageScope.type			= TScope
vMonochromeTwoMGImageScope.m_Entries.1	= vMonochromeTwoScopeEntry
vMonochromeTwoMGImageScope.m_Entries.2	= vMGImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 1 Magnetic Resonance Images
#------------------------------------------------------------------------------
vMonochromeOneMRImageScope.type			= TScope
vMonochromeOneMRImageScope.m_Entries.1	= vMonochromeOneScopeEntry
vMonochromeOneMRImageScope.m_Entries.2	= vMRImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 2 Magnetic Resonance Images
#------------------------------------------------------------------------------
vMonochromeTwoMRImageScope.type			= TScope
vMonochromeTwoMRImageScope.m_Entries.1	= vMonochromeTwoScopeEntry
vMonochromeTwoMRImageScope.m_Entries.2	= vMRImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 1 Computed Tomography Images
#------------------------------------------------------------------------------
vMonochromeOneCTImageScope.type			= TScope
vMonochromeOneCTImageScope.m_Entries.1	= vMonochromeOneScopeEntry
vMonochromeOneCTImageScope.m_Entries.2	= vCTImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 2 Computed Tomography Images
#------------------------------------------------------------------------------
vMonochromeTwoCTImageScope.type			= TScope
vMonochromeTwoCTImageScope.m_Entries.1	= vMonochromeTwoScopeEntry
vMonochromeTwoCTImageScope.m_Entries.2	= vCTImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 1 Nuclear Medicine Images
#------------------------------------------------------------------------------
vMonochromeOneNMImageScope.type			= TScope
vMonochromeOneNMImageScope.m_Entries.1	= vMonochromeOneScopeEntry
vMonochromeOneNMImageScope.m_Entries.2	= vNMImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 2 Nuclear Medicine Images
#------------------------------------------------------------------------------
vMonochromeTwoNMImageScope.type			= TScope
vMonochromeTwoNMImageScope.m_Entries.1	= vMonochromeTwoScopeEntry
vMonochromeTwoNMImageScope.m_Entries.2	= vNMImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 1 Positron Emission Tomography Images
#------------------------------------------------------------------------------
vMonochromeOnePTImageScope.type			= TScope
vMonochromeOnePTImageScope.m_Entries.1	= vMonochromeOneScopeEntry
vMonochromeOnePTImageScope.m_Entries.2	= vPTImageScopeEntry
#------------------------------------------------------------------------------
# Monochrome 2 Positron Emission Tomography Images
#------------------------------------------------------------------------------
vMonochromeTwoPTImageScope.type			= TScope
vMonochromeTwoPTImageScope.m_Entries.1	= vMonochromeTwoScopeEntry
vMonochromeTwoPTImageScope.m_Entries.2	= vPTImageScopeEntry


#------------------------------------------------------------------------------
#  Scopes based on number of bits allocated
#------------------------------------------------------------------------------
v8BitAllocatedScope.type				= TScope
v8BitAllocatedScope.m_Entries.1			= v8BitAllocatedScopeEntry
#------------------------------------------------------------------------------
v16BitAllocatedScope.type				= TScope
v16BitAllocatedScope.m_Entries.1		= v16BitAllocatedScopeEntry
#------------------------------------------------------------------------------

###############################################################################
# Definition of the 'usage' of a configuration variable
###############################################################################

#------------------------------------------------------------------------------
# Definition of the usage of an IP specific configuration resource
#------------------------------------------------------------------------------
TUsage.type = enumeration
TUsage.EnumeratorNames = (eGeneralUsage, eOriginalPresentationUsage, \
						 eImageConstructionUsage, ePreprocessingUsage, \
						 eInitialPresentationUsage, ePostProcessingUsage, \
						 eAllUsage,eInitialLutEstimatorUsage, \
						 eCadOverlaySelectionUsage, eCadMarkPresentationUsage )
TUsage.EnumeratorValues = (0,1,2,3,4,5,6,7,8,9)
#------------------------------------------------------------------------------
# enumeration allowing the description of the purpose of a customization resource
#------------------------------------------------------------------------------

###############################################################################
# Type definitions related to Look-Up Tables
###############################################################################

#------------------------------------------------------------------------------
# Definition of a histogram type
#------------------------------------------------------------------------------
THistogram.type = type
THistogram.EntryNames = ( m_LeftCutLevel, m_RightCutLevel, m_bUseCummulatedLevels, \
						  m_bUseROI, m_ROI)
THistogram.EntryTypes = ( double, double, bool, \
						  bool default false, TRectangle optional )
#------------------------------------------------------------------------------
# m_LeftCutLevel,m_RightCutLevel: specify the cut levels on the histogram
# when m_bUseCummulatedLevels is false, the first Y value of the histogram
# greater than leftCutLevel gives the x cut level
# when m_bUseCummulatedLevels is true, the first value Y added to the histogram
# subgraph cummulated area producing a sum greater than 'm_LeftCutLevel'
# gives the x axis cut level
# same applies for m_RightCutLevel, but this time the computations takes place
# from the right to the left of the histogram x axis
# m_bUseRoi determines whether (true) or not (false) a region of interest of the
# image should be used for computing the histogram
# m_ROI is the description of the region of interest and should be given in
# normalized image coordinates
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of a window & level pair
#------------------------------------------------------------------------------
TWindowLevelPair.type = type
TWindowLevelPair.EntryNames = ( m_Window, m_Level )
TWindowLevelPair.EntryTypes = ( double, double )
#------------------------------------------------------------------------------
# m_Window - the range of values
# m_Level - the position of the middle of the window within the image pixel range
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# the type of the LUT range correction enumeration
# Specifies how to limit the W/L during interactive operations
#------------------------------------------------------------------------------
TLutRangeCorrectionType.type = enumeration
TLutRangeCorrectionType.EnumeratorNames = ( eNoRangeCorrection, eFullRangeCorrection, \
								eUsedRangeCorrection, eDetectMinMaxRangeCorrection )
TLutRangeCorrectionType.EnumeratorValues = ( 0, 1, 2, 3 )
#------------------------------------------------------------------------------
# eNoRangeCorrection: no range correction specified
# eFullRangeCorrection (low contrast): allows the modification of the LUT range
# within the limits of the physical pixel range (allocated bits)
# eUsedRangeCorrection (medium contrast): allows the modification of the LUT range
# within the limits of the pixel used bits
# eDetectMinMaxRangeCorrection (high contrast): allows the modification of the
# LUT range within the limits given by the actual minimum and maximum pixel values
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# LUT range validation enumeration type
# Specifies how to compute the validation interval when the original DICOM W/L
# are validated during original presentation construction
#------------------------------------------------------------------------------
TLutRangeValidatorType.type = enumeration
TLutRangeValidatorType.EnumeratorNames = ( eFullRangeLutValidation, eUsedRangeLutValidation, \
										  eDetectMinMaxLutValidation, eHistogramLutValidation )
TLutRangeValidatorType.EnumeratorValues = ( 1,2,3,4 )
#------------------------------------------------------------------------------
# eFullRangeLutValidation: the allocated range of the image pixels
# eUsedRangeLutValidation: the used bit range of the image pixels
# eDetectMinMaxLutValidation: the interval given by the actual min and max
# pixel values of the image
# eHistogramLutValidation: a histogram info description will give the
# validation interval
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# LUT range validator type (used to check the DICOM original WL data)
#------------------------------------------------------------------------------
TLutRangeValidator.type = type
TLutRangeValidator.EntryNames = ( m_ValidatorType, m_Tolerance, m_Histogram )
TLutRangeValidator.EntryTypes = ( TLutRangeValidatorType,double, THistogram optional)
#------------------------------------------------------------------------------
# m_ValidatorType: specifies how to compute the reference validation interval
# m_Tolerance: it is given in normalized units [0;1] and specifies how far
# the original W/L can deviate from the reference validation interval
# as follows
#  * when the original interval defined by the W/L pair is included in the
# interval obtained by the estimator, the W/L is valid and thus not corrected
#  * when at least one of the limits of the original interval defined by the
# W/L pair is outside the reference validation interval, and the distance
# to the nearest limit of this interval is greater than tolerance multiplied by
# the reference validation interval size, the W/L pair is invalid and
# it is corrected to the new limits
# m_Histogram: should be given when m_ValidatorType is eHistogramLutValidation
#------------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vDefaultLutRangeValidator holds the default DICOM lut validation parameters
#-----------------------------------------------------------------------------
vDefaultLutRangeValidator.type = TLutRangeValidator
vDefaultLutRangeValidator.m_ValidatorType = eDetectMinMaxLutValidation
# Cristian Bonciu, August 17, 2005, relaxed the tolerance to avoid modifying
# series common DICOM luts
vDefaultLutRangeValidator.m_Tolerance = 0.25
#-----------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the LUT range types
#------------------------------------------------------------------------------
TLutRangeType.type = enumeration
TLutRangeType.EnumeratorNames = ( eFullRange,eMinMaxRange,eWindowLevelRange, \
                                 eDetectMinMaxRange,eDicomOriginalRange )
TLutRangeType.EnumeratorValues = (1,2,3,4,5)
#------------------------------------------------------------------------------
# eFullRange: range defined by the allocated image bits and the pixel representation
# signed or unsigned
# eMinMaxRange: range defined by a pair of min / max values
# eWindowLevelRange: range defined by a window / level pair
# eDetectMinMaxRange: range defined by the actual min and max of the pixel values
# of the image
# eDicomOriginalRange: range defined by the limits of a nonlinear DICOM lut
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the LUT range
#------------------------------------------------------------------------------
TLutRangeInfo.type = type
TLutRangeInfo.EntryNames = ( m_LutRangeType, m_bHasOriginalValues, m_OriginalMinVal, \
						m_OriginalMaxVal, m_WLPair, \
						m_bUseUnits, m_Units, m_CorrectionType, m_bUseHistogram, \
						m_bUseValidator, m_Histogram, m_Validator  )
TLutRangeInfo.EntryTypes = ( TLutRangeType, bool, double optional, \
						double optional, TWindowLevelPair, \
						bool, string optional, TLutRangeCorrectionType, bool, \
						bool default false, THistogram optional, \
						TLutRangeValidator optional )
#------------------------------------------------------------------------------
# m_LutRangeType: gives the type of the LUT range
# m_bHasOriginalValues: true when the range has original values
# m_OriginalMinVal, m_OriginalMaxVal: gives the interval in which the range is
# constructed
# m_WLPair: the pair of W/L values, ignored if m_LutRangeType is not of type
# eWindowLevelRange
# m_bHasUnits: when it is true, the range is described in the image units given in
# m_Units; when it is false, the range is described in the m_OriginalMinVal,
# m_OriginalMaxVal interval
# m_CorrectionType: specifies how this range is to be corrected during interactive
# operations
# m_bUseHistogram, m_Histogram: optional specification of a histogram description
# to be used when m_LutRangeType is eDetectMinMaxRange
# when m_bHasUnits is false, the window and level values are considered in the range
# given by the m_OriginalMinVal, m_OriginalMaxVal interval
# m_bUseValidator, m_Validator: optional specification of a validator description
# to be used to validate the range against the image pixel data
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of a LUT shape of type function
#------------------------------------------------------------------------------
TLutFunction.type = type
TLutFunction.EntryNames = ( m_Identifier, m_Name, m_Expression, m_bAutoscale, \
				m_NbParameters, m_Parameters, m_Name@ML )
TLutFunction.EntryTypes = ( TGuid, string, string, bool, int, vector TParameter, multistring )
#------------------------------------------------------------------------------
# m_Identifier: unique identifier for the LUT shape function
# m_Name: the display name of the function
# m_Expression: the mathematical expression of the function
# m_bAutoscale: when it is true, the output values of the function will be
# rescaled to fit the output range of the LUT;
# when it is false, the output of the function is kept as generated
# m_NbParameters: the number of the parameters of the LUT function
# m_Parameters: the vector of function parameters
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the LUT shape types
#------------------------------------------------------------------------------
TLutShapeInfoType.type = enumeration
TLutShapeInfoType.EnumeratorNames = ( eLinearShape, eFunctionShape, eEqualizerShape)
TLutShapeInfoType.EnumeratorValues = (1,5,2)
#------------------------------------------------------------------------------
# enumeration for the lut shapes descriptions
# eLinearShape: linear shape, the default for all DICOM original LUTs given by
# WL pairs
# eFunctionShape: shape described by a function,
# eEqualizerShape: shape automatically constructed to equalize the resulted image
# histogram
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the LUT shape
#------------------------------------------------------------------------------
TLutShapeInfo.type = type
TLutShapeInfo.EntryNames = ( m_ShapeType, m_bInvert,m_Function, m_Histogram )
TLutShapeInfo.EntryTypes = ( TLutShapeInfoType, bool default false, TLutFunction optional, \
						 THistogram optional)
#------------------------------------------------------------------------------
# m_ShapeType: gives the type of the LUT Shape
# m_bInvert: when it is true, the LUT will be inverted (black<->white)
# m_Function: the function description, used only when m_ShapeType = eFunctionShape
# m_Histogram: the histogram description, used only when m_ShapeType = eEqualizerShape
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# definition of a scoped lut shape
#------------------------------------------------------------------------------
TLutShape.type = type
TLutShape.EntryNames = ( m_Usage, m_Scope, m_LutShape )
TLutShape.EntryTypes = ( TUsage, TScope, TLutShapeInfo )
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the LUT (a LUT range and a LUT shape)
#------------------------------------------------------------------------------
TLutInfo.type = type
TLutInfo.EntryNames = ( m_Description, m_Range, m_Shape )
TLutInfo.EntryTypes = ( string, TLutRangeInfo, TLutShapeInfo )
#------------------------------------------------------------------------------
# m_Description: description of the LUT
# m_Range: the LUT range description
# m_Shape: the LUT shape description
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of a Scoped LUT (used for example as a modality-specific estimator)
#------------------------------------------------------------------------------
TScopedLut.type = type
TScopedLut.EntryNames = (m_Usage, m_Scope, m_LutInfo)
TScopedLut.EntryTypes = (TUsage, TScope, TLutInfo)
#------------------------------------------------------------------------------

###############################################################################
# Type definitions related to zoom/pan presentation options
###############################################################################

#------------------------------------------------------------------------------
# Definition of the mapping mode enumeration
#------------------------------------------------------------------------------
TMappingMode.type = enumeration
TMappingMode.EnumeratorNames = ( ePixelPerPixel, eMmPerMm )
TMappingMode.EnumeratorValues = (1,2)
#------------------------------------------------------------------------------
# enumeration allowing the description of supported re-size transform
# mapping modes
# ePixelPerPixel: maps input pixels to output pixels through a zoom factor
# eMmPerMm: maps input milimeters to output milimeters
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
TZoomPanCorrector.type = type
TZoomPanCorrector.EntryNames = ( m_MinZoomFactor, m_MaxZoomFactor )
TZoomPanCorrector.EntryTypes = ( double, double )
#------------------------------------------------------------------------------
# m_MinZoomFactor, m_MaxZoomFactor: gives the limits of the zoom factor during
# interactive operations
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
TZoomPan.type = type
TZoomPan.EntryNames = ( m_bNormalizedCoordinates, m_ZoomCenter, m_ZoomFactor, \
						m_MappingMode, m_bAutoFit, m_bUseCorrection, m_Corrector )
TZoomPan.EntryTypes = ( bool, TPoint, double, \
					   TMappingMode, bool default true, bool, TZoomPanCorrector )
#------------------------------------------------------------------------------
# m_bNormalizedCoordinates: when true, the zoom center is given in normalized
# image coordinates
# m_MappingMode: the mapping mode
# m_ZoomCenter: the center of the ROI to be displayed, in (normalized) image coordinates
# m_ZoomFactor: depends on mapping mode as follows
# eAutoFit mode:
#	zoomFactor 1 means that the entire image is displayed
#	in the viewport regardless the viewport size;
#	zoomFactor 2 means that half of the image around the zoom
#	center is displayed in the viewport regardless the viewport size
#	zoomFactor 0.5 means that the viewport would display entirely an
#	image twice as big as the current one regardless the viewport size
# ePixelPerPixel mode:
#	1 pixel from input image is displayed as 'zoomFactor' pixels on the viewport
#	smaller viewports will display a smaller ROI than larger viewports
# eLifeSize mode:
#	1 mm from input image (the image must have DICOM calibration)
#	is displayed as 'zoomFactor' mm on the viewport (the monitor must be already
#	calibrated)
#	smaller viewports will display a smaller ROI than larger viewports
#------------------------------------------------------------------------------

###############################################################################
# Type definitions related to re-size algorithms options
###############################################################################

#------------------------------------------------------------------------------
# Shrink algorithms enumeration
#------------------------------------------------------------------------------
TShrinkAlgorithmType.type = enumeration
TShrinkAlgorithmType.EnumeratorNames = ( eShrinkNearestNeighbour, eShrinkAverage, \
				    eShrinkAntialiasingBox, eShrinkAntialiasingGridWeighted, \
				    eShrinkAntialiasingPyramid, eShrinkAntialiasingGauss, eShrinkAntialiasingPosWeighted )
TShrinkAlgorithmType.EnumeratorValues = (1,2,3,4,5,6,7)

#------------------------------------------------------------------------------
# enumeration allowing the symbolic description of supported shrink algorithms
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the types of the algorithms used to shrink an image
#------------------------------------------------------------------------------
TShrinkAlgorithm.type = type
TShrinkAlgorithm.EntryNames = ( m_ShrinkType, m_ShrinkParameters )
TShrinkAlgorithm.EntryTypes = ( TShrinkAlgorithmType, vector TParameter optional)
#------------------------------------------------------------------------------
# m_ShrinkType gives the type of the algorithm
# m_ShrinkParameters contains a vector of parameters to be used by the algorithm
# two parameters are needed for eShrinkAntialiasingBox, eShrinkAntialiasingPyramid
# and eShrinkAntialiasingGauss containing the preimage extension width and height
# one more parameter is needed for eShrinkAntialiasingPyramid and
# eShrinkAntialiasingGauss containing the scaling factor (see factory settings
# below for details)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the types describing the algorithms used to stretch an image
#------------------------------------------------------------------------------
TStretchAlgorithmType.type = enumeration
TStretchAlgorithmType.EnumeratorNames = (eStretchReplication, eStretchLinearInterpolation)
# will be available in v3.2 or v4.0
# eStretchCubicInterpolation, eStretchCubicSplineInterpolation )
TStretchAlgorithmType.EnumeratorValues = (1,2)
#------------------------------------------------------------------------------
# enumeration allowing the symbolic description of supported stretch algorithms
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the algorithms used to stretch an image
#------------------------------------------------------------------------------
TStretchAlgorithm.type = type
TStretchAlgorithm.EntryNames = ( m_StretchType, m_StretchParameters )
TStretchAlgorithm.EntryTypes = ( TStretchAlgorithmType, vector TParameter optional)
#------------------------------------------------------------------------------
# m_StretchType: gives the type of the algorithm
# m_StretchParameters: the vector of parameters used by the algorithms
# eStretchReplication, eStretchLinearInterpolation, eStretchCubicInterpolation
# does not use parameters,
# available in v3.2 or v4.0
# eStretchCubicSplineInterpolation uses a 'Shape' parameter with default value 1
# supported values IP v3.0,v3.1 are eStretchReplication and eStretchLinearInterpolation
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the resize algorithm (containing one shrink and one stretch
# algorithm descriptors)
#------------------------------------------------------------------------------
TResizeAlgorithm.type = type
TResizeAlgorithm.EntryNames = ( m_bForMaxSpeedMode,m_ShrinkMethod, m_StretchMethod)
TResizeAlgorithm.EntryTypes = ( bool, TShrinkAlgorithm, TStretchAlgorithm )
#------------------------------------------------------------------------------
# m_bForMaxSpeedMode: when it is true, the algorithm is applied for pipeline
# set in max speed mode, when it is false, the algorithm is applied for pipeline
# set in max quality mode
# m_ShrinkMethod: describes the algorithm used during shrinking
# m_StretchMethod: describes the algorithm used during stretching
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the resize options (containing one descriptor for max quality
# and one for max speed pipeline modes)
#------------------------------------------------------------------------------
TResizeProcessingInfo.type = type
TResizeProcessingInfo.EntryNames = ( m_bHasMaxQualityInfo, m_bHasMaxSpeedInfo, \
									m_AlgorithmInfo )
TResizeProcessingInfo.EntryTypes = ( bool, bool, vector TResizeAlgorithm )
#------------------------------------------------------------------------------
# m_bHasMaxQualityInfo: when it is true, maxQualityInfo must be given
# m_bHasMaxSpeedInfo: when it is true, maxSpeedInfo must be given
# m_MaxQualityInfo: describes the algorithms used for max quality pipeline mode
# m_bMaxSpeedInfo: describes the algorithms used for max speed pipeline mode
#------------------------------------------------------------------------------

###############################################################################
# Type definitions related to Flip/Rotate presentation options
###############################################################################

#------------------------------------------------------------------------------
# flip and rotation operation description type cb:ok
#------------------------------------------------------------------------------
TFlipRotate.type = type
TFlipRotate.EntryNames = ( m_bHorizontalFlip, m_bVerticalFlip, m_RotationAngle )
TFlipRotate.EntryTypes = ( bool default false, bool default false, int default 0)
#------------------------------------------------------------------------------
# m_bHorizontalFlip and m_bVerticalFlip: describe the flip operation
# m_RotationAngle: describes the rotation operation, in degrees (0 to 360)
# any flip takes precedence on rotation, that is, the image is first
# flipped and then rotated when both rotation and flip are set
#------------------------------------------------------------------------------

###############################################################################
# Type definitions related to the Convolution Filtering presentation options
###############################################################################

#------------------------------------------------------------------------------
# Convolution filtering operation description type
#------------------------------------------------------------------------------
TConvolutionFilterInfo.type = type
TConvolutionFilterInfo.EntryNames = ( m_Name, m_Rows, m_Columns, \
								 m_Coefficients, m_bAutoBias, \
						  m_bCheckBounds, m_Bias, m_Name@ML )
TConvolutionFilterInfo.EntryTypes = ( string, int, int, \
								 vector vector short, bool default false, \
						  bool default false, int default 0, multistring )
#------------------------------------------------------------------------------
# m_Name: the display name of the filter
# m_Rows: gives the rows of the filter (< 20)
# m_Columns: gives the columns of the filter (< 20)
# m_Coefficients: matrix indexed by row (first index) and by column (second index)
# m_bAutoBias: it should be set to false for non-zero mean filters
# (like the regular smoothing and sharpening filters defined by default)
# it should be set to true for zero mean filters, in order to be auto-biased
# in such a way that the filtered image pixel value range is the same as the
# pixel range of the input image
# m_bCheckBounds: when it is true, specifies that the output of the filtering operation
# should be checked for overflow with respect to the image data range
# It should be used only for sharpending filters (negative coefficients filters)
# In all the other cases, it should be set to false
# because the implementation is faster without the overflow check
# m_Bias: reserved for future use (ISG deployment 3.2 and higher)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Convolution filters scoped variables type
# to be used for general queries for convolution filters
#------------------------------------------------------------------------------
TConvolutionFilter.type = type
TConvolutionFilter.EntryNames = ( m_Usage, m_Scope, m_Filter )
TConvolutionFilter.EntryTypes = ( TUsage, TScope, TConvolutionFilterInfo )
#------------------------------------------------------------------------------

###############################################################################
# Definition of the types used for
# Image Construction (Normalization) operations
###############################################################################

#------------------------------------------------------------------------------
# DICOM bitmap overlay processing options
#------------------------------------------------------------------------------
TDicomBitmapOverlayOptions.type = enumeration
TDicomBitmapOverlayOptions.EnumeratorNames = (	eExtractOverlay, eBurnInOverlay, \
												eIgnoreOverlay )
TDicomBitmapOverlayOptions.EnumeratorValues = (0,1,2)
#------------------------------------------------------------------------------
# eExtractOverlay: the overlays are extracted as separate image planes and then the
# application display options could hide or show them interactively
# eBurnInOverlay: the overlays are extracted and burn in the pixel data plane
# the application cannot hide or show the overlays since they are be embedded
# into the pixel data
# eIgnoreOverlay: the DICOM overlays are not not processed at all
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# DICOM shutter processing options
#------------------------------------------------------------------------------
TDicomShutterOptions.type = enumeration
TDicomShutterOptions.EnumeratorNames = ( eExtractShutter, eBurnInShutter, \
										 eIgnoreShutter )
TDicomShutterOptions.EnumeratorValues = (0,1,2)
#------------------------------------------------------------------------------
# eExtractShutter: the shutters are extracted as regions and then the application
# display options could hide or show them interactively
# eBurnInShutter: the shutter information is extracted and burned into the pixel data
# the application cannot hide or show the shutters once they are burnt into
# pixel data and extreme WL processing will not keep the shutter areas black
# eIgnoreShutter: the shutter information is not not processed at all
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Color Images conversion options
#------------------------------------------------------------------------------
TDicomColorConversionOptions.type = enumeration
TDicomColorConversionOptions.EnumeratorNames  = ( eSameAsSource, eColorByPlane, \
												  eColorByPixel )
TDicomColorConversionOptions.EnumeratorValues = ( 0,1,2 )
#------------------------------------------------------------------------------
# eSameAsSource: when it is true, the conversion of the RGB DICOM image
# is performed to the closest supported IP format (by plane or by pixel)
# eColorByPlane: convert to RGB by plane any RGB DICOM image
# eColorByPixel: convert RGB by pixel any RGB DICOM image
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Options of how to handling DICOM Planar Configuration tag (0028, 0006)
#------------------------------------------------------------------------------
# eTrustPlanarConfigurationValue  - use value of Planar Configuration tag.
# eAlwaysSetAsByPlane  - ignore tag (0028, 0006). Set pixel arrangement as color by plane.
# eAlwaysSetAsByPixel  - ignore tag (0028, 0006). Set pixel arrangement as color by pixel.
#------------------------------------------------------------------------------
TPlanarConfigurationTagOption.type = enumeration
TPlanarConfigurationTagOption.EnumeratorNames = ( eTrustPlanarConfigurationValue, \
                                                  eAlwaysSetAsByPlane, \
                                                  eAlwaysSetAsByPixel )
TPlanarConfigurationTagOption.EnumeratorValues = ( 0, 1, 2 )

#------------------------------------------------------------------------------
# image construction/conversion operation options
#------------------------------------------------------------------------------
TNormalizerInfo.type = type
TNormalizerInfo.EntryNames = ( m_ShutterOptions, m_BitmapOverlayOptions, \
							 m_ColorConversionOptions, m_bConvertPalette2RGB, \
                             m_PlanarConfigurationTagOption )
TNormalizerInfo.EntryTypes = ( TDicomShutterOptions, TDicomBitmapOverlayOptions, \
							 TDicomColorConversionOptions, bool optional default true, \
                             TPlanarConfigurationTagOption )
#------------------------------------------------------------------------------
# the operations group the bitmap overlays, shutter and
# color conversion options as described above
# m_bConvertPalette2RGB should be set to true for ISG deployments older than 3.2
# m_PlanarConfigurationTagOption how to use value of Planar Configuration tag
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Image construction default options
#------------------------------------------------------------------------------
vNormalizerOptions.type = TNormalizerInfo
vNormalizerOptions.m_ShutterOptions = eExtractShutter
vNormalizerOptions.m_BitmapOverlayOptions = eExtractOverlay
vNormalizerOptions.m_ColorConversionOptions = eSameAsSource
vNormalizerOptions.m_bConvertPalette2RGB = true
vNormalizerOptions.m_PlanarConfigurationTagOption = eTrustPlanarConfigurationValue
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Image construction default options for all scopes
#------------------------------------------------------------------------------
TNormalizerOptions.type = type
TNormalizerOptions.EntryNames = ( m_Usage, m_Scope, m_NormalizerOptions )
TNormalizerOptions.EntryTypes = ( TUsage, TScope, TNormalizerInfo )
#------------------------------------------------------------------------------

###############################################################################
# Definition of the types used for Preprocessing operations
###############################################################################

#------------------------------------------------------------------------------
# Definition of the viewport horizontal edges enumerator
#------------------------------------------------------------------------------
TViewportHEdge.type = enumeration
TViewportHEdge.EnumeratorNames = ( eTopViewportEdge, eBottomViewportEdge )
TViewportHEdge.EnumeratorValues = (0,1)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the viewport vertical edges enumerator
#------------------------------------------------------------------------------
TViewportVEdge.type = enumeration
TViewportVEdge.EnumeratorNames = ( eLeftViewportEdge, eRightViewportEdge )
TViewportVEdge.EnumeratorValues = (0,1)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Patient orientation labels enumeration
#------------------------------------------------------------------------------
TPatientOrientationLabel.type = enumeration
TPatientOrientationLabel.EnumeratorNames = ( ePatientOrientationLabelLeft,\
		ePatientOrientationLabelRight, ePatientOrientationLabelAnterior,\
		ePatientOrientationLabelPosterior, ePatientOrientationLabelHead,\
		ePatientOrientationLabelFoot )
TPatientOrientationLabel.EnumeratorValues = (1,2,3,4,5,6)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Horizontal patient orientation type
#------------------------------------------------------------------------------
THorizontalOrientationOption.type = type
THorizontalOrientationOption.EntryNames = ( m_OrientationLabel, m_HorizontalEdge )
THorizontalOrientationOption.EntryTypes = ( TPatientOrientationLabel, TViewportHEdge )
#-----------------------------------------------------------------------------
# associates a patient orientation label m_OrientationLabel to the horizontal edge
# of the viewport m_HorizontalEdge
#-----------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Vertical patient orientation type
#------------------------------------------------------------------------------
TVerticalOrientationOption.type = type
TVerticalOrientationOption.EntryNames = ( m_OrientationLabel, m_VerticalEdge )
TVerticalOrientationOption.EntryTypes = ( TPatientOrientationLabel, TViewportVEdge )
#------------------------------------------------------------------------------
# associates a patient orientation label m_OrientationLabel to a vertical edge
# of the viewport m_VerticalEdge
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Patient orientation option
#------------------------------------------------------------------------------
TOrientationOption.type = type
TOrientationOption.EntryNames = ( m_OrientationOptionV, m_OrientationOptionH )
TOrientationOption.EntryTypes = (	TVerticalOrientationOption, \
									THorizontalOrientationOption )
#------------------------------------------------------------------------------
# associates a pair of orientation labels to a pair of
# vertical and a horizontal viewport edges
# when incompatible options are defined (e.g ePatientOrientationLabelLeft
# -> m_LeftViewportEdge AND ePatientOrientationLabelLeft -> m_TopViewportEdge,
# the vertical option is considered and the horizontal one is ignored
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Orientation correction option type
#------------------------------------------------------------------------------
TOrientationCorrection.type = type
TOrientationCorrection.EntryNames = ( m_NbCorrections, m_Corrections )
TOrientationCorrection.EntryTypes = ( int, vector TOrientationOption )
#------------------------------------------------------------------------------
# specifies the set of options related to the orientation to be applied to
# the image when displayed in the viewport
# at least one option specification should be given
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Preprocessor options type
#------------------------------------------------------------------------------
TPreprocessorInfo.type = type
TPreprocessorInfo.EntryNames = (  m_bApplyModalityLut, m_bApplyCorrectionLut, \
		m_bApplyModalityBeforeCorrection, m_bApplyAspectRatioCorrection, \
		m_bApplyOrientationCorrection, m_bApplyConvolutionFilter, m_CorrectionLut, \
		m_OrientationCorrection, m_ConvolutionFilter )
TPreprocessorInfo.EntryTypes = ( bool default true, bool default false, \
		bool default true, bool default true, bool default false, \
		bool default false, TLutInfo optional, TOrientationCorrection optional, \
		TConvolutionFilterInfo optional )
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Preprocessor options non-scoped default
#------------------------------------------------------------------------------
vPreprocessorOptions.type = TPreprocessorInfo
vPreprocessorOptions.m_bApplyModalityLut = true
vPreprocessorOptions.m_bApplyCorrectionLut = false
vPreprocessorOptions.m_bApplyModalityBeforeCorrection = true
vPreprocessorOptions.m_bApplyAspectRatioCorrection = true
vPreprocessorOptions.m_bApplyOrientationCorrection = false
vPreprocessorOptions.m_bApplyConvolutionFilter = false
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Preprocessing options scoped variable type
#------------------------------------------------------------------------------
TPreprocessorOptions.type = type
TPreprocessorOptions.EntryNames = ( m_Usage, m_Scope, m_PreprocessorOption )
TPreprocessorOptions.EntryTypes = ( TUsage, TScope, TPreprocessorInfo )

###############################################################################
# Predefined LUT function shapes
###############################################################################

#------------------------------------------------------------------------------
# Gamma function for LUTs
#------------------------------------------------------------------------------
vGammaLutFunction.type = TLutFunction
vGammaLutFunction.m_Name = "Gamma"
vGammaLutFunction.m_Name@ML.m_MLString.1.m_Language = "ENU"
vGammaLutFunction.m_Name@ML.m_MLString.2.m_Language = "FRC"
vGammaLutFunction.m_Name@ML.m_MLString.1.m_Value = "Gamma"
vGammaLutFunction.m_Name@ML.m_MLString.2.m_Value = "Gamma"
vGammaLutFunction.m_Identifier = { cea7057d, a16d, 4a02, ( a5, 66, f9, c3, c, c7, 52, 9 )}
vGammaLutFunction.m_Expression = "(( normx ) ^ ( 2 ^ g )) * dimacty + minacty"
vGammaLutFunction.m_bAutoscale = true
vGammaLutFunction.m_NbParameters = 1
vGammaLutFunction.m_Parameters.1.m_Name = "g"
vGammaLutFunction.m_Parameters.1.m_bHidden = false
vGammaLutFunction.m_Parameters.1.m_MinRange = -5
vGammaLutFunction.m_Parameters.1.m_MaxRange = 5
vGammaLutFunction.m_Parameters.1.m_DefaultValue = 1
vGammaLutFunction.m_Parameters.1.m_ActualValue = 1
vGammaLutFunction.m_Parameters.1.m_DisplayName = "Gamma"
vGammaLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.1.m_Language = "ENU"
vGammaLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.2.m_Language = "FRC"
vGammaLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.1.m_Value = "Gamma"
vGammaLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.2.m_Value = "Gamma"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Sigmoid function
#------------------------------------------------------------------------------
vSigmoidLutFunction.type = TLutFunction
vSigmoidLutFunction.m_Name = "Sigmoid"
vSigmoidLutFunction.m_Name@ML.m_MLString.1.m_Language = "ENU"
vSigmoidLutFunction.m_Name@ML.m_MLString.2.m_Language = "FRC"
vSigmoidLutFunction.m_Name@ML.m_MLString.1.m_Value = "Sigmoid"
vSigmoidLutFunction.m_Name@ML.m_MLString.2.m_Value = "Sigmoïd"
vSigmoidLutFunction.m_Identifier = { 1c3c33e5, ea88, 44ea, ( 91, 3, dd, 76, 4, ea, 34, 63 )}
vSigmoidLutFunction.m_Expression = "(1 / (1 + exp ( (0.5-normx) * g ) )) * dimacty + minacty"
vSigmoidLutFunction.m_NbParameters = 1
vSigmoidLutFunction.m_bAutoscale = true
vSigmoidLutFunction.m_Parameters.1.m_Name = "g"
vSigmoidLutFunction.m_Parameters.1.m_bHidden = false
vSigmoidLutFunction.m_Parameters.1.m_MinRange = 1
vSigmoidLutFunction.m_Parameters.1.m_MaxRange = 100
vSigmoidLutFunction.m_Parameters.1.m_DefaultValue = 10
vSigmoidLutFunction.m_Parameters.1.m_ActualValue = 10
vSigmoidLutFunction.m_Parameters.1.m_DisplayName = "Curvature"
vSigmoidLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.1.m_Language = "ENU"
vSigmoidLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.2.m_Language = "FRC"
vSigmoidLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.1.m_Value = "Curvature"
vSigmoidLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.2.m_Value = "Courbure"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# H&D function
#------------------------------------------------------------------------------
vHDLutFunction.type = TLutFunction
#"Hurter & Driffield"
vHDLutFunction.m_Name = "H & D"
vHDLutFunction.m_Name@ML.m_MLString.1.m_Language = "ENU"
vHDLutFunction.m_Name@ML.m_MLString.2.m_Language = "FRC"
vHDLutFunction.m_Name@ML.m_MLString.1.m_Value = "H & D"
vHDLutFunction.m_Name@ML.m_MLString.2.m_Value = "H & D"
vHDLutFunction.m_Identifier = { 6ef303fe, f40b, 4fcc, ( b2, 3e, 3, c6, 67, 8b, 2a, 49 )}
vHDLutFunction.m_Expression = "dimacty * 0.5 * (( 1 / ((1 + exp ((normx - 0.5 - c * \
						ln((2^(1/dl))-1))/(0-c))) ^ dl)) + \
						(1 - 1 / ((1 + exp ((normx - 0.5 + c * ln((2^(1/dr))-1))/c)) ^ dr))) \
						+ minacty"
vHDLutFunction.m_bAutoscale = true
vHDLutFunction.m_NbParameters = 3
vHDLutFunction.m_Parameters.1.m_Name = "c"
vHDLutFunction.m_Parameters.1.m_bHidden = true
vHDLutFunction.m_Parameters.1.m_MinRange = 0.05
vHDLutFunction.m_Parameters.1.m_MaxRange = 2
vHDLutFunction.m_Parameters.1.m_DefaultValue = 0.1
vHDLutFunction.m_Parameters.1.m_ActualValue = 0.1
vHDLutFunction.m_Parameters.1.m_DisplayName= "Curvature"
vHDLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.1.m_Language = "ENU"
vHDLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.2.m_Language = "FRC"
vHDLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.1.m_Value = "Curvature"
vHDLutFunction.m_Parameters.1.m_DisplayName@ML.m_MLString.2.m_Value = "Courbure"
#------------------------------------------------------------------------------
vHDLutFunction.m_Parameters.2.m_Name = "dl"
vHDLutFunction.m_Parameters.2.m_bHidden = false
vHDLutFunction.m_Parameters.2.m_MinRange = 0.5
vHDLutFunction.m_Parameters.2.m_MaxRange = 3.5
vHDLutFunction.m_Parameters.2.m_DefaultValue = 1
vHDLutFunction.m_Parameters.2.m_ActualValue =  1
vHDLutFunction.m_Parameters.2.m_DisplayName = "Toe"
vHDLutFunction.m_Parameters.2.m_DisplayName@ML.m_MLString.1.m_Language = "ENU"
vHDLutFunction.m_Parameters.2.m_DisplayName@ML.m_MLString.2.m_Language = "FRC"
vHDLutFunction.m_Parameters.2.m_DisplayName@ML.m_MLString.1.m_Value = "Toe"
vHDLutFunction.m_Parameters.2.m_DisplayName@ML.m_MLString.2.m_Value = "Orteil"
#------------------------------------------------------------------------------
vHDLutFunction.m_Parameters.3.m_Name = "dr"
vHDLutFunction.m_Parameters.3.m_bHidden = false
vHDLutFunction.m_Parameters.3.m_MinRange = 0.5
vHDLutFunction.m_Parameters.3.m_MaxRange = 3.5
vHDLutFunction.m_Parameters.3.m_DefaultValue = 1
vHDLutFunction.m_Parameters.3.m_ActualValue =  1
vHDLutFunction.m_Parameters.3.m_DisplayName = "Shoulder"
vHDLutFunction.m_Parameters.3.m_DisplayName@ML.m_MLString.1.m_Language = "ENU"
vHDLutFunction.m_Parameters.3.m_DisplayName@ML.m_MLString.2.m_Language = "FRC"
vHDLutFunction.m_Parameters.3.m_DisplayName@ML.m_MLString.1.m_Value = "Shoulder"
vHDLutFunction.m_Parameters.3.m_DisplayName@ML.m_MLString.2.m_Value = "Épaule"
#------------------------------------------------------------------------------

###############################################################################
# Original presentation options type
###############################################################################

#------------------------------------------------------------------------------
# Definition of the calibration selection options
#------------------------------------------------------------------------------
TCalibrationSelectionOption.type = type
TCalibrationSelectionOption.EntryNames = ( m_NbIDs, m_ElementIDs, m_dERMFMinThreshold, m_dERMFMaxThreshold )
TCalibrationSelectionOption.EntryTypes = ( int, vector TDicomID, double default 0, double default 150 )
#------------------------------------------------------------------------------
# specifies the DICOM elements to be used to extract the calibration information
# for the image,
# m_NbIDs: the number of DICOM element IDs
# m_ElementIDs: the vector of DICOM element IDs
# the first element from the vector found with valid values for the image
# is considered as conveying the image calibration information
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of DICOM Sigmoid LUT usage type
#------------------------------------------------------------------------------
# eUseDicomSigmoidLutImage  - use the DICOM Sigmoid VOI LUT Function if
#                             present in the image header
# eUseDicomSigmoidLutNever  - ignore the DICOM Sigmoid VOI LUT Function
#                             even if present in the image header
# eUseDicomSigmoidLutAlways - use DICOM Sigmoid shaped LUT instead of
#                             (piecewise) linear window width and window
#                             level LUT
#------------------------------------------------------------------------------

TDicomSigmoidLUTOption.type = enumeration
TDicomSigmoidLUTOption.EnumeratorNames = ( eUseDicomSigmoidLutImage, \
                                           eUseDicomSigmoidLutNever, \
                                           eUseDicomSigmoidLutAlways )
TDicomSigmoidLUTOption.EnumeratorValues = ( 0, 1, 2 )



#------------------------------------------------------------------------------
# Definition of the original presentation options
#------------------------------------------------------------------------------
TOriginalPresentationInfo.type = type
TOriginalPresentationInfo.EntryNames = ( m_CalibrationInfo, \
                                         m_bValidateLut, \
                                         m_bIgnoreDicomMinMaxElements, \
                                         m_LutValidatorInfo, \
                                         m_bIgnoreUnits, \
                                         m_dImageOrientationSkewTolerance, \
                                         m_bUsePixelPaddingValue, \
                                         m_dicomSigmoidLutOption, \
                                         m_bHasLutShapeFunction, \
                                         m_LutShapeFunction )

TOriginalPresentationInfo.EntryTypes = ( TCalibrationSelectionOption, \
                                         bool, \
                                         bool default false, \
                                         TLutRangeValidator optional, \
                                         bool default false, \
                                         double default 0.01, \
                                         bool default true, \
                                         TDicomSigmoidLUTOption, \
                                         bool default false, \
                                         TLutFunction optional)
#------------------------------------------------------------------------------
# specifies the options for the original presentation construction
# from where calibration should be read and if the luts should be validated
# m_CalibrationInfo: the calibration selection option
# m_bValidateLut: when it is true, m_LutValidatorInfo must specify the LUT
# validator information; when it is false, m_LutValidatorInfo is ignored
# and no DICOM lut validation will take place
# m_bIgnoreDicomMinMaxElements: if true the image's DICOM Smallest and
# Largest Pixel Value elements (if present) will be ignored. If false, these
# elements are used to initialize the image's minimum and maximum pixel values.
# m_bIgnoreUnits: if true, the modality lut units and the slope & intercept
# values, if any, will be ignored; if false, the modality lut units
# and the slope & intercept values, if any, will be processed (the default)
# m_bUsePixelPaddingValue: if true, padding pixels will be ignored in
# Window/Level & histogram computations
# m_dicomSigmoidLutOption: specifies option for converting piecewise linear
#   window width and window level LUT to nonlinear DICOM sigmoid LUT
#------------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vDefaultOriginalPresentation holds the default non-scoped
# original presentation construction options
#-----------------------------------------------------------------------------
vDefaultOriginalPresentation.type = TOriginalPresentationInfo
vDefaultOriginalPresentation.m_CalibrationInfo.m_NbIDs = 2
# image pixel spacing DICOM element
vDefaultOriginalPresentation.m_CalibrationInfo.m_ElementIDs.1.m_GroupID = 28
vDefaultOriginalPresentation.m_CalibrationInfo.m_ElementIDs.1.m_ElementID = 30
# imager pixel spacing DICOM element
# (for projective modalities like CR and especially DX)
vDefaultOriginalPresentation.m_CalibrationInfo.m_ElementIDs.2.m_GroupID = 18
vDefaultOriginalPresentation.m_CalibrationInfo.m_ElementIDs.2.m_ElementID = 1164
vDefaultOriginalPresentation.m_bValidateLut = true
vDefaultOriginalPresentation.m_bIgnoreDicomMinMaxElements = false
vDefaultOriginalPresentation.m_bIgnoreUnits = false
vDefaultOriginalPresentation.m_dImageOrientationSkewTolerance = 0.01
vDefaultOriginalPresentation.m_LutValidatorInfo = vDefaultLutRangeValidator
vDefaultOriginalPresentation.m_bUsePixelPaddingValue = true
vDefaultOriginalPresentation.m_dicomSigmoidLutOption = eUseDicomSigmoidLutNever
#-----------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Original presentation construction option for all scopes
#------------------------------------------------------------------------------
TOriginalPresentationOption.type = type
TOriginalPresentationOption.EntryNames = ( m_Usage, m_Scope, m_Options )
TOriginalPresentationOption.EntryTypes = ( TUsage, TScope, TOriginalPresentationInfo )
#------------------------------------------------------------------------------

###############################################################################
# Initial presentation construction option types
###############################################################################

#------------------------------------------------------------------------------
# Definition of DICOM VOI LUT selection type
#------------------------------------------------------------------------------
TVoiLutSelectionType.type = enumeration
TVoiLutSelectionType.EnumeratorNames = ( eVoiSelectFirst, eVoiSelectLast, \
										eVoiSelectNone, eVoiSelectExplicit )
TVoiLutSelectionType.EnumeratorValues = ( 0,1,2,3 )
#------------------------------------------------------------------------------
# eVoiSelectFirst: select the first DICOM lut
# eVoiSelectLast: select the last DICOM lut
# eVoiSelectNone: ignore the DICOM luts
# eVoiSelectExplicit: select the DICOM lut at the given index (see below)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# DICOM VOI LUT selection option type
#------------------------------------------------------------------------------
TVoiLutSelectionOption.type = type
TVoiLutSelectionOption.EntryNames = ( m_bSelectLinearFirst,m_LinearLutSelectionType, \
						m_LinearLutIndex, m_NonLinearLutSelectionType, \
						m_NonLinearLutIndex,m_bHasEstimator, m_Estimator )
TVoiLutSelectionOption.EntryTypes = ( bool default true, TVoiLutSelectionType, \
						int optional default 0, TVoiLutSelectionType, \
						int optional default 0, bool, TLutInfo optional )
#------------------------------------------------------------------------------
# m_bSelectLinearFirst: when it is true the linear luts will be searched for first
# and then the nonlinear ones, IFF none of the linear ones does not match the
# selection type; when it is false, the nonlinear ones are searched for first
# m_LinearLutSelectionType: specifies the way of selecting one of the original
# linear DICOM LUTs
# m_NonlinearLutSelectionType: specifies the way of selecting one of the original
# nonlinear DICOM LUT
# m_(Non)LinearLutIndex : specify the index of the DICOM lut to be selected
# when m_(Non)LinearLutSelectionType is of type eVoiSelectExplicit
# m_bHasEstimator: when it is true and the selection of the DICOM luts based
# on the above options fails, an estimator will be used; when it is false,
# no LUT estimator will be provided when the options above cannot
# select a DICOM lut (not a recommended option)
# m_Estimator: the LUT description to be used when no DICOM Lut can be retrieved
# using the given selection option or when no DICOM Luts are given in the
# DICOM header
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Initial presentation option type
#------------------------------------------------------------------------------
TInitialPresentationInfo.type = type
TInitialPresentationInfo.EntryNames = ( m_Description, m_bHasOrientationCorrection,\
		m_bHasConvolutionFilter,m_bHasResizeInfo,m_bHasPresentationLut, \
		m_bApplyVOIBeforePresentation, m_LutSelectionOption, m_ZoomPanInfo,\
		m_OrientationCorrection, m_ConvolutionFilter, m_ResizeProcessingInfo, \
		m_PresentationLut )
TInitialPresentationInfo.EntryTypes = ( string,bool default false,\
		bool default false,bool default false, bool default false,\
		bool default true,TVoiLutSelectionOption,TZoomPan,\
		TOrientationCorrection optional, TConvolutionFilterInfo optional, \
		TResizeProcessingInfo  optional, TLutInfo optional )
#------------------------------------------------------------------------------
# specifies the image processing parameters of the initial presentation of the image
# m_Description: the descriptive name of the initial presentation
# m_bHasOrientationCorrection: whether or not orientation correction is specified
# m_bHasConvolutionFilter: whether or not a convolution filter is specified
# m_bHasResizeInfo:whether or not resize info is specified
# m_bHasPresentationLut: whether or not a compensation LUT is specified
# m_bApplyVOIBeforePresentation: specifies the order of the LUT operations
# Presentation before VOI when it is true or the other way around
# m_LutSelectionOption: specifies how to select the DICOM
# m_ZoomPanInfo: predefined zoom information
# m_OrientationCorrection: the orientation correction options to be used
# to adjust the flip and rotate presentation parameters if needed
# m_ConvolutionFilter: the convolution filter to be applied
# m_ResizeProcessingInfo: information about the type of algorithms used
# for resizing the image
# m_PresentationLut: the specification of the correction LUT to be applied
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Initial presentation scoped type
#------------------------------------------------------------------------------
TInitialPresentationOption.type = type
TInitialPresentationOption.EntryNames = ( m_Usage, m_Scope, m_Presentation )
TInitialPresentationOption.EntryTypes = ( TUsage, TScope, TInitialPresentationInfo )
#------------------------------------------------------------------------------

###############################################################################
# Initial presentation non-scoped default variables
# (used by the IP initial presentation engine) if nothing else specified
# for a more specialized scope
###############################################################################

#-----------------------------------------------------------------------------
# vDefaultLutRangeIP  min-max range estimator
#-----------------------------------------------------------------------------
vDefaultLutRangeIP.type = TLutRangeInfo
vDefaultLutRangeIP.m_LutRangeType = eDetectMinMaxRange
vDefaultLutRangeIP.m_bHasOriginalValues = false
vDefaultLutRangeIP.m_OriginalMinVal = 0
vDefaultLutRangeIP.m_OriginalMaxVal = 0
vDefaultLutRangeIP.m_WLPair.m_Window = 0
vDefaultLutRangeIP.m_WLPair.m_Level = 0
vDefaultLutRangeIP.m_bUseUnits = false
vDefaultLutRangeIP.m_bUseHistogram = false
vDefaultLutRangeIP.m_bUseValidator = false
vDefaultLutRangeIP.m_CorrectionType = eUsedRangeCorrection
vDefaultLutRangeIP.m_Histogram.m_LeftCutLevel = 0.001
vDefaultLutRangeIP.m_Histogram.m_RightCutLevel = 0.002
vDefaultLutRangeIP.m_Histogram.m_bUseCummulatedLevels = false
vDefaultLutRangeIP.m_Histogram.m_bUseROI = false
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vDefaultLutIP(Lut) linear LUT with min-max range estimator
#-----------------------------------------------------------------------------
vDefaultLutIP.type = TLutInfo
vDefaultLutIP.m_Description = "All scopes default LUT Estimator"
vDefaultLutIP.m_Range = vDefaultLutRangeIP
vDefaultLutIP.m_Shape.m_ShapeType = eLinearShape
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vDefaultLutSelectionIP: the default selection rule
# first non-linear, first linear, estimator
#-----------------------------------------------------------------------------
vDefaultLutSelectionIP.type = TVoiLutSelectionOption
vDefaultLutSelectionIP.m_bSelectLinearFirst = false
vDefaultLutSelectionIP.m_LinearLutSelectionType = eVoiSelectFirst
vDefaultLutSelectionIP.m_NonLinearLutSelectionType = eVoiSelectFirst
vDefaultLutSelectionIP.m_bHasEstimator = true
vDefaultLutSelectionIP.m_Estimator = vDefaultLutIP
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vDefaultZoomPanCorrectorIP: the default zoom limits
#-----------------------------------------------------------------------------
vDefaultZoomPanCorrectorIP.type = TZoomPanCorrector
vDefaultZoomPanCorrectorIP.m_MinZoomFactor = 0.01
vDefaultZoomPanCorrectorIP.m_MaxZoomFactor = 1000

#-----------------------------------------------------------------------------
# vDefaultZoomPanIP the default zoom pan (autofit, zoom 1)
#-----------------------------------------------------------------------------
vDefaultZoomPanIP.type = TZoomPan
vDefaultZoomPanIP.m_bNormalizedCoordinates = true
vDefaultZoomPanIP.m_ZoomCenter.m_x = 0.5
vDefaultZoomPanIP.m_ZoomCenter.m_y = 0.5
vDefaultZoomPanIP.m_ZoomFactor = 1
vDefaultZoomPanIP.m_MappingMode = ePixelPerPixel
vDefaultZoomPanIP.m_bAutoFit = true
vDefaultZoomPanIP.m_bUseCorrection = true
vDefaultZoomPanIP.m_Corrector = vDefaultZoomPanCorrectorIP
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vDefaultFlipRotationIP(FlipRotate) the default flip and rotation
#-----------------------------------------------------------------------------
vDefaultFlipRotationIP.type = TFlipRotate
vDefaultFlipRotationIP.m_bHorizontalFlip = false
vDefaultFlipRotationIP.m_bVerticalFlip = false
vDefaultFlipRotationIP.m_RotationAngle = 0
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vDefaultMaxQualityAlgorithmIP is the default set of algorithms for max quality
# resize processing
#-----------------------------------------------------------------------------
vDefaultMaxQualityAlgorithmIP.type = TResizeAlgorithm
vDefaultMaxQualityAlgorithmIP.m_bForMaxSpeedMode = false
vDefaultMaxQualityAlgorithmIP.m_ShrinkMethod.m_ShrinkType = eShrinkAverage
vDefaultMaxQualityAlgorithmIP.m_StretchMethod.m_StretchType = eStretchLinearInterpolation
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vDefaultMaxSpeedAlgorithmIP is the default set of algorithms for max speed
# resize processing
#-----------------------------------------------------------------------------
vDefaultMaxSpeedAlgorithmIP.type = TResizeAlgorithm
vDefaultMaxSpeedAlgorithmIP.m_bForMaxSpeedMode = true
vDefaultMaxSpeedAlgorithmIP.m_ShrinkMethod.m_ShrinkType = eShrinkNearestNeighbour
vDefaultMaxSpeedAlgorithmIP.m_StretchMethod.m_StretchType = eStretchReplication
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# default resize processing for initial presentation
#-----------------------------------------------------------------------------
vDefaultResizeProcessingInfoIP.type = TResizeProcessingInfo
vDefaultResizeProcessingInfoIP.m_bHasMaxQualityInfo = true
vDefaultResizeProcessingInfoIP.m_bHasMaxSpeedInfo = true
vDefaultResizeProcessingInfoIP.m_AlgorithmInfo.1 = vDefaultMaxQualityAlgorithmIP
vDefaultResizeProcessingInfoIP.m_AlgorithmInfo.2 = vDefaultMaxSpeedAlgorithmIP

#-----------------------------------------------------------------------------
# default orientation correction for initial presentation
#-----------------------------------------------------------------------------
vDefaultOrientationCorrectionIP.type = TOrientationCorrection
vDefaultOrientationCorrectionIP.m_NbCorrections = 3
vDefaultOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelLeft
vDefaultOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionV.m_VerticalEdge = eRightViewportEdge
vDefaultOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelHead
vDefaultOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

vDefaultOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelLeft
vDefaultOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionV.m_VerticalEdge = eRightViewportEdge
vDefaultOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelAnterior
vDefaultOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

vDefaultOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelAnterior
vDefaultOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionV.m_VerticalEdge = eLeftViewportEdge
vDefaultOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelHead
vDefaultOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# vinitialPresentation is used when no other specializations are found
#-----------------------------------------------------------------------------
vInitialPresentation.type = TInitialPresentationInfo
vInitialPresentation.m_Description = "All modalities initial presentation"
vInitialPresentation.m_bHasOrientationCorrection   = true
vInitialPresentation.m_bHasPresentationLut         = false
vInitialPresentation.m_bApplyVOIBeforePresentation = true
vInitialPresentation.m_bHasConvolutionFilter = false
vInitialPresentation.m_LutSelectionOption = vDefaultLutSelectionIP
vInitialPresentation.m_ZoomPanInfo = vDefaultZoomPanIP
vInitialPresentation.m_bHasResizeInfo = true
vInitialPresentation.m_ResizeProcessingInfo = vDefaultResizeProcessingInfoIP
vInitialPresentation.m_OrientationCorrection = vDefaultOrientationCorrectionIP
#-----------------------------------------------------------------------------


###############################################################################
###############################################################################
###############################################################################
####    SECTION 2 Factory defaults for the ISG subsystems                   ###
###############################################################################
###############################################################################
###############################################################################


###############################################################################
# LUT shapes based on predefined functions
###############################################################################

#------------------------------------------------------------------------------
# LUT shape variable based on gamma function
#------------------------------------------------------------------------------
vGammaLutShape.type = TLutShape
vGammaLutShape.m_Usage = eGeneralUsage
vGammaLutShape.m_Scope = vDefaultScope
vGammaLutShape.m_LutShape.m_ShapeType = eFunctionShape
vGammaLutShape.m_LutShape.m_bInvert = false
vGammaLutShape.m_LutShape.m_Function = vGammaLutFunction
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# LUT shape variable based on sigmoid function
#------------------------------------------------------------------------------
vSigmoidLutShape.type = TLutShape
vSigmoidLutShape.m_Usage = eGeneralUsage
vSigmoidLutShape.m_Scope = vDefaultScope
vSigmoidLutShape.m_LutShape.m_ShapeType = eFunctionShape
vSigmoidLutShape.m_LutShape.m_bInvert = false
vSigmoidLutShape.m_LutShape.m_Function = vSigmoidLutFunction
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# LUT shape variable based on H&D function
#------------------------------------------------------------------------------
vHDLutShape.type = TLutShape
vHDLutShape.m_Usage = eGeneralUsage
vHDLutShape.m_Scope = vDefaultScope
vHDLutShape.m_LutShape.m_ShapeType = eFunctionShape
vHDLutShape.m_LutShape.m_bInvert = false
vHDLutShape.m_LutShape.m_Function = vHDLutFunction
#------------------------------------------------------------------------------

###############################################################################
# General usage convolution filters sorted by increasing weight
# in increments of 10 (to reserve space for future insertions)
# smaller weight = smoother, greater weight = sharper
###############################################################################

#------------------------------------------------------------------------------
# Smoothing Convolution filter 6(GX numer)
#------------------------------------------------------------------------------
vFilterSmooth60.type = TConvolutionFilter
vFilterSmooth60.m_Usage = eGeneralUsage
vFilterSmooth60.m_Scope = vDefaultScope
vFilterSmooth60.m_Scope.m_Entries.1.m_MatchWeight = 70
vFilterSmooth60.m_Filter.m_Name = "Smooth 6"
vFilterSmooth60.m_Filter.m_Rows = 3
vFilterSmooth60.m_Filter.m_Columns = 3
vFilterSmooth60.m_Filter.m_Coefficients.1 = ( 4,4,4 )
vFilterSmooth60.m_Filter.m_Coefficients.2 = ( 4,0,4 )
vFilterSmooth60.m_Filter.m_Coefficients.3 = ( 4,4,4 )
vFilterSmooth60.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSmooth60.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Smooth 6"
vFilterSmooth60.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSmooth60.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Lisse 6"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Smoothing Convolution filter 5(GX numer)
#------------------------------------------------------------------------------
vFilterSmooth50.type = TConvolutionFilter
vFilterSmooth50.m_Usage = eGeneralUsage
vFilterSmooth50.m_Scope = vDefaultScope
vFilterSmooth50.m_Scope.m_Entries.1.m_MatchWeight = 80
vFilterSmooth50.m_Filter.m_Name = "Smooth 5"
vFilterSmooth50.m_Filter.m_Rows = 3
vFilterSmooth50.m_Filter.m_Columns = 3
vFilterSmooth50.m_Filter.m_Coefficients.1 = ( 3,4,3 )
vFilterSmooth50.m_Filter.m_Coefficients.2 = ( 4,4,4 )
vFilterSmooth50.m_Filter.m_Coefficients.3 = ( 3,4,3 )
vFilterSmooth50.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSmooth50.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Smooth 5"
vFilterSmooth50.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSmooth50.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Lisse 5"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Smoothing Convolution filter 4(GX number)
#------------------------------------------------------------------------------
vFilterSmooth40.type = TConvolutionFilter
vFilterSmooth40.m_Usage = eGeneralUsage
vFilterSmooth40.m_Scope = vDefaultScope
vFilterSmooth40.m_Scope.m_Entries.1.m_MatchWeight = 90
vFilterSmooth40.m_Filter.m_Name = "Smooth 4"
vFilterSmooth40.m_Filter.m_Rows = 3
vFilterSmooth40.m_Filter.m_Columns = 3
vFilterSmooth40.m_Filter.m_Coefficients.1 = ( 1,2,1 )
vFilterSmooth40.m_Filter.m_Coefficients.2 = ( 2,4,2 )
vFilterSmooth40.m_Filter.m_Coefficients.3 = ( 1,2,1 )
vFilterSmooth40.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSmooth40.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Smooth 4"
vFilterSmooth40.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSmooth40.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Lisse 4"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Smoothing Convolution filter 3(GX number)
#------------------------------------------------------------------------------
vFilterSmooth30.type = TConvolutionFilter
vFilterSmooth30.m_Usage = eGeneralUsage
vFilterSmooth30.m_Scope = vDefaultScope
vFilterSmooth30.m_Scope.m_Entries.1.m_MatchWeight = 100
vFilterSmooth30.m_Filter.m_Name = "Smooth 3"
vFilterSmooth30.m_Filter.m_Rows = 3
vFilterSmooth30.m_Filter.m_Columns = 3
vFilterSmooth30.m_Filter.m_Coefficients.1 = ( 1,1,1 )
vFilterSmooth30.m_Filter.m_Coefficients.2 = ( 1,8,1 )
vFilterSmooth30.m_Filter.m_Coefficients.3 = ( 1,1,1 )
vFilterSmooth30.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSmooth30.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Smooth 3"
vFilterSmooth30.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSmooth30.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Lisse 3"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Smoothing Convolution filter 2(GX number)
#------------------------------------------------------------------------------
vFilterSmooth20.type = TConvolutionFilter
vFilterSmooth20.m_Usage = eGeneralUsage
vFilterSmooth20.m_Scope = vDefaultScope
vFilterSmooth20.m_Scope.m_Entries.1.m_MatchWeight = 110
vFilterSmooth20.m_Filter.m_Name = "Smooth 2"
vFilterSmooth20.m_Filter.m_Rows = 3
vFilterSmooth20.m_Filter.m_Columns = 3
vFilterSmooth20.m_Filter.m_Coefficients.1 = ( 0,1,0 )
vFilterSmooth20.m_Filter.m_Coefficients.2 = ( 1,4,1 )
vFilterSmooth20.m_Filter.m_Coefficients.3 = ( 0,1,0 )
vFilterSmooth20.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSmooth20.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Smooth 2"
vFilterSmooth20.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSmooth20.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Lisse 2"
#------------------------------------------------------------------------------


#------------------------------------------------------------------------------
# Smoothing Convolution filter 1(GX number)
#------------------------------------------------------------------------------
vFilterSmooth10.type = TConvolutionFilter
vFilterSmooth10.m_Usage = eGeneralUsage
vFilterSmooth10.m_Scope = vDefaultScope
vFilterSmooth10.m_Scope.m_Entries.1.m_MatchWeight = 120
vFilterSmooth10.m_Filter.m_Name = "Smooth 1"
vFilterSmooth10.m_Filter.m_Rows = 3
vFilterSmooth10.m_Filter.m_Columns = 3
vFilterSmooth10.m_Filter.m_Coefficients.1 = ( 0,1,0 )
vFilterSmooth10.m_Filter.m_Coefficients.2 = ( 1,12,1 )
vFilterSmooth10.m_Filter.m_Coefficients.3 = ( 0,1,0 )
vFilterSmooth10.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSmooth10.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Smooth 1"
vFilterSmooth10.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSmooth10.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Lisse 1"
#------------------------------------------------------------------------------


#------------------------------------------------------------------------------
# Sharpening Convolution filter 1(GX number)
#------------------------------------------------------------------------------
vFilterSharp10.type = TConvolutionFilter
vFilterSharp10.m_Usage = eGeneralUsage
vFilterSharp10.m_Scope = vDefaultScope
vFilterSharp10.m_Scope.m_Entries.1.m_MatchWeight = 130
vFilterSharp10.m_Filter.m_Name = "Sharp 1"
vFilterSharp10.m_Filter.m_Rows = 3
vFilterSharp10.m_Filter.m_Columns = 3
vFilterSharp10.m_Filter.m_Coefficients.1 = ( 0,-1,0 )
vFilterSharp10.m_Filter.m_Coefficients.2 = ( -1,12,-1 )
vFilterSharp10.m_Filter.m_Coefficients.3 = ( 0,-1,0 )
vFilterSharp10.m_Filter.m_bCheckBounds = true
vFilterSharp10.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSharp10.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Sharp 1"
vFilterSharp10.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSharp10.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Accentuée 1"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Sharpening Convolution filter 2(GX number)
#------------------------------------------------------------------------------
vFilterSharp20.type = TConvolutionFilter
vFilterSharp20.m_Usage = eGeneralUsage
vFilterSharp20.m_Scope = vDefaultScope
vFilterSharp20.m_Scope.m_Entries.1.m_MatchWeight = 140
vFilterSharp20.m_Filter.m_Name = "Sharp 2"
vFilterSharp20.m_Filter.m_Rows = 3
vFilterSharp20.m_Filter.m_Columns = 3
vFilterSharp20.m_Filter.m_Coefficients.1 = ( 0,-1,0 )
vFilterSharp20.m_Filter.m_Coefficients.2 = ( -1,8,-1 )
vFilterSharp20.m_Filter.m_Coefficients.3 = ( 0,-1,0 )
vFilterSharp20.m_Filter.m_bCheckBounds = true
vFilterSharp20.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSharp20.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Sharp 2"
vFilterSharp20.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSharp20.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Accentuée 2"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Sharpening Convolution filter 3(GX number)
#------------------------------------------------------------------------------
vFilterSharp30.type = TConvolutionFilter
vFilterSharp30.m_Usage = eGeneralUsage
vFilterSharp30.m_Scope = vDefaultScope
vFilterSharp30.m_Scope.m_Entries.1.m_MatchWeight = 150
vFilterSharp30.m_Filter.m_Name = "Sharp 3"
vFilterSharp30.m_Filter.m_Rows = 3
vFilterSharp30.m_Filter.m_Columns = 3
vFilterSharp30.m_Filter.m_Coefficients.1 = ( 0,-1,0 )
vFilterSharp30.m_Filter.m_Coefficients.2 = ( -1,6,-1 )
vFilterSharp30.m_Filter.m_Coefficients.3 = ( 0,-1,0 )
vFilterSharp30.m_Filter.m_bCheckBounds = true
vFilterSharp30.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSharp30.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Sharp 3"
vFilterSharp30.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSharp30.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Accentuée 3"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Sharpening Convolution filter 4(GX number)
#------------------------------------------------------------------------------
vFilterSharp40.type = TConvolutionFilter
vFilterSharp40.m_Usage = eGeneralUsage
vFilterSharp40.m_Scope = vDefaultScope
vFilterSharp40.m_Scope.m_Entries.1.m_MatchWeight = 160
vFilterSharp40.m_Filter.m_Name = "Sharp 4"
vFilterSharp40.m_Filter.m_Rows = 3
vFilterSharp40.m_Filter.m_Columns = 3
vFilterSharp40.m_Filter.m_Coefficients.1 = ( 0,-1,0 )
vFilterSharp40.m_Filter.m_Coefficients.2 = ( -1,5,-1 )
vFilterSharp40.m_Filter.m_Coefficients.3 = ( 0,-1,0 )
vFilterSharp40.m_Filter.m_bCheckBounds = true
vFilterSharp40.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSharp40.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Sharp 4"
vFilterSharp40.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSharp40.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Accentuée 4"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Sharpening Convolution filter 5(GX number)
#------------------------------------------------------------------------------
vFilterSharp50.type = TConvolutionFilter
vFilterSharp50.m_Usage = eGeneralUsage
vFilterSharp50.m_Scope = vDefaultScope
vFilterSharp50.m_Scope.m_Entries.1.m_MatchWeight = 170
vFilterSharp50.m_Filter.m_Name = "Sharp 5"
vFilterSharp50.m_Filter.m_Rows = 3
vFilterSharp50.m_Filter.m_Columns = 3
vFilterSharp50.m_Filter.m_Coefficients.1 = ( 0,-2,0 )
vFilterSharp50.m_Filter.m_Coefficients.2 = ( -2,9,-2 )
vFilterSharp50.m_Filter.m_Coefficients.3 = ( 0,-2,0 )
vFilterSharp50.m_Filter.m_bCheckBounds = true
vFilterSharp50.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSharp50.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Sharp 5"
vFilterSharp50.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSharp50.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Accentuée 5"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Sharpening Convolution filter 6(GX number)
#------------------------------------------------------------------------------
vFilterSharp60.type = TConvolutionFilter
vFilterSharp60.m_Usage = eGeneralUsage
vFilterSharp60.m_Scope = vDefaultScope
vFilterSharp60.m_Scope.m_Entries.1.m_MatchWeight = 180
vFilterSharp60.m_Filter.m_Name = "Sharp 6"
vFilterSharp60.m_Filter.m_Rows = 3
vFilterSharp60.m_Filter.m_Columns = 3
vFilterSharp60.m_Filter.m_Coefficients.1 = ( -1,-1,-1 )
vFilterSharp60.m_Filter.m_Coefficients.2 = ( -1,9,-1 )
vFilterSharp60.m_Filter.m_Coefficients.3 = ( -1,-1,-1 )
vFilterSharp60.m_Filter.m_bCheckBounds = true
vFilterSharp60.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSharp60.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Sharp 6"
vFilterSharp60.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSharp60.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Accentuée 6"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Sharpening Convolution filter 7(GX number)
#------------------------------------------------------------------------------
vFilterSharp70.type = TConvolutionFilter
vFilterSharp70.m_Usage = eGeneralUsage
vFilterSharp70.m_Scope = vDefaultScope
vFilterSharp70.m_Scope.m_Entries.1.m_MatchWeight = 190
vFilterSharp70.m_Filter.m_Name = "Sharp 7"
vFilterSharp70.m_Filter.m_Rows = 3
vFilterSharp70.m_Filter.m_Columns = 3
vFilterSharp70.m_Filter.m_Coefficients.1 = ( -1,-2,-1 )
vFilterSharp70.m_Filter.m_Coefficients.2 = ( -2,13,-2 )
vFilterSharp70.m_Filter.m_Coefficients.3 = ( -1,-2,-1 )
vFilterSharp70.m_Filter.m_bCheckBounds = true
vFilterSharp70.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSharp70.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Sharp 7"
vFilterSharp70.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSharp70.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Accentuée 7"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Sharpening Convolution filter 8(GX number)
#------------------------------------------------------------------------------
vFilterSharp80.type = TConvolutionFilter
vFilterSharp80.m_Usage = eGeneralUsage
vFilterSharp80.m_Scope = vDefaultScope
vFilterSharp80.m_Scope.m_Entries.1.m_MatchWeight = 200
vFilterSharp80.m_Filter.m_Name = "Sharp 8"
vFilterSharp80.m_Filter.m_Rows = 3
vFilterSharp80.m_Filter.m_Columns = 3
vFilterSharp80.m_Filter.m_Coefficients.1 = ( -2,-2,-2 )
vFilterSharp80.m_Filter.m_Coefficients.2 = ( -2,17,-2 )
vFilterSharp80.m_Filter.m_Coefficients.3 = ( -2,-2,-2 )
vFilterSharp80.m_Filter.m_bCheckBounds = true
vFilterSharp80.m_Filter.m_Name@ML.m_MLString.1.m_Language = "ENU"
vFilterSharp80.m_Filter.m_Name@ML.m_MLString.1.m_Value = "Sharp 8"
vFilterSharp80.m_Filter.m_Name@ML.m_MLString.2.m_Language = "FRC"
vFilterSharp80.m_Filter.m_Name@ML.m_MLString.2.m_Value = "Accentuée 8"
#------------------------------------------------------------------------------


###############################################################################
# Image construction variables (used for the IP Normalizer components)
###############################################################################

#------------------------------------------------------------------------------
# Image construction variable for the default scope (all)
#------------------------------------------------------------------------------
vDefaultNormalizerOptions.type = TNormalizerOptions
vDefaultNormalizerOptions.m_Usage = eImageConstructionUsage
vDefaultNormalizerOptions.m_Scope = vDefaultScope
vDefaultNormalizerOptions.m_NormalizerOptions = vNormalizerOptions

#------------------------------------------------------------------------------
# Mammography image construction specialization
# to specify that the overlay planes, if any, need to be burnt in
# are too big to carry them through the pipeline
#------------------------------------------------------------------------------
vMGNormalizerOptions.type = TNormalizerOptions
vMGNormalizerOptions.m_Usage = eImageConstructionUsage
vMGNormalizerOptions.m_Scope = vMGImageScope
vMGNormalizerOptions.m_NormalizerOptions = vNormalizerOptions
# CB: July 4, 2005, changed to the default due to FDA concerns
vMGNormalizerOptions.m_NormalizerOptions.m_BitmapOverlayOptions = eExtractOverlay
# eBurnInOverlay
#------------------------------------------------------------------------------

###############################################################################
# Image preprocessing variables (used for the IP Preprocessor component)
###############################################################################

#------------------------------------------------------------------------------
# Image preprocessing variable for the default scope (all)
#------------------------------------------------------------------------------
vDefaultPreprocessorOptions.type = TPreprocessorOptions
vDefaultPreprocessorOptions.m_Usage = ePreprocessingUsage
vDefaultPreprocessorOptions.m_Scope = vDefaultScope
vDefaultPreprocessorOptions.m_PreprocessorOption = vPreprocessorOptions
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Image preprocessing variable for XA Images (no modality LUT processing)
#------------------------------------------------------------------------------
vXAImagePreprocessorOptions.type                                     = TPreprocessorOptions
vXAImagePreprocessorOptions.m_Usage                                  = ePreprocessingUsage
vXAImagePreprocessorOptions.m_Scope                                  = vXAImageScope
vXAImagePreprocessorOptions.m_PreprocessorOption                     = vPreprocessorOptions
vXAImagePreprocessorOptions.m_PreprocessorOption.m_bApplyModalityLut = false
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Image preprocessing variable for RF Images (no modality LUT processing)
#------------------------------------------------------------------------------
vRFImagePreprocessorOptions.type                                     = TPreprocessorOptions
vRFImagePreprocessorOptions.m_Usage                                  = ePreprocessingUsage
vRFImagePreprocessorOptions.m_Scope                                  = vRFImageScope
vRFImagePreprocessorOptions.m_PreprocessorOption                     = vPreprocessorOptions
vRFImagePreprocessorOptions.m_PreprocessorOption.m_bApplyModalityLut = false
#------------------------------------------------------------------------------



###############################################################################
# Original presentation variables
###############################################################################

#-----------------------------------------------------------------------------
# vDefaultOriginalPres is the scoped variable used for the original presentation
# purpose when no other specialization through a narrower scope is found
#-----------------------------------------------------------------------------
vDefaultOriginalPres.type      = TOriginalPresentationOption
vDefaultOriginalPres.m_Usage   = eOriginalPresentationUsage
vDefaultOriginalPres.m_Scope   = vDefaultScope
vDefaultOriginalPres.m_Options = vDefaultOriginalPresentation
#-----------------------------------------------------------------------------


###############################################################################
# Initial presentation variables
###############################################################################

#------------------------------------------------------------------------------
# vDefaultInitialPres is the scoped variable used for the initial presentation
# purpose when no other specialization through a narrower scope is found
#------------------------------------------------------------------------------
vDefaultInitialPres.type           = TInitialPresentationOption
vDefaultInitialPres.m_Usage        = eInitialPresentationUsage
vDefaultInitialPres.m_Scope        = vDefaultScope
vDefaultInitialPres.m_Presentation = vInitialPresentation
#------------------------------------------------------------------------------


#------------------------------------------------------------------------------
# Initial image presentation specializations by modality and image types
# modalities: CR CT MR NM US OT ES MA PT ST XA RT DX MG
#------------------------------------------------------------------------------


#------------------------------------------------------------------------------
# Default LUT estimator
#------------------------------------------------------------------------------
vDefaultLutEstimator.type      = TScopedLut
vDefaultLutEstimator.m_Usage   = eInitialLutEstimatorUsage
vDefaultLutEstimator.m_Scope   = vDefaultScope
vDefaultLutEstimator.m_LutInfo = vDefaultLutIP

#------------------------------------------------------------------------------
# Initial LUT Estimator specializations scoped by modality and image types
# modalities: CR CT MR NM US OT ES MA PT ST XA RT DX MG
#------------------------------------------------------------------------------


#------------------------------------------------------------------------------
# The default LUT estimators for the initial presentations for MR, CT and NM
# are chosen to agree with those implemented by the DICOM Library.
# The DICOM Library uses modality-specific cut points based on the image's
# cumulative histogram.
#------------------------------------------------------------------------------


#------------------------------------------------------------------------------
# (DICOM Library Compatible) LUT Estimator for Monochrome 1 MR Images
#------------------------------------------------------------------------------

vMonochromeOneMRLutEstimator.type                                                 = TScopedLut
vMonochromeOneMRLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeOneMRLutEstimator.m_Scope                                              = vMonochromeOneMRImageScope
vMonochromeOneMRLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeOneMRLutEstimator.m_LutInfo.m_Description                              = "MR Monochrome 1 LUT Estimator"
vMonochromeOneMRLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeOneMRLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = true
vMonochromeOneMRLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.08
vMonochromeOneMRLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.01
vMonochromeOneMRLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# (DICOM Library Compatible) LUT Estimator for Monochrome 2 MR Images
#------------------------------------------------------------------------------
vMonochromeTwoMRLutEstimator.type                                                 = TScopedLut
vMonochromeTwoMRLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeTwoMRLutEstimator.m_Scope                                              = vMonochromeTwoMRImageScope
vMonochromeTwoMRLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeTwoMRLutEstimator.m_LutInfo.m_Description                              = "MR Monochrome 2 LUT Estimator"
vMonochromeTwoMRLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeTwoMRLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = true
vMonochromeTwoMRLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.01
vMonochromeTwoMRLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.08
vMonochromeTwoMRLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# (DICOM Library Compatible) LUT Estimator for Monochrome 1 CT Images
#------------------------------------------------------------------------------
vMonochromeOneCTLutEstimator.type                                                 = TScopedLut
vMonochromeOneCTLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeOneCTLutEstimator.m_Scope                                              = vMonochromeOneCTImageScope
vMonochromeOneCTLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeOneCTLutEstimator.m_LutInfo.m_Description                              = "CT Monochrome 1 LUT Estimator"
vMonochromeOneCTLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeOneCTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = true
vMonochromeOneCTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.03
vMonochromeOneCTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.05
vMonochromeOneCTLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# (DICOM Library Compatible) LUT Estimator for Monochrome 2 CT Images
#------------------------------------------------------------------------------
vMonochromeTwoCTLutEstimator.type                                                 = TScopedLut
vMonochromeTwoCTLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeTwoCTLutEstimator.m_Scope                                              = vMonochromeTwoCTImageScope
vMonochromeTwoCTLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeTwoCTLutEstimator.m_LutInfo.m_Description                              = "CT Monochrome 2 LUT Estimator"
vMonochromeTwoCTLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeTwoCTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = true
vMonochromeTwoCTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.05
vMonochromeTwoCTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.03
vMonochromeTwoCTLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# (DICOM Library Compatible) LUT Estimator for Monochrome 1 NM Images
#------------------------------------------------------------------------------
vMonochromeOneNMLutEstimator.type                                                 = TScopedLut
vMonochromeOneNMLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeOneNMLutEstimator.m_Scope                                              = vMonochromeOneNMImageScope
vMonochromeOneNMLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeOneNMLutEstimator.m_LutInfo.m_Description                              = "NM Monochrome 1 LUT Estimator"
vMonochromeOneNMLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeOneNMLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = true
vMonochromeOneNMLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.01
vMonochromeOneNMLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.01
vMonochromeOneNMLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# (DICOM Library Compatible) LUT Estimator for Monochrome 2 NM Images
#------------------------------------------------------------------------------
vMonochromeTwoNMLutEstimator.type                                                 = TScopedLut
vMonochromeTwoNMLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeTwoNMLutEstimator.m_Scope                                              = vMonochromeTwoNMImageScope
vMonochromeTwoNMLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeTwoNMLutEstimator.m_LutInfo.m_Description                              = "NM Monochrome 2 LUT Estimator"
vMonochromeTwoNMLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeTwoNMLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = true
vMonochromeTwoNMLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.01
vMonochromeTwoNMLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.01
vMonochromeTwoNMLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# LUT Estimator for Monochrome 1 MG Images
#------------------------------------------------------------------------------
vMonochromeOneMGLutEstimator.type                                                 = TScopedLut
vMonochromeOneMGLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeOneMGLutEstimator.m_Scope                                              = vMonochromeOneMGImageScope
vMonochromeOneMGLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeOneMGLutEstimator.m_LutInfo.m_Description                              = "MG Monochrome 1 LUT Estimator"
vMonochromeOneMGLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeOneMGLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = true
vMonochromeOneMGLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.00
vMonochromeOneMGLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.30
vMonochromeOneMGLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# LUT Estimator for Monochrome 2 MG Images
#------------------------------------------------------------------------------
vMonochromeTwoMGLutEstimator.type                                                 = TScopedLut
vMonochromeTwoMGLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeTwoMGLutEstimator.m_Scope                                              = vMonochromeTwoMGImageScope
vMonochromeTwoMGLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeTwoMGLutEstimator.m_LutInfo.m_Description                              = "MG Monochrome 2 LUT Estimator"
vMonochromeTwoMGLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeTwoMGLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = true
vMonochromeTwoMGLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.30
vMonochromeTwoMGLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.00
vMonochromeTwoMGLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# LUT Estimator for Monochrome 1 PT Images
#------------------------------------------------------------------------------
vMonochromeOnePTLutEstimator.type                                                 = TScopedLut
vMonochromeOnePTLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeOnePTLutEstimator.m_Scope                                              = vMonochromeOnePTImageScope
vMonochromeOnePTLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeOnePTLutEstimator.m_LutInfo.m_Description                              = "PT Monochrome 1 LUT Estimator"
vMonochromeOnePTLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeOnePTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = false
vMonochromeOnePTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.00
vMonochromeOnePTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.01
vMonochromeOnePTLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# LUT Estimator for Monochrome 2 PT Images
#------------------------------------------------------------------------------
vMonochromeTwoPTLutEstimator.type                                                 = TScopedLut
vMonochromeTwoPTLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
vMonochromeTwoPTLutEstimator.m_Scope                                              = vMonochromeTwoPTImageScope
vMonochromeTwoPTLutEstimator.m_LutInfo                                            = vDefaultLutIP
vMonochromeTwoPTLutEstimator.m_LutInfo.m_Description                              = "PT Monochrome 2 LUT Estimator"
vMonochromeTwoPTLutEstimator.m_LutInfo.m_Range.m_bUseHistogram                    = true
vMonochromeTwoPTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_bUseCummulatedLevels = false
vMonochromeTwoPTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_LeftCutLevel         = 0.01
vMonochromeTwoPTLutEstimator.m_LutInfo.m_Range.m_Histogram.m_RightCutLevel        = 0.00
vMonochromeTwoPTLutEstimator.m_LutInfo.m_Shape.m_ShapeType                        = eLinearShape

#------------------------------------------------------------------------------
# LUT Estimator for 8 Bit Allocated Images
#------------------------------------------------------------------------------
v8BitAllocatedLutEstimator.type                                                 = TScopedLut
v8BitAllocatedLutEstimator.m_Usage                                              = eInitialLutEstimatorUsage
v8BitAllocatedLutEstimator.m_Scope                                              = v8BitAllocatedScope
v8BitAllocatedLutEstimator.m_LutInfo                                            = vDefaultLutIP
v8BitAllocatedLutEstimator.m_LutInfo.m_Description                              = "8 Bit Images Estimator"
v8BitAllocatedLutEstimator.m_LutInfo.m_Range.m_LutRangeType                     = eFullRange

###############################################################################
# Annotation subsystem initialization - UI component multilanguage strings
###############################################################################

#------------------------------------------------------------------------------
# Disable orientation correction for sagittal & coronal images from series
# containing rotated (tumble like) sections
#------------------------------------------------------------------------------
# 3D sectional images (also known as MIPs for MR) scope
#------------------------------------------------------------------------------
# January 19,2006, Cristian Bonciu,
# changed the 3D MR scope into the scope of the images having
# the "Image Type" sequencing property with the value "MIP"
# (more robust implementation)
#------------------------------------------------------------------------------
vImageTypePropID.type = TDicomElementID
vImageTypePropID.m_GroupID = 3711
vImageTypePropID.m_ElementID = 1101
vImageTypePropID.m_ValueIndex = 0
vImageTypePropID.m_IndexInValue = -1
#------------------------------------------------------------------------------
v3DSectionsProp.type	= TDicomElement
v3DSectionsProp.m_ID	= vImageTypePropID
v3DSectionsProp.m_Value = "MIP"
#------------------------------------------------------------------------------
v3DSectionsScopeEntry.type = TScopeEntry
v3DSectionsScopeEntry.m_MatchWeight = 7
v3DSectionsScopeEntry.m_Elements.1 = v3DSectionsProp
#------------------------------------------------------------------------------
v3DSectionsScope.type = TScope
v3DSectionsScope.m_Entries.1 = v3DSectionsScopeEntry
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Initial presetation for 3D sections images
# should not propose any orientation correction
#------------------------------------------------------------------------------
v3DSectionsInitialPres.type           = TInitialPresentationOption
v3DSectionsInitialPres.m_Usage        = eInitialPresentationUsage
v3DSectionsInitialPres.m_Scope        = v3DSectionsScope
v3DSectionsInitialPres.m_Presentation = vInitialPresentation
v3DSectionsInitialPres.m_Presentation.m_bHasOrientationCorrection = false
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Prone acquisiton images scope (usually for CTs)
# based on sequencing property "Position" (0x3711,0x1112)
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
vPositionPropID.type = TDicomElementID
vPositionPropID.m_GroupID = 3711
vPositionPropID.m_ElementID = 1112
vPositionPropID.m_ValueIndex = 0
vPositionPropID.m_IndexInValue = -1
#------------------------------------------------------------------------------
vPronePositionProp.type = TDicomElement
vPronePositionProp.m_ID = vPositionPropID
vPronePositionProp.m_Value = "Prone"
#------------------------------------------------------------------------------
vPronePositionPropScopeEntry.type = TScopeEntry
vPronePositionPropScopeEntry.m_MatchWeight = 10
vPronePositionPropScopeEntry.m_Elements.1 = vPronePositionProp
#------------------------------------------------------------------------------
vPronePositionPropScope.type = TScope
vPronePositionPropScope.m_Entries.1 = vPronePositionPropScopeEntry
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# For the sectional scan images acquired with the patient in the prone position
# the initial presentation proposes posterior on top and anterior on bottom
# orientation correction (the default is the other way around)
#------------------------------------------------------------------------------
vPositionPropPronePres.type           = TInitialPresentationOption
vPositionPropPronePres.m_Usage        = eInitialPresentationUsage
vPositionPropPronePres.m_Scope        = vPronePositionPropScope
vPositionPropPronePres.m_Presentation = vInitialPresentation
vPositionPropPronePres.m_Presentation.m_OrientationCorrection.m_Corrections.2.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelPosterior
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# January 19,2006, Cristian Bonciu,
# Axial images with patient position Decubitus Left and Decubitus Right
# do not need L-R orientation correction, because the scanner table needs
# to be presented on the bottom of the viewport for clinical reasons
# We disable here the orientation correction based on View property
# "Axial" and the Position property "Decubitus-left" or "Decubitus-right"
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
vDecubitusLeftPositionProp.type = TDicomElement
vDecubitusLeftPositionProp.m_ID = vPositionPropID
vDecubitusLeftPositionProp.m_Value = "Decubitus left"
#------------------------------------------------------------------------------
vDecubitusRightPositionProp.type = TDicomElement
vDecubitusRightPositionProp.m_ID = vPositionPropID
vDecubitusRightPositionProp.m_Value = "Decubitus right"
#------------------------------------------------------------------------------
vDecubitusRightPosPropScopeEntry.type = TScopeEntry
vDecubitusRightPosPropScopeEntry.m_MatchWeight = 10
vDecubitusRightPosPropScopeEntry.m_Elements.1 = vDecubitusRightPositionProp
#------------------------------------------------------------------------------
vDecubitusLeftPosPropScopeEntry.type = TScopeEntry
vDecubitusLeftPosPropScopeEntry.m_MatchWeight = 10
vDecubitusLeftPosPropScopeEntry.m_Elements.1 = vDecubitusLeftPositionProp
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
vAxialViewPropID.type = TDicomElementID
vAxialViewPropID.m_GroupID = 3711
vAxialViewPropID.m_ElementID = 1102
vAxialViewPropID.m_ValueIndex = 0
vAxialViewPropID.m_IndexInValue = -1
#------------------------------------------------------------------------------
vAxialViewProp.type = TDicomElement
vAxialViewProp.m_ID = vAxialViewPropID
vAxialViewProp.m_Value = "Axial"
#------------------------------------------------------------------------------
vAxialViewPropScopeEntry.type = TScopeEntry
vAxialViewPropScopeEntry.m_MatchWeight = 10
vAxialViewPropScopeEntry.m_Elements.1 = vAxialViewProp
#------------------------------------------------------------------------------
vAxialDecubitusRightPosPropScope.type = TScope
vAxialDecubitusRightPosPropScope.m_Entries.1 = vAxialViewPropScopeEntry
vAxialDecubitusRightPosPropScope.m_Entries.2 = vDecubitusRightPosPropScopeEntry
#------------------------------------------------------------------------------
vAxialDecubitusLeftPosPropScope.type = TScope
vAxialDecubitusLeftPosPropScope.m_Entries.1 = vAxialViewPropScopeEntry
vAxialDecubitusLeftPosPropScope.m_Entries.2 = vDecubitusLeftPosPropScopeEntry
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# For the axial scan images acquired with the patient in the decubitus position
# (left or right) the initial presentation does not propose any orientation correction
#------------------------------------------------------------------------------
vDecubitusRightPropPres.type           = TInitialPresentationOption
vDecubitusRightPropPres.m_Usage        = eInitialPresentationUsage
vDecubitusRightPropPres.m_Scope        = vAxialDecubitusRightPosPropScope
vDecubitusRightPropPres.m_Presentation = vInitialPresentation
vDecubitusRightPropPres.m_Presentation.m_bHasOrientationCorrection = false
#------------------------------------------------------------------------------
vDecubitusLeftPropPres.type           = TInitialPresentationOption
vDecubitusLeftPropPres.m_Usage        = eInitialPresentationUsage
vDecubitusLeftPropPres.m_Scope        = vAxialDecubitusLeftPosPropScope
vDecubitusLeftPropPres.m_Presentation = vInitialPresentation
vDecubitusLeftPropPres.m_Presentation.m_bHasOrientationCorrection = false
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# February 6,2006, Cristian Bonciu,
# MG images needs to be reoriented depending on the laterality
# as defined below
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
#   Laterality of the body part examined scope definitions
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# laterality property element ID
#------------------------------------------------------------------------------
vLateralityPropID.type			= TDicomElementID
#vLateralityPropID.m_GroupID	= 3711
#vLateralityPropID.m_ElementID	= 1108
vLateralityPropID.m_GroupID		= 20
vLateralityPropID.m_ElementID	= 62
vLateralityPropID.m_ValueIndex	= 0
vLateralityPropID.m_IndexInValue = -1
#------------------------------------------------------------------------------
# left/right laterality
#------------------------------------------------------------------------------
vLeftLateralityProp.type		= TDicomElement
vLeftLateralityProp.m_ID		= vLateralityPropID
vLeftLateralityProp.m_Value		= "L"
#------------------------------------------------------------------------------
vRightLateralityProp.type		= TDicomElement
vRightLateralityProp.m_ID		= vLateralityPropID
vRightLateralityProp.m_Value	= "R"
#------------------------------------------------------------------------------
# laterality sequence property element ID
#------------------------------------------------------------------------------
vLateralitySequencePropID.type			= TDicomElementID
vLateralitySequencePropID.m_GroupID		= 3711
vLateralitySequencePropID.m_ElementID	= 1108
vLateralitySequencePropID.m_ValueIndex	= 0
vLateralitySequencePropID.m_IndexInValue = -1
#------------------------------------------------------------------------------
# left/right laterality
#------------------------------------------------------------------------------
vLeftLateralitySequenceProp.type		= TDicomElement
vLeftLateralitySequenceProp.m_ID        = vLateralitySequencePropID
vLeftLateralitySequenceProp.m_Value     = "L"
#------------------------------------------------------------------------------
vRightLateralitySequenceProp.type       = TDicomElement
vRightLateralitySequenceProp.m_ID       = vLateralitySequencePropID
vRightLateralitySequenceProp.m_Value    = "R"
#------------------------------------------------------------------------------
#   left/right laterality of the body part examined Scope Entries
#------------------------------------------------------------------------------
vLeftLateralityScopeEntry.type			= TScopeEntry
vLeftLateralityScopeEntry.m_MatchWeight	= 10
vLeftLateralityScopeEntry.m_Elements.1	= vLeftLateralityProp
vLeftLateralityScopeEntry.m_Elements.2	= vLeftLateralitySequenceProp
#------------------------------------------------------------------------------
vRightLateralityScopeEntry.type			= TScopeEntry
vRightLateralityScopeEntry.m_MatchWeight = 10
vRightLateralityScopeEntry.m_Elements.1	= vRightLateralityProp
vRightLateralityScopeEntry.m_Elements.2	= vRightLateralitySequenceProp

# Left/Right breast Mammography image scope
#------------------------------------------------------------------------------
vMGLeftBreastImageScope.type			= TScope
vMGLeftBreastImageScope.m_Entries.1		= vMGImageScopeEntry
vMGLeftBreastImageScope.m_Entries.2		= vLeftLateralityScopeEntry
#------------------------------------------------------------------------------
vMGRightBreastImageScope.type			= TScope
vMGRightBreastImageScope.m_Entries.1	= vMGImageScopeEntry
vMGRightBreastImageScope.m_Entries.2	= vRightLateralityScopeEntry
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# For Mammography images the initial presentation has orientation correction as follows
# Left breast:
# Anterior on the right of the viewport, when "A" or "P" are present
# as Patient Orientation labels for the X axis of the image
# Left on top of the viewport, when "L" or "R" are present
# as Patient Orientation labels for the Y axis of the image
# Right breast:
# Anterior on the left of the viewport , when "A" or "P" is present
# as Patient Orientation for the X axis of the image
# Right on top of the viewport, when "L" or "R" are present
# as Patient Orientation labels for the Y axis of the image
# All the other cases should be treated by using the default orientation rules
#------------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# orientation correction for initial presentation of left breast MG images
#-----------------------------------------------------------------------------
vLeftBreastMGOrientationCorrectionIP.type = TOrientationCorrection
vLeftBreastMGOrientationCorrectionIP.m_NbCorrections = 3

vLeftBreastMGOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelAnterior
vLeftBreastMGOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionV.m_VerticalEdge = eRightViewportEdge
vLeftBreastMGOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelLeft
vLeftBreastMGOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

vLeftBreastMGOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelAnterior
vLeftBreastMGOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionV.m_VerticalEdge = eRightViewportEdge
vLeftBreastMGOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelHead
vLeftBreastMGOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

vLeftBreastMGOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelLeft
vLeftBreastMGOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionV.m_VerticalEdge = eRightViewportEdge
vLeftBreastMGOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelHead
vLeftBreastMGOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

#-----------------------------------------------------------------------------
# orientation correction for initial presentation of right breast MG images
#-----------------------------------------------------------------------------
vRightBreastMGOrientationCorrectionIP.type = TOrientationCorrection
vRightBreastMGOrientationCorrectionIP.m_NbCorrections = 3

vRightBreastMGOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelAnterior
vRightBreastMGOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionV.m_VerticalEdge = eLeftViewportEdge
vRightBreastMGOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelRight
vRightBreastMGOrientationCorrectionIP.m_Corrections.1.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

vRightBreastMGOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelAnterior
vRightBreastMGOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionV.m_VerticalEdge = eLeftViewportEdge
vRightBreastMGOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelHead
vRightBreastMGOrientationCorrectionIP.m_Corrections.2.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

vRightBreastMGOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelLeft
vRightBreastMGOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionV.m_VerticalEdge = eRightViewportEdge
vRightBreastMGOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelHead
vRightBreastMGOrientationCorrectionIP.m_Corrections.3.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

#-----------------------------------------------------------------------------
vLeftBreastPres.type           = TInitialPresentationOption
vLeftBreastPres.m_Usage        = eInitialPresentationUsage
vLeftBreastPres.m_Scope        = vMGLeftBreastImageScope
vLeftBreastPres.m_Presentation = vInitialPresentation
vLeftBreastPres.m_Presentation.m_OrientationCorrection = vLeftBreastMGOrientationCorrectionIP
#------------------------------------------------------------------------------
vRightBreastPres.type           = TInitialPresentationOption
vRightBreastPres.m_Usage        = eInitialPresentationUsage
vRightBreastPres.m_Scope        = vMGRightBreastImageScope
vRightBreastPres.m_Presentation = vInitialPresentation
vRightBreastPres.m_Presentation.m_OrientationCorrection = vRightBreastMGOrientationCorrectionIP
#------------------------------------------------------------------------------

################################################################################
# Orientation correction rules for Hand CR and DX images (fingertips up)
# CB, Dec 15, 2006, added for 11.5
###############################################################################
#------------------------------------------------------------------------------
# define body region properties
#------------------------------------------------------------------------------
vDefaultBodyRegionPropElementID.type = TDicomElementID
vDefaultBodyRegionPropElementID.m_GroupID = 3711
vDefaultBodyRegionPropElementID.m_ElementID = 1104
vDefaultBodyRegionPropElementID.m_ValueIndex = 0
vDefaultBodyRegionPropElementID.m_IndexInValue = -1
#------------------------------------------------------------------------------
vDefaultBRHandPropElement.type = TDicomElement
vDefaultBRHandPropElement.m_ID = vDefaultBodyRegionPropElementID
vDefaultBRHandPropElement.m_Value = "HAND"
#------------------------------------------------------------------------------
vDefaultBRWristPropElement.type = TDicomElement
vDefaultBRWristPropElement.m_ID = vDefaultBodyRegionPropElementID
vDefaultBRWristPropElement.m_Value = "WRIST"
#------------------------------------------------------------------------------
vDefaultBRFingerPropElement.type = TDicomElement
vDefaultBRFingerPropElement.m_ID = vDefaultBodyRegionPropElementID
vDefaultBRFingerPropElement.m_Value = "FINGER"
#------------------------------------------------------------------------------
vDefaultBRThumbPropElement.type = TDicomElement
vDefaultBRThumbPropElement.m_ID = vDefaultBodyRegionPropElementID
vDefaultBRThumbPropElement.m_Value = "THUMB"
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# define anatomic region elements
#------------------------------------------------------------------------------
vDefaultAnatomicRegionPropElementID.type = TDicomElementID
vDefaultAnatomicRegionPropElementID.m_GroupID = 8
vDefaultAnatomicRegionPropElementID.m_ElementID = 2218
vDefaultAnatomicRegionPropElementID.m_ValueIndex = 0
vDefaultAnatomicRegionPropElementID.m_IndexInValue = -1
#------------------------------------------------------------------------------
vDefaultARHandPropElement.type = TDicomElement
vDefaultARHandPropElement.m_ID = vDefaultAnatomicRegionPropElementID
vDefaultARHandPropElement.m_Value = "HAND"
#------------------------------------------------------------------------------
vDefaultARWristPropElement.type = TDicomElement
vDefaultARWristPropElement.m_ID = vDefaultAnatomicRegionPropElementID
vDefaultARWristPropElement.m_Value = "WRIST"
#------------------------------------------------------------------------------
vDefaultARFingerPropElement.type = TDicomElement
vDefaultARFingerPropElement.m_ID = vDefaultAnatomicRegionPropElementID
vDefaultARFingerPropElement.m_Value = "FINGER"
#------------------------------------------------------------------------------
vDefaultARThumbPropElement.type = TDicomElement
vDefaultARThumbPropElement.m_ID = vDefaultAnatomicRegionPropElementID
vDefaultARThumbPropElement.m_Value = "THUMB"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
vDefaultHandScopeEntry.type = TScopeEntry
vDefaultHandScopeEntry.m_MatchWeight = 10
vDefaultHandScopeEntry.m_Elements.1 = vDefaultBRHandPropElement
vDefaultHandScopeEntry.m_Elements.2 = vDefaultBRWristPropElement
vDefaultHandScopeEntry.m_Elements.3 = vDefaultBRFingerPropElement
vDefaultHandScopeEntry.m_Elements.4 = vDefaultBRThumbPropElement
vDefaultHandScopeEntry.m_Elements.5 = vDefaultARHandPropElement
vDefaultHandScopeEntry.m_Elements.6 = vDefaultARWristPropElement
vDefaultHandScopeEntry.m_Elements.7 = vDefaultARFingerPropElement
vDefaultHandScopeEntry.m_Elements.8 = vDefaultARThumbPropElement
#------------------------------------------------------------------------------
vDefaultXRaysScopeEntry.type = TScopeEntry
vDefaultXRaysScopeEntry.m_MatchWeight = 10
vDefaultXRaysScopeEntry.m_Elements.1 = vDXModalityElement
vDefaultXRaysScopeEntry.m_Elements.2 = vCRModalityElement
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# define scope on body / anatomic regions "Hand", "Wrist" and "Finger"
# for X rays
#------------------------------------------------------------------------------
vDefaultXRaysHandScope.type = TScope
vDefaultXRaysHandScope.m_Entries.1 = vDefaultHandScopeEntry
vDefaultXRaysHandScope.m_Entries.2 = vDefaultXRaysScopeEntry
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# hand orientation correction rules
# (fingertips up given the default acquisition with fingertips down)
#------------------------------------------------------------------------------
vDefaultHandOCRules.type = TOrientationCorrection
vDefaultHandOCRules.m_NbCorrections = 3

vDefaultHandOCRules.m_Corrections.1.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelLeft
vDefaultHandOCRules.m_Corrections.1.m_OrientationOptionV.m_VerticalEdge = eRightViewportEdge
vDefaultHandOCRules.m_Corrections.1.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelHead
vDefaultHandOCRules.m_Corrections.1.m_OrientationOptionH.m_HorizontalEdge = eBottomViewportEdge

vDefaultHandOCRules.m_Corrections.2.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelLeft
vDefaultHandOCRules.m_Corrections.2.m_OrientationOptionV.m_VerticalEdge = eRightViewportEdge
vDefaultHandOCRules.m_Corrections.2.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelAnterior
vDefaultHandOCRules.m_Corrections.2.m_OrientationOptionH.m_HorizontalEdge = eTopViewportEdge

vDefaultHandOCRules.m_Corrections.3.m_OrientationOptionV.m_OrientationLabel = ePatientOrientationLabelAnterior
vDefaultHandOCRules.m_Corrections.3.m_OrientationOptionV.m_VerticalEdge = eLeftViewportEdge
vDefaultHandOCRules.m_Corrections.3.m_OrientationOptionH.m_OrientationLabel = ePatientOrientationLabelHead
vDefaultHandOCRules.m_Corrections.3.m_OrientationOptionH.m_HorizontalEdge = eBottomViewportEdge
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# XRays Hand studies initial presentation with orientation correction
# "fingers up", a.k.a. the foot label on top of the viewport
#------------------------------------------------------------------------------
vXRayDefaultHandPres.type           = TInitialPresentationOption
vXRayDefaultHandPres.m_Usage        = eInitialPresentationUsage
vXRayDefaultHandPres.m_Scope        = vDefaultXRaysHandScope
vXRayDefaultHandPres.m_Presentation = vInitialPresentation
vXRayDefaultHandPres.m_Presentation.m_OrientationCorrection = vDefaultHandOCRules
vXRayDefaultHandPres.m_Presentation.m_Description = "Fingertips up"
#------------------------------------------------------------------------------

###############################################################################
# Orientation correction rules for MRI Breast axials images
# (should be the default even if a prone acquisition is involved)
# CB, Dec 15, 2006, added for 11.5
###############################################################################

#------------------------------------------------------------------------------
vDefaultBreastPropElement.type = TDicomElement
vDefaultBreastPropElement.m_ID = vDefaultBodyRegionPropElementID
vDefaultBreastPropElement.m_Value = "BREAST"
#------------------------------------------------------------------------------
vDefaultBreastScopeEntry.type = TScopeEntry
vDefaultBreastScopeEntry.m_MatchWeight = 10
vDefaultBreastScopeEntry.m_Elements.1 = vDefaultBreastPropElement
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
vDefaultAxialProneMRIBreastScope.type = TScope
vDefaultAxialProneMRIBreastScope.m_Entries.1 = vDefaultBreastScopeEntry
vDefaultAxialProneMRIBreastScope.m_Entries.1.m_MatchWeight = 15
vDefaultAxialProneMRIBreastScope.m_Entries.2 = vAxialViewPropScopeEntry
vDefaultAxialProneMRIBreastScope.m_Entries.2.m_MatchWeight = 15
vDefaultAxialProneMRIBreastScope.m_Entries.3 = vPronePositionPropScopeEntry
vDefaultAxialProneMRIBreastScope.m_Entries.3.m_MatchWeight = 15
vDefaultAxialProneMRIBreastScope.m_Entries.4 = vMRImageScopeEntry
vDefaultAxialProneMRIBreastScope.m_Entries.4.m_MatchWeight = 15
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# MRI Prone Axial Breast initial presentation is the same as the default
#------------------------------------------------------------------------------
aDefaultAxialProneMRIBreastPres.type           = TInitialPresentationOption
aDefaultAxialProneMRIBreastPres.m_Usage        = eInitialPresentationUsage
aDefaultAxialProneMRIBreastPres.m_Scope        = vDefaultAxialProneMRIBreastScope
aDefaultAxialProneMRIBreastPres.m_Presentation = vInitialPresentation
aDefaultAxialProneMRIBreastPres.m_Presentation.m_OrientationCorrection = vDefaultOrientationCorrectionIP
aDefaultAxialProneMRIBreastPres.m_Presentation.m_Description = "MR Breast orientation"
#------------------------------------------------------------------------------

###############################################################################
#		CB,	March 19 2007:
#		Disabled orientation correction for all images with
#		image type "Screen Save"(CRDB00048056)
###############################################################################

#------------------------------------------------------------------------------
# Image Type scope
#------------------------------------------------------------------------------
vDefaultImageTypePropElementID.type = TDicomElementID
vDefaultImageTypePropElementID.m_GroupID = 3711
vDefaultImageTypePropElementID.m_ElementID = 1101
vDefaultImageTypePropElementID.m_ValueIndex = 0
vDefaultImageTypePropElementID.m_IndexInValue = -1
#------------------------------------------------------------------------------
vDefaultScreenSaveElement.type = TDicomElement
vDefaultScreenSaveElement.m_ID = vDefaultImageTypePropElementID
vDefaultScreenSaveElement.m_Value = "Screen Save"
#------------------------------------------------------------------------------
vDefaultScreenSaveScopeEntry.type = TScopeEntry
vDefaultScreenSaveScopeEntry.m_MatchWeight = 30
vDefaultScreenSaveScopeEntry.m_Elements.1 = vDefaultScreenSaveElement
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
vDefaultScreenSaveScope.type = TScope
vDefaultScreenSaveScope.m_Entries.1 = vDefaultScreenSaveScopeEntry
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# We do not apply orientation correction on images of type "Screen Save"
#------------------------------------------------------------------------------
vDefaultScreenSavePres.type           = TInitialPresentationOption
vDefaultScreenSavePres.m_Usage        = eInitialPresentationUsage
vDefaultScreenSavePres.m_Scope        = vDefaultScreenSaveScope
vDefaultScreenSavePres.m_Presentation = vInitialPresentation
vDefaultScreenSavePres.m_Presentation.m_bHasOrientationCorrection = false
vDefaultScreenSavePres.m_Presentation.m_Description = "Screen Save Images"
#------------------------------------------------------------------------------

#########################################################################
#####  Start of ROI Detection Options Additions
#########################################################################

#-----------------------------------------------------------------------
#   Region of Interest (ROI) Detection Options Info
#-----------------------------------------------------------------------
TROITresholdType.type             = enumeration
TROITresholdType.EnumeratorNames  = ( eNoThreshold,                    \
                                      eAbsoluteThreshold,              \
                                      eRelativeThreshold,              \
                                      eLocalMinThreshold,              \
                                      eLinearDiscriminantThreshold,    \
                                      eMidRangeThreshold )

TROITresholdType.EnumeratorValues = (0,1,2,3,4,5)
#-----------------------------------------------------------------------
#-----------------------------------------------------------------------
TROIOptionsInfo.type       = type
TROIOptionsInfo.EntryNames = ( m_bUseShrinkPower,  \
                               m_ShrinkPower,      \
                               m_eThresholdType,   \
                               m_Threshold )
TROIOptionsInfo.EntryTypes = ( bool,               \
                               int,                \
                               TROITresholdType,   \
                               double )
#-----------------------------------------------------------------------

#-----------------------------------------------------------------------
#   Default Non-Scoped Region of Interest (ROI) Detection Options
#-----------------------------------------------------------------------
vDefaultROIOptionsInfo.type              = TROIOptionsInfo
vDefaultROIOptionsInfo.m_bUseShrinkPower = true
vDefaultROIOptionsInfo.m_ShrinkPower     = 4
vDefaultROIOptionsInfo.m_eThresholdType  = eRelativeThreshold
vDefaultROIOptionsInfo.m_Threshold       = 0.01
#-----------------------------------------------------------------------

#-----------------------------------------------------------------------
#   Region of Interest (ROI) Detection Options Info
#-----------------------------------------------------------------------
TROIOptions.type       = type
TROIOptions.EntryNames = ( m_Usage, m_Scope, m_OptionsInfo )
TROIOptions.EntryTypes = ( TUsage, TScope, TROIOptionsInfo )
#-----------------------------------------------------------------------
#   Default Scoped Region of Interest (ROI) Detection Options
#-----------------------------------------------------------------------
vDefaultROIOptions.type          = TROIOptions
vDefaultROIOptions.m_Usage       = eGeneralUsage
vDefaultROIOptions.m_Scope       = vDefaultScope
vDefaultROIOptions.m_OptionsInfo = vDefaultROIOptionsInfo


#-----------------------------------------------------------------------
#  Use Local Min Threshold Algorithm for Premium View Images
#-----------------------------------------------------------------------

#=======================================================================
vAcqDeviceProcessingDescriptionElementID.type           = TDicomElementID
vAcqDeviceProcessingDescriptionElementID.m_GroupID      = 0018
vAcqDeviceProcessingDescriptionElementID.m_ElementID    = 1400
vAcqDeviceProcessingDescriptionElementID.m_ValueIndex   = 0
vAcqDeviceProcessingDescriptionElementID.m_IndexInValue = -1
#=======================================================================
vPremiumViewElement.type    = TDicomElement
vPremiumViewElement.m_ID    = vAcqDeviceProcessingDescriptionElementID
vPremiumViewElement.m_Value = "PREMIUM_VIEW"
#=======================================================================
vPremiumViewScopeEntry.type          = TScopeEntry
vPremiumViewScopeEntry.m_MatchWeight = 100
vPremiumViewScopeEntry.m_Elements.1  = vPremiumViewElement
#=======================================================================
vPremiumViewScope.type                      = TScope
vPremiumViewScope.m_Entries.1               = vMGImageScopeEntry
vPremiumViewScope.m_Entries.1.m_MatchWeight = 100
vPremiumViewScope.m_Entries.2               = vPremiumViewScopeEntry
vPremiumViewScope.m_Entries.2.m_MatchWeight = 100
#=======================================================================

#-----------------------------------------------------------------------
#   Premium View Region of Interest (ROI) Detection Options
#-----------------------------------------------------------------------
vPremiumViewROIOptions.type                           = TROIOptions
vPremiumViewROIOptions.m_Usage                        = eGeneralUsage
vPremiumViewROIOptions.m_Scope                        = vPremiumViewScope
vPremiumViewROIOptions.m_OptionsInfo                  = vDefaultROIOptionsInfo
vPremiumViewROIOptions.m_OptionsInfo.m_eThresholdType = eLocalMinThreshold


#-----------------------------------------------------------------------
#  Use Linear Discriminant Threshold Algorithm for WSD Converted Images
#-----------------------------------------------------------------------


#=======================================================================
vConversionTypeElementID.type           = TDicomElementID
vConversionTypeElementID.m_GroupID      = 0008
vConversionTypeElementID.m_ElementID    = 0064
vConversionTypeElementID.m_ValueIndex   = 0
vConversionTypeElementID.m_IndexInValue = -1
#=======================================================================
vWSDConversionTypeElement.type       = TDicomElement
vWSDConversionTypeElement.m_ID       = vConversionTypeElementID
vWSDConversionTypeElement.m_Value    = "WSD"
#=======================================================================
vWSDConversionScopeEntry.type          = TScopeEntry
vWSDConversionScopeEntry.m_MatchWeight = 100
vWSDConversionScopeEntry.m_Elements.1  = vWSDConversionTypeElement
#=======================================================================
vWSDConversionScope.type                      = TScope
vWSDConversionScope.m_Entries.1               = vMGImageScopeEntry
vWSDConversionScope.m_Entries.1.m_MatchWeight = 200
vWSDConversionScope.m_Entries.2               = vWSDConversionScopeEntry
vWSDConversionScope.m_Entries.2.m_MatchWeight = 200
#=======================================================================

#-----------------------------------------------------------------------
#   Workstation Conversion Images ROI Detection Options
#-----------------------------------------------------------------------
vWSDConversionROIOptions.type                           = TROIOptions
vWSDConversionROIOptions.m_Usage                        = eGeneralUsage
vWSDConversionROIOptions.m_Scope                        = vWSDConversionScope
vWSDConversionROIOptions.m_OptionsInfo                  = vDefaultROIOptionsInfo
vWSDConversionROIOptions.m_OptionsInfo.m_eThresholdType = eLinearDiscriminantThreshold





#########################################################################
#  End of ROI Detection Options Additions
#########################################################################

###############################################################################
# Type definitions for DICOM Overlay Operations
###############################################################################

#------------------------------------------------------------------------------
# Definition of DICOM Overlay selection type
#------------------------------------------------------------------------------
TOverlaySelectionType.type = enumeration
TOverlaySelectionType.EnumeratorNames =  ( eOverlaySelectFirst, eOverlaySelectLast, \
                                           eOverlaySelectNone, eOverlaySelectExplicit )
TOverlaySelectionType.EnumeratorValues = ( 0,1,2,3 )
#------------------------------------------------------------------------------
# eOverlaySelectFirst: select the first DICOM overlay
# eOverlaySelectLast: select the last DICOM overlay
# eOverlaySelectNone: ignore the DICOM overlays
# eOverlaySelectExplicit: select the DICOM overlay at the given index (see below)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# DICOM Overlay selection option type
#------------------------------------------------------------------------------
TOverlaySelectionOption.type = type
TOverlaySelectionOption.EntryNames = ( m_OverlaySelectionType, m_OverlayIndex )
TOverlaySelectionOption.EntryTypes = ( TOverlaySelectionType, int optional default 0 )
#------------------------------------------------------------------------------
# m_OverlaySelectionType: specifies the way of selecting one of the overlays
# m_OverlayIndex : specify the zero-based index of the DICOM overlay
# when m_OverlaySelectionType is of type eOverlaySelectExplicit
#------------------------------------------------------------------------------

#----------------------------------------------------------------------
#  Default non-scoped overlay selection option
#----------------------------------------------------------------------
vDefaultOverlaySelectionOption.type                    = TOverlaySelectionOption
vDefaultOverlaySelectionOption.m_OverlaySelectionType  = eOverlaySelectFirst
vDefaultOverlaySelectionOption.m_OverlayIndex          = 0
#----------------------------------------------------------------------

#----------------------------------------------------------------------
#  Definition of Overlay Selection
#----------------------------------------------------------------------
TOverlaySelection.type       = type
TOverlaySelection.EntryNames = (m_Usage, m_Scope, m_OverlaySelection)
TOverlaySelection.EntryTypes = (TUsage, TScope, TOverlaySelectionOption)
#----------------------------------------------------------------------

###############################################################################
# Annotation subsystem initialization - UI component multilanguage strings
###############################################################################

#------------------------------------------------------------------------------
# Definition of the default multilanguage annotation UI text structure
#------------------------------------------------------------------------------
TLocalizedUIText.type = type
TLocalizedUIText.EntryNames = ( m_sStdDev, m_sPerimeter, m_sAverage, m_sMinimum, m_sMaximum, m_sArea, \
				m_sNormal, m_sProjection, m_sMF, m_sManual, \
				m_sStdDev@ML, m_sPerimeter@ML, m_sAverage@ML, m_sMinimum@ML, m_sMaximum@ML, m_sArea@ML, \
				m_sNormal@ML, m_sProjection@ML, m_sMF@ML,  m_sManual@ML )
TLocalizedUIText.EntryTypes = ( string, string, string, string, string, string, string, string, string, string, \
				multistring, multistring, multistring, multistring, multistring, multistring, \
				multistring, multistring, multistring, multistring )
#------------------------------------------------------------------------------
vLocalizationText.type = TLocalizedUIText
#------------------------------------------------------------------------------
vLocalizationText.m_sStdDev = "StdDev"
vLocalizationText.m_sStdDev@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sStdDev@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sStdDev@ML.m_MLString.1.m_Value = "StdDev"
vLocalizationText.m_sStdDev@ML.m_MLString.2.m_Value = "ÉcartType"
#------------------------------------------------------------------------------
vLocalizationText.m_sPerimeter = "Perim"
vLocalizationText.m_sPerimeter@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sPerimeter@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sPerimeter@ML.m_MLString.1.m_Value = "Perim"
vLocalizationText.m_sPerimeter@ML.m_MLString.2.m_Value = "Périm"
#------------------------------------------------------------------------------
vLocalizationText.m_sAverage = "Avg"
vLocalizationText.m_sAverage@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sAverage@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sAverage@ML.m_MLString.1.m_Value = "Average"
vLocalizationText.m_sAverage@ML.m_MLString.2.m_Value = "Moyenne"
#------------------------------------------------------------------------------
vLocalizationText.m_sMinimum = "Min"
vLocalizationText.m_sMinimum@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sMinimum@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sMinimum@ML.m_MLString.1.m_Value = "Min"
vLocalizationText.m_sMinimum@ML.m_MLString.2.m_Value = "Min"
#------------------------------------------------------------------------------
vLocalizationText.m_sMaximum = "Max"
vLocalizationText.m_sMaximum@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sMaximum@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sMaximum@ML.m_MLString.1.m_Value = "Max"
vLocalizationText.m_sMaximum@ML.m_MLString.2.m_Value = "Max"
#------------------------------------------------------------------------------
vLocalizationText.m_sArea = "Area"
vLocalizationText.m_sArea@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sArea@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sArea@ML.m_MLString.1.m_Value = "Area"
vLocalizationText.m_sArea@ML.m_MLString.2.m_Value = "Aire"
#------------------------------------------------------------------------------
vLocalizationText.m_sNormal = ""
vLocalizationText.m_sNormal@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sNormal@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sNormal@ML.m_MLString.1.m_Value = ""
vLocalizationText.m_sNormal@ML.m_MLString.2.m_Value = ""
#------------------------------------------------------------------------------
vLocalizationText.m_sProjection = "P"
vLocalizationText.m_sProjection@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sProjection@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sProjection@ML.m_MLString.1.m_Value = "P"
vLocalizationText.m_sProjection@ML.m_MLString.2.m_Value = "P"
#------------------------------------------------------------------------------
vLocalizationText.m_sMF = "MP"
vLocalizationText.m_sMF@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sMF@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sMF@ML.m_MLString.1.m_Value = "MP"
vLocalizationText.m_sMF@ML.m_MLString.2.m_Value = "GP"
#------------------------------------------------------------------------------
vLocalizationText.m_sManual = "R"
vLocalizationText.m_sManual@ML.m_MLString.1.m_Language = "ENU"
vLocalizationText.m_sManual@ML.m_MLString.2.m_Language = "FRC"
vLocalizationText.m_sManual@ML.m_MLString.1.m_Value = "R"
vLocalizationText.m_sManual@ML.m_MLString.2.m_Value = "R"
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the 'contains CAD overlay' structure used by HasCADOverlay2( )
#------------------------------------------------------------------------------
TCadBitmapOverlayOptions.type          =   type
TCadBitmapOverlayOptions.EntryNames    = ( m_bContainsCADOverlay )
TCadBitmapOverlayOptions.EntryTypes    = ( bool default FALSE )
#------------------------------------------------------------------------------
# m_bContainsCADOverlay: flag indicating whether or not to treat the accompanying
# scope as though its overlays (if present) contain CAD marks that should be hidden
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the queryable bitmap overlay options object - for CAD overlays
#------------------------------------------------------------------------------
TBitmapOverlayOptions.type             =   type
TBitmapOverlayOptions.EntryNames       = ( m_Usage, m_Scope, m_CadOverlayOptions )
TBitmapOverlayOptions.EntryTypes       = ( TUsage, TScope, TCadBitmapOverlayOptions )
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the CAD Structured Report 'version options' type
#------------------------------------------------------------------------------
TCadSRVersionOptions.type              =   type
TCadSRVersionOptions.EntryNames        = ( m_bVersionSupported )
TCadSRVersionOptions.EntryTypes        = ( bool default FALSE )
#------------------------------------------------------------------------------
# m_bSupportedVersion: flag indicating whether CAD SR with the matching scope
#      is considered a supported version (!should be FALSE for default scope!)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the scopable CAD Structured Report 'supported version' type
#------------------------------------------------------------------------------
TCadSRSupportedVersion.type            =   type
TCadSRSupportedVersion.EntryNames      = ( m_Usage, m_Scope, m_Options )
TCadSRSupportedVersion.EntryTypes      = ( TUsage, TScope, TCadSRVersionOptions )
#------------------------------------------------------------------------------
# mUsage: purpose for which being queried - typically eCadMarkPresentationUsage
# m_Scope: the scope is compared to the attribute collection from the SR object
# m_Options: structure specifying whether or not this scope is supported CAD SR
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the merge policies available for grouping multiple SR properties
#------------------------------------------------------------------------------
TCadSRMergeOperator.type               =   enumeration
TCadSRMergeOperator.EnumeratorNames    = ( ePolicyAccumulate, \
                                           ePolicyConcatenate, \
                                           ePolicyOverwrite )
TCadSRMergeOperator.EnumeratorValues   = ( 0, 1, 2 )
#------------------------------------------------------------------------------
# ePolicyAccumulate: when specified, relevant numeric properties will be summed
# ePolicyConcatenate: when specified, relevant text values will be concatenated
# ePolicyOverwrite: when specified the value from the last valid loaded SR wins
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the property-level merge policy type (for CAD related stuff)
#------------------------------------------------------------------------------
TCadPropertyMergePolicy.type           =   type
TCadPropertyMergePolicy.EntryNames     = ( m_eMergePolicy, m_sPropertyKey )
TCadPropertyMergePolicy.EntryTypes     = ( TCadSRMergeOperator, string )
#------------------------------------------------------------------------------
# m_eMergePolicy: ePolicyAccumulate or ePolicyConcatenate or ePolicyOverwrite
# m_sPropertyKey: literal key from the internal ISG dictionary that corresponds
#      to the current property (ie. "#densities") paired with ePolicyAccumulate
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the report-level merge policy type (for CAD SR related stuff)
#------------------------------------------------------------------------------
TCadSRMergePolicies.type               =   type
TCadSRMergePolicies.EntryNames         = ( m_eMergePolicy, m_nPropertyPolicies, \
                                           m_vPropertyPolicies )
TCadSRMergePolicies.EntryTypes         = ( TCadSRMergeOperator, int default 0, \
                                           vector TCadPropertyMergePolicy )
#------------------------------------------------------------------------------
# m_eMergePolicy: ePolicyAccumulate or ePolicyConcatenate or ePolicyOverwrite
#      this affects how the system behaves when multiple SR objects are loaded
# m_nPropertyPolicies: the number of individual property policies in the vector
# m_vPropertyPolicies: the vector containing individual property merge policies
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the CAD Single Image Finding tooltip-contents extraction policy
#------------------------------------------------------------------------------
# This enumeration dictates how the accompanying list of codevalue keys will be
# treated when composing collection of single image findings in the CAD manager
#
# POLICY               when a list of code values and abbreviations is present:
# eTooltipsShowAll  - all tooltips will be shown regardless of whats in the list
# eTooltipsShowList - only values specified in the list will have their contents shown
# eTooltipsHideList - only values NOT specified in the list will have their contents shown
# eTooltipsHideAll  - none of the tooltip info will be displayed for corresponding mark type
#------------------------------------------------------------------------------
TTooltipExtractionRule.type             =   enumeration
TTooltipExtractionRule.EnumeratorNames  = ( eTooltipsShowAll, eTooltipsShowList, \
                                            eTooltipsHideList, eTooltipsHideAll )
TTooltipExtractionRule.EnumeratorValues = ( 0, 1, 2, 3 )
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the CAD Single Image Finding expected mark types
#------------------------------------------------------------------------------
# This enumeration is the switch for any of the CAD mark-type specific options:
#
#                         any options set for this type will apply to:
# eUnknownFinding       - default (applies to all other types not specified)
# eDensityFinding       - single image findings of type 'density' or 'mass'
# eClusterFinding       - single image findings of type 'calcification cluster'
# eMaCalFinding         - composite findings of type 'mass with calcifications'
#                       - only contains one density and a group of clusters
# eCalcificationFinding - single image subfindings of type 'calcification'
#------------------------------------------------------------------------------
TCadMarkFindingType.type               =   enumeration
TCadMarkFindingType.EnumeratorNames    = ( eUnknownFinding, eDensityFinding, \
                                           eClusterFinding, eMaCalFinding, \
                                           eCalcificationFinding )
TCadMarkFindingType.EnumeratorValues   = ( 0, 1, 2, 3, 4 )
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the entries that should be displayed during CAD tooltip hover
#------------------------------------------------------------------------------
TCadMarkTooltipField.type              =   type
TCadMarkTooltipField.EntryNames        = ( m_sCodeValue, m_bHasAbbreviation, \
                                           m_sAbbreviation, m_sAbbreviation@ML )
TCadMarkTooltipField.EntryTypes        = ( string, bool default FALSE, \
                                           string optional, multistring optional )
#------------------------------------------------------------------------------
# m_sCodeValue: code value as appears in the SR (or derived MIG property keyword)
# m_bHasAbbreviation: when TRUE the abbreviation displays instead of code meaning
# m_sAbbreviation: the default short-text to appear on the GUI with this property
# m_sAbbreviation@ML: the localized short-text to appear on the GUI (iff TRUE)
#      when m_bHasAbbreviation == FALSE, the corresponding code meaning is used
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the tooltip entries that should be displayed per CAD mark type
#------------------------------------------------------------------------------
TCadMarkTooltipsPerMark.type           =   type
TCadMarkTooltipsPerMark.EntryNames     = ( m_eFindingType, m_eExtractionRule, \
                                           m_nTooltipFields, m_vTooltipFields )
TCadMarkTooltipsPerMark.EntryTypes     = ( TCadMarkFindingType default eUnknownFinding, \
                                           TTooltipExtractionRule default eTooltipsShowAll, \
                                           int default 0, vector TCadMarkTooltipField )
#------------------------------------------------------------------------------
# m_eFindingType: the type of cadmark finding to which these tooltip rules apply
# m_eExtractionRule: can be one of {'ShowAll', 'ShowList', 'HideAll', 'HideList'}
# m_nTooltipFields: the number of items in the corresponding tooltip fields vector
# m_vTooltipFields: the vector of shown items (ShowList) or hidden items (HideList)
#
##############################################################################
#
#  PLEASE NOTE : Regardless of the setting of the Tooltip Extraction Rule
#  m_eExtractionRule or Number of Tooltip Fields m_nTooltipFields at most
#  nine CAD mark tooltip items will be displayed. (CR 79134)
#
##############################################################################
#
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The complete definition of tooltip contents for all cad mark types in a study
#------------------------------------------------------------------------------
TCadMarkTooltipContents.type           =   type
TCadMarkTooltipContents.EntryNames     = ( m_nCadMarkTooltips, m_vCadMarkTooltips )
TCadMarkTooltipContents.EntryTypes     = ( int default 0, vector TCadMarkTooltipsPerMark )
#------------------------------------------------------------------------------
# m_nCadMarkTooltips: the number of cadmark types for which tooltips are specified
# m_vCadMarkTooltips: vector of cadmark tooltip rules for each specific type of mark
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the scopable CAD mark tooltips contents for a particular vendor
#------------------------------------------------------------------------------
TCadMarkTooltipOptions.type            =   type
TCadMarkTooltipOptions.EntryNames      = ( m_Usage, m_Scope, m_TooltipContents )
TCadMarkTooltipOptions.EntryTypes      = ( TUsage, TScope, TCadMarkTooltipContents )
#------------------------------------------------------------------------------
# m_Usage: purpose of the query - typically this value is eCadMarkPresentationUsage
# m_Scope: the scope of CAD SR images to which the accompanying tooltip rules apply
#      (it's possible to include/exclude specific text depending on vendor name etc)
# m_TooltipContents: tooltip content object which contains a vector of rules by type
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the font properties used during rendering of CAD mark tooltips
#------------------------------------------------------------------------------
TFontProperties.type                   =   type
TFontProperties.EntryNames             = ( m_sFontName, m_nPointSize, m_nTextColor, \
                                           m_bHasBackgroundColor, m_nBackgroundColor )
TFontProperties.EntryTypes             = ( string, int default 14, huint default 00FFFFFF, \
                                           bool default FALSE, huint default 00000000 )
#------------------------------------------------------------------------------
# m_sFontName: name of the font - this should be "Arial" for the MIG products
# m_nPointSize: the height of the font on screen in points, it does not scale
# m_bHasBackgroundColor: if TRUE then the text background is first painted with
# m_nBackgroundColor: the color of the background brush, before adding the text
# m_nTextColor: the color of the text (foreground)
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the minimum set of graphic properties used to render a CAD mark
#------------------------------------------------------------------------------
TGraphicProperties.type                =   type
TGraphicProperties.EntryNames          = ( m_nThickness, m_nLineColor, \
                                           m_bHasFillColor, m_nFillColor )
TGraphicProperties.EntryTypes          = ( int default 0, huint default 00FFFFFFFF, \
                                           bool default FALSE, huint default 00000000 )
#------------------------------------------------------------------------------
# m_nThickness: the thickness of the pen used to draw the CAD mark's border
# m_nLineColor: the color of the pen used to draw the CAD mark's border
# m_bHasFillColor: if TRUE the enclosed polygon of the CAD mark is filled using
# m_nFillColor: the color of the fill brush
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the graphic properties for each CAD mark by mark type
#------------------------------------------------------------------------------
TCadMarkDescription.type               =   type
TCadMarkDescription.EntryNames         = ( m_eFindingType, m_xCentroidProperties, \
                                           m_xOutlineProperties, m_xFontProperties, \
                                           m_bHasMinDisplaySize, m_dMinDisplaySize, \
                                           m_bHideOutline )
TCadMarkDescription.EntryTypes         = ( TCadMarkFindingType, TGraphicProperties, \
                                           TGraphicProperties, TFontProperties, \
                                           bool default FALSE, double default 0.00, \
                                           bool default FALSE )
#------------------------------------------------------------------------------
# m_eFindingType: type of cadmark finding to which the graphic properties apply
# m_xCentroidProperties: the graphic properties for this mark type in centroid mode
# m_xOutlineProperties: the graphic properties for this mark type in outline mode
# m_xFontProperties: the font properties for this mark type (mode independent)
# m_bHasMinDisplaySize: if TRUE then individual calcification cad mark will appear
#      at no less than the specified minimum size - this variable also controls
#      the size of the remaining cadmark types when displayed in centroid mode
# m_dMinDisplaySize: the minimum screen (output space) size in millimeters
# m_bHideOutline: if TRUE the outline of the corresponding mark type will not
#      appear when the CAD mark presentation mode is switched to 'outline'
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the collection of CAD mark presentation options per mark type
#------------------------------------------------------------------------------
TCadMarkPresentationOptions.type       =   type
TCadMarkPresentationOptions.EntryNames = ( m_nCadMarkDescriptor, m_vCadMarkDescriptor )
TCadMarkPresentationOptions.EntryTypes = ( int default 0, vector TCadMarkDescription )
#------------------------------------------------------------------------------
# m_nCadMarkDescriptor: the number of descriptors - should be one per mark type
# m_vCadMarkDescriptor: the vector of display property descriptions
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of the default Font Properties for the default cadmark tooltips
#------------------------------------------------------------------------------
vDefaultCadFontProperties.type                                =  TFontProperties
vDefaultCadFontProperties.m_sFontName                         =  "Arial"
vDefaultCadFontProperties.m_nTextColor                        =  00FFFFFF
vDefaultCadFontProperties.m_nBackgroundColor                  =  00000000
vDefaultCadFontProperties.m_bHasBackgroundColor               =  FALSE
vDefaultCadFontProperties.m_nPointSize                        =  12
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of default graphic properties for cadmarks displayed in centroid mode
#------------------------------------------------------------------------------
vDefaultCentroidProperties.type                               =  TGraphicProperties
vDefaultCentroidProperties.m_nLineColor                       =  00FFFFFF
vDefaultCentroidProperties.m_nFillColor                       =  00000000
vDefaultCentroidProperties.m_bHasFillColor                    =  TRUE
vDefaultCentroidProperties.m_nThickness                       =  0
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of default graphic properties for cadmarks displayed in outline mode
#------------------------------------------------------------------------------
vDefaultOutlineProperties.type                                =  TGraphicProperties
vDefaultOutlineProperties.m_nLineColor                        =  00FFFFFF
vDefaultOutlineProperties.m_nFillColor                        =  00000000
vDefaultOutlineProperties.m_bHasFillColor                     =  FALSE
vDefaultOutlineProperties.m_nThickness                        =  3
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of default graphic properties for individual calcification marks
#------------------------------------------------------------------------------
vDefaultCalcificationOutlineProperties.type                                =  TGraphicProperties
vDefaultCalcificationOutlineProperties.m_nLineColor                        =  00FFFFFF
vDefaultCalcificationOutlineProperties.m_nFillColor                        =  00FFFFFF
vDefaultCalcificationOutlineProperties.m_bHasFillColor                     =  TRUE
vDefaultCalcificationOutlineProperties.m_nThickness                        =  0
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The default display properties for CAD marks of type 'density'
#------------------------------------------------------------------------------
vDefaultDensityDescription.type                               =  TCadMarkDescription
vDefaultDensityDescription.m_eFindingType                     =  eDensityFinding
vDefaultDensityDescription.m_xCentroidProperties              =  vDefaultCentroidProperties
vDefaultDensityDescription.m_xOutlineProperties               =  vDefaultOutlineProperties
vDefaultDensityDescription.m_xFontProperties                  =  vDefaultCadFontProperties
vDefaultDensityDescription.m_bHasMinDisplaySize                        =  TRUE
# The display size of a 'density' mark in centroid mode
vDefaultDensityDescription.m_dMinDisplaySize                           =  5.00
vDefaultDensityDescription.m_bHideOutline                              =  FALSE
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The default display properties for CAD marks of type 'calcification cluster'
#------------------------------------------------------------------------------
vDefaultClusterDescription.type                               =  TCadMarkDescription
vDefaultClusterDescription.m_eFindingType                     =  eClusterFinding
vDefaultClusterDescription.m_xCentroidProperties              =  vDefaultCentroidProperties
vDefaultClusterDescription.m_xOutlineProperties               =  vDefaultOutlineProperties
vDefaultClusterDescription.m_xFontProperties                  =  vDefaultCadFontProperties
vDefaultClusterDescription.m_bHasMinDisplaySize                        =  TRUE
# The display size of a 'calcification cluster' mark in centroid mode
vDefaultClusterDescription.m_dMinDisplaySize                           =  5.00
vDefaultClusterDescription.m_bHideOutline                              =  TRUE
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The default display properties for CAD marks of type 'mass with calcifications'
#------------------------------------------------------------------------------
vDefaultMaCalDescription.type                             =  TCadMarkDescription
vDefaultMaCalDescription.m_eFindingType                   =  eMaCalFinding
vDefaultMaCalDescription.m_xCentroidProperties            =  vDefaultCentroidProperties
vDefaultMaCalDescription.m_xOutlineProperties             =  vDefaultOutlineProperties
vDefaultMaCalDescription.m_xFontProperties                =  vDefaultCadFontProperties
vDefaultMaCalDescription.m_bHasMinDisplaySize                      =  TRUE
# The display size of a 'mass with calcifications' mark in centroid mode
vDefaultMaCalDescription.m_dMinDisplaySize                         =  5.00
vDefaultMaCalDescription.m_bHideOutline                            =  FALSE
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The default display properties for CAD marks of type 'individual calcification'
#------------------------------------------------------------------------------
vDefaultCalcificationDescription.type                         =  TCadMarkDescription
vDefaultCalcificationDescription.m_eFindingType               =  eCalcificationFinding
vDefaultCalcificationDescription.m_xCentroidProperties        =  vDefaultCentroidProperties
vDefaultCalcificationDescription.m_xOutlineProperties         =  vDefaultCalcificationOutlineProperties
vDefaultCalcificationDescription.m_xFontProperties            =  vDefaultCadFontProperties
vDefaultCalcificationDescription.m_bHasMinDisplaySize                  =  TRUE
# The minimum display size of a 'individual calcification' mark in outline mode
# If the mark is smaller than this size, render a circle with diameter of this size,
# and the center point would be the centroid mark of this individual calcification
vDefaultCalcificationDescription.m_dMinDisplaySize                     =  0.7
vDefaultCalcificationDescription.m_bHideOutline                        =  FALSE
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The default grouping of display properties for all supported CAD mark types
#------------------------------------------------------------------------------
vCadMarkPresentation.type                                     =  TCadMarkPresentationOptions
vCadMarkPresentation.m_vCadMarkDescriptor.1                   =  vDefaultDensityDescription
vCadMarkPresentation.m_vCadMarkDescriptor.2                   =  vDefaultClusterDescription
vCadMarkPresentation.m_vCadMarkDescriptor.3                   =  vDefaultMaCalDescription
vCadMarkPresentation.m_vCadMarkDescriptor.4                   =  vDefaultCalcificationDescription
vCadMarkPresentation.m_nCadMarkDescriptor                     =  4
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Default policy for when multiple CAD structured reports exist (override in site)
#------------------------------------------------------------------------------
vCadMergePolicies.type                              =  TCadSRMergePolicies
vCadMergePolicies.m_eMergePolicy                    =  ePolicyAccumulate
vCadMergePolicies.m_nPropertyPolicies               =  6
#------------------------------------------------------------------------------
vCadMergePolicies.m_vPropertyPolicies.1.m_sPropertyKey = "manufacturer name"
vCadMergePolicies.m_vPropertyPolicies.1.m_eMergePolicy = ePolicyConcatenate
#------------------------------------------------------------------------------
vCadMergePolicies.m_vPropertyPolicies.2.m_sPropertyKey = "software version"
vCadMergePolicies.m_vPropertyPolicies.2.m_eMergePolicy = ePolicyConcatenate
#------------------------------------------------------------------------------
vCadMergePolicies.m_vPropertyPolicies.3.m_sPropertyKey = "#findings"
vCadMergePolicies.m_vPropertyPolicies.3.m_eMergePolicy = ePolicyAccumulate
#------------------------------------------------------------------------------
vCadMergePolicies.m_vPropertyPolicies.4.m_sPropertyKey = "#densities"
vCadMergePolicies.m_vPropertyPolicies.4.m_eMergePolicy = ePolicyAccumulate
#------------------------------------------------------------------------------
vCadMergePolicies.m_vPropertyPolicies.5.m_sPropertyKey = "#calclusters"
vCadMergePolicies.m_vPropertyPolicies.5.m_eMergePolicy = ePolicyAccumulate
#------------------------------------------------------------------------------
vCadMergePolicies.m_vPropertyPolicies.6.m_sPropertyKey = "#composites"
vCadMergePolicies.m_vPropertyPolicies.6.m_eMergePolicy = ePolicyAccumulate
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# The default CAD Structure Reports supported versions scope is 'unsupported'
#------------------------------------------------------------------------------
vDefaultVersionOptions.type                         =  TCadSRVersionOptions
#------------------------------------------------------------------------------
vDefaultCadVersions.type                            =  TCadSRSupportedVersion
vDefaultCadVersions.m_Usage                         =  eCadMarkPresentationUsage
vDefaultCadVersions.m_Scope                         =  vDefaultScope
vDefaultCadVersions.m_Options                       =  vDefaultVersionOptions
vDefaultCadVersions.m_Options.m_bVersionSupported   =  FALSE
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Default CAD Bitmap Overlay options, all mammo images assumed to contain CAD.
#------------------------------------------------------------------------------
vMGCadOverlayOptions.type                      =  TBitmapOverlayOptions
vMGCadOverlayOptions.m_Usage                   =  eCadMarkPresentationUsage
vMGCadOverlayOptions.m_Scope                   =  vMGImageScope

#------------------------------------------------------------------------------
vMGCadOverlayOptions.m_CadOverlayOptions.m_bContainsCADOverlay = TRUE

#------------------------------------------------------------------------------
vDefaultCadOverlayOptions.type                      =  TBitmapOverlayOptions
vDefaultCadOverlayOptions.m_Usage                   =  eCadMarkPresentationUsage
vDefaultCadOverlayOptions.m_Scope                   =  vDefaultScope

#------------------------------------------------------------------------------
vDefaultCadOverlayOptions.m_CadOverlayOptions.m_bContainsCADOverlay = FALSE

// CAD MARK FEATURE - TEST CONSTUCTS

#------------------------------------------------------------------------------
viCadDefaultTooltips.type                                                           =  TCadMarkTooltipsPerMark
viCadDefaultTooltips.m_eFindingType                                                 =  eUnknownFinding
viCadDefaultTooltips.m_eExtractionRule                                              =  eTooltipsShowList
viCadDefaultTooltips.m_nTooltipFields                                               =  2
#---------------------------------------------------------------------------->>
viCadDefaultTooltips.m_vTooltipFields.1.m_sCodeValue                                =  "111001"
viCadDefaultTooltips.m_vTooltipFields.1.m_bHasAbbreviation                          =  TRUE
viCadDefaultTooltips.m_vTooltipFields.1.m_sAbbreviation                             =  "LOCALIZATION FAILED"
viCadDefaultTooltips.m_vTooltipFields.1.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
viCadDefaultTooltips.m_vTooltipFields.1.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
viCadDefaultTooltips.m_vTooltipFields.1.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Algorithm Name"
viCadDefaultTooltips.m_vTooltipFields.1.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Nom de l'algorithme"
#---------------------------------------------------------------------------->>
viCadDefaultTooltips.m_vTooltipFields.2.m_sCodeValue                                =  "111003"
viCadDefaultTooltips.m_vTooltipFields.2.m_bHasAbbreviation                          =  TRUE
viCadDefaultTooltips.m_vTooltipFields.2.m_sAbbreviation                             =  "LOCALIZATION FAILED"
viCadDefaultTooltips.m_vTooltipFields.2.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
viCadDefaultTooltips.m_vTooltipFields.2.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
viCadDefaultTooltips.m_vTooltipFields.2.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Algorithm Version"
viCadDefaultTooltips.m_vTooltipFields.2.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Version de l'algorithme"
#---------------------------------------------------------------------------->>
#Please note that since m_nTooltipFields is set to 2, the rest of the code value listed here are just for reference
#viCadDefaultTooltips.m_vTooltipFields.3.m_sCodeValue                                =  "111038"
#viCadDefaultTooltips.m_vTooltipFields.3.m_bHasAbbreviation                          =  TRUE
#viCadDefaultTooltips.m_vTooltipFields.3.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#viCadDefaultTooltips.m_vTooltipFields.3.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#viCadDefaultTooltips.m_vTooltipFields.3.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#viCadDefaultTooltips.m_vTooltipFields.3.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Number of Calcifications"
#viCadDefaultTooltips.m_vTooltipFields.3.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Nombre de calcifications"
#---------------------------------------------------------------------------->>
#viCadDefaultTooltips.m_vTooltipFields.4.m_sCodeValue                                =  "111012"
#viCadDefaultTooltips.m_vTooltipFields.4.m_bHasAbbreviation                          =  TRUE
#viCadDefaultTooltips.m_vTooltipFields.4.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#viCadDefaultTooltips.m_vTooltipFields.4.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#viCadDefaultTooltips.m_vTooltipFields.4.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#viCadDefaultTooltips.m_vTooltipFields.4.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Certainty of Finding"
#viCadDefaultTooltips.m_vTooltipFields.4.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Certitude de l'observation"
#---------------------------------------------------------------------------->>
#viCadDefaultTooltips.m_vTooltipFields.5.m_sCodeValue                                =  "111046"
#viCadDefaultTooltips.m_vTooltipFields.5.m_bHasAbbreviation                          =  TRUE
#viCadDefaultTooltips.m_vTooltipFields.5.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#viCadDefaultTooltips.m_vTooltipFields.5.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#viCadDefaultTooltips.m_vTooltipFields.5.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#viCadDefaultTooltips.m_vTooltipFields.5.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Percent Glandular Tissue"
#viCadDefaultTooltips.m_vTooltipFields.5.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Pourcentage de tissu glandulaire"
#---------------------------------------------------------------------------->>
#viCadDefaultTooltips.m_vTooltipFields.6.m_sCodeValue                                =  "111071"
#viCadDefaultTooltips.m_vTooltipFields.6.m_bHasAbbreviation                          =  TRUE
#viCadDefaultTooltips.m_vTooltipFields.6.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#viCadDefaultTooltips.m_vTooltipFields.6.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#viCadDefaultTooltips.m_vTooltipFields.6.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#viCadDefaultTooltips.m_vTooltipFields.6.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "CAD Operating Point"
#viCadDefaultTooltips.m_vTooltipFields.6.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Point actif du CAD"
#---------------------------------------------------------------------------->>
#viCadDefaultTooltips.m_vTooltipFields.7.m_sCodeValue                                =  "111088"
#viCadDefaultTooltips.m_vTooltipFields.7.m_bHasAbbreviation                          =  TRUE
#viCadDefaultTooltips.m_vTooltipFields.7.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#viCadDefaultTooltips.m_vTooltipFields.7.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#viCadDefaultTooltips.m_vTooltipFields.7.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#viCadDefaultTooltips.m_vTooltipFields.7.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Case Sensitivity"
#viCadDefaultTooltips.m_vTooltipFields.7.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Sensibilité de cas"
#---------------------------------------------------------------------------->>
#viCadDefaultTooltips.m_vTooltipFields.8.m_sCodeValue                                =  "111089"
#viCadDefaultTooltips.m_vTooltipFields.8.m_bHasAbbreviation                          =  TRUE
#viCadDefaultTooltips.m_vTooltipFields.8.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#viCadDefaultTooltips.m_vTooltipFields.8.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#viCadDefaultTooltips.m_vTooltipFields.8.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#viCadDefaultTooltips.m_vTooltipFields.8.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Lesion Sensitivity"
#viCadDefaultTooltips.m_vTooltipFields.8.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Sensibilité de lésion"
#------------------------------------------------------------------------------
viCADDefaultTooltipContents.type                                                    =  TCadMarkTooltipContents
viCADDefaultTooltipContents.m_vCadMarkTooltips.1                                    =  viCadDefaultTooltips
viCADDefaultTooltipContents.m_nCadMarkTooltips                                      =  1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
vR2DefaultTooltips.type                             =  TCadMarkTooltipsPerMark
vR2DefaultTooltips.m_eFindingType                   =  eUnknownFinding
vR2DefaultTooltips.m_eExtractionRule                =  eTooltipsShowList
vR2DefaultTooltips.m_nTooltipFields                 =  2
#---------------------------------------------------------------------------->>
vR2DefaultTooltips.m_vTooltipFields.1.m_sCodeValue                                =  "111001"
vR2DefaultTooltips.m_vTooltipFields.1.m_bHasAbbreviation                          =  TRUE
vR2DefaultTooltips.m_vTooltipFields.1.m_sAbbreviation                             =  "LOCALIZATION FAILED"
vR2DefaultTooltips.m_vTooltipFields.1.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
vR2DefaultTooltips.m_vTooltipFields.1.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
vR2DefaultTooltips.m_vTooltipFields.1.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Algorithm Name"
vR2DefaultTooltips.m_vTooltipFields.1.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Nom de l'algorithme"
#---------------------------------------------------------------------------->>
vR2DefaultTooltips.m_vTooltipFields.2.m_sCodeValue                                =  "111003"
vR2DefaultTooltips.m_vTooltipFields.2.m_bHasAbbreviation                          =  TRUE
vR2DefaultTooltips.m_vTooltipFields.2.m_sAbbreviation                             =  "LOCALIZATION FAILED"
vR2DefaultTooltips.m_vTooltipFields.2.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
vR2DefaultTooltips.m_vTooltipFields.2.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
vR2DefaultTooltips.m_vTooltipFields.2.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Algorithm Version"
vR2DefaultTooltips.m_vTooltipFields.2.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Version de l'algorithme"
#---------------------------------------------------------------------------->>
#Please note that since m_nTooltipFields is set to 2, the rest of the code value listed here are just for reference
#vR2DefaultTooltips.m_vTooltipFields.3.m_sCodeValue                                =  "111038"
#vR2DefaultTooltips.m_vTooltipFields.3.m_bHasAbbreviation                          =  TRUE
#vR2DefaultTooltips.m_vTooltipFields.3.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#vR2DefaultTooltips.m_vTooltipFields.3.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#vR2DefaultTooltips.m_vTooltipFields.3.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#vR2DefaultTooltips.m_vTooltipFields.3.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Number of Calcifications"
#vR2DefaultTooltips.m_vTooltipFields.3.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Nombre de calcifications"
#---------------------------------------------------------------------------->>
#vR2DefaultTooltips.m_vTooltipFields.4.m_sCodeValue                                =  "111012"
#vR2DefaultTooltips.m_vTooltipFields.4.m_bHasAbbreviation                          =  TRUE
#vR2DefaultTooltips.m_vTooltipFields.4.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#vR2DefaultTooltips.m_vTooltipFields.4.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#vR2DefaultTooltips.m_vTooltipFields.4.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#vR2DefaultTooltips.m_vTooltipFields.4.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Certainty of Finding"
#vR2DefaultTooltips.m_vTooltipFields.4.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Certitude de l'observation"
#---------------------------------------------------------------------------->>
#vR2DefaultTooltips.m_vTooltipFields.5.m_sCodeValue                                =  "111046"
#vR2DefaultTooltips.m_vTooltipFields.5.m_bHasAbbreviation                          =  TRUE
#vR2DefaultTooltips.m_vTooltipFields.5.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#vR2DefaultTooltips.m_vTooltipFields.5.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#vR2DefaultTooltips.m_vTooltipFields.5.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#vR2DefaultTooltips.m_vTooltipFields.5.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Percent Glandular Tissue"
#vR2DefaultTooltips.m_vTooltipFields.5.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Pourcentage de tissu glandulaire"
#---------------------------------------------------------------------------->>
#vR2DefaultTooltips.m_vTooltipFields.6.m_sCodeValue                                =  "111071"
#vR2DefaultTooltips.m_vTooltipFields.6.m_bHasAbbreviation                          =  TRUE
#vR2DefaultTooltips.m_vTooltipFields.6.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#vR2DefaultTooltips.m_vTooltipFields.6.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#vR2DefaultTooltips.m_vTooltipFields.6.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#vR2DefaultTooltips.m_vTooltipFields.6.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "CAD Operating Point"
#vR2DefaultTooltips.m_vTooltipFields.6.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Point actif du CAD"
#---------------------------------------------------------------------------->>
#vR2DefaultTooltips.m_vTooltipFields.7.m_sCodeValue                                =  "111088"
#vR2DefaultTooltips.m_vTooltipFields.7.m_bHasAbbreviation                          =  TRUE
#vR2DefaultTooltips.m_vTooltipFields.7.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#vR2DefaultTooltips.m_vTooltipFields.7.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#vR2DefaultTooltips.m_vTooltipFields.7.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#vR2DefaultTooltips.m_vTooltipFields.7.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Case Sensitivity"
#vR2DefaultTooltips.m_vTooltipFields.7.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Sensibilité de cas"
#---------------------------------------------------------------------------->>
#vR2DefaultTooltips.m_vTooltipFields.8.m_sCodeValue                                =  "111089"
#vR2DefaultTooltips.m_vTooltipFields.8.m_bHasAbbreviation                          =  TRUE
#vR2DefaultTooltips.m_vTooltipFields.8.m_sAbbreviation                             =  "LOCALIZATION FAILED"
#vR2DefaultTooltips.m_vTooltipFields.8.m_sAbbreviation@ML.m_MLString.1.m_Language  =  "ENU"
#vR2DefaultTooltips.m_vTooltipFields.8.m_sAbbreviation@ML.m_MLString.2.m_Language  =  "FRC"
#vR2DefaultTooltips.m_vTooltipFields.8.m_sAbbreviation@ML.m_MLString.1.m_Value     =  "Lesion Sensitivity"
#vR2DefaultTooltips.m_vTooltipFields.8.m_sAbbreviation@ML.m_MLString.2.m_Value     =  "Sensibilité de lésion"
#------------------------------------------------------------------------------
vR2DefaultTooltipContents.type                      =  TCadMarkTooltipContents
vR2DefaultTooltipContents.m_vCadMarkTooltips.1      =  vR2DefaultTooltips
vR2DefaultTooltipContents.m_nCadMarkTooltips        =  1
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of an iCAD scope for config testing purposes
#------------------------------------------------------------------------------
viCadMammoElement.type                              =  TDicomElement
viCadMammoElement.m_ID                              =  vManufacturerNameElementID
viCadMammoElement.m_Value                           =  "iCAD, Inc."

#------------------------------------------------------------------------------
viCadMammoVersionElement1.type                              =  TDicomElement
viCadMammoVersionElement1.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement1.m_Value                           =  "7.0-M"
#------------------------------------------------------------------------------
viCadMammoVersionElement2.type                              =  TDicomElement
viCadMammoVersionElement2.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement2.m_Value                           =  "7.2-H"
#------------------------------------------------------------------------------
viCadMammoVersionElement3.type                              =  TDicomElement
viCadMammoVersionElement3.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement3.m_Value                           =  "7.2-M"
#------------------------------------------------------------------------------
viCadMammoVersionElement4.type                              =  TDicomElement
viCadMammoVersionElement4.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement4.m_Value                           =  "7.2-H+"
#------------------------------------------------------------------------------
viCadMammoVersionElement5.type                              =  TDicomElement
viCadMammoVersionElement5.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement5.m_Value                           =  "7.2-M+"
#------------------------------------------------------------------------------
viCadMammoVersionElement6.type                              =  TDicomElement
viCadMammoVersionElement6.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement6.m_Value                           =  "Premier-D"
#------------------------------------------------------------------------------
viCadMammoVersionElement7.type                              =  TDicomElement
viCadMammoVersionElement7.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement7.m_Value                           =  "Premier-H"
#------------------------------------------------------------------------------
viCadMammoVersionElement8.type                              =  TDicomElement
viCadMammoVersionElement8.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement8.m_Value                           =  "Premier-S"
#------------------------------------------------------------------------------
viCadMammoVersionElement9.type                              =  TDicomElement
viCadMammoVersionElement9.m_ID                              =  vCadSRVersionElementID
viCadMammoVersionElement9.m_Value                           =  "Premier-M"
#------------------------------------------------------------------------------


#------------------------------------------------------------------------------
viCadMammoScopeEntry.type                           =  TScopeEntry
viCadMammoScopeEntry.m_Elements.1                   =  viCadMammoElement
viCadMammoScopeEntry.m_MatchWeight                  =  10
#------------------------------------------------------------------------------
viCadMammoScopeVersionEntry.type                    =  TScopeEntry
viCadMammoScopeVersionEntry.m_Elements.1            =  viCadMammoVersionElement1
viCadMammoScopeVersionEntry.m_Elements.2            =  viCadMammoVersionElement2
viCadMammoScopeVersionEntry.m_Elements.3            =  viCadMammoVersionElement3
viCadMammoScopeVersionEntry.m_Elements.4            =  viCadMammoVersionElement4
viCadMammoScopeVersionEntry.m_Elements.5            =  viCadMammoVersionElement5
viCadMammoScopeVersionEntry.m_Elements.6            =  viCadMammoVersionElement6
viCadMammoScopeVersionEntry.m_Elements.7            =  viCadMammoVersionElement7
viCadMammoScopeVersionEntry.m_Elements.8            =  viCadMammoVersionElement8
viCadMammoScopeVersionEntry.m_Elements.9            =  viCadMammoVersionElement9
viCadMammoScopeVersionEntry.m_MatchWeight           =  10
#------------------------------------------------------------------------------
viCadMammoScopeSR.type                              =  TScope
viCadMammoScopeSR.m_Entries.1                       =  vSRImageScopeEntry
viCadMammoScopeSR.m_Entries.2                       =  viCadMammoScopeEntry
viCadMammoScopeSR.m_Entries.3                       =  viCadMammoScopeVersionEntry
#------------------------------------------------------------------------------
viCadMammoScopeMG.type                              =  TScope
viCadMammoScopeMG.m_Entries.1                       =  vCTImageScopeEntry
#------------------------------------------------------------------------------
viCadTooltipSpecification.type                      =  TCadMarkTooltipOptions
viCadTooltipSpecification.m_Usage                   =  eCadMarkPresentationUsage
viCadTooltipSpecification.m_Scope                   =  viCadMammoScopeSR
viCadTooltipSpecification.m_TooltipContents         =  viCADDefaultTooltipContents
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Definition of an R2 scope for config testing purposes
#------------------------------------------------------------------------------
vR2MammoElement.type                                =  TDicomElement
vR2MammoElement.m_ID                                =  vManufacturerNameElementID
vR2MammoElement.m_Value                             =  "R2 Technology, Inc."

#------------------------------------------------------------------------------
vR2MammoVersionElement1.type                        =  TDicomElement
vR2MammoVersionElement1.m_ID                        =  vCadSRVersionElementID
vR2MammoVersionElement1.m_Value                     =  "1.2.0.27"
#------------------------------------------------------------------------------
vR2MammoVersionElement2.type                        =  TDicomElement
vR2MammoVersionElement2.m_ID                        =  vCadSRVersionElementID
vR2MammoVersionElement2.m_Value                     =  "1.5.0.36"
#------------------------------------------------------------------------------
vR2MammoVersionElement3.type                        =  TDicomElement
vR2MammoVersionElement3.m_ID                        =  vCadSRVersionElementID
vR2MammoVersionElement3.m_Value                     =  "1.5.0.42"
#------------------------------------------------------------------------------
vR2MammoVersionElement4.type                        =  TDicomElement
vR2MammoVersionElement4.m_ID                        =  vCadSRVersionElementID
vR2MammoVersionElement4.m_Value                     =  "1.5.0.43"
#------------------------------------------------------------------------------
vR2MammoVersionElement5.type                        =  TDicomElement
vR2MammoVersionElement5.m_ID                        =  vCadSRVersionElementID
vR2MammoVersionElement5.m_Value                     =  "1.5.1.5"

#------------------------------------------------------------------------------
vR2MammoScopeEntry.type                             =  TScopeEntry
vR2MammoScopeEntry.m_Elements.1                     =  vR2MammoElement
vR2MammoScopeEntry.m_MatchWeight                    =  10

#------------------------------------------------------------------------------
vR2MammoScopeVersionEntry.type                      =  TScopeEntry
vR2MammoScopeVersionEntry.m_Elements.1              =  vR2MammoVersionElement1
vR2MammoScopeVersionEntry.m_Elements.2              =  vR2MammoVersionElement2
vR2MammoScopeVersionEntry.m_Elements.3              =  vR2MammoVersionElement3
vR2MammoScopeVersionEntry.m_Elements.4              =  vR2MammoVersionElement4
vR2MammoScopeVersionEntry.m_Elements.5              =  vR2MammoVersionElement5
vR2MammoScopeVersionEntry.m_MatchWeight             =  10
#------------------------------------------------------------------------------
vR2MammoScope.type                                  =  TScope
vR2MammoScope.m_Entries.1                           =  vSRImageScopeEntry
vR2MammoScope.m_Entries.2                           =  vR2MammoScopeEntry
vR2MammoScope.m_Entries.3                           =  vR2MammoScopeVersionEntry
#------------------------------------------------------------------------------
vR2TooltipSpecification.type                        =  TCadMarkTooltipOptions
vR2TooltipSpecification.m_Usage                     =  eCadMarkPresentationUsage
vR2TooltipSpecification.m_Scope                     =  vR2MammoScope
vR2TooltipSpecification.m_TooltipContents           =  vR2DefaultTooltipContents
#------------------------------------------------------------------------------

# override this value so no SR fail validation during testing
#------------------------------------------------------------------------------
vDefaultCadVersions.m_Options.m_bVersionSupported   =  FALSE
#------------------------------------------------------------------------------

# Turn on the support for R2 CAD SR
vR2DefaultVersionOptions.type                         =  TCadSRVersionOptions
#------------------------------------------------------------------------------
vR2DefaultCadVersions.type                            =  TCadSRSupportedVersion
vR2DefaultCadVersions.m_Usage                         =  eCadMarkPresentationUsage
vR2DefaultCadVersions.m_Scope                         =  vR2MammoScope
vR2DefaultCadVersions.m_Options                       =  vDefaultVersionOptions
vR2DefaultCadVersions.m_Options.m_bVersionSupported   =  TRUE

# Turn on the support for iCAD SR
viCADDefaultVersionOptions.type                         =  TCadSRVersionOptions
#------------------------------------------------------------------------------
viCADDefaultCadVersions.type                            =  TCadSRSupportedVersion
viCADDefaultCadVersions.m_Usage                         =  eCadMarkPresentationUsage
viCADDefaultCadVersions.m_Scope                         =  viCadMammoScopeSR
viCADDefaultCadVersions.m_Options                       =  vDefaultVersionOptions
viCADDefaultCadVersions.m_Options.m_bVersionSupported   =  TRUE

#========================================================================
# Construct Dicom Sigmoid MG scope
#==============================================================================
vMGDicomSigmoidScopeEntry.type          = TScopeEntry
vMGDicomSigmoidScopeEntry.m_Elements.1  = vMGModalityElement
vMGDicomSigmoidScopeEntry.m_MatchWeight = 90
#========================================================================
vMGDicomSigmoidScope.type                       = TScope
vMGDicomSigmoidScope.m_Entries.1                = vMGDicomSigmoidScopeEntry
vMGDicomSigmoidScope.m_Entries.1.m_MatchWeight  = 90
#========================================================================
vMGDicomSigmoidOrigPres.type                                = TOriginalPresentationOption
vMGDicomSigmoidOrigPres.m_Usage                             = eOriginalPresentationUsage
vMGDicomSigmoidOrigPres.m_Scope                             = vMGDicomSigmoidScope
vMGDicomSigmoidOrigPres.m_Options                           = vDefaultOriginalPresentation
vMGDicomSigmoidOrigPres.m_Options.m_dicomSigmoidLutOption   = eUseDicomSigmoidLutImage
