def sprawl(
cls,
sprawl_area: np.ndarray,
core_objects: np.ndarray,
data: np.ndarray,
components_num: int,
spacing,
side_connection: bool,
operator: Callable[[Any, Any], bool],
arguments: dict,
lower_bound,
upper_bound,
):
if components_num > 250:
raise SegmentationLimitException("Current implementation of MSO do not support more than 250 components")
mso = PyMSO()
neigh, dist = calculate_distances_array(spacing, get_neigh(side_connection))
components_arr = np.copy(core_objects).astype(np.uint8)
components_arr[components_arr > 0] += 1
components_arr[sprawl_area == 0] = 1
mso.set_neighbourhood(neigh, dist)
mso.set_components(components_arr, components_num + 1)
mso.set_use_background(False)
try:
mu_array = calculate_mu(data.copy("C"), lower_bound, upper_bound, MuType.base_mu)
except OverflowError:
raise SegmentationLimitException("Wrong range for ")
if arguments["reflective"]:
mu_array[mu_array < 0.5] = 1 - mu_array[mu_array < 0.5]
mso.set_mu_array(mu_array)
try:
mso.run_MSO(arguments["step_limits"])
except RuntimeError as e:
if e.args[0] == "to many steps: constrained dilation":
raise SegmentationLimitException(*e.args)
raise
# print("Steps: ", mso.steps_done(), file=sys.stderr)
result = mso.get_result_catted()
result[result > 0] -= 1
return result
def _test_background_simple(self):
components = np.ones((20, 20, 20), dtype=np.uint8)
components[1:-1, 1:-1, 1:-1] = 0
components[9:11, 9:11, 9:11] = 2
mu_array = np.zeros(components.shape)
mu_array[1:-1, 1:-1, 1:-1] = 0.7
mu_array[3:-3, 3:-3, 3:-3] = 0.6
mu_array[5:-5, 5:-5, 5:-5] = 0.4
mu_array[6:-6, 6:-6, 6:-6] = 0.6
mu_array[8:-8, 8:-8, 8:-8] = 0.7
mu_array[components > 0] = 1.0
mso = PyMSO()
neigh, dist = calculate_distances_array((1, 1, 1), NeighType.vertex)
mso.set_neighbourhood(neigh, dist)
mso.set_use_background(True)
mso.set_components(components, 3)
mso.set_mu_array(mu_array)
mso.set_components_num(3)
mso.run_MSO(10)
mso.get_result_catted()
def test_two_components_bridge(self):
components = np.zeros((10, 10, 20), dtype=np.uint8)
components[:] = 1
components[2:8, 2:8, 2:18] = 0
components[4:6, 4:6, 4:6] = 2
components[4:6, 4:6, 14:16] = 3
mu_arr = np.zeros(components.shape, dtype=np.float64)
mu_arr[components == 0] = 0.5
mu_arr[components > 1] = 1
mu_arr[2:8, 2:8, (9, 10)] = 0.1
mso = PyMSO()
neigh, dist = calculate_distances_array((1, 1, 1), NeighType.vertex)
mso.set_neighbourhood(neigh, dist)
mso.set_components(components, 3)
mso.set_mu_array(mu_arr)
mso.set_components_num(3)
mso.run_MSO(10)
res = mso.get_result_catted()
assert mso.steps_done() == 2
arr = np.copy(components)
arr[arr == 1] = 0
arr[2:8, 2:8, 2:9] = 2
arr[2:8, 2:8, 11:18] = 3
assert np.all(res == arr)
class BaseMultiScaleOpening(TwoLevelThresholdBaseAlgorithm,
ABC): # pragma: no cover
@classmethod
def get_fields(cls):
return [
AlgorithmProperty(
"threshold",
"Threshold",
next(iter(double_threshold_dict.keys())),
possible_values=double_threshold_dict,
property_type=AlgorithmDescribeBase,
),
AlgorithmProperty(
"mu_mid",
"Mu mid value",
next(iter(mu_mid_dict.keys())),
possible_values=mu_mid_dict,
property_type=AlgorithmDescribeBase,
),
AlgorithmProperty("step_limits",
"Limits of Steps",
100,
options_range=(1, 1000),
property_type=int),
] + super().get_fields()
def get_info_text(self):
return ("Threshold: " + ", ".join(map(str, self.threshold_info)) +
"\nMid sizes: " + ", ".join(
map(str, self._sizes_array[1:self.components_num + 1])) +
"\nFinal sizes: " + ", ".join(map(str, self.final_sizes[1:])) +
f"\nsteps: {self.steps}")
def __init__(self):
super().__init__()
self.finally_segment = None
self.final_sizes = []
self.threshold_info = [None, None]
self.steps = 0
self.mso = PyMSO()
self.mso.set_use_background(True)
def clean(self):
self.sprawl_area = None
self.mso = PyMSO()
self.mso.set_use_background(True)
super().clean()
def set_image(self, image):
super().set_image(image)
self.threshold_info = [None, None]
def calculation_run(self, report_fun) -> SegmentationResult:
if self.new_parameters["side_connection"] != self.parameters[
"side_connection"]:
neigh, dist = calculate_distances_array(
self.image.spacing,
get_neigh(self.new_parameters["side_connection"]))
self.mso.set_neighbourhood(neigh, dist)
segment_data = super().calculation_run(report_fun)
if segment_data is not None and self.components_num == 0:
self.final_sizes = []
return segment_data
if segment_data is None:
restarted = False
finally_segment = np.copy(self.finally_segment)
else:
self.finally_segment = segment_data.roi
finally_segment = segment_data.roi
if np.max(finally_segment) > 250:
raise SegmentationLimitException(
"Current implementation of MSO do not support more than 250 components"
)
components = finally_segment.astype(np.uint8)
components[components > 0] += 1
components[self.sprawl_area == 0] = 1
self.mso.set_components(components, self.components_num)
restarted = True
if (restarted or self.old_threshold_info[1] != self.threshold_info[1]
or self.new_parameters["mu_mid"] != self.parameters["mu_mid"]):
if self.threshold_operator(self.threshold_info[1],
self.threshold_info[0]):
self.final_sizes = np.bincount(finally_segment.flat)
return self.prepare_result(self.finally_segment)
mu_calc: BaseMuMid = mu_mid_dict[self.new_parameters["mu_mid"]
["name"]]
self.parameters["mu_mid"] = self.new_parameters["mu_mid"]
sprawl_area = (self.sprawl_area > 0).astype(np.uint8)
sprawl_area[finally_segment > 0] = 0
mid_val = mu_calc.value(
sprawl_area,
self.channel,
self.threshold_info[0],
self.threshold_info[1],
self.new_parameters["mu_mid"]["values"],
)
mu_array = calculate_mu_mid(self.channel, self.threshold_info[0],
mid_val, self.threshold_info[1])
self.mso.set_mu_array(mu_array)
restarted = True
if restarted or self.new_parameters["step_limits"] != self.parameters[
"step_limits"]:
self.parameters["step_limits"] = self.new_parameters["step_limits"]
count_steps_factor = 20 if self.image.is_2d else 3
self.mso.run_MSO(self.new_parameters["step_limits"],
count_steps_factor)
self.steps = self.mso.steps_done()
new_segment = self.mso.get_result_catted()
new_segment[new_segment > 0] -= 1
self.final_sizes = np.bincount(new_segment.flat)
return self.prepare_result(new_segment)