Image.py

Go to the documentation of this file.

#
# Copyright 2009, MeVis Medical Solutions AG
#
# The user may use this file in accordance with the license agreement provided with
# the Software or, alternatively, in accordance with the terms contained in a
# written agreement between the user and MeVis Medical Solutions AG.
#
# For further information use the contact form at https://www.mevislab.de/contact
#
 
 
 
# -- system imports ----------------------------------------------------------------------------{{{-
import os
import sys
import traceback
# ----------------------------------------------------------------------------------------------}}}-
 
# -- local imports -----------------------------------------------------------------------------{{{-
import mevis
 
from TestSupport.TestHelper import TestHelper
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def calculateHashFromImage ----------------------------------------------------------------{{{-
 
def calculateHashFromImage (fileName, hashMethod='SHA256', encoder='Hex'):
  helpCtx = TestHelper.getInstance().getHelperContext()
 
  modImgLoad = helpCtx.module("iHSImgLoad")
  modImgHash = helpCtx.module("iHSImageHash")
 
  hashSelectorField = modImgHash.field('hashSelector')
  if hashMethod not in hashSelectorField.items():
    raise Exception("Hash method %s unknown. Valid values are: %s" % (hashMethod, ', '.join(hashSelectorField.items())))
  hashSelectorField.value = hashMethod
 
  encoderSelectorField = modImgHash.field('encoderSelector')
  if encoder not in encoderSelectorField.items():
    raise Exception("Encoder %s unknown. Valid values are: %s" % (encoder, ', '.join(encoderSelectorField.items())))
  encoderSelectorField.value = encoder
 
  result = ""
  modImgLoad.field('filename').value = fileName
  if not modImgHash.field('hashValid').value:
    Logging_error("Failed to create hash of image (%s)" % (fileName))
  else:
    result = modImgHash.field('hash').value
  modImgLoad.field('close').touch()
  return result
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def getVoxelValue -------------------------------------------------------------------------{{{-
 
def getVoxelValue (outFieldName, position, coordinateType="Voxel", useStoredValue=False):
  testCtx = Base_getTestCaseContext()
  helpCtx = TestHelper.getInstance().getHelperContext()
 
  result = (None, None)
 
  outField = testCtx.field(outFieldName)
  if outField:
    module = helpCtx.module("GetVoxelValue")
    module.field("input0").connectFrom(outField)
    module.field("coordinateType").value = coordinateType
    module.field("position").value = position
    module.field("updateButton").touch()
    if not useStoredValue:
      result = (module.field("outputStringValue").value, module.field("outputValue").value)
    else:
      result = (module.field("storedStringValue").value, module.field("storedValue").value)
  if not outField or not module.field("valid").value:
    Logging_error("Failed to retrieve voxel value.")
 
  return result
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def __imageCompare ------------------------------------------------------------------------{{{-
 
def __imageCompare (compareModule, outFieldA, outFieldB):
  testCtx = Base_getTestCaseContext()
  helpCtx = TestHelper.getInstance().getHelperContext()
 
  fieldA = testCtx.field(outFieldA)
  fieldB = testCtx.field(outFieldB)
  if fieldA and fieldB:
    module = helpCtx.module(compareModule)
    module.field("input0").connectFrom(fieldA)
    module.field("input1").connectFrom(fieldB)
    module.field("compare").touch()
    if module.field("testPassed").value:
      Logging_info("Image Compare with (%s): No differences found" % (compareModule))
    else:
      Logging_info("Image Compare with (%s): differences found" % (compareModule))
    return module.field("testPassed").value
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def compareImages -------------------------------------------------------------------------{{{-
 
def compareImages (outFieldA, outFieldB):
  return __imageCompare("ImageCompareDefault", outFieldA, outFieldB)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def compareImagesProperties -------------------------------------------------------------------------{{{-
 
def compareImagesProperties (outFieldA, outFieldB):
  return __imageCompare("ImageCompareProperties", outFieldA, outFieldB)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def compareImagesData ---------------------------------------------------------------------{{{-
 
def compareImagesData (outFieldA, outFieldB):
  return __imageCompare("ImageCompareData", outFieldA, outFieldB)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def compareImagesAllProps -----------------------------------------------------------------{{{-
 
def compareImagesAllProps (outFieldA, outFieldB):
  return __imageCompare("ImageCompareAllProps", outFieldA, outFieldB)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def getTrueMinMaxValues ------------------------------------------------------------------------{{{-
def getTrueMinMaxValues(outFieldName):
  """! Returns the true min/max range of the image data, which is therefore scanned entirely using a MinMaxScan module.
       @param outFieldName String: Name of the output image field
       @return tuple(Number, Number): Returns a tuple (trueMinimumValue, trueMaximumValue) or (None, None) if the image could not be scanned
  """
  testCtx = Base_getTestCaseContext()
  helpCtx = TestHelper.getInstance().getHelperContext()
  trueMin = None
  trueMax = None
  outField = testCtx.field(outFieldName)
  if outField and outField.isValid():
    module = helpCtx.module("MinMaxScan")
    module.field("input0").connectFrom(testCtx.field(outFieldName))
    module.field("update").touch()
    if module.field("upToDate").value:
      trueMin = module.field("trueMinValue").value
      trueMax = module.field("trueMaxValue").value
  return trueMin, trueMax
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def verifyMinMaxPropertyValues -----------------------------------------------------------------{{{-
def verifyMinMaxPropertyValues(outFieldName, expectedMin = None, expectedMax = None, requireExactMin = False, requireExactMax = False, logOnSuccess = True):
  """! Verifies the min/max image property values. By default (none of the optional arguments
       provided) the functions just checks if the min/max range specified by the image properties include the actual
       min/max range of the image data, which is therefore scanned. Note that this check is always done, since ML
       images always need to fulfill the condition. In addition, it is possible to check against expected values, or
       to require exact matches of the range boundaries (using the expected values, if provided, and the actual
       values otherwise). Logs an error if the output image is valid and any of the checks fail.
       @outFieldName String: Name of the output image field to perform the check on.
       @param expectedMin Number: If given, the minimum value image property is compared against expectedMin
       @param expectedMax Number: If given, the maximum value image property is compared against expectedMax
       @param requireExactMin Bool: If given, the minimum value image property must be identical to expectedMin (if given) or the actual image minimum (otherwise)
       @param requireExactMax Bool: If given, the maximum value image property must be identical to expectedMax (if given) or the actual image maximum (otherwise)
       @param logOnSuccess Bool: If enabled, provide success message
  """
  errorOccurred = False
  outField = Base_getTestCaseContext().field( outFieldName )
  comparisonErrorComment = "Min/max value error for field %s." % outFieldName
  if outField.isValid():
    trueMin, trueMax = getTrueMinMaxValues( outFieldName )
    if trueMin is None or trueMax is None:
      errorOccurred = True
      Logging_error("Image.verifyMinMaxPropertyValues(): Unexpected error scanning the image at field %s!" % outFieldName)
    else:
      if expectedMin is None:
        expectedMin = outField.minValue()
      if expectedMax is None:
        expectedMax = outField.maxValue()
      if requireExactMin:
        if not Base_compareFloatEqual(trueMin, expectedMin, comparisonErrorComment):
          errorOccurred = True
      else:
        if not Base_compareFloatLessThanOrEqual(expectedMin, trueMin, comparisonErrorComment):
          errorOccurred = True
      if requireExactMax:
        if not Base_compareFloatEqual(trueMax, expectedMax, comparisonErrorComment):
          errorOccurred = True
      else:
        if not Base_compareFloatLessThanOrEqual(trueMax, expectedMax, comparisonErrorComment):
          errorOccurred = True
 
  if not errorOccurred and logOnSuccess:
    Logging_info( "Image.verifyMinMaxPropertyValues(%s): SUCCESS" % outFieldName )
  return
 
 # ----------------------------------------------------------------------------------------------}}}-
 
from .Logging import error as Logging_error, info as Logging_info
from .Base import getTestCaseContext as Base_getTestCaseContext, \
                  compareFloatEqual as Base_compareFloatEqual, \
                  compareFloatLessThanOrEqual as Base_compareFloatLessThanOrEqual