def black_tophat(image, selem=None, out=None):
"""Return black top hat of an image.
The black top hat of an image is defined as its morphological closing minus
the original image. This operation returns the dark spots of the image that
are smaller than the structuring element. Note that dark spots in the
original image are bright spots after the black top hat.
Parameters
----------
image : ndarray
Image array.
selem : ndarray, optional
The neighborhood expressed as a 2-D array of 1's and 0's.
If None, use cross-shaped structuring element (connectivity=1).
out : ndarray, optional
The array to store the result of the morphology. If None
is passed, a new array will be allocated.
Returns
-------
out : array, same shape and type as `image`
The result of the morphological black top hat.
See also
--------
white_tophat
References
----------
.. [1] https://en.wikipedia.org/wiki/Top-hat_transform
Examples
--------
>>> # Change dark peak to bright peak and subtract background
>>> import cupy as cp
>>> from cucim.skimage.morphology import square
>>> dark_on_grey = cp.asarray([[7, 6, 6, 6, 7],
... [6, 5, 4, 5, 6],
... [6, 4, 0, 4, 6],
... [6, 5, 4, 5, 6],
... [7, 6, 6, 6, 7]], dtype=cp.uint8)
>>> black_tophat(dark_on_grey, square(3))
array([[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 1, 5, 1, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
"""
if out is image:
original = image.copy()
else:
original = image
out = closing(image, selem, out=out)
if cp.issubdtype(out.dtype, bool):
cp.logical_xor(out, original, out=out)
else:
out -= original
return out
def logical_xor(x1: Array, x2: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.logical_xor <numpy.logical_xor>`.
See its docstring for more information.
"""
if x1.dtype not in _boolean_dtypes or x2.dtype not in _boolean_dtypes:
raise TypeError("Only boolean dtypes are allowed in logical_xor")
# Call result type here just to raise on disallowed type combinations
_result_type(x1.dtype, x2.dtype)
x1, x2 = Array._normalize_two_args(x1, x2)
return Array._new(np.logical_xor(x1._array, x2._array))
def _get_peak_mask(image, footprint, threshold, mask=None):
"""
Return the mask containing all peak candidates above thresholds.
"""
if footprint.size == 1 or image.size == 1:
return image > threshold
image_max = ndi.maximum_filter(image, footprint=footprint,
mode='constant')
out = image == image_max
# no peak for a trivial image
image_is_trivial = np.all(out) if mask is None else np.all(out[mask])
if image_is_trivial: # synchronize
out[:] = False
if mask is not None:
# isolated pixels in masked area are returned as peaks
isolated_px = cp.logical_xor(mask, ndi.binary_opening(mask))
out[isolated_px] = True
out &= image > threshold
return out
def white_tophat(image, selem=None, out=None):
"""Return white top hat of an image.
The white top hat of an image is defined as the image minus its
morphological opening. This operation returns the bright spots of the image
that are smaller than the structuring element.
Parameters
----------
image : ndarray
Image array.
selem : ndarray, optional
The neighborhood expressed as an array of 1's and 0's.
If None, use cross-shaped structuring element (connectivity=1).
out : ndarray, optional
The array to store the result of the morphology. If None
is passed, a new array will be allocated.
Returns
-------
out : array, same shape and type as `image`
The result of the morphological white top hat.
See also
--------
black_tophat
References
----------
.. [1] https://en.wikipedia.org/wiki/Top-hat_transform
Examples
--------
>>> # Subtract grey background from bright peak
>>> import cupy as cp
>>> from cucim.skimage.morphology import square
>>> bright_on_grey = cp.asarray([[2, 3, 3, 3, 2],
... [3, 4, 5, 4, 3],
... [3, 5, 9, 5, 3],
... [3, 4, 5, 4, 3],
... [2, 3, 3, 3, 2]], dtype=cp.uint8)
>>> white_tophat(bright_on_grey, square(3))
array([[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 1, 5, 1, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
"""
if out is image:
opened = opening(image, selem)
if cp.issubdtype(opened.dtype, cp.bool_):
cp.logical_xor(out, opened, out=out)
else:
out -= opened
return out
elif out is None:
out = cp.empty_like(image)
# work-around for NumPy deprecation warning for arithmetic
# operations on bool arrays
if isinstance(image, cp.ndarray) and image.dtype == bool:
image_ = image.view(dtype=cp.uint8)
else:
image_ = image
if isinstance(out, cp.ndarray) and out.dtype == bool:
out_ = out.view(dtype=cp.uint8)
else:
out_ = out
out_ = ndi.white_tophat(image_, footprint=selem, output=out_)
return out
def General_n_Balance_n_Collision_Eff(self,
_new_path,
length_only = True,
GPU_accelerating = False,
GPU_accelerating_data = None,
matrix_data = None):
ITC = {}
max_ITC = 1
min_ITC = sys.maxsize
total_cost = 0
max_order = 0
total_order = 0
standard_index = self.tools.GetWidth()**2 + self.tools.GetHeight()**2
# Parallelization
if GPU_accelerating and length_only:
n_AGV, population_size = GPU_accelerating_data
T_matrix, S_matrix = matrix_data
T_matrix = cp.array(T_matrix)
S_matrix = cp.array(np.array(S_matrix).astype(float))
ITC_matrix = cp.reshape(cp.dot(T_matrix, cp.array([[1],[1]])), (population_size, n_AGV))
O_matrix = cp.reshape(cp.dot(T_matrix, cp.array([[0],[1]])), (population_size, n_AGV))
TC_matrix = cp.reshape(cp.dot(ITC_matrix, cp.ones((n_AGV, 1))), (population_size))
TO_matrix = cp.reshape(cp.dot(O_matrix, cp.ones((n_AGV, 1))), (population_size))
max_ITC_matrix = cp.amax(ITC_matrix, axis=1)
min_ITC_matrix = cp.amin(ITC_matrix, axis=1)
max_order_matrix = cp.amax(O_matrix, axis=1)
_, n_order_points, _ = S_matrix.shape
t_m = cp.reshape(cp.dot(S_matrix, cp.array([[[1],[0],[0],[0],[0]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
x_m = cp.reshape(cp.dot(S_matrix, cp.array([[[0],[1],[0],[0],[0]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
y_m = cp.reshape(cp.dot(S_matrix, cp.array([[[0],[0],[1],[0],[0]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
l_m = cp.reshape(cp.dot(S_matrix, cp.array([[[0],[0],[0],[1],[0]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
o_m = cp.reshape(cp.dot(S_matrix, cp.array([[[0],[0],[0],[0],[1]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
t_m_l = cp.reshape(cp.dot(S_matrix, cp.array([[[1],[0],[0],[0],[0]]])),
(population_size, n_order_points))
t_m_diff = t_m - cp.transpose(t_m, (0, 2, 1))
x_m_diff = x_m - cp.transpose(x_m, (0, 2, 1))
y_m_diff = y_m - cp.transpose(y_m, (0, 2, 1))
m_xy_diff = cp.absolute(x_m_diff) + cp.absolute(y_m_diff)
m_diff = cp.absolute(t_m_diff) + m_xy_diff
m_diff_l = m_diff - l_m * 2
m_diff_l_sign = (cp.logical_xor(cp.sign(m_diff_l) + 1, True))
m_diff_l_eff = cp.multiply(m_diff, m_diff_l_sign)
m_diff_l_sign = cp.sign(m_diff_l_eff)
m_diff_l_H = cp.multiply(cp.multiply(cp.reciprocal(m_diff_l_eff + m_diff_l_sign - 1), m_diff_l_sign),
cp.log10(m_diff_l_eff + cp.absolute(m_diff_l_sign - 1)))
d_m = cp.reciprocal(cp.sum(m_diff_l_H,
(1,2)))
# Occupancy test
"""
t_m_o = t_m + o_m - 1
m_diff_o = cp.absolute(t_m_o - cp.transpose(t_m_o, (0, 2, 1))) - o_m - 1
m_occupancy = (cp.logical_xor(cp.sign(m_diff_o) + 1, True))
m_idn = cp.identity(n_order_points)
OT = cp.prod(cp.logical_or(m_xy_diff,
cp.logical_not(m_occupancy - m_idn)),
(1,2))
"""
G1 = max_order_matrix/max_ITC_matrix
G2 = TO_matrix/TC_matrix
BU = min_ITC_matrix/max_ITC_matrix
CI = cp.multiply(d_m, BU) # d_m * 0.1
E_matrix = G1 + G2 + BU + CI
cp.cuda.Stream.null.synchronize()
return (list(E_matrix), (list(max_ITC_matrix), list(TC_matrix), list(BU), list(CI)))
# Non-Paralleization
else:
print("[Scheduling] Must be use GPU to calculate")
for each_AGV_ID in _new_path.keys():
each_AGV_len_schedule = 0
each_AGV_num_orders = 0
if length_only:
each_AGV_len_schedule, each_num_order, each_order_list = _new_path[each_AGV_ID]
each_AGV_num_orders = each_num_order
else:
each_path = _new_path[each_AGV_ID]
for each_pos_path in each_path:
if len(each_pos_path) == 3:
each_AGV_num_orders += 1
each_AGV_len_schedule += 1
cost = each_AGV_len_schedule + each_AGV_num_orders
ITC[each_AGV_ID] = cost
if each_AGV_num_orders > max_order:
max_order = each_AGV_num_orders
total_order += each_AGV_num_orders
for _, each_value in ITC.items():
if each_value > max_ITC:
max_ITC = each_value
if each_value < min_ITC:
min_ITC = each_value
total_cost += each_value
TT = max_ITC
TTC = total_cost
BU = min_ITC / max_ITC
CI = 0
G1 = max_order/TT
G2 = total_order/TTC
value = G1 + G2 + BU + CI
return (value, (TT, TTC, BU, CI))