def interrupt_calculation(self):
"""
Kills any running calculation.
"""
if self.calculation_thread is None:
Debug(
self,
".interrupt_calculation: WARNING: No calculation thread to interrupt",
color=Theme.WarningColor,
force=True)
return
if self.calculation_thread.isRunning():
Debug(self,
".interrupt_calculation(): Requesting interruption",
color=Theme.PrimaryColor)
self.calculation_thread.requestInterruption()
if self.calculation_thread.wait(5000):
Debug(self,
".interrupt_calculation(): Exited gracefully",
color=Theme.PrimaryColor)
else:
Assert_Dialog(False, "Failed to terminate calculation thread")
if self.calculation_thread is not None:
if self.calculation_thread.isRunning():
Debug(
self,
".interrupt_calculation(): WARNING: Terminating ungracefully",
color=Theme.WarningColor,
force=True)
self.calculation_thread.terminate()
self.calculation_thread.wait()
else:
Debug(
self,
".interrupt_calculation: WARNING: Calculation thread should be running",
color=Theme.WarningColor,
force=True)
self.calculation_thread = None
def __init__(self, resolution: int):
"""
Initializes an empty sampling volume, with zero bounds and no constraints.
@param resolution: Resolution
"""
Debug(self, ": Init")
self._resolution = resolution
self.constraints = []
self._bounds_min = np.zeros(3)
self._bounds_max = np.zeros(3)
self._points = None
self._permeabilities = None
self._labeled_indices = None
self._neighbor_indices = None
Assert_Dialog(resolution > 0, "Resolution must be > 0")
def recalculate(self, sampling_volume, field, progress_callback) -> bool:
"""
Recalculates color and alpha values for field.
@param sampling_volume: SamplingVolume
@param field: Field
@param progress_callback: Progress callback
@return: True (currently non-interruptable)
"""
Debug(self, ".recalculate()", color=Theme.SuccessColor)
n = len(field.get_vectors())
progress_callback(0)
# Sampling volume length element (only needed for divergence metric)
dL = Metric.LengthScale / sampling_volume.get_resolution()
# Calculate color metric values
if self._color_preset["norm_id"] == "Divergence":
# Calculate divergence
color_norm_values = self._divergence_worker(
sampling_volume.get_neighbor_indices(), field.get_vectors(),
dL, self._color_preset["polarity"])
else:
# Calculate other norm
color_norm_values = self._norm_worker(
self._color_preset["norm_id"], field.get_vectors())
progress_callback(25)
# Calculate alpha metric values
if self._alpha_preset["norm_id"] == "Divergence":
# Calculate divergence
alpha_norm_values = self._divergence_worker(
sampling_volume.get_neighbor_indices(), field.get_vectors(),
dL, self._alpha_preset["polarity"])
else:
# Calculate other norm
alpha_norm_values = self._norm_worker(
self._alpha_preset["norm_id"], field.get_vectors())
progress_callback(50)
# Select color range
if self._color_preset["is_angle"]:
color_norm_min, color_norm_max = 0.0, 1.0
else:
color_norm_min, color_norm_max = np.nanmin(
color_norm_values), np.nanmax(color_norm_values)
# Select alpha range
if self._alpha_preset["is_angle"]:
alpha_norm_min, alpha_norm_max = 0.0, 1.0
else:
alpha_norm_min, alpha_norm_max = np.nanmin(
alpha_norm_values), np.nanmax(alpha_norm_values)
# Select color normalizer
if self._color_preset["is_log"]:
# Logarithmic normalization
Assert_Dialog(not self._color_preset["is_angle"],
"Logarithmic angles don't make any sense")
# Adjust range for logarithm (out-of-range values will be clipped in the loop below)
color_norm_min_ = max(
color_norm_min, Metric.LogNormMinimum
) # avoiding ValueError: min must be positive
color_norm_max_ = max(
color_norm_min_,
color_norm_max) # avoiding ValueError: min must be <= max
else:
# Linear normalization
color_norm_min_ = color_norm_min
color_norm_max_ = color_norm_max
# Select alpha normalizer
if self._alpha_preset["is_log"]:
# Logarithmic normalization
Assert_Dialog(not self._alpha_preset["is_angle"],
"Logarithmic angles don't make any sense")
# Adjust range for logarithm (out-of-range values will be clipped in the loop below)
alpha_norm_min_ = max(
alpha_norm_min, Metric.LogNormMinimum
) # avoiding ValueError: min must be positive
alpha_norm_max_ = max(
alpha_norm_min_,
alpha_norm_max) # avoiding ValueError: min must be <= max
else:
# Linear normalization
alpha_norm_min_ = alpha_norm_min
alpha_norm_max_ = alpha_norm_max
colors = np.zeros([n, 4])
# Calculate final color values
# Note: If using logarithmic scaling, out-of-range values (still exceeding [0...1] here) may be clipped
colors = self._normalize_worker(
self._color_preset["colormap"], self._color_preset["is_log"],
color_norm_values, color_norm_min_, color_norm_max_,
self._alpha_preset["is_log"], alpha_norm_values, alpha_norm_min_,
alpha_norm_max_, colors)
self._colors = colors
self._limits = {
"color_min": color_norm_min,
"color_max": color_norm_max,
"alpha_min": alpha_norm_min,
"alpha_max": alpha_norm_max
}
progress_callback(100)
return True
