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 autoWhiteBalance(fl_input, fl_output, method = "automatic"):
print("imageProcessing::autoWhiteBalance(fl_input, fl_output, method = 'automatic'")
try:
# Open the image object to be adjusted.
img_pil_input = Image.open(fl_input)
# Define the empty image object.
img_pil_adj = None
if method == "stretch": img_pil_adj = to_pil(cca.stretch(from_pil(img_pil_input)))
elif method == "gray_world": img_pil_adj = to_pil(cca.gray_world(from_pil(img_pil_input)))
elif method == "max_white": img_pil_adj = to_pil(cca.max_white(from_pil(img_pil_input)))
elif method == "retinex": img_pil_adj = to_pil(cca.cca.retinex(from_pil(img_pil_input)))
elif method == "retinex_adjusted": img_pil_adj = to_pil(cca.retinex_with_adjust(from_pil(img_pil_input)))
elif method == "stdev_luminance": img_pil_adj = to_pil(cca.standard_deviation_and_luminance_weighted_gray_world(from_pil(img_pil_input)))
elif method == "stdev_grey_world": img_pil_adj = to_pil(cca.standard_deviation_weighted_grey_world(from_pil(img_pil_input)))
elif method == "luminance_weighted": img_pil_adj = to_pil(cca.luminance_weighted_gray_world(from_pil(img_pil_input)))
elif method == "automatic": img_pil_adj = to_pil(cca.automatic_color_equalization(from_pil(img_pil_input)))
# Save the adjusted image.
img_pil_adj.save(fl_output)
# Return the output file name.
return(fl_output)
except Exception as e:
print("Error occured in imageProcessing::autoWhiteBalance(fl_input, fl_output, method = 'automatic'")
print(str(e))
error.ErrorMessageImageProcessing(details=str(e), show=True, language="en")
return(None)
def stretch_eq(self, img):
# convert to pil format
img_pil = self.opencv_to_pil(img)
img_stretch_pil = to_pil(cca.stretch(from_pil(img_pil)))
img_stretch_opencv = cv2.cvtColor(np.array(img_stretch_pil),
cv2.COLOR_RGB2BGR)
return img_stretch_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 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 extract_and_save_features(path_to_tiles, path_to_save_features):
"""Extract ResNet features from tile images.
"""
model = ResNet50(weights='imagenet', include_top=True)
model = Model(inputs=model.inputs,
outputs=model.get_layer('avg_pool').output)
if not os.path.exists(path_to_save_features):
os.mkdir(path_to_save_features)
for cat in [
'ADI', 'MUC', 'BACK', 'LYM', 'NORM', 'DEB', 'MUS', 'STR', 'TUM'
]:
X = []
for filename in tqdm(os.listdir(os.path.join(path_to_tiles, cat))):
try:
tile = Image.open(os.path.join(path_to_tiles, cat, filename))
tile = to_pil(cca.stretch(from_pil(tile)))
tile = np.array(tile)
features = model.predict(preprocess_input(tile[np.newaxis]),
batch_size=1)
X.append(features)
except ZeroDivisionError:
pass
np.save(os.path.join(path_to_save_features, f'{cat}.npy'), np.array(X))
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 find_new_KLT(cap, frame_index):
face_found = False
nose_mask = []
old_gray = []
p0_nose = []
while(not face_found):
ret,frame = cap.read()
if ret == True:
frame = cca.stretch(cv2.resize(frame, FRAME_RESIZE))
cv2.imshow('frame',frame)
frame_index += 1
out.write(frame)
cv2.waitKey(1)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
(faces, eyes, noses) = get_features(gray)
nose_mask = np.zeros(gray.shape)
for (x,y,w,h) in faces:
# Detect the face and save to DF
cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0), 2)
for (ex,ey,ew,eh) in eyes:
cv2.rectangle(frame,(x+ex,y+ey),(x+ex+ew,y+ey+eh),(0,255,0),2)
print "Found face " + str(len(eyes)) + " " + str(len(noses))
for (nx,ny,nw,nh) in noses:
cv2.rectangle(frame,(x+nx,y+ny),(x+nx+nw,y+ny+nh),(0,0,255),2)
if (len(noses) == 1):
face_found = True
old_frame = frame
"""
for (ex,ey,ew,eh) in eyes:
# ex and ey are relative to the face frame, need to shift to entire frame
tx = ex+x
ty = ey+y
eye_mask[ty:ty+eh, tx:tx+ew] = 1.
"""
for (nx,ny,nw,nh) in noses:
# ex and ey are relative to the face frame, need to shift to entire frame
tx = nx+x
ty = ny+y+h/3
nose_mask[ty:ty+nh, tx:tx+nw] = 1.
nose_mask = nose_mask.astype(np.uint8)
break
# Take first frame and find corners in it
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
#p0_eyes = cv2.goodFeaturesToTrack(old_gray, mask = eye_mask, **feature_params)
p0_nose = cv2.goodFeaturesToTrack(old_gray, mask = nose_mask, **feature_params)
return (old_gray, frame_index, frame, p0_nose)
def getOneEvent(cap, frame_index, old_gray, p0_nose):
ERROR_ALLOWANCE = 5
if (cap.isOpened()):
ret, frame = cap.read()
if (ret == False):
print "NO FRAME FOUND"
raise NoFramesLeftError()
else:
# Within each iteration, there are 3 outcomes:
# 1. We have KLT points which are stable and within the Viola-Area
# 2. We have no KLT points, but we have a face. Initialize KLT.
frame = cca.stretch(cv2.resize(frame, FRAME_RESIZE))
frame_index += 1
out.write(frame)
cv2.waitKey(1)
this_event = dict(
time=time.time(),
isFrontFace=0,
faceLeft=-1,
faceRight=-1,
faceTop=-1,
faceBottom=-1,
noseX=-1,
noseY=-1,
frameIndex=-1
)
### KLT : Optical Flow
# calculate optical flow
while (p0_nose == None or len(p0_nose) < 3):
(old_gray, index, frame, p0_nose) = find_new_KLT(cap, frame_index)
frame_index = index
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
p1_nose, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0_nose, None, **lk_params)
good_new_nose = p1_nose[st==1]
good_old_nose = p0_nose[st==1]
# draw the tracks
for i,(new,old) in enumerate(zip(good_new_nose,good_old_nose)):
a,b = new.ravel()
c,d = old.ravel()
cv2.line(frame, (a,b),(c,d),(0,255,255), 2)
cv2.circle(frame,(a,b),5,(0,255,255),-1)
# Now update the previous frame and previous points
old_gray = frame_gray.copy()
p0_nose = good_new_nose.reshape(-1,1,2)
this_event.update(dict(
noseX=np.mean(p0_nose, axis=0)[0][0],
noseY=np.mean(p0_nose, axis=0)[0][1],
frameIndex = frame_index
))
################################################################################
### Viola-Jones : Regional Detection
(faces, eyes, noses) = get_features(frame_gray)
if (len(faces) == 1):
(x,y,w,h) = faces[0]
this_event.update(dict(
isFrontFace=1,
faceLeft=x,
faceRight=(x+w),
faceTop=(y),
faceBottom=(y+h)
))
# Detect the face and save to DF
cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0), 2)
for (ex,ey,ew,eh) in eyes:
cv2.rectangle(frame,(x+ex,y+ey),(x+ex+ew,y+ey+eh),(0,255,0),2)
if (len(noses) == 1):
(nx,ny,nw,nh) = noses[0]
i = 0
p0_nose_filter = np.ones(len(p0_nose), dtype=bool)
while i < len(p0_nose):
px = p0_nose[i][0][0]
py = p0_nose[i][0][1]
if not(px > x+nx-ERROR_ALLOWANCE and px < x+nx+nw+ERROR_ALLOWANCE) \
or not(py > y+ny+(h/3)-ERROR_ALLOWANCE and py < y+ny+nh+(h/3)+ERROR_ALLOWANCE):
p0_nose_filter[i] = False
i += 1
p0_nose = p0_nose[p0_nose_filter]
cv2.rectangle(frame,(x+nx,y+ny+(h/3)),(x+nx+nw,y+ny+nh+(h/3)),(0,0,255),2)
cv2.imshow('frame',frame)
cv2.waitKey(1)
return (this_event, frame_index, old_gray, p0_nose)
print "cap is closed"
return
def extract_tile_features(level, coord, zoom):
tile = np.array(zoom.get_tile(level, (coord[1], coord[2])))
tile = Image.fromarray(tile)
tile = to_pil(cca.stretch(from_pil(tile)))
tile = np.array(tile)
return tile
# -*- 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)))
print("Creation of the directory %s failed" % colcor_path)
else:
print("Successfully created the directory %s " % colcor_path)
Iter = 0
print("Executing...")
for thisFile in os.listdir(target_dir):
file_name = os.path.join(target_dir, thisFile)
if os.path.isfile(file_name):
file_name = os.path.join(target_dir, thisFile)
Iter += 1
print("\r" + str(Iter) + '/' + str(file_count), end='')
img = Image.open(file_name)
img = to_pil(cca.stretch(cca.gray_world(from_pil(img))))
img = ImageOps.autocontrast(img, 0)
img = img.filter(ImageFilter.SHARPEN)
basename = os.path.basename(file_name)
abs_filename = colcor_path + '/' + basename
img.save(abs_filename, quality=95)
print("\nDone.")
def find_new_KLT(cap, frame_index, ideal_width, ideal_height):
face_found = False
nose_mask = []
old_gray = []
p0_nose = []
while(not face_found):
ret,frame = cap.read()
if ret == True:
frame = cca.stretch(cv2.resize(frame, FRAME_RESIZE))
cv2.imshow('frame',frame)
frame_index += 1
out.write(frame)
cv2.waitKey(1)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
(faces, eyes, noses) = get_features(gray)
nose_mask = np.zeros(gray.shape)
# Determine best face
# Multiple faces in the frame
if len(faces) > 1:
largest_w = -1
#find the largest face
for (x,y,w,h) in faces:
if (w > largest_w):
# Face variables
fx = x
fy = y
fw = w
fh = h
# Only one, just use it
elif len(faces) == 1:
fx = faces[0][0]
fy = faces[0][1]
fw = faces[0][2]
fh = faces[0][3]
else:
continue
# Detect the face and save to DF
cv2.rectangle(frame,(fx,fy),(fx+fw,fy+fh),(255,0,0), 2)
for (ex,ey,ew,eh) in eyes:
cv2.rectangle(frame,(fx+ex,fy+ey),(fx+ex+ew,fy+ey+eh),(0,255,0),2)
print "Found face " + str(len(eyes)) + " " + str(len(noses))
for (nx,ny,nw,nh) in noses:
cv2.rectangle(frame,(fx+nx,fy+ny),(fx+nx+nw,fy+ny+nh),(0,0,255),2)
if (len(noses) == 1):
# Not set yet: take first face as the ideal
if (ideal_width < 0):
ideal_width = fw
ideal_height = fh
print "ideal w:" + str(ideal_width) + " h: " + str(ideal_height)
else:
if (fw < (0.9 * ideal_width) and fh < (0.9 * ideal_height)):
print "rejected due to size"
else:
face_found = True
old_frame = frame
for (nx,ny,nw,nh) in noses:
# ex and ey are relative to the face frame, need to shift to entire frame
tx = nx+fx
ty = ny+fy+fh/3
nose_mask[ty:ty+nh, tx:tx+nw] = 1.
nose_mask = nose_mask.astype(np.uint8)
# Take first frame and find corners in it
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
#p0_eyes = cv2.goodFeaturesToTrack(old_gray, mask = eye_mask, **feature_params)
p0_nose = cv2.goodFeaturesToTrack(old_gray, mask = nose_mask, **feature_params)
return (old_gray, frame_index, frame, p0_nose, ideal_width, ideal_height)
