def scale_and_size_image(image, scalar, percentile_low, percentile_high):
image = img_as_float(image)
resize_shape = [int(x * scalar) for x in image.shape]
image = resize(image, resize_shape)
low, p98 = np.percentile(image, [percentile_low, percentile_high])
img_rescale = exposure.rescale_intensity(image, in_range=(low, p98))
return img_rescale
def apply(self, image_list):
self.descriptor = []
for i, image in enumerate(image_list):
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
desc, hog_image = None, None
if self.show_images:
desc, hog_image = hog(image=image,
orientations=self.orientation,
pixels_per_cell=self.pixels_per_cells,
cells_per_block=self.cells_per_block,
block_norm=self.block_norm,
visualize=self.show_images,
feature_vector=self.feature_vector)
fig, ax = plt.subplots(1,
2,
figsize=(8, 4),
sharex=True,
sharey=True)
ax[0].axis('off')
ax[1].axis('off')
hog_image = exposure.rescale_intensity(hog_image,
in_range=(0, 10))
ax[0].imshow(image_list[i])
ax[1].imshow(hog_image, cmap=plt.cm.gray)
plt.show()
else:
desc = hog(image=image,
orientations=self.orientation,
pixels_per_cell=self.pixels_per_cells,
cells_per_block=self.cells_per_block,
block_norm=self.block_norm,
visualize=self.show_images,
feature_vector=self.feature_vector)
self.descriptor.append(desc)
def _contrast_equalization(self, img):
'''
rescale intensities to maximize contrast
'''
from skimage.exposure.exposure import rescale_intensity
# from numpy import percentile
# Contrast stretching
# p2 = percentile(img, 2)
# p98 = percentile(img, 98)
return rescale_intensity(img).astype('uint8')
def imshow_rescale(im, rescale=True):
import matplotlib.pyplot as plt
im = np.array(im)
if rescale:
from skimage.exposure import exposure
p2, p98 = np.percentile(im, (2, 98))
im = exposure.rescale_intensity(im, in_range=(p2, p98))
plt.imshow(im, interpolation='nearest', aspect='auto', origin='lower')
show_plot()
def _pre_plot_image(self, image):
resize_shape = [
int(x * self.scalar) for x in self.system.camera.dimensions
]
image = resize(image, resize_shape)
image = adjust_gamma(image, gamma=self.gamma, gain=self.gain)
low, p98 = np.percentile(image,
[self.percentiles, 1 - self.percentiles])
img_rescale = exposure.rescale_intensity(image, in_range=(low, p98))
return image
def plot_imshow(simulations, rows, transpose=False, name=None):
simulations["MODEL"] = np.array(simulations["MODEL"])
simulations["HARDWARE"] = np.array(simulations["HARDWARE"])
fig, ax = plt.subplots(1, 2, figsize=figsize, sharex='all', sharey='all')
if name:
fig.suptitle(name, fontsize=14, fontweight='bold')
from skimage.exposure import exposure
inp = np.reshape(simulations["MODEL"], (-1, rows))
if transpose:
inp = inp.T
p2, p98 = np.percentile(inp, (2, 98))
inp = exposure.rescale_intensity(inp, in_range=(p2, p98))
ax[0].imshow(inp, interpolation='nearest', aspect='auto', origin='lower')
ax[0].set(title=f'MODEL')
ax[0].set_xlabel('Time')
ax[0].set_ylabel('Magnitude')
inp = np.reshape(simulations["MODEL"], (-1, rows))
if transpose:
inp = inp.T
p2, p98 = np.percentile(inp, (2, 98))
inp = exposure.rescale_intensity(inp, in_range=(p2, p98))
ax[1].imshow(inp, interpolation='nearest', aspect='auto', origin='lower')
ax[1].set(
title=
f'PYHA, SQNR={SQNR(simulations["MODEL"], simulations["HARDWARE"]):.2f} dB'
)
ax[1].set_xlabel('Time')
ax[1].set_ylabel('Magnitude')
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()
def _pre_plot_image(self, image):
# image = adjust_gamma(image, gamma=self.gamma, gain=self.gain)
try:
self.percentiles = [self.lower_var.get(), self.upper_var.get()]
except Exception as e:
pass
print(self.percentiles)
low, hi = np.percentile(image, self.percentiles)
print(low, hi)
img_rescale = exposure.rescale_intensity(image, in_range=(low, hi))
print(img_rescale)
return img_rescale
def generate_contrast_img(self):
img_path_crop = config.output_path_cropped_rectangle
pig_img_folders = os.listdir(img_path_crop)
for i, pig_name in enumerate(pig_img_folders):
img_path = os.path.join(img_path_crop, pig_name)
image_names = glob.glob(os.path.join(img_path, 'DSC*'))
for image_name in image_names:
image_name = os.path.basename(image_name)
img_orig = load_img(os.path.join(img_path, image_name))
img_orig_opencv = np.array(img_orig)
p2, p98 = np.percentile(img_orig_opencv, (2, 98))
img_rescale = exposure.rescale_intensity(img_orig_opencv,
in_range=(p2, p98))
pil_img = Pil_Image.fromarray(img_rescale)
aug_img_name = 'C-' + image_name
pil_img.save(os.path.join(img_path, aug_img_name))
self.log.info("augmentation in process sharpness: " + str(i))
self.log.info('augmentation finished (contrast)')
def white_balance(img):
width = img.shape[1]
height = img.shape[0]
# calculate the mean of the center block
block_size_R = 100
block_size_C = 100
center = [height / 2 - 1, width / 2 - 1]
center_block = img[int(center[0] - block_size_R / 2 +
1):int(center[0] + int(block_size_R / 2 + 1)),
int(center[1] - int(block_size_C / 2) +
1):int(center[1] + int(block_size_C / 2) + 1), :]
center_mean = np.mean((np.mean(center_block, axis=0)), axis=0)
balance = np.max(center_mean) / center_mean
# apply balance gain for each channel
img = img.astype(np.uint16)
img = img * balance
img = rescale_intensity(img, out_range=(0, 255))
return img.astype(np.uint8)
def car_plate_color(img, iteration=1):
"""
Color matching
:param img:
:param color: str, i.e. "green", "red", "blue"
:return:
"""
# define the lower and upper boundaries of the "car_plate" in the HSV color space
# from organge to yellow to green to cyan to blue
# plate_colorLower = (20, 43, 46)
# plate_colorUpper = (124, 255, 255)
# blue
plate_colorLower = (100, 43, 46)
plate_colorUpper = (124, 255, 255)
# white
white_colorLower = (0, 0, 221)
white_colorUpper = (180, 30, 255)
# black
black_colorLower = (0, 0, 0)
black_colorUpper = (180, 255, 46)
for i in range(iteration):
# rescale
img = exposure.rescale_intensity(img, out_range=(0, 255))
# resize the img, blur it, and convert it to the HSV color space
img = imutils.resize(img, width=300, inter=cv2.INTER_LANCZOS4)
ori_img = img
ori_h, ori_w = img.shape[:2]
img = cv2.copyMakeBorder(img,
int(0.2 * ori_h),
int(0.2 * ori_h),
int(0.2 * ori_w),
int(0.2 * ori_w),
cv2.BORDER_CONSTANT,
value=0)
blurred = cv2.GaussianBlur(img, (117, 117), 0)
hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
# construct a mask for the color, then perform a series of dilations and erosions to remove any small blobs left in the mask
mask_plate = cv2.inRange(hsv, plate_colorLower, plate_colorUpper)
# mask_white = cv2.inRange(hsv, white_colorLower, white_colorUpper)
# mask_black = cv2.inRange(hsv, black_colorLower, black_colorUpper)
# mask = cv2.bitwise_or(mask_white, mask_plate)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (150, 50))
mask = cv2.morphologyEx(mask_plate,
cv2.MORPH_CLOSE,
kernel,
iterations=1,
borderType=cv2.BORDER_CONSTANT,
borderValue=0)
mask = cv2.dilate(mask, None, iterations=2)
cnts = cv2.findContours(mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
if len(cnts) > 0:
c = sorted(cnts, key=cv2.contourArea, reverse=True)[0]
mask_cnts = np.zeros_like(mask, dtype=np.uint8)
cv2.drawContours(mask_cnts, [c], 0, (255, 255, 255), -1)
mask = mask_cnts
mask = np.dstack([mask, mask, mask])
img = cv2.bitwise_and(mask, img)
h, w = img.shape[:2]
img = img[int(0.2 * ori_h):h - int(0.2 * ori_h),
int(0.2 * ori_w):w - int(0.2 * ori_w)]
return img
def calculate(self, image: np.ndarray, mask: np.ndarray, **kwargs) -> np.ndarray:
stream = kwargs["stream"]
progress = kwargs["progress"]
# imshow(image)
# plt.show()
org = kwargs["origin"]
or_shape = image.shape
part = 500 / or_shape[1]
im_gr = rescale(image, part, anti_aliasing=False)
r, g, b = rescale(org[:, :, 0], part, anti_aliasing=False), rescale(org[:, :, 1], part, anti_aliasing=False), \
rescale(org[:, :, 2], part, anti_aliasing=False)
im_col = np.zeros((r.shape[0], r.shape[1], 3))
progress.progress(2)
for i in range(len(r)):
for j in range(len(r[i])):
im_col[i, j, 0] = r[i, j]
im_col[i, j, 1] = g[i, j]
im_col[i, j, 2] = b[i, j]
# im_col = rescale(org, part, anti_aliasing=False)
ma_sc = rescale(mask, part, anti_aliasing=False)
ma_sc = ma_sc > 0.5
progress.progress(5)
result = np.zeros(im_gr.shape)
le = len(ma_sc[0]) - 5
data = []
for i in tqdm(range(5, len(ma_sc) - 5)):
for j in range(5, le):
if not ma_sc[i, j]:
p = [*[float(i) for i in get_color_var(im_col, (i, j))],
*[float(i) for i in get_moments(im_gr, (i, j))]]
data.append(p)
result[i, j] = self.__tree.predict([p])
progress.progress(5 + int(80 * ((i + 1) / (len(ma_sc) - 10))))
data = self.__tree.predict(data)
dI = 0
for i in tqdm(range(5, len(ma_sc) - 5)):
for j in range(5, le):
if not ma_sc[i, j]:
result[i, j] = data[dI]
dI += 1
# imshow(result)
# plt.show()
stream[1].append(result)
stream[0].image(stream[1], width=300)
result = gaussian(result, 2)
# result = maximum(minimum(result, disk(6)), disk(7))
# imshow(result)
# plt.show()
stream[1].append(result)
stream[0].image(stream[1], width=300, clamp=True)
# result = minimum(maximum(result, disk(5)), disk(5))
p2, p98 = np.percentile(result, (10, 95))
result = exposure.rescale_intensity(result, in_range=(p2, p98))
# result = gaussian(result, 2)
# result = self.mult(result)
stream[1].append(result)
stream[0].image(stream[1], width=300, clamp=True)
# imshow(result)
# plt.show()
# result = np.where(result > 0.25, 1.0, 0.0)
# imshow(result)
# plt.show()
# stream[1].append(result)
# stream[0].image(stream[1], width=300)
result = resize(result, or_shape, anti_aliasing=False)
result = np.where(result > 0.4, 1.0, 0.0)
# imshow(result)
# plt.show()
return result
def contrast_augment(data, min_per, max_per):
# in_range = (np.percentile(data, q=min_per), np.percentile(data, q=max_per))
in_range = (min_per, max_per)
return exposure.rescale_intensity(data,
in_range=in_range,
out_range='image')