def mix_brock():
img_src1 = cv.imread("./img/1.png", 1)
img_src2 = cv.imread("./img/2.png", 1)
img_src3 = cv.imread("./img/3.png", 1)
try:
pal = cv.getTrackbarPos('hoge', winName)
except:
pal = 150
img_ave = img_src1 * (1 / 3) + img_src2 * (1 / 3) + img_src3 * (
1 / 3) + pal - 150
cv.imwrite("./img/mix.png", img_ave)
img = Image.open('./img/mix.png')
to_pil(cca.grey_world(from_pil(to_pil(cca.stretch(
from_pil(img)))))).save('./img/block.png')
try:
pal2 = cv.getTrackbarPos('hige', winName)
except:
pal2 = 0
if pal2 == 0:
to_pil(cca.grey_world(from_pil(to_pil(cca.stretch(
from_pil(img)))))).save('./img/block.png')
elif pal2 == 1:
to_pil(cca.retinex_with_adjust(cca.retinex(
from_pil(img)))).save('./img/block.png')
elif pal2 == 2:
to_pil(cca.stretch(from_pil(img))).save('./img/block.png')
def grey_world(self, img):
# convert to pil format
img_pil = self.opencv_to_pil(img)
img_gw_pil = to_pil(cca.grey_world(from_pil(img_pil)))
img_gw_opencv = cv2.cvtColor(np.array(img_gw_pil), cv2.COLOR_RGB2BGR)
return img_gw_opencv
def test_all(self):
to_pil(stretch(from_pil(self.img)))
to_pil(grey_world(from_pil(self.img)))
to_pil(retinex(from_pil(self.img)))
to_pil(max_white(from_pil(self.img)))
to_pil(retinex_with_adjust(retinex(from_pil(self.img))))
to_pil(
standard_deviation_weighted_grey_world(from_pil(self.img), 20, 20))
to_pil(
standard_deviation_and_luminance_weighted_gray_world(
from_pil(self.img), 20, 20))
to_pil(luminance_weighted_gray_world(from_pil(self.img), 20, 20))
to_pil(automatic_color_equalization(from_pil(self.img)))
def add_white_microscope(self, image):
image = cca.grey_world(from_pil(image)) # array np.uint8
circle = cv2.circle((np.ones(image.shape) * 255).astype(np.uint8),
(image.shape[0] // 2, image.shape[1] // 2),
random.randint(image.shape[0] // 2 - 10,
image.shape[0] // 2 + 10),
(0, 0, 0), -1)
mask = circle - 255
image[mask == 0] = 255
image = skimage.filters.gaussian(image, sigma=random.random())
image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX)
image = PIL.Image.fromarray(image.astype(np.uint8))
return image
def crop(filename, input_dir, output_dir, size=256, colorcorrect=False):
filename = Path(filename)
name = filename.name.replace(filename.suffix, '')
path_in = Path(input_dir) / filename
path_out_rgb_dir = Path(output_dir) / 'RGB'
path_out_nir_dir = Path(output_dir) / 'NIR'
ds = gdal.Open(str(path_in))
data_matrix = ds.ReadAsArray()
rgb = np.transpose(data_matrix[:3, :, :], (1, 2, 0))
nir = data_matrix[3, :, :]
height, width = nir.shape
hnum = height // size
wnum = width // size
num = 0
rejected = 0
for h in range(hnum):
for w in range(wnum):
crop_rgb = rgb[size * h:size * h + size, size * w:size * w + size]
crop_nir = nir[size * h:size * h + size, size * w:size * w + size]
if not check_nodata(crop_rgb, crop_nir):
rejected += 1
continue
if colorcorrect:
crop_rgb = cca.stretch(cca.grey_world(crop_rgb))
path_out_rgb = path_out_rgb_dir / '{}_{:06d}.png'.format(name, num)
path_out_nir = path_out_nir_dir / '{}_{:06d}.png'.format(name, num)
num += 1
Image.fromarray(crop_rgb).save(path_out_rgb)
Image.fromarray(crop_nir).save(path_out_nir)
print('{} images rejected'.format(rejected))
print('{} images generated'.format(num))
def color_balance(self, imgLabel, n_algorithm, image, displayed_image):
# Check if images exists
if not self.__images_exists():
return
# Choose algorithm and save original image
orig_image = copy.deepcopy(image)
if n_algorithm == 0:
image.paste(ccu.to_pil(cca.max_white(ccu.from_pil(image))))
elif n_algorithm == 1:
image.paste(ccu.to_pil(cca.grey_world(ccu.from_pil(image))))
elif n_algorithm == 2:
image.paste(
ccu.to_pil(
cca.automatic_color_equalization(ccu.from_pil(image))))
self.__paste_image__(image, displayed_image, imgLabel)
answer = tk.messagebox.askyesno("Changes prompt", "Apply changes?")
# If no, restore image
if not answer:
image.paste(orig_image.copy())
self.__paste_image__(image, displayed_image, imgLabel)
import colorcorrect.algorithm as cca
import numpy as np
import sys
def from_pil(pimg):
pimg = pimg.convert(mode='RGB')
nimg = np.array(pimg)[:]
# nimg.flags.writeable = True
return nimg
def to_pil(nimg):
return Image.fromarray(np.uint8(nimg))
if __name__ == "__main__":
img = Image.open(sys.argv[1])
# img.show()
to_pil(cca.stretch(from_pil(img)))
to_pil(cca.grey_world(from_pil(img)))
to_pil(cca.retinex(from_pil(img)))
to_pil(cca.max_white(from_pil(img)))
to_pil(cca.retinex_with_adjust(cca.retinex(from_pil(img))))
to_pil(cca.standard_deviation_weighted_grey_world(from_pil(img), 20, 20))
to_pil(
cca.standard_deviation_and_luminance_weighted_gray_world(
from_pil(img), 20, 20))
to_pil(cca.luminance_weighted_gray_world(from_pil(img), 20, 20))
to_pil(cca.automatic_color_equalization(from_pil(img)))
def collect_false(
bbs_dt_dict,
bbs_gt_dict,
data_path,
write_path,
num_neg_to_pick=0,
prob_threshold=0.,
overlap_threshold=0.5,
data_set_name='train',
ind_round=0,
flag_rescale=True,
target_width=32,
target_height=32,
flag_rgb=True,
flag_trans_aug=False,
dist_trans_list=(-2, 0, 2),
):
'''
Take detected bounding boxes and ground truth bounding boxes and output
global statistics including:
false positive per image
missing rate
precision at moth level
recall at moth level
'''
neg_examples = []
pos_examples = []
# change prob_threshold, if num_neg_to_pick is specified
if num_neg_to_pick > 0:
prob_threshold = get_neg_to_pick_thresh(bbs_dt_dict, num_neg_to_pick)
print "selected {} examples".format(num_neg_to_pick)
print "thresh set to {}".format(prob_threshold)
for img_name in bbs_dt_dict:
bbs_dt = bbs_dt_dict[img_name]
bbs_gt = bbs_gt_dict[img_name]
if prob_threshold > 0.:
bbs_dt = np.array(
[item for item in bbs_dt if item[4] > prob_threshold])
matches, unmatched_dt, unmatched_gt = match_bbs(
bbs_dt, bbs_gt, overlap_threshold)
try:
im = scipy.misc.imread(os.path.join(data_path, img_name))
except IOError:
logger.warn("There was a problem reading the jpg: %s." % img_name)
continue
im = grey_world(im)
if flag_rgb:
im_take = im
else:
im_y, im_i, im_q = colorsys.rgb_to_yiq(
*np.rollaxis(im[..., :3], axis=-1))
# the rollaxis command rolls the last (-1) axis back
# until the start
# do a colourspace conversion
im_take = im_y
def augment_bbs_by_trans_wrap(bbs_orig):
bbs_totake = np.cast['int'](bbs_orig)[:, :4]
if flag_trans_aug:
bbs_totake = x1y1x2y2_to_x1y1wh_batch(bbs_totake)
bbs_totake = augment_bbs_by_trans(bbs_totake, dist_trans_list)
bbs_totake = x1y1wh_to_x1y1x2y2_batch(bbs_totake)
return bbs_totake
def coord_valid(x1,
y1,
x2,
y2,
min_x=0,
min_y=0,
max_x=im_take.shape[1],
max_y=im_take.shape[0]):
return x1 < min_x or y1 < min_y or x2 > max_x or y2 > max_y
# gather negative examples from unmatched bb_dt
if len(unmatched_dt) > 0:
for x1, y1, x2, y2 in \
augment_bbs_by_trans_wrap(bbs_dt[unmatched_dt]):
if coord_valid(x1, y1, x2, y2):
continue
if y2 - y1 != target_height or x2 - x1 != target_width:
neg_examples.append(
scipy.misc.imresize(im_take[y1:y2, x1:x2],
(target_height, target_width)))
else:
neg_examples.append(im_take[y1:y2, x1:x2])
# gather positive examples from unmatched bb_gt
if len(unmatched_gt) > 0:
for x1, y1, x2, y2 in \
augment_bbs_by_trans_wrap(bbs_gt[unmatched_gt]):
if coord_valid(x1, y1, x2, y2):
continue
# !!! here the target sizes should take parameters instead
# of fixed 32 size.
# determine if the xy, width, height are postive and within
# range
values_with_in_range = x2 - x1 > 0 and y2 - y1 > 0 \
and y1 >= 0 and y2 < im_take.shape[0] \
and x1 >= 0 and x2 < im_take.shape[1]
if not values_with_in_range:
print "Bad boundingbox, ignored"
print x1, y1, x2 - x1, y2 - y1
continue
if flag_rescale:
im_p = crop_and_rescale(im_take, (x1, y1),
x2 - x1,
y2 - y1,
target_width=target_width,
target_height=target_height)
else:
im_p = crop_centered_box(im_take, (x1, y1),
x2 - x1,
y2 - y1,
target_width=target_width,
target_height=target_height)
pos_examples.append(im_p)
return pos_examples, neg_examples
# -*- coding: utf-8 -*-
import sys
from PIL import Image
from colorcorrect.algorithm import stretch, grey_world, retinex, retinex_with_adjust, max_white
from colorcorrect.algorithm import standard_deviation_weighted_grey_world
from colorcorrect.algorithm import standard_deviation_and_luminance_weighted_gray_world
from colorcorrect.algorithm import automatic_color_equalization
from colorcorrect.algorithm import luminance_weighted_gray_world
from colorcorrect.util import from_pil, to_pil
if __name__ == "__main__":
img = Image.open(sys.argv[1])
# img.show()
to_pil(stretch(from_pil(img)))
to_pil(grey_world(from_pil(img)))
to_pil(retinex(from_pil(img)))
to_pil(max_white(from_pil(img)))
to_pil(retinex_with_adjust(retinex(from_pil(img))))
to_pil(standard_deviation_weighted_grey_world(from_pil(img), 20, 20))
to_pil(
standard_deviation_and_luminance_weighted_gray_world(
from_pil(img), 20, 20))
to_pil(luminance_weighted_gray_world(from_pil(img), 20, 20))
to_pil(automatic_color_equalization(from_pil(img)))
temp_list[-1] = np.concatenate(temp_list[-1], axis=1)
return np.concatenate(temp_list, axis=0)
raw_dir = os.path.expanduser('~/Work/automoth/gen_fig/raw')
proc_dir = os.path.expanduser('~/Work/automoth/gen_fig/proc')
fig_dir = os.path.expanduser('~/Dropbox/automoth_paper/figs')
name_list = [name for name in os.listdir(raw_dir)]
path_list = [os.path.join(raw_dir, name) for name in name_list]
img_list = map(imread, path_list)
img_proc_list = []
# process images
for img, name in zip(img_list, name_list):
img_proc_list.append(grey_world(img))
imsave(os.path.join(proc_dir, name), img_proc_list[-1])
# concatenate and down sample for output
multi_size = (4, 4)
orig_size = img_list[0].shape[:2]
img_raw_cat = np.zeros(
tuple(np.array(multi_size) * np.array(orig_size)) + (3, ))
subsample = 2 # 2 or 4
imsave(os.path.join(fig_dir, 'colorcorrect_raw.png'),
concatenate_images(img_list)[::subsample, ::subsample, :])
imsave(os.path.join(fig_dir, 'colorcorrect_proc.png'),
concatenate_images(img_proc_list)[::subsample, ::subsample, :])
))
for i, file in enumerate(files_glob):
img = Image.open(file)
if args.negative is True:
print("Invert colors.")
img = ImageOps.invert(img)
if args.colorautoadjust is True:
print("Using automatic color equalization.")
img = to_pil(cca.automatic_color_equalization(from_pil(img)))
if args.colorstretch is True:
print("Using gray world color equalization.")
img = to_pil(cca.stretch(cca.grey_world(from_pil(img))))
if img.mode == "RGBA":
img.load()
background = Image.new("RGB", img.size, (255, 255, 255))
background.paste(img, mask=img.split()[3])
img = background
if args.monochrome is True:
if img.mode == "L" or img.mode == "LA":
pass
if img.mode != "RGB":
img = img.convert("RGB")
rgb = np.array(img, dtype="float32")
def get_neg(
data_path,
target_height,
target_width,
flag_rescale=True,
flag_rgb=True,
num_appr=2500,
flag_trans_aug=False,
dist_trans_list=(-2, 0, 2),
):
'''
generate negative training examples, which does not contain moths
'''
jpg_train = [f for f in os.listdir(data_path) if f.find('.jpg') > 0]
blobs = []
blob_resized_list = []
for i, j in enumerate(jpg_train):
try:
im = scipy.misc.imread(os.path.join(data_path, j))
except IOError:
logger.warn("There was a problem reading the jpg: %s." % j)
continue
im = grey_world(im)
# negative patches are extracted on color input image
contours, c_area = get_contours(im)
c_idx = np.argsort(c_area)[::-1] # largest first
contours = contours[c_idx]
c_area = c_area[c_idx]
# fig1, subs1 = plt.subplots(nrows=1, ncols=1)
# cv2.drawContours(im, contours[:2], -1, (0, 255, 0), -1)
# for c in xrange(2):
# boundingRect returns top left corner xy
# width, and height
# bx,by,bw,bh = cv2.boundingRect(contours[c])
# cv2.rectangle(im,(bx,by),(bx+bw,by+bh),(255,0,0),3) # draw rectangle in blue color)
# subs1.imshow(im, **imargs)
# subs1.set_title(j)
# plt.tight_layout()
if not flag_rgb:
# im will be assigned to the new gray image
# the rollaxis command rolls the last (-1) axis back until the start
# do a colourspace conversion
im, im_i, im_q = colorsys.rgb_to_yiq(
*np.rollaxis(im[..., :3], axis=-1))
# get certain amount of bbs from this image based on the approximate
# wanted number
num_per_image = num_appr / len(jpg_train)
if flag_trans_aug:
num_per_image = num_per_image / (len(dist_trans_list)**2)
bbs = []
for c in contours[:num_per_image]:
# boundingRect returns top left corner xy width, and height
bx, by, bw, bh = cv2.boundingRect(c)
xy = (bx, by)
bbs.append([xy, bx, by])
if flag_trans_aug:
bbs = augment_bbs_by_trans(bbs, dist_trans_list)
for (bx, by), bw, bh in bbs:
# remember y is indexed first in image
blob = im[by:(by + bh), bx:(bx + bw)]
blobs.append(blob)
# print moth.shape
if flag_rescale:
blob_resized = crop_and_rescale(im, xy, bw, bh, target_width,
target_height)
else:
blob_resized = crop_centered_box(im, xy, bw, bh, target_width,
target_height)
blob_resized_list.append(blob_resized)
return blob_resized_list
def get_pos(
data_path,
target_height,
target_width,
flag_rescale=False,
flag_multiscale=False,
flag_rgb=True,
detect_width_list=[8, 16, 32, 64],
detect_height_list=[8, 16, 32, 64],
flag_trans_aug=False,
dist_trans_list=(-2, 0, 2),
):
""" Get positive training examples
examples are rescaled to target_height and target_width
With the assumption that the annotation file have the same name with
the image but with no extension
flag_trans_aug: if do translation augmentation
"""
jpg_train = [f for f in os.listdir(data_path) if f.find('.jpg') > 0]
# moths = []
moth_resized_list = []
for i, j in enumerate(jpg_train):
try:
im = scipy.misc.imread(os.path.join(data_path, j))
except IOError:
logger.warn("There was a problem reading the jpg: %s." % j)
continue
im = grey_world(im)
if not flag_rgb:
# im will be assigned to the new gray image
# the rollaxis command rolls the last (-1) axis back until the start
# do a colourspace conversion
im, im_i, im_q = colorsys.rgb_to_yiq(
*np.rollaxis(im[..., :3], axis=-1))
ann_file = j.split('.')[0]
ann_path = os.path.join(data_path, ann_file)
annotation = get_annotation(ann_path)
# get all bbs for this image
bbs = get_bbs(annotation)
if flag_trans_aug:
bbs = augment_bbs_by_trans(bbs, dist_trans_list)
for xy, width, height in bbs:
x, y = xy
# determine if the xy, width, height are postive and within range
values_with_in_range = width > 0 and height > 0 \
and y >= 0 and y + height < im.shape[0] \
and x >= 0 and x + width < im.shape[1]
if not values_with_in_range:
print "Bad boundingbox, ignored"
print xy, width, height
continue
# remember y is indexed first in image
# moth = im[y:(y + height), x:(x + width)]
# moths.append(moth)
# print moth.shape
if flag_multiscale:
moth_resized = crop_and_rescale_nearest(
im,
xy,
width,
height,
target_width,
target_height,
detect_width_list=detect_width_list,
detect_height_list=detect_height_list)
elif flag_rescale:
moth_resized = crop_and_rescale(im, xy, width, height,
target_width, target_height)
else:
moth_resized = crop_centered_box(im, xy, width, height,
target_width, target_height)
moth_resized_list.append(moth_resized)
return moth_resized_list
def get_sliding_patch_features(data_path,
write_path,
target_width,
target_height,
x_stride,
y_stride,
detect_width=None,
detect_height=None,
n_images=-1,
flag_rgb=True,
img_ext='.jpg',
rot_kind=0):
# detect_width and detect_height are for the directly snipped patches from
# images.
# target_width and target_height are the sizes of classifier input
# determines if need to rescale and report
flag_rescaling_test = False
# determine if needed to rescale patches
if detect_height == target_height and detect_width == target_width:
print "Snipping patch sizes are equal to classifier input size."
elif detect_height is None or detect_width is None:
print "Patch sizes are not assigned. Assign them as classifier input size."
detect_height, detect_width = target_height, target_width
else:
flag_rescaling_test = True
print "Need to rescale patches to feed them into classifier."
if not flag_rescaling_test:
print "No need to rescale at test time."
img_train = [
img_f for img_f in os.listdir(data_path) if img_f.find(img_ext) > 0
]
# if n_images is specified, then only look at the first n_images
if n_images > 1:
img_train = img_train[:min(len(img_train), n_images)]
patch_feature_dict = {}
for ind_img, img_name in enumerate(img_train):
try:
im = imread(os.path.join(data_path, img_name))
except IOError:
logger.warn("There was a problem reading the image: %s." %
img_name)
continue
if im.ndim == 3:
im = grey_world(im)
# logger.debug("processing %s" % img_name)
# print "processing %s" % img_name
new_im_width = np.int(im.shape[1] * (1. * target_width / detect_width))
new_im_height = np.int(im.shape[0] *
(1. * target_width / detect_width))
if flag_rgb:
assert im.shape[2] == 3
im = imresize(im, (new_im_height, new_im_width))
# below is a slow implementation can remove
# windows_list = []
# for ind_rgb in range(3):
# shape (65, 88, 28, 28)
# windows = sliding_window(im[:, :, ind_rgb],
# win_height=target_height,
# win_width=target_width,
# x_stride=x_stride,
# y_stride=y_stride)
# windows_list.append(windows)
# shape (3, 65, 88, 28, 28)
# windows = np.asarray(windows_list)
# shape (65, 88, 28, 28, 3)
windows = sliding_window(im,
win_height=target_height,
win_width=target_width,
x_stride=x_stride,
y_stride=y_stride)
# shape (65, 88, 3, 28, 28)
windows = np.rollaxis(windows, 4, 2)
windows = rot_img_array(windows, kind=rot_kind)
# shape (65, 88, 2352)
windows = windows.reshape(
(windows.shape[0], windows.shape[1],
windows.shape[2] * windows.shape[3] * windows.shape[4]))
else:
# the rollaxis command rolls the last (-1) axis back until the start
# do a colourspace conversion
if im.ndim == 3:
im_y, im_i, im_q = colorsys.rgb_to_yiq(
*np.rollaxis(im[..., :3], axis=-1))
else:
im_y = im
im_y = imresize(im_y, (new_im_height, new_im_width))
windows = sliding_window(im_y,
win_height=target_height,
win_width=target_width,
x_stride=x_stride,
y_stride=y_stride)
# print windows.shape
windows = rot_img_array(windows, kind=rot_kind)
windows = windows.reshape((windows.shape[0], windows.shape[1],
windows.shape[2] * windows.shape[3]))
# shape (2352 or 784, 65, 88)
windows = np.rollaxis(windows, 2)
# n_d number of feature dimension,
# n_r number sliding windows in row direction
# n_c number sliding windows in column direction
n_d, n_r, n_c = windows.shape
# shape (2352 or 784, 65 * 88)
windows = windows.reshape(
(windows.shape[0], windows.shape[1] * windows.shape[2]))
# shape (65 * 88, 2352 or 784)
X = windows.T
patch_feature_dict[img_name] = X
# above is sliding window
return patch_feature_dict, n_r, n_c
