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,
)