HelperFunctions.py

Go to the documentation of this file.

#
# Copyright 2011, 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
#
 
from mevis import MLAB
from TestSupport import Base
from TestSupport.Macros import INFO, ERROR, ASSERT_TRUE
import numpy
import sys
 
LOGVOXEL = False  # trigger for logging voxel comparison
LOGONSUCCESS = False  # trigger for logging voxel comparison if success (gLogVoxel needs to be True)
EPSILON = 0.0001  # absolute value to compensate floating point imprecisions with voxel comparison
 
INTTYPES = {
    "int8": (-128, 127),
    "int16": (-32768, 32767),
    "int32": (-2147483648, 2147483647),
    "int64": (-9223372036854775808, 9223372036854775807),
    "uint8": (0, 255),
    "uint16": (0, 65535),
    "uint32": (0, 4294967295),
    "uint64": (0, 18446744073709551615),
}
 
 
 
def generateTestDictionary(function, testDictionaries):
    if isinstance(testDictionaries, (list, tuple)):
        testDict = {}
        for d in testDictionaries:
            testDict.update(d)
    else:
        testDict = testDictionaries
    for key in testDict:
        testDict[key][0] = function
    return testDict
 
 
 
def initModuleFromTemplate(
    targetModuleName, templateModuleName=None, fieldValueOverrides=None, alsoInitNonEditableFields=False
):
    context = Base.getTestCaseContext()
    ASSERT_TRUE(
        context.hasModule(targetModuleName),
        msg="Target module {} not found!".format(targetModuleName),
        logOnSuccess=False,
    )
    if templateModuleName is None:
        templateModuleName = "{}_ParameterTemplate".format(targetModuleName)
 
    #
    def ___applyTemplateParameters():
        ASSERT_TRUE(
            context.hasModule(templateModuleName),
            msg="Template module {} not found!".format(templateModuleName),
            logOnSuccess=False,
        )
        for f in context.module(templateModuleName).parameterFields():
            if f.name != "instanceName" and f.type != "Trigger" and (alsoInitNonEditableFields or f.isEditable()):
                value = f.vectorValue() if "vec" in f.type.lower() else f.value
                context.field("{}.{}".format(targetModuleName, f.name)).updateValue(value)
 
    #
    def ___applyOverrideParameters():
        targetModule = context.module(targetModuleName)
        for fieldName, fieldValue in fieldValueOverrides.items():
            ASSERT_TRUE(
                targetModule.hasField(fieldName),
                msg="Invalid field value override: Field {} does not exist.".format(fieldName),
                logOnSuccess=False,
            )
            targetModule.field(fieldName).updateValue(fieldValue)
 
    #
    ___applyTemplateParameters()
    if fieldValueOverrides:
        ___applyOverrideParameters()
 
 
 
def getMinMax(fv1, fv2=None):
    """Determines max/min value of given fill value(s)."""
    if isinstance(fv1, str):
        fv1 = sorted([float(comp) for comp in fv1.split()])
    else:
        fv1 = sorted(fv1)
    max1 = fv1[len(fv1) - 1]
    min1 = fv1[0]
 
    if fv2:
        if isinstance(fv2, str):
            fv2 = sorted([float(comp) for comp in fv2.split()])
        else:
            fv2 = sorted(fv2)
        max2 = fv2[len(fv2) - 1]
        min2 = fv2[0]
        min = min1 if min1 < min2 else min2
        max = max1 if max1 > max2 else max2
        return (min, max)
    else:
        return (min1, max1)
 
 
 
def getNumComponentsFromImage(imageField):
    """Returns the number of components of the image data type."""
    mlType = imageField.image().dataType()
    return MLAB.ML.MLTypeGetNumComponents(mlType)
 
 
 
def getNumComponentsFromString(dataType):
    if "int" in dataType or "float" in dataType or "double" in dataType:
        num = 1
    elif "complex" in dataType:
        num = 2
    elif "quaternion" in dataType:
        num = 4
    else:
        num = ""
        for i in dataType:
            if i in "0123456789":
                num += i
            elif num != "":
                break
        # Matrix data types: num*num
        num = int(num) ** 2 if "mat" in dataType else int(num)
    return num
 
 
 
def getNumpyTypeFromImage(imageField, context=None):
    """Returns a NumPy data type object used with the image."""
    # Std data types
    if MLAB.ML.MLIsStandardType(imageField.image().dataType()):
        return type(imageField.image().getTile((0, 0, 0), (1, 1, 1))[0][0][0])
    # Adv data types
    else:
        try:
            td = context.addModule(MLAB.moduleLiteral("TypeDecomposer64"))
        except:
            raise Exception(
                'Use parameter "context = ctx" with "getNumpyType()" because the image uses an adv. data type!'
            )
        td.field("input0").connectFrom(imageField)
        npType = type(td.field("output0").image().getTile((0, 0, 0), (1, 1, 1))[0][0][0])
        td.remove()
        return npType
 
 
 
def getNumpyTypeFromString(dataType):
    if "unsigned" in dataType:
        if "8" in dataType:
            npType = numpy.uint8
        elif "16" in dataType:
            npType = numpy.uint16
        elif "32" in dataType:
            npType = numpy.uint32
        elif "64" in dataType:
            npType = numpy.uint64
 
    elif "int8" in dataType or "i8" in dataType:
        npType = numpy.int8
    elif "int16" in dataType or "i16" in dataType:
        npType = numpy.int16
    elif "int32" in dataType or "i32" in dataType:
        npType = numpy.int32
    elif "int64" in dataType or "i64" in dataType:
        npType = numpy.int64
 
    elif dataType in ("float", "complexf", "quaternionf") or "vecf" in dataType or "matf" in dataType:
        npType = numpy.float32
    elif dataType in ("double", "complexd", "quaterniond") or "vec" in dataType or "mat" in dataType:
        npType = numpy.float64
    elif dataType in ("long double", "complexld", "quaternionld"):
        npType = numpy.float64  
 
    elif "stringuchar" in dataType:
        npType = numpy.uint8
 
    return npType
 
 
 
def castToNumpy(value, numpyType):
    """Returns the value casted to the given NumPy data type."""
    typeName = numpyType.__name__
    # if convert to int and outside int32 or to uint and outside uint32
    if ("uint" in typeName and (value < INTTYPES["uint32"][0] or value > INTTYPES["uint32"][1])) or (
        "uint" not in typeName and "int" in typeName and (value < INTTYPES["int32"][0] or value > INTTYPES["int32"][1])
    ):
        if sys.version_info.major == 2:
            value = long(value)
        else:
            value = int(value)
        # newValue = value % (intMax + 1) + intMin * (value / (intMax + 1) % 2)
        value = value % (INTTYPES[typeName][1] + 1) + INTTYPES[typeName][0] * (value // (INTTYPES[typeName][1] + 1) % 2)
    return numpyType(value)
 
 
 
def convertVoxelType(voxel, oldType, newType):
    """Coverts fill values of any input data type to std output data type."""
    try:
        numComp = len(voxel)
    except:
        numComp = 1
        voxel = tuple(voxel)
 
    numpyType = getNumpyTypeFromString(newType)
    newVoxel = voxel[0] if "quaternion" not in oldType else voxel[3]
    newVoxel = castToNumpy(newVoxel, numpyType)
    return newVoxel
 
 
 
def getImage3D(imageField, imageStart=(0, 0, 0), imageSize=None, context=None):
    image = []
    if not imageSize:
        imageSize = imageField.size3D()
    numComp = getNumComponentsFromImage(imageField)
    # adv. data type
    if numComp > 1:
        try:
            td = context.addModule(MLAB.moduleLiteral("TypeDecomposer64"))
        except:
            raise Exception(
                'Use parameter "context = ctx" with "getImage3D()" because the image uses an adv. data type!'
            )
 
        td.field("input0").connectFrom(imageField)
        for comp in range(numComp):
            image.append(td.field("output{0}".format(comp)).image().getTile(imageStart, imageSize))
        td.remove()
    # std. data type
    else:
        image.append(imageField.image().getTile(imageStart, imageSize))
    return image
 
 
 
def getImage6D(imageField, imageStart=(0, 0, 0, 0, 0, 0), imageSize=None, context=None):
    image = []
    if not imageSize:
        imageSize = imageField.size6D()
    numComp = getNumComponentsFromImage(imageField)
    # adv. data type
    if numComp > 1:
        try:
            td = context.addModule(MLAB.moduleLiteral("TypeDecomposer64"))
        except:
            raise Exception(
                'Use parameter "context = ctx" with "getImage6D()" because the image uses an adv. data type!'
            )
 
        td.field("input0").connectFrom(imageField)
        for comp in range(numComp):
            image.append(td.field("output{0}".format(comp)).image().getTile(imageStart, imageSize))
        td.remove()
    # std. data type
    else:
        image.append(imageField.image().getTile(imageStart, imageSize))
    return image
 
 
 
def compareImages3D(resultImage, expectedImage):
    isEqual = True
    numErrors = 0
    # get # of components and extent of expected image; changes shape to [component][z][y][x] if it is not
    try:
        numComp = len(expectedImage)
        expectedSize = [len(expectedImage[0][0][0]), len(expectedImage[0][0]), len(expectedImage[0])]
    except TypeError:
        numComp = 1
        expectedImage = [expectedImage]
        expectedSize = [len(expectedImage[0][0][0]), len(expectedImage[0][0]), len(expectedImage[0])]
    # get extent of result image; changes shape to [component][z][y][x] if it is not
    try:
        resultSize = [len(resultImage[0][0][0]), len(resultImage[0][0]), len(resultImage[0])]
    except TypeError:
        resultImage = [resultImage]
        resultSize = [len(resultImage[0][0][0]), len(resultImage[0][0]), len(resultImage[0])]
 
    if resultSize != expectedSize:
        ERROR(
            "Image compare failed: expected and output image are not not of the same size >> "
            + "result {0} != expected {1}".format(resultSize, expectedSize)
        )
        return False
 
    elif numComp != len(resultImage):
        ERROR(
            "Image compare failed: expected and output image have different number of data type components >> "
            + "result {0} != expected {1}".format(numComp, len(resultImage))
        )
        return False
 
    if not numpy.allclose(expectedImage, resultImage, 0, EPSILON) or LOGONSUCCESS:
        for z in range(resultSize[2]):
            for y in range(resultSize[1]):
                for x in range(resultSize[0]):
                    for comp in range(numComp):
                        # get expected and out voxel are a number or inf/nan as bool
                        finiteExp = numpy.isfinite(expectedImage[comp][z][y][x])
                        finiteOut = numpy.isfinite(resultImage[comp][z][y][x])
                        # check for difference between voxel
                        if (
                            finiteExp != finiteOut
                            or (finiteExp, finiteOut) == (True, True)
                            and abs(resultImage[comp][z][y][x] - expectedImage[comp][z][y][x]) > EPSILON
                        ):
                            if LOGVOXEL:
                                ERROR(
                                    """Voxel ({0},{1},{2}) of Result and Expected image are not equal (Epsilon = {3}):
                      >> {4} == {5} : False""".format(
                                        x,
                                        y,
                                        z,
                                        EPSILON,
                                        [resultImage[comp][z][y][x] for comp in range(numComp)],
                                        [expectedImage[comp][z][y][x] for comp in range(numComp)],
                                    )
                                )
                            isEqual = False
                            numErrors += 1
                            break
                        # voxel are equal
                        elif LOGVOXEL and LOGONSUCCESS and comp == numComp - 1:
                            INFO(
                                """Voxel ({0},{1},{2}) of Result and Expected image are equal (Epsilon = {3}):
                    >> {4} == {5} : True""".format(
                                    x,
                                    y,
                                    z,
                                    EPSILON,
                                    [resultImage[comp][z][y][x] for comp in range(numComp)],
                                    [expectedImage[comp][z][y][x] for comp in range(numComp)],
                                )
                            )
 
    if isEqual:
        INFO("Image compare passed: expected and out image are equal")
    else:
        ERROR(
            "Image compare failed: expected and output image are not equal >> "
            + "{0} of {1} voxels are different".format(numErrors, resultSize[0] * resultSize[1] * resultSize[2])
        )
    return isEqual
 
 
 
def compareImages6D(resultImage, expectedImage):
    isEqual = True
    numErrors = 0
    # get # of components and extent of expected image; changes shape to [component][u][t][c][z][y][x] if it is not
    try:
        numComp = len(expectedImage)
        expectedSize = [
            len(expectedImage[0][0][0][0][0][0]),
            len(expectedImage[0][0][0][0][0]),
            len(expectedImage[0][0][0][0]),
            len(expectedImage[0][0][0]),
            len(expectedImage[0][0]),
            len(expectedImage[0]),
        ]
    except TypeError:
        numComp = 1
        expectedImage = [expectedImage]
        expectedSize = [
            len(expectedImage[0][0][0][0][0][0]),
            len(expectedImage[0][0][0][0][0]),
            len(expectedImage[0][0][0][0]),
            len(expectedImage[0][0][0]),
            len(expectedImage[0][0]),
            len(expectedImage[0]),
        ]
    # get extent of result image; changes shape to [component][u][t][c][z][y][x] if it is not
    try:
        resultSize = [
            len(resultImage[0][0][0][0][0][0]),
            len(resultImage[0][0][0][0][0]),
            len(resultImage[0][0][0][0]),
            len(resultImage[0][0][0]),
            len(resultImage[0][0]),
            len(resultImage[0]),
        ]
    except TypeError:
        numComp = 1
        resultImage = [resultImage]
        resultSize = [
            len(resultImage[0][0][0][0][0][0]),
            len(resultImage[0][0][0][0][0]),
            len(resultImage[0][0][0][0]),
            len(resultImage[0][0][0]),
            len(resultImage[0][0]),
            len(resultImage[0]),
        ]
 
    if resultSize != expectedSize:
        ERROR(
            "Image compare failed: expected and output image are not not of the same size >> "
            + "result {0} != expected {1}".format(resultSize, expectedSize)
        )
        return False
 
    elif numComp != len(resultImage):
        ERROR(
            "Image compare failed: expected and output image have different number of data type components >> "
            + "result {0} != expected {1}".format(numComp, len(resultImage))
        )
        return False
 
    if not numpy.allclose(expectedImage, resultImage, 0, EPSILON) or LOGONSUCCESS:
        for u in range(resultSize[5]):
            for t in range(resultSize[4]):
                for c in range(resultSize[3]):
                    for z in range(resultSize[2]):
                        for y in range(resultSize[1]):
                            for x in range(resultSize[0]):
                                for comp in range(numComp):
                                    # get expected and out voxel are a number or inf/nan as bool
                                    finiteExp = numpy.isfinite(expectedImage[comp][u][t][c][z][y][x])
                                    finiteOut = numpy.isfinite(resultImage[comp][u][t][c][z][y][x])
                                    # check for difference between voxel
                                    if (
                                        finiteExp != finiteOut
                                        or (finiteExp, finiteOut) == (True, True)
                                        and abs(
                                            resultImage[comp][u][t][c][z][y][x] - expectedImage[comp][u][t][c][z][y][x]
                                        )
                                        > EPSILON
                                    ):
                                        if LOGVOXEL:
                                            ERROR(
                                                """Voxel ({0},{1},{2},{3},{4},{5}) of Result and Expected image are not equal (Epsilon = {6}):
                            >> {7} == {8} : False""".format(
                                                    x,
                                                    y,
                                                    z,
                                                    c,
                                                    t,
                                                    u,
                                                    EPSILON,
                                                    [resultImage[comp][u][t][c][z][y][x] for comp in range(numComp)],
                                                    [expectedImage[comp][u][t][c][z][y][x] for comp in range(numComp)],
                                                )
                                            )
                                        isEqual = False
                                        numErrors += 1
                                        break
                                    # voxel are equal
                                    elif LOGVOXEL and LOGONSUCCESS and comp == numComp - 1:
                                        INFO(
                                            """Voxel ({0},{1},{2},{3},{4},{5}) of Result and Expected image are equal (Epsilon = {6}):
                          >> {7} == {8} : True""".format(
                                                x,
                                                y,
                                                z,
                                                c,
                                                t,
                                                u,
                                                EPSILON,
                                                [resultImage[comp][u][t][c][z][y][x] for comp in range(numComp)],
                                                [expectedImage[comp][u][t][c][z][y][x] for comp in range(numComp)],
                                            )
                                        )
 
    if isEqual:
        INFO("Image compare passed: expected and out image are equal")
    else:
        ERROR(
            "Image compare failed: expected and output image are not equal >> "
            + "{0} of {1} voxels are different".format(
                numErrors, resultSize[0] * resultSize[1] * resultSize[2] * resultSize[3] * resultSize[4] * resultSize[5]
            )
        )
    return isEqual