Skip to content

Compare

Functions to measure the structural similarity between devices.

dice_coefficient(device_a, device_b)

Calculates the Dice coefficient between two binary devices. A value closer to 1 indicates more similarity. The Dice coefficient is calculated as twice the number of pixels in common divided by the total number of pixels in the two devices.

Parameters:

Name Type Description Default
device_a Device

The first device (binarized).

 required
device_b Device

The second device (binarized).

 required

Returns:

Type Description
float

The Dice coefficient between two devices.
Warnings

UserWarning If one or both devices are not binarized.

Source code in prefab/compare.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
def dice_coefficient(device_a: Device, device_b: Device) -> float:
    """
    Calculates the Dice coefficient between two binary devices. A value closer to 1
    indicates more similarity. The Dice coefficient is calculated as twice the number of
    pixels in common divided by the total number of pixels in the two devices.

    Parameters
    ----------
    device_a : Device
        The first device (binarized).
    device_b : Device
        The second device (binarized).

    Returns
    -------
    float
        The Dice coefficient between two devices.

    Warnings
    --------
    UserWarning
        If one or both devices are not binarized.
    """
    if not device_a.is_binary or not device_b.is_binary:
        warnings.warn(
            "One or both devices are not binarized.", UserWarning, stacklevel=2
        )

    intersection = 2.0 * np.sum(
        np.logical_and(device_a.device_array, device_b.device_array)
    )
    size_a = np.sum(device_a.device_array)
    size_b = np.sum(device_b.device_array)
    return intersection / (size_a + size_b)

hamming_distance(device_a, device_b)

Calculates the Hamming distance between two binary devices. A lower value indicates more similarity. The Hamming distance is calculated as the number of positions at which the corresponding pixels are different.

Parameters:

Name Type Description Default
device_a Device

The first device (binarized).

 required
device_b Device

The second device (binarized).

 required

Returns:

Type Description
int

The Hamming distance between two devices.
Warnings

UserWarning If one or both devices are not binarized.

Source code in prefab/compare.py 
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
def hamming_distance(device_a: Device, device_b: Device) -> int:
    """
    Calculates the Hamming distance between two binary devices. A lower value indicates
    more similarity. The Hamming distance is calculated as the number of positions at
    which the corresponding pixels are different.

    Parameters
    ----------
    device_a : Device
        The first device (binarized).
    device_b : Device
        The second device (binarized).

    Returns
    -------
    int
        The Hamming distance between two devices.

    Warnings
    --------
    UserWarning
        If one or both devices are not binarized.
    """
    if not device_a.is_binary or not device_b.is_binary:
        warnings.warn(
            "One or both devices are not binarized.", UserWarning, stacklevel=2
        )

    return int(np.sum(device_a.device_array != device_b.device_array))

intersection_over_union(device_a, device_b)

Calculates the Intersection over Union (IoU) between two binary devices. A value closer to 1 indicates more similarity (more overlap).

Parameters:

Name Type Description Default
device_a Device

The first device (binarized).

 required
device_b Device

The second device (binarized).

 required

Returns:

Type Description
float

The Intersection over Union between two devices.
Warnings

UserWarning If one or both devices are not binarized.

Source code in prefab/compare.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
def intersection_over_union(device_a: Device, device_b: Device) -> float:
    """
    Calculates the Intersection over Union (IoU) between two binary devices. A value
    closer to 1 indicates more similarity (more overlap).

    Parameters
    ----------
    device_a : Device
        The first device (binarized).
    device_b : Device
        The second device (binarized).

    Returns
    -------
    float
        The Intersection over Union between two devices.

    Warnings
    --------
    UserWarning
        If one or both devices are not binarized.
    """
    if not device_a.is_binary or not device_b.is_binary:
        warnings.warn(
            "One or both devices are not binarized.", UserWarning, stacklevel=2
        )

    return np.sum(
        np.logical_and(device_a.device_array, device_b.device_array)
    ) / np.sum(np.logical_or(device_a.device_array, device_b.device_array))

mean_squared_error(device_a, device_b)

Calculate the mean squared error (MSE) between two non-binarized devices. A lower value indicates more similarity.

Parameters:

Name Type Description Default
device_a Device

The first device (non-binarized).

 required
device_b Device

The second device (non-binarized).

 required

Returns:

Type Description
float

The mean squared error between two devices.
Source code in prefab/compare.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def mean_squared_error(device_a: Device, device_b: Device) -> float:
    """
    Calculate the mean squared error (MSE) between two non-binarized devices. A lower
    value indicates more similarity.

    Parameters
    ----------
    device_a : Device
        The first device (non-binarized).
    device_b : Device
        The second device (non-binarized).

    Returns
    -------
    float
        The mean squared error between two devices.
    """
    return float(np.mean((device_a.device_array - device_b.device_array) ** 2))