def crop_image(x, target_height=227, target_width=227):
if isinstance(x, str):
image = skimage.img_as_float(skimage.io.imread(x)).astype(np.float32)
else:
image = skimage.img_as_float(x).astype(np.float32)
if len(image.shape) == 2:
image = np.tile(image[:,:,None], 3)
elif len(image.shape) == 4:
image = image[:,:,:,0]
height, width, rgb = image.shape
if width == height:
resized_image = cv2.resize(image, (target_height,target_width))
elif height < width:
resized_image = cv2.resize(image, (int(width * float(target_height)/height), target_width))
cropping_length = int((resized_image.shape[1] - target_height) / 2)
resized_image = resized_image[:,cropping_length:resized_image.shape[1] - cropping_length]
else:
resized_image = cv2.resize(image, (target_height, int(height * float(target_width) / width)))
cropping_length = int((resized_image.shape[0] - target_width) / 2)
resized_image = resized_image[cropping_length:resized_image.shape[0] - cropping_length,:]
return cv2.resize(resized_image, (target_height, target_width))
def transform_image(image, params=[], tags=[]):
image = apply_tags(image, tags)
image = extract_roi(image, params)
for k,v in params:
if k=='saturation':
saturation = float(v)
image = scale_saturation(image, saturation)
elif k=='gamma':
gamma = float(v)
image = np.power(img_as_float(image), gamma)
elif k=='brightness':
b = float(v)
image = (img_as_float(image) * b).clip(0.,1.)
elif k=='width':
scale = float(v) / image.shape[1]
image = rescale(image, scale)
elif k=='maxwidth':
w = float(v)
if image.shape[1] > w:
scale = w / image.shape[1]
image = rescale(image, scale)
elif k=='height':
scale = float(v) / image.shape[0]
image = rescale(image, scale)
elif k=='maxheight':
h = float(v)
if image.shape[0] > h:
scale = h / image.shape[0]
image = rescale(image, scale)
return image
def readTrainingFragment(datapath, fragList, imgSize=(1,224,224), meanImage=[], classNum=10):
ch, ih, iw = imgSize
fragLen = len(fragList)
if ch == 1:
X = np.zeros((fragLen, 1, ih, iw))
Y = np.zeros((fragLen), dtype=int)
idx = -1
print('reading data')
for f in fragList:
idx += 1
# print(f)
label = np.int(f[0])
img = skimage.img_as_float(skio.imread(datapath+f) )
# img -= meanImage
X[idx, 0, ...] = img
Y[idx] = label
elif ch == 3:
X = np.zeros((fragLen, 3, ih, iw))
Y = np.zeros((fragLen), dtype=int)
idx = -1
print('reading data')
for f in fragList:
idx += 1
label = np.int(f[0])
img = skimage.img_as_float(skio.imread(datapath+f) )
img = img.swapaxes(1, 2)
img = img.swapaxes(0, 1)
# img -= meanImage
X[idx, ...] = img
Y[idx] = label
X -= np.tile(meanImage, [fragLen, 1, 1, 1])
Y = np_utils.to_categorical(Y, classNum)
return X, Y
def main():
img = img_as_float(imread("HJoceanSmall.png"))
img_seam_v = img_as_float(imread("HJoceanSmall.png"))
img_transformed_v = img_as_float(imread("HJoceanSmall.png"))
iterations = 20
img_seam_v, img_transformed_v = seam_carve(iterations, img_seam_v, img_transformed_v)
figure()
subplot(221)
imshow(img)
title("1. Original")
subplot(222)
imshow(img_seam_v)
title("2. Seam carved vertical")
# Transposed Image
img_seam_hv = img_transformed_v.transpose(1, 0, 2)
img_transformed_hv = img_transformed_v.transpose(1, 0, 2)
iterations = 20
img_seam_hv, img_transformed_hv = seam_carve(iterations, img_seam_hv, img_transformed_hv)
subplot(223)
imshow(img_seam_hv.transpose(1, 0, 2))
title("3. Seam carved horizontal")
subplot(224)
imshow(img_transformed_hv.transpose(1, 0, 2))
title("4. Transformed Image")
show()
def image_compare(df, IMAGES_DIR='/home/ryan/asi_images/'):
'''
takes a list of n image ids and returns sum(n..n-1) n comparisons of r2 difference, r2(fft) difference, and average number of thresholded pixels
'''
img_buffer = {}
return_list = []
artdf = df[['_id', 'images']].copy()
artdf.images = artdf.images.apply(getpath)
paths = artdf[['_id','images']].dropna()
paths.index = paths._id
paths = paths.images
if paths.shape[0] < 2:
return DataFrame([])
for id_pair in combinations(paths.index, 2):
if id_pair[0] in img_buffer:
img1 = img_buffer[id_pair[0]]
else:
img_buffer[id_pair[0]] = img_as_float(rgb2gray(resize(imread(IMAGES_DIR + paths[id_pair[0]]), (300,300))))
img1 = img_buffer[id_pair[0]]
if id_pair[1] in img_buffer:
img2 = img_buffer[id_pair[1]]
else:
img_buffer[id_pair[1]] = img_as_float(rgb2gray(resize(imread(IMAGES_DIR + paths[id_pair[1]]), (300,300))))
img2 = img_buffer[id_pair[1]]
return_list.append(
[id_pair[0], id_pair[1], \
norm(img1 - img2), \
norm(fft2(img1) - fft2(img2)), \
#mean([sum(img1 > threshold_otsu(img1)), sum(img2 > threshold_otsu(img2))])]
#mean([sum(img1 > 0.9), sum(img2 > 0.9)])]
std(img1)+std(img2)/2.]
)
return DataFrame(return_list, columns=['id1','id2','r2diff', 'fftdiff', 'stdavg'])
def readTestingFragment(datapath, fragList, imgSize=(1,224,224), meanImage=[]):
ch, ih, iw = imgSize
fragLen = len(fragList)
if ch == 1:
X = np.zeros((fragLen, 1, ih, iw))
idx = -1
print('reading data')
for f in fragList:
idx += 1
# print(f)
img = skimage.img_as_float(skio.imread(datapath+f) )
# img -= meanImage
X[idx, 0, ...] = img
elif ch == 3:
X = np.zeros((fragLen, 3, ih, iw))
idx = -1
print('reading data')
for f in fragList:
idx += 1
img = skimage.img_as_float(skio.imread(datapath+f) )
img = img.swapaxes(1, 2)
img = img.swapaxes(0, 1)
# img -= meanImage
X[idx, ...] = img
X -= np.tile(meanImage, [fragLen, 1, 1, 1])
return X
def main():
img = imread('givenImg.png')
img = img_as_float(img)
subplot(1, 3, 1)
imshow(imread('givenImg.png'))
title('Given')
figure()
gray()
"""
>>>img = imread('givenImg.png')
>>>img = img_as_float(img)
>>>energy=dual_gradient_energy(img)
>>>minval,minIndex,sOfIJ=find_seam(img,energy)
>>>print minval
0.488050766739
"""
for i in range(50): #Plot 50 Seams
energy = dual_gradient_energy(img)
minval, minIndex, sOfIJ = find_seam(img, energy)
img = plot_seam(img, minIndex, sOfIJ)
subplot(1, 3, 2)
imshow(img)
title('Seam Plot')
img = imread('givenImg.png')
img = img_as_float(img)
for i in range(50): #Delete 50 Seams
energy = dual_gradient_energy(img)
minval, minIndex, sOfIJ = find_seam(img, energy)
print minval
img = remove_seam(img, minIndex, sOfIJ)
subplot(1, 3, 3)
imshow(img)
title('Resized Image')
show()
pass
def compute_mean_image(training_data_path, testing_data_path, save_flag=True, save_file=''):
print('computing mean images')
folder = os.listdir(training_data_path)
trainNum = len(folder)
init_flag = True
for f in folder:
img = skimage.img_as_float( skio.imread(training_data_path+f) )
if init_flag:
mean_image = img
init_flag = False
else:
mean_image += img
folder = os.listdir(testing_data_path)
testNum = len(folder)
for f in folder:
img = skimage.img_as_float( skio.imread(testing_data_path+f) )
mean_image += img
mean_image /= (trainNum + testNum)
if len(mean_image.shape) == 2:
'''if gray, (h, w) to (1, h, w)'''
tmp = np.zeros((1, mean_image.shape[0], mean_image.shape[1]))
tmp[0, ...] = mean_image
mean_image = tmp
else:
'''if color, swap (h, w, ch) to (ch, h, w)'''
mean_image = mean_image.swapaxes(1,2)
mean_image = mean_image.swapaxes(0,1)
if save_flag:
with open(save_file, 'wb') as f:
np.save(f, mean_image)
return mean_image
def computeMeanImage(trainingPath, testingPath, savePath, imgSize):
ch, ih, iw = imgSize
meanImage = np.zeros((ch, ih, iw))
print('computing mean image')
folder = os.listdir(trainingPath)
trainNum = 0
for f in folder:
if not f[-4:] == '.jpg':
continue
img = skimage.img_as_float( skio.imread(trainingPath+f) )
trainNum += 1
if ch == 3:
img = img.swapaxes(1, 2)
img = img.swapaxes(0, 1)
meanImage += img
folder = os.listdir(testingPath)
testNum = 0
for f in folder:
if not f[-4:] == '.jpg':
continue
img = skimage.img_as_float( skio.imread(testingPath+f) )
testNum += 1
if ch == 3:
img = img.swapaxes(1, 2)
img = img.swapaxes(0, 1)
meanImage += img
meanImage /= (trainNum + testNum)
with open(savePath, 'wb') as f:
np.save(f, meanImage)
def mpl_image_to_rgba(mpl_image):
"""Return RGB image from the given matplotlib image object.
Each image in a matplotlib figure has its own colormap and normalization
function. Return RGBA (RGB + alpha channel) image with float dtype.
Parameters
----------
mpl_image : matplotlib.image.AxesImage object
The image being converted.
Returns
-------
img : array of float, shape (M, N, 4)
An image of float values in [0, 1].
"""
image = mpl_image.get_array()
if image.ndim == 2:
input_range = (mpl_image.norm.vmin, mpl_image.norm.vmax)
image = rescale_intensity(image, in_range=input_range)
# cmap complains on bool arrays
image = mpl_image.cmap(img_as_float(image))
elif image.ndim == 3 and image.shape[2] == 3:
# add alpha channel if it's missing
image = np.dstack((image, np.ones_like(image)))
return img_as_float(image)
def find_movement():
# img = imread('shot1.jpg')
# img2 = imread('shot2.jpg')
img = imread("frame0.jpg")
img2 = imread("frame2.jpg")
img1 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
img1 = img_as_float(img1)
img2 = img_as_float(img2)
# print img1
h1, w1 = img1.shape
h2, w2 = img2.shape
img3 = zeros((h1, w1))
for x in range(0, h1 - 1):
for y in range(0, w1 - 1):
if abs(img1[x, y] - img2[x, y]) > 0.01:
# print img1[x, y], " ", img2[x, y]
img3[x, y] = 1
figure()
# subplot(1, 2, 1), imshow(img)
# subplot(1, 2, 2), \
imshow(img3)
show()
def repeated_sales(df, artistname, artname, r2thresh=7000, fftr2thresh=10000, IMAGES_DIR='/home/ryan/asi_images/'):
"""
Takes a dataframe, artistname and artname and tries to decide, via image matching, if there is a repeat sale. Returns a dict of lot_ids, each entry a list of repeat sales
"""
artdf = df[(df['artistID']==artistname) & (df['artTitle']==artname)]
artdf.images = artdf.images.apply(getpath)
paths = artdf[['_id','images']].dropna()
id_dict = {}
img_buffer = {}
already_ordered = []
for i, path_i in paths.values:
id_dict[i] = []
img_buffer[i] = img_as_float(rgb2gray(resize(imread(IMAGES_DIR + path_i), (300,300))))
for j, path_j in paths[paths._id != i].values:
if j > i and j not in already_ordered:
if j not in img_buffer.keys():
img_buffer[j] = img_as_float(rgb2gray(resize(imread(IMAGES_DIR + path_j), (300,300))))
if norm(img_buffer[i] - img_buffer[j]) < r2thresh and\
norm(fft2(img_buffer[i]) - fft2(img_buffer[j])) < fftr2thresh:
id_dict[i].append(j)
already_ordered.append(j)
for key in id_dict.keys():
if id_dict[key] == []:
id_dict.pop(key)
return id_dict
def __init__(self, headers, lightfield_name, darkfield_name):
"""
Load images from a detector for given Header(s). Subtract
dark images from each corresponding light image automatically.
Parameters
----------
headers : Header or list of Headers
lightfield_name : str
alias (data key) of lightfield images
darkfield_name : str
alias (data key) of darkfield images
Example
-------
>>> header = DataBroker[-1]
>>> images = SubtractedImages(header, 'my_lightfield', 'my_darkfield')
>>> for image in images:
# do something
"""
self.light = Images(headers, lightfield_name)
self.dark = Images(headers, darkfield_name)
if len(self.light) != len(self.dark):
raise ValueError("The streams from {0} and {1} have unequal "
"length and cannot be automatically subtracted.")
self._len = len(self.light)
example = img_as_float(self.light[0]) - img_as_float(self.dark[0])
self._dtype = example.dtype
self._shape = example.shape
def test_copy():
x = np.array([1], dtype=np.float64)
y = img_as_float(x)
z = img_as_float(x, force_copy=True)
assert y is x
assert z is not x
def main(image):
matplotlib.rcParams["font.size"] = 10
def show_img(img, axes):
"""Plot the image as float"""
# img = img_as_float(img)
ax_img = axes
ax_img.imshow(img, cmap=plt.cm.gray)
ax_img.set_axis_off()
return ax_img
# Open and read in the fits image
try:
fits = pyfits.open(image)
# fits = Image.open(image)
except IOError:
print "Can not read the fits image: " + image + " !!"
# Check the input image
img = fits[0].data
# img = np.array(fits)
if img.ndim != 2:
raise NameError("Data need to be 2-D image !")
# Logrithm scaling of the image
img_log = np.log10(img)
img_log = img_as_float(img_log)
# Contrast streching
p5, p95 = np.percentile(img, (2, 98))
img_rescale = exposure.rescale_intensity(img, in_range=(p5, p95))
# Adaptive equalization
img_new = bytescale(img_rescale)
img_ahe = exposure.equalize_adapthist(img_new, ntiles_x=16, ntiles_y=16, clip_limit=0.05, nbins=256)
img_ahe = img_as_float(img_ahe)
# Display results
fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(16, 5))
# Original image
ax_img = show_img(img_log, axes[0])
ax_img.set_title("Original")
# Contrast Enhanced one
ax_img = show_img(img_rescale, axes[1])
ax_img.set_title("Rescale")
# AHE Enhanced one
ax_img = show_img(img_ahe, axes[2])
ax_img.set_title("AHE")
# Prevent overlap of y-axis
fig.subplots_adjust(bottom=0.1, right=0.9, top=0.9, left=0.1, wspace=0.05)
# Save a PNG file
plt.gcf().savefig("ahe_test.png")
def test_bounding_values():
image = img_as_float(data.page())
template = np.zeros((3, 3))
template[1, 1] = 1
result = match_template(img_as_float(data.page()), template)
print(result.max())
assert result.max() < 1 + 1e-7
assert result.min() > -1 - 1e-7
def main():
"""
>>> img = imread('C:\Users\DELL\PycharmProjects\cc3\image.png')
>>> img = img_as_float(img)
>>> energy = dual_gradient_energy(img)
>>> minVal,minIndex,sOfTJ=find_seam(img,energy)
>>> img_modified, path = plot_seam(img, minIndex, sOfTJ)
>>> print minVal
0.488050766739
"""
img = imread("C:\Users\DELL\PycharmProjects\cc3\image.png")
img = img_as_float(img)
R = img[:, :, 0]
G = img[:, :, 1]
B = img[:, :, 2]
figure(1)
gray()
subplot(1, 4, 1)
imshow(img)
title("RGB")
subplot(1, 4, 2)
imshow(R)
title("Red")
subplot(1, 4, 3)
imshow(G)
title("Green")
subplot(1, 4, 4)
imshow(B)
title("Blue")
show()
energy = dual_gradient_energy(img)
figure(2)
subplot(2, 1, 1)
imshow(energy)
title("Dual Energy Gradient")
show()
for i in range(50):
energy = dual_gradient_energy(img)
val, index, seam = find_seam(img, energy)
img1, path = plot_seam(img, index, seam)
figure(3)
subplot(3, 2, 1)
imshow(img1)
title("Seams Plotted")
img = imread('C:\Users\DELL\PycharmProjects\cc3\image.png')
img = img_as_float(img)
for i in range(50):
energy = dual_gradient_energy(img)
val, index, seam = find_seam(img, energy)
img1, path = plot_seam(img, index, seam)
img = remove_seam(img1, path)
subplot(3, 2, 2)
imshow(img)
title("Seams Removed")
show()
def mpl_image_to_rgba(mpl_image):
"""Return RGB image from the given matplotlib image object.
Each image in a matplotlib figure has it's own colormap and normalization
function. Return RGBA (RGB + alpha channel) image with float dtype.
"""
input_range = (mpl_image.norm.vmin, mpl_image.norm.vmax)
image = rescale_intensity(mpl_image.get_array(), in_range=input_range)
image = mpl_image.cmap(img_as_float(image)) # cmap complains on bool arrays
return img_as_float(image)
def preprocess(im, blur=True, boxcar=True, noise_size=1, boxcar_width=5):
"""
Perform bluring and background subtraction of image.
Parameters
----------
im : ndarray
Image to preprocess.
blur : bool
If True, perform a Gaussian blur on each image.
boxcar : bool
If True, perfrom a boxcar (mean) filter to compute background.
The background is then subtracted.
noise_size : float
The characteristic length scale of noise in the images
in units of pixels. This is used to set the sigma value
in the Gaussian blur. Ignored if blur is False.
boxcar_width : int
Width of the boxcar filter. Should be an odd integer greater
than the pixel radius, but smaller than interparticle distance.
Returns
-------
output : ndarray, shape as im, dtype float
Blurred, background subtracted image.
"""
# Convert the image to float
im = skimage.img_as_float(im)
# Return image back if we do nothing
if not blur and not boxcar:
return skimage.img_as_float(im)
# Compute background using boxcar (mean) filter
if boxcar:
if boxcar_width % 2 == 0:
raise ValueError('boxcar_width must be odd.')
# Perform mean filter with a square structuring element
im_bg = scipy.ndimage.uniform_filter(im, boxcar_width)
else:
im_bg = 0.0
# Perform Gaussian blur
if blur:
im_blur = skimage.filters.gaussian(im, noise_size)
else:
im_blur = im
# Subtract background from blurred image
bg_subtracted_image = im_blur - im_bg
# Set negative values to zero and return
return np.maximum(bg_subtracted_image, 0)
def compute_mean_image(training_data_path
, testing_data_path
, save_file):
if os.path.exists(save_file):
logging.info("mean file already exists at %s, return it directly" % save_file)
mean_img = skio.imread(save_file)
logging.info("mean img is %s" % mean_img)
return mean_img
logging.info('computing mean images')
folder = ["c%d" % x for x in range(10)]
total_num = 0
mean_image = None
# count image first
for train_path in training_data_path:
for f in folder:
folder_path = os.path.join(train_path, f)
total_num += len(load_image_path_list(folder_path))
for path in testing_data_path:
total_num += len(load_image_path_list(path))
i = 0
for train_path in training_data_path:
for f in folder:
folder_path = os.path.join(train_path, f)
for img_path in load_image_path_list(folder_path):
i += 1
if i % 100 == 0:
logging.info("process %d/%d images now" % (i, total_num))
img = skimage.img_as_float(skio.imread(img_path))
if mean_image is None:
mean_image = np.zeros(img.shape)
mean_image += img / total_num
for path in testing_data_path:
for file_path in load_image_path_list(path):
i += 1
if i % 100 == 0:
logging.info("process %d/%d images now" % (i, total_num))
img = skimage.img_as_float( skio.imread(file_path))
mean_image += img / total_num
if save_file != "":
base_path = os.path.dirname(save_file)
if not os.path.exists(base_path):
os.makedirs(base_path)
with open(save_file, 'wb') as f:
imsave(f, mean_image)
logging.debug("saving mean file to %s" % save_file)
print mean_image
return mean_image
def match_ims(a, b):
""" Match the mean of image b to
image a; return image b.
"""
a = img_as_float(a)
b = img_as_float(b)
# z_im = (b - b.mean()) / b.std()
# renormed = a.mean() + z_im * a.std()
renormed = (b - b.mean()) + a.mean()
renormed[renormed < 0.] = 0.
renormed[renormed > 1.] = 1.
return renormed
def main():
img = pylab.imread('someimage.png') # getting the image
transpose_img = img.transpose(1, 0, 2) # getting the transpose image
img = img_as_float(img)
transpose_img = img_as_float(transpose_img)
seam = find_seam(img) # find seam
transpose_seam = find_seam(transpose_img) # find transpose seam
plot_seam(img, seam) # plot seam
plot_seam(transpose_img, transpose_seam) # plot transpose seam
pylab.figure()
pylab.subplot(2, 2, 1)
pylab.imshow(img) # plot original image
pylab.title("Original Image")
h, w = img.shape[:2]
print 'original image dimensions: W = ' + str(w) + ' H = ' + str(h)
pylab.subplot(2, 2, 2)
pylab.imshow(transpose_img) # plot transpose of original image
pylab.title("Transpose Image")
h, w = transpose_img.shape[:2]
print 'Transpose image dimensions: W = ' + str(w) + ' H = ' + str(h)
removed_img = remove_seam(img, seam)
for i in range(0, 49): # image after removing 50 seams
seam = find_seam(removed_img)
removed_img = remove_seam(removed_img, seam)
pylab.subplot(2, 2, 3)
pylab.imshow(removed_img) # plot original image after carving 50 times
pylab.title("Image after Carving")
h, w = removed_img.shape[:2]
print 'After carving image dimensions: W = ' + str(w) + ' H = ' + str(h)
removed_transpose_img = remove_seam(transpose_img, transpose_seam)
for i in range(0, 49): # transpose image after removing 50 seams
transpose_seam = find_seam(removed_transpose_img)
removed_transpose_img = remove_seam(removed_transpose_img, transpose_seam)
pylab.subplot(2, 2, 4)
pylab.imshow(removed_transpose_img) # plot original image after carving 50 times
pylab.title("Transpose Image after Carving")
h, w = removed_transpose_img.shape[:2]
print 'After carving transpose image dimensions: W = ' + str(w) + ' H = ' + str(h)
pylab.show()
def main():
args = sys.argv[1:]
if len(args) < 3:
print >> sys.stderr, 'check_dist.py a.png b.png out.pfm'
sys.exit(1)
if use_c:
pfm_arg = args[2]
if os.path.splitext(pfm_arg)[1] == '.mat':
nnf = read_mat(pfm_arg)
if nnf.shape[2] != 3:
nnf = numpy.dstack((nnf, numpy.zeros((nnf.shape[0], nnf.shape[1]))))
pfm_arg = '_temp_dist.pfm'
pfm.writepfm(nnf, pfm_arg)
ans = subprocess.check_output('./patchtable check_dist %s %s %s' % (args[0], args[1], pfm_arg), shell=True)
sys.stdout.write(ans)
return
a = skimage.img_as_float(skimage.io.imread(args[0]))
b = skimage.img_as_float(skimage.io.imread(args[1]))
if os.path.splitext(args[2])[1] == '.pfm':
nnf = pfm.readpfm(args[2])
else:
nnf = read_mat(args[2])
beh = b.shape[0]-patch_w+1
bew = b.shape[1]-patch_w+1
nnf_h = a.shape[0]-patch_w+1
nnf_w = a.shape[1]-patch_w+1
dimg = numpy.zeros((nnf_h, nnf_w))
for ay in range(nnf_h):
for ax in range(nnf_w):
bx = nnf[ay,ax,0]
by = nnf[ay,ax,1]
assert 0 <= bx < bew, (bx, bew)
assert 0 <= by < beh, (by, beh)
apatch = a[ay:ay+patch_w, ax:ax+patch_w, :].flatten()
bpatch = b[by:by+patch_w, bx:bx+patch_w, :].flatten()
d = (apatch-bpatch)
d = numpy.sqrt(numpy.sum(d*d))
dimg[ay,ax] = d
#d_nnf = numpy.sqrt(nnf[ay,ax,2])
#delta = abs(d-d_nnf)
#if delta > 1e-4:
# print 'error:', ay, ax, d, dcorrect
#print '0,0 nnf:', nnf[0,0,:]
#print '0,0 correct distance:', dimg[0,0]
#print '%d,0 nnf:'%(nnf_w-1), nnf[0,nnf_w-1,:]
#print '%d,0 correct distance:'%(nnf_w-1), dimg[0,nnf_w-1]
print numpy.mean(dimg.flatten())
def add_bg(self, nobgimg, bgid=None):
'''
Add background to the rendered image
The sky option in 'Render Layers' needs to be disabled
'''
import skimage.io
from skimage import img_as_float
import random
import numpy as np
if isinstance(nobgimg, str):
nobgimg = skimage.io.imread(nobgimg)
im = nobgimg
alpha = im[:,:,3]
im = im[:,:,0:3]
[h, w, c] = im.shape
bgfiles = self.get_bgfiles()
if bgid is None:
bgid = random.randint(0, len(bgfiles)-1)
bgfile = bgfiles[bgid]
L.debug('BG id is %d', bgid)
# bg = plt.imread(bgfile)
bg = skimage.io.imread(bgfile)
bg = img_as_float(bg)
im = img_as_float(im)
assert im.dtype == bg.dtype, 'im type %s and bg type %s' % (im.dtype, bg.dtype)
bgCrop = bg[0:h, 0:w, :]
L.debug('The range of alpha is (%f, %f)', alpha.min(), alpha.max())
fgmask = np.tile(alpha[:,:,np.newaxis], (1, 1, 3));
bgmask = 1 - fgmask;
combine = bgCrop * bgmask + im * fgmask
if L.isDebug():
L.debug('Show the images for composite')
import matplotlib.pyplot as plt
plt.subplot(2,2,1)
plt.imshow(im)
plt.subplot(2,2,2)
plt.imshow(bgCrop)
plt.subplot(2,2,3)
plt.imshow(combine)
plt.show()
return combine
def ssim(self, image1, image2):
image1 = Image.open(image1).convert('RGB')
if image1.size[0] > 300:
new_size = (300, int(image1.size[1] / image1.size[0] * 300))
else:
new_size = image1.size
print(image1.size, new_size)
image1 = image1.resize(new_size)
image2 = Image.open(image2).resize(new_size).convert('RGB')
image1 = array(image1)
image2 = array(image2)
img1 = img_as_float(image1)
img2 = img_as_float(image2)
return compare_ssim(img1, img2, win_size=None, gradient=False, multichannel=True)
def ReadInFaces(Faces, NFaces):
for index in range(100):
# if (sys.platform == 'linux2'):
# path1 = "Faces/face" + str(index) + ".png"
# path2 = "NonFaces/nface" + str(index) + ".png"
# else:
# path1 = "Faces\\face" + str(index) + ".png"
# path2 = "NonFaces\\nface" + str(index) + ".png"
path1 = "Testset\\test" + str(index) + ".png"
path2 = "Testset\\test" + str(index + 100) + ".png"
Faceimage = skimage.img_as_float(skimage.io.imread(path1))
NFaceimage = skimage.img_as_float(skimage.io.imread(path2))
Faces[index] = Faceimage
NFaces[index] = NFaceimage
return
def _detect(self, board):
input_images = [transformer.preprocess('data', skimage.img_as_float(square).astype(np.float32)) for square in row for row in board]
net.blobs['data'].data[...] = np.array(input_images)
out = net.forward()['prob']
predictions = np.asarray(map(lambda x: categories[x], np.argmax(out, axis=1)))
prob = np.sum(np.max(out, axis=1))
return np.reshape(predictions, (8, 8)), prob
def mono_check(plugin, fmt='png'):
"""Check the roundtrip behavior for images that support most types.
All major input types should be handled.
"""
img = img_as_ubyte(data.moon())
r1 = roundtrip(img, plugin, fmt)
testing.assert_allclose(img, r1)
img2 = img > 128
r2 = roundtrip(img2, plugin, fmt)
testing.assert_allclose(img2.astype(np.uint8), r2)
img3 = img_as_float(img)
r3 = roundtrip(img3, plugin, fmt)
if r3.dtype.kind == 'f':
testing.assert_allclose(img3, r3)
else:
testing.assert_allclose(r3, img_as_uint(img))
img4 = img_as_int(img)
if fmt.lower() in (('tif', 'tiff')):
img4 -= 100
r4 = roundtrip(img4, plugin, fmt)
testing.assert_allclose(r4, img4)
else:
r4 = roundtrip(img4, plugin, fmt)
testing.assert_allclose(r4, img_as_uint(img4))
img5 = img_as_uint(img)
r5 = roundtrip(img5, plugin, fmt)
testing.assert_allclose(r5, img5)
def save_segmented_image(self, filepath_image, modality='t1c', show=False):
'''
Creates an image of original brain with segmentation overlay and save it in ./predictions
INPUT (1) str 'filepath_image': filepath to test image for segmentation, including file extension
(2) str 'modality': imaging modality to use as background. defaults to t1c. options: (flair, t1, t1c, t2)
(3) bool 'show': If true, shows output image. defaults to False.
OUTPUT (1) if show is True, shows image of segmentation results
(2) if show is false, returns segmented image.
'''
modes = {'flair': 0, 't1': 1, 't1c': 2, 't2': 3}
segmentation = self.predict_image(filepath_image, show=False)
print 'segmentation = ' + str(segmentation)
img_mask = np.pad(segmentation, (16, 16), mode='edge')
ones = np.argwhere(img_mask == 1)
twos = np.argwhere(img_mask == 2)
threes = np.argwhere(img_mask == 3)
fours = np.argwhere(img_mask == 4)
test_im = io.imread(filepath_image)
test_back = test_im.reshape(5, 216, 160)[modes[modality]]
# overlay = mark_boundaries(test_back, img_mask)
gray_img = img_as_float(test_back)
# adjust gamma of image
image = adjust_gamma(color.gray2rgb(gray_img), 0.65)
sliced_image = image.copy()
red_multiplier = [1, 0.2, 0.2]
yellow_multiplier = [1, 1, 0.25]
green_multiplier = [0.35, 0.75, 0.25]
blue_multiplier = [0, 0.25, 0.9]
print str(len(ones))
print str(len(twos))
print str(len(threes))
print str(len(fours))
# change colors of segmented classes
for i in xrange(len(ones)):
sliced_image[ones[i][0]][ones[i][1]] = red_multiplier
for i in xrange(len(twos)):
sliced_image[twos[i][0]][twos[i][1]] = green_multiplier
for i in xrange(len(threes)):
sliced_image[threes[i][0]][threes[i][1]] = blue_multiplier
for i in xrange(len(fours)):
sliced_image[fours[i][0]][fours[i][1]] = yellow_multiplier
#if show=True show the prediction
if show:
print 'Showing...'
io.imshow(sliced_image)
plt.show()
#save the prediction
print 'Saving...'
try:
mkdir_p('./predictions/')
io.imsave('./predictions/' + os.path.basename(filepath_image) + '.png', sliced_image)
print 'prediction saved.'
except:
io.imsave('./predictions/' + os.path.basename(filepath_image) + '.png', sliced_image)
print 'prediction saved.'
def test_histogram_of_oriented_gradients():
img = img_as_float(data.astronaut()[:256, :].mean(axis=2))
fd = feature.hog(img, orientations=9, pixels_per_cell=(8, 8),
cells_per_block=(1, 1))
assert len(fd) == 9 * (256 // 8) * (512 // 8)
def stabilize_video(f_name,
use_first_as_reference=False,
print_full_results=False,
use_gaussian_weights=True,
selected_points=None):
"""
Stabilization of video sample.
:param f_name: path to the video sample file
:param use_first_as_reference: use first frame as a reference image, default is False
:param print_full_results: if you want print all results from stabilization
:param use_gaussian_weights: use gaussian weights in SSIM calculation
:param selected_points: selected 5 points
"""
if selected_points is None:
selected_points = {}
capture = cv2.VideoCapture(f_name)
frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
frame_size = (int(capture.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT)) - 65)
fps = capture.get(cv2.CAP_PROP_FPS)
stabilized_video_name = f_name + "_stabilized.avi"
vid_writer = get_video_writer(stabilized_video_name, frame_size, fps)
print("Start stabilization of video:", f_name)
print("Using first frame as reference:", use_first_as_reference)
image_process = ImageProcess()
r_frames = 0
print_results = []
first = True
first_i, image1 = None, None
euclid_distances = []
start_time = time.time()
while True:
ret, image2 = capture.read()
if ret:
# read the camera image:
rows, cols, _ = image2.shape
image2 = image2[65:rows, 0:cols]
if first:
first = False
image1 = np.copy(image2)
first_i = image1
if not selected_points:
selected_points = image_process.select_reference_points(
image2)
else:
# perform stabilization
if use_first_as_reference:
result, print_result = image_process.stabilize_picture(
first_i, image2)
ref_image = img_as_float(image_process.to_gray(first_i))
else:
result, print_result = image_process.stabilize_picture(
image1, image2)
ref_image = img_as_float(image_process.to_gray(image1))
if r_frames % 10 == 0:
tracking_points = image_process.tracking_points(
selected_points, result)
euclid_distances.append(
image_process.euclid_distance(selected_points,
tracking_points))
# write stabilized frame
vid_writer.write(result)
image1 = np.copy(result)
# compute SSIM index
res_image = img_as_float(image_process.to_gray(result))
print_result['score'] = ssim(
ref_image,
res_image,
data_range=res_image.max() - res_image.min(),
multichannel=True,
gaussian_weights=use_gaussian_weights)
print_result['rmse'] = image_process.rmse(ref_image, res_image)
print_results.append(print_result)
print("'\rRemaining frames: {0}. Actual frame: {1}".format(
frames - r_frames, r_frames),
end='')
else:
break
r_frames += 1
if capture.isOpened():
capture.release()
if vid_writer.isOpened():
vid_writer.release()
print("'\rRemaining frames: DONE", end='\n')
print("Result stabilized video:", stabilized_video_name)
print("-STATS--------------")
print("DURATION:", round(time.time() - start_time, 3), "s")
print("EUCLID DISTANCES: ", euclid_distances)
euclid_average = mean_euclid_distances(euclid_distances)
print("EUCLID DISTANCES AVERAGE: ", euclid_average)
if print_full_results:
ImageProcess.print_ordered("ALL RESULTS::", print_results)
av = sum(item.get('score', 0)
for item in print_results) / len(print_results)
print("MSSIM AVERAGE: ", round(av * 100, 2))
rmse = sum(item.get('rmse', 0)
for item in print_results) / len(print_results)
print("RMSE AVERAGE: ", round(rmse * 100, 2))
print()
def active_contour(image,
snake,
alpha=0.01,
beta=0.1,
w_line=0,
w_edge=1,
gamma=0.01,
bc='periodic',
max_px_move=1.0,
max_iterations=2500,
convergence=0.1):
"""Active contour model.
Active contours by fitting snakes to features of images. Supports single
and multichannel 2D images. Snakes can be periodic (for segmentation) or
have fixed and/or free ends.
The output snake has the same length as the input boundary.
As the number of points is constant, make sure that the initial snake
has enough points to capture the details of the final contour.
Parameters
----------
image : (N, M) or (N, M, 3) ndarray
Input image.
snake : (N, 2) ndarray
Initialisation coordinates of snake. For periodic snakes, it should
not include duplicate endpoints.
alpha : float, optional
Snake length shape parameter. Higher values makes snake contract
faster.
beta : float, optional
Snake smoothness shape parameter. Higher values makes snake smoother.
w_line : float, optional
Controls attraction to brightness. Use negative values to attract to
dark regions.
w_edge : float, optional
Controls attraction to edges. Use negative values to repel snake from
edges.
gamma : float, optional
Explicit time stepping parameter.
bc : {'periodic', 'free', 'fixed'}, optional
Boundary conditions for worm. 'periodic' attaches the two ends of the
snake, 'fixed' holds the end-points in place, and'free' allows free
movement of the ends. 'fixed' and 'free' can be combined by parsing
'fixed-free', 'free-fixed'. Parsing 'fixed-fixed' or 'free-free'
yields same behaviour as 'fixed' and 'free', respectively.
max_px_move : float, optional
Maximum pixel distance to move per iteration.
max_iterations : int, optional
Maximum iterations to optimize snake shape.
convergence: float, optional
Convergence criteria.
Returns
-------
snake : (N, 2) ndarray
Optimised snake, same shape as input parameter.
References
----------
.. [1] Kass, M.; Witkin, A.; Terzopoulos, D. "Snakes: Active contour
models". International Journal of Computer Vision 1 (4): 321
(1988).
Examples
--------
>>> from skimage.draw import circle_perimeter
>>> from skimage.filters import gaussian
Create and smooth image:
>>> img = np.zeros((100, 100))
>>> rr, cc = circle_perimeter(35, 45, 25)
>>> img[rr, cc] = 1
>>> img = gaussian(img, 2)
Initiliaze spline:
>>> s = np.linspace(0, 2*np.pi,100)
>>> init = 50*np.array([np.cos(s), np.sin(s)]).T+50
Fit spline to image:
>>> snake = active_contour(img, init, w_edge=0, w_line=1) #doctest: +SKIP
>>> dist = np.sqrt((45-snake[:, 0])**2 +(35-snake[:, 1])**2) #doctest: +SKIP
>>> int(np.mean(dist)) #doctest: +SKIP
25
"""
split_version = scipy.__version__.split('.')
if not (split_version[-1].isdigit()):
split_version.pop()
scipy_version = list(map(int, split_version))
new_scipy = scipy_version[0] > 0 or \
(scipy_version[0] == 0 and scipy_version[1] >= 14)
if not new_scipy:
raise NotImplementedError(
'You are using an old version of scipy. '
'Active contours is implemented for scipy versions '
'0.14.0 and above.')
max_iterations = int(max_iterations)
if max_iterations <= 0:
raise ValueError("max_iterations should be >0.")
convergence_order = 10
valid_bcs = [
'periodic', 'free', 'fixed', 'free-fixed', 'fixed-free', 'fixed-fixed',
'free-free'
]
if bc not in valid_bcs:
raise ValueError("Invalid boundary condition.\n" +
"Should be one of: " + ", ".join(valid_bcs) + '.')
img = img_as_float(image)
RGB = img.ndim == 3
# Find edges using sobel:
if w_edge != 0:
if RGB:
edge = [
sobel(img[:, :, 0]),
sobel(img[:, :, 1]),
sobel(img[:, :, 2])
]
else:
edge = [sobel(img)]
for i in range(3 if RGB else 1):
edge[i][0, :] = edge[i][1, :]
edge[i][-1, :] = edge[i][-2, :]
edge[i][:, 0] = edge[i][:, 1]
edge[i][:, -1] = edge[i][:, -2]
else:
edge = [0]
# Superimpose intensity and edge images:
if RGB:
img = w_line*np.sum(img, axis=2) \
+ w_edge*sum(edge)
else:
img = w_line * img + w_edge * edge[0]
# Interpolate for smoothness:
if new_scipy:
intp = RectBivariateSpline(np.arange(img.shape[1]),
np.arange(img.shape[0]),
img.T,
kx=2,
ky=2,
s=0)
else:
intp = np.vectorize(
interp2d(np.arange(img.shape[1]),
np.arange(img.shape[0]),
img,
kind='cubic',
copy=False,
bounds_error=False,
fill_value=0))
x, y = snake[:, 0].astype(np.float), snake[:, 1].astype(np.float)
xsave = np.empty((convergence_order, len(x)))
ysave = np.empty((convergence_order, len(x)))
# Build snake shape matrix for Euler equation
n = len(x)
a = np.roll(np.eye(n), -1, axis=0) + \
np.roll(np.eye(n), -1, axis=1) - \
2*np.eye(n) # second order derivative, central difference
b = np.roll(np.eye(n), -2, axis=0) + \
np.roll(np.eye(n), -2, axis=1) - \
4*np.roll(np.eye(n), -1, axis=0) - \
4*np.roll(np.eye(n), -1, axis=1) + \
6*np.eye(n) # fourth order derivative, central difference
A = -alpha * a + beta * b
# Impose boundary conditions different from periodic:
sfixed = False
if bc.startswith('fixed'):
A[0, :] = 0
A[1, :] = 0
A[1, :3] = [1, -2, 1]
sfixed = True
efixed = False
if bc.endswith('fixed'):
A[-1, :] = 0
A[-2, :] = 0
A[-2, -3:] = [1, -2, 1]
efixed = True
sfree = False
if bc.startswith('free'):
A[0, :] = 0
A[0, :3] = [1, -2, 1]
A[1, :] = 0
A[1, :4] = [-1, 3, -3, 1]
sfree = True
efree = False
if bc.endswith('free'):
A[-1, :] = 0
A[-1, -3:] = [1, -2, 1]
A[-2, :] = 0
A[-2, -4:] = [-1, 3, -3, 1]
efree = True
# Only one inversion is needed for implicit spline energy minimization:
inv = scipy.linalg.inv(A + gamma * np.eye(n))
# Explicit time stepping for image energy minimization:
for i in range(max_iterations):
if new_scipy:
fx = intp(x, y, dx=1, grid=False)
fy = intp(x, y, dy=1, grid=False)
else:
fx = intp(x, y, dx=1)
fy = intp(x, y, dy=1)
if sfixed:
fx[0] = 0
fy[0] = 0
if efixed:
fx[-1] = 0
fy[-1] = 0
if sfree:
fx[0] *= 2
fy[0] *= 2
if efree:
fx[-1] *= 2
fy[-1] *= 2
xn = np.dot(inv, gamma * x + fx)
yn = np.dot(inv, gamma * y + fy)
# Movements are capped to max_px_move per iteration:
dx = max_px_move * np.tanh(xn - x)
dy = max_px_move * np.tanh(yn - y)
if sfixed:
dx[0] = 0
dy[0] = 0
if efixed:
dx[-1] = 0
dy[-1] = 0
x += dx
y += dy
# Convergence criteria needs to compare to a number of previous
# configurations since oscillations can occur.
j = i % (convergence_order + 1)
if j < convergence_order:
xsave[j, :] = x
ysave[j, :] = y
else:
dist = np.min(
np.max(
np.abs(xsave - x[None, :]) + np.abs(ysave - y[None, :]),
1))
if dist < convergence:
break
return np.array([x, y]).T
def sr_saliency(rgb_image, sigma=3, display_result=False):
"""This Function computes Spectral Residue Based Saliency map
Parameters
----------
Inputs
rgbimage: M x N x 3 array (rgb color image)
rgb input image for computation of saliency
sigma: scalar ,optional
standard deviation of the smoothing filter for
smoothed log magnitude of input rgbimage
display_result: bool value, optional
set true if you want the result to be displayed
Returns
-------
Outputs: 2D array
function return the saliency map of the rgbimage.
Number of rows and cols of output is same as input
References
----------
Xiaodi Hou,Liquin Zhang,
Saliency Detection: A spectral residue approach
IEEE Computer Visoin and Pattern Recognition(2007)
Examples:
>>filename = 'image.jpg'(path of image)
>>rgb_image = imread(filename);
>>saliency_map = sr_saliency(rgb_image,display_result = True)
"""
#handle cases where the input isn't an rgbimage
try:
gray_image = rgb2gray(rgb_image)
except ValueError:
gray_image = rgb_image
gray_image = img_as_float(gray_image)
# Spectral Residue Computation
#compute fourier transform on image
fft_gray_image = fftpack.fft2(gray_image)
log_magnitude = np.log(np.abs(fft_gray_image))
phase = np.angle(fft_gray_image)
#smooth the log magnitude response
avg_log_magnitude = filters.gaussian_filter(log_magnitude,
sigma,
mode="nearest")
#compute spectral residue
spectral_residual = log_magnitude - avg_log_magnitude
#find inverse fourier transform of spectral residue to obtain the saliency map
saliency_map = np.abs(fftpack.ifft2(np.exp(spectral_residual +
1j * phase)))**2
saliency_map = ndimage.gaussian_filter(saliency_map, sigma=3)
#display option
if (display_result):
plt.imshow(saliency_map)
plt.show()
return saliency_map
import cv2
from matplotlib import pyplot as plt
from skimage import io, img_as_float
from skimage.restoration import denoise_tv_chambolle
img = img_as_float(io.imread('images/noisy/noisy_gaussian.jpg'))
# plt.hist(img.flat, bins=100, range=(0, 1))
# plt.show()
denoise_img = denoise_tv_chambolle(img,
weight=0.1,
eps=0.0002,
n_iter_max=200,
multichannel=True)
io.imsave('images/chambolle_denois.jpg', denoise_img)
plt.hist(denoise_img.flat, bins=100,
range=(0, 1)) # .flat returns the flattened numpy array (1D)
cv2.imshow("Original", img)
cv2.imshow("TV Filtered", denoise_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def process(self, image): processor = LocalMax(self.squareSize) localMax = skimage.img_as_float(processor.process(image)) log.saveNumpyImage(localMax, processor.name()) return image * ((image + self.range) >= localMax)
def setup(self):
self.image = img_as_float(data.moon())
self.image = rescale(self.image, 2.0, anti_aliasing=False)
### Example script showing how to perform a weighted 2D Total-Variation filtering with proxTV
import prox_tv as ptv
import numpy as np
from pylab import *
import matplotlib.pyplot as plt
import time
import skimage as ski
from skimage import data, io, filters, color, util
# Load image
X = io.imread('colors.png')
X = ski.img_as_float(X)
X = color.rgb2gray(X)
# Introduce noise
noiseLevel = 0.01
N = util.random_noise(X, mode='speckle', var=noiseLevel)
# Gradient in columns
W1 = 0.01 * np.cumsum(np.ones((X.shape[0] - 1, X.shape[1])), 1)
W2 = 0.01 * np.ones((X.shape[0], X.shape[1] - 1))
print('Solving 2D weighted TV...')
start = time.time()
FW = ptv.tv1w_2d(N, W1, W2)
end = time.time()
print('Elapsed time ' + str(end - start))
plt.subplot(3, 4, 1)
io.imshow(W1)
plt.title('Weights along columns')
plt.subplot(3, 4, 5)
import pandas as pd
from sklearn.cluster import KMeans
from skimage.io import imread
from skimage import img_as_float
import pylab
import numpy as np
from ml_intro.custutils import to_path
# read data as numpy array with shape n * m * 3, where n an dm is image sizes
image = imread(to_path('parrots.jpg'))
# show image
pylab.imshow(image)
# skimage float format is value in range [0; 1]
img_float = img_as_float(image)
# Reshape array to construct features-objects: every pixel is object, every
# object has 3 features - R, G, B
# reshape with -1: total array size divided by product of all other listed
# dimensions (in this case last dim is 3)
X = img_float.reshape(-1, img_float.shape[-1])
# data frame will be used to groupby by clusters
clust_data = pd.DataFrame(X, columns=['R', 'G', 'B'])
# define psnr - Peak signal-to-noise ratio
def psnr(y_true, y_pred):
"""both params should be vectors, otherwise reshape(-1) performed
for details see https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
in this implementation assumed that image encoded in float format which
means max signal value is 1.0"""
if len(y_true.shape) > 1:
lamda = 0.05
rho = 100
K = 200
err = 0.0001
para_tv = pa.Parameter(lamda, rho, K, err, 0)
lamda = 0.1
rho = 50
K = 200
err = 0.0001
alpha_ratio = 0.5
para_mctv = pa.Parameter(lamda, rho, K, err, alpha_ratio)
# denoising
X1 = tv2d.denoising_2D_TV(noi_img, para_tv)
X2 = img_as_float(mpimg.imread('NLTV.jpg'))
X3 = mctv2d.denoising_2D_MCTV(noi_img, para_mctv)
# plot demo result figure
plt.figure()
plt.subplots_adjust(left=0.05,
bottom=0.05,
right=0.95,
top=0.95,
wspace=0.05,
hspace=0.05)
sub_plot_org()
sub_plot_res(4, noi_img, 'Noisy Image')
sub_plot_res(6, X1, 'TV')
sub_plot_res(8, X2, 'NLTV')
factor = cholesky(A)
x = factor(b)
x = x.reshape(img.shape, order='F').toarray()
else:
x = sparse.linalg.spsolve(A, b)
x = x.reshape(img.shape, order='F')
time_taken = time.time() - start_time
print(solver, " time:", time_taken)
return x
if __name__ == "__main__":
#TODO: Replace with your own image
im = io.imread(path.join('images', 'task4.jpg'), as_gray=True)
im = skimage.img_as_float(im)
G = img2grad_field(im)
Gm = np.sqrt(np.sum(G * G, axis=2))
w = 1 / (Gm + 0.0001) # To avoid pinching artefacts
# imr = reconstruct_grad_field(G,w,im[0,0], im, "spsolve").clip(0,1)
imr = reconstruct_grad_field(G, w, im[0, 0], im, "cholesky").clip(0, 1)
plt.figure(figsize=(9, 3))
plt.subplot(131)
plt.title('Original')
plt.axis('off')
plt.imshow(im, cmap='gray')
u,v = get_window(img, x, y, b)
out[y,x] = np.amax(u+v)
return out
def opening(img,b):
return dialate(erode(img,b),b)
def closing(img,b):
return erode(dialate(img,b),b)
def disc(r):
r2 = r//2
t = np.fromfunction(lambda x,y: (x-r2)**2+(y-r2)**2 <=r2**2,(r,r))
w = np.zeros((r,r))
w[t]=1
return w
img = io.imread("input/Fig0935(a)(ckt_board_section).tif")
img = skimage.img_as_float(img)
d3 = disc(3*2+1)*0.2
d5 = disc(5*2+1)*0.2
f,axs = plt.subplots(1,3,figsize=(12,9))
axs[0].imshow(img,cmap="gray")
axs[1].imshow(opening(img,d3),cmap="gray")
axs[2].imshow(closing(img,d5),cmap="gray")
plt.show()
def test_each_channel():
filtered = edges_each(COLOR_IMAGE)
for i, channel in enumerate(np.rollaxis(filtered, axis=-1)):
expected = img_as_float(filter.sobel(COLOR_IMAGE[:, :, i]))
assert_allclose(channel, expected)
import matplotlib.pyplot as plt
from skimage import img_as_float
import skimage.segmentation
from img import mydata as my
image = img_as_float(my.hollywood())
image = image.sum(-1)
# print(image)
# Feel free to play around with the parameters to see how they impact the result
cv = skimage.segmentation.chan_vese(image,
mu=0.25,
lambda1=1,
lambda2=1,
tol=1e-3,
max_iter=200,
dt=0.5,
init_level_set="checkerboard",
extended_output=True)
fig, axes = plt.subplots(2, 2, figsize=(8, 8))
ax = axes.flatten()
ax[0].imshow(image, cmap="gray")
ax[0].set_axis_off()
ax[0].set_title("Original Image", fontsize=12)
ax[1].imshow(cv[0], cmap="gray")
ax[1].set_axis_off()
title = "Chan-Vese segmentation - {} iterations".format(len(cv[2]))
ax[1].set_title(title, fontsize=12)
cfg = {
'disp_path': '/media/tom/seagate-8tb-ext4/data/kitti_derived/monodepth_disparities_kitti/disparities_pp.npy',
'output_path': '/home/tom/Dropbox/PhD/Experiments/ICCV2019_depth/matlab/roll_fit.csv',
'output_img': '/home/tom/Dropbox/PhD/Experiments/ICCV2019_depth/matlab/roll_fit.png',
'index': 0,
'test_disp': (0.03, 0.031),
'roll_range': np.linspace(-30.0, 30.0, 100),
'image_shape': (375, 1242),
}
disp = np.load(cfg['disp_path'], mmap_mode='r')
disp = disp[cfg['index']]
disp = resize(disp, cfg['image_shape'])
slice = (cfg['test_disp'][0] < disp) & (disp < cfg['test_disp'][1])
h, theta, d = hough_line(slice, theta=np.linspace(np.deg2rad(90 - 30), np.deg2rad(90 + 30), 250))
_, angles, dists = hough_line_peaks(h, theta, d, num_peaks=1)
roll = 90 - np.rad2deg(angles[0])
y0 = dists[0] / np.sin(angles[0])
y1 = (dists[0] - slice.shape[1] * np.cos(angles[0])) / np.sin(angles[0])
plt.imshow(img_as_float(slice))
plt.plot([0, slice.shape[1]], [y0, y1])
with open(cfg['output_path'], 'wt') as f:
w = csv.writer(f)
w.writerow([y0, y1])
imsave(cfg['output_img'], img_as_float(slice))
def standardize(self, x):
"""Apply the normalization configuration to a batch of inputs.
# Arguments
x: batch of inputs to be normalized.
# Returns
The inputs, normalized.
"""
if self.preprocessing_function:
x = self.preprocessing_function(x)
if self.rescale:
x *= self.rescale
# x is a single image, so it doesn't have image number at index 0
img_channel_axis = self.channel_axis - 1
if self.samplewise_center:
x -= np.mean(x, axis=img_channel_axis, keepdims=True)
if self.samplewise_std_normalization:
x /= (np.std(x, axis=img_channel_axis, keepdims=True) + 1e-7)
if self.featurewise_center:
if self.mean is not None:
x -= self.mean
else:
warnings.warn('This ImageDataGenerator specifies '
'`featurewise_center`, but it hasn\'t'
'been fit on any training data. Fit it '
'first by calling `.fit(numpy_data)`.')
if self.featurewise_std_normalization:
if self.std is not None:
x /= (self.std + 1e-7)
else:
warnings.warn('This ImageDataGenerator specifies '
'`featurewise_std_normalization`, but it hasn\'t'
'been fit on any training data. Fit it '
'first by calling `.fit(numpy_data)`.')
if self.zca_whitening:
if self.principal_components is not None:
flatx = np.reshape(x, (x.size))
whitex = np.dot(flatx, self.principal_components)
x = np.reshape(whitex, (x.shape[0], x.shape[1], x.shape[2]))
else:
warnings.warn('This ImageDataGenerator specifies '
'`zca_whitening`, but it hasn\'t'
'been fit on any training data. Fit it '
'first by calling `.fit(numpy_data)`.')
# Define Custom CLAHE Algorithm For Image Preprocessing
if self.adaptive_equalization:
if np.shape(x)[2] == 1:
x = exposure.equalize_adapthist(x, clip_limit=0.03, nbins=48)
if np.shape(x)[2] == 3:
x = img_as_float(x)
img_hsv = color.rgb2hsv(x)
brightness = img_hsv[:, :, 2]
with warnings.catch_warnings():
warnings.simplefilter("ignore")
b_adapteq = exposure.equalize_adapthist(brightness,
clip_limit=0.03,
nbins=48)
img_hsv[:, :, 2] = b_adapteq
x = color.hsv2rgb(img_hsv)
else:
warnings.warn('Improper Image Size - Expected Format - ?,?,3')
return x
def inpaint_biharmonic(image, mask, multichannel=False):
"""Inpaint masked points in image with biharmonic equations.
Parameters
----------
image : (M[, N[, ..., P]][, C]) ndarray
Input image.
mask : (M[, N[, ..., P]]) ndarray
Array of pixels to be inpainted. Have to be the same shape as one
of the 'image' channels. Unknown pixels have to be represented with 1,
known pixels - with 0.
multichannel : boolean, optional
If True, the last `image` dimension is considered as a color channel,
otherwise as spatial.
Returns
-------
out : (M[, N[, ..., P]][, C]) ndarray
Input image with masked pixels inpainted.
References
----------
.. [1] N.S.Hoang, S.B.Damelin, "On surface completion and image inpainting
by biharmonic functions: numerical aspects",
:arXiv:`1707.06567`
.. [2] C. K. Chui and H. N. Mhaskar, MRA Contextual-Recovery Extension of
Smooth Functions on Manifolds, Appl. and Comp. Harmonic Anal.,
28 (2010), 104-113,
:DOI:`10.1016/j.acha.2009.04.004`
Examples
--------
>>> img = np.tile(np.square(np.linspace(0, 1, 5)), (5, 1))
>>> mask = np.zeros_like(img)
>>> mask[2, 2:] = 1
>>> mask[1, 3:] = 1
>>> mask[0, 4:] = 1
>>> out = inpaint_biharmonic(img, mask)
"""
if image.ndim < 1:
raise ValueError('Input array has to be at least 1D')
img_baseshape = image.shape[:-1] if multichannel else image.shape
if img_baseshape != mask.shape:
raise ValueError('Input arrays have to be the same shape')
if np.ma.isMaskedArray(image):
raise TypeError('Masked arrays are not supported')
image = skimage.img_as_float(image)
mask = mask.astype(np.bool)
# Split inpainting mask into independent regions
kernel = ndi.morphology.generate_binary_structure(mask.ndim, 1)
mask_dilated = ndi.morphology.binary_dilation(mask, structure=kernel)
mask_labeled, num_labels = label(mask_dilated, return_num=True)
mask_labeled *= mask
if not multichannel:
image = image[..., np.newaxis]
out = np.copy(image)
for idx_channel in range(image.shape[-1]):
known_points = image[..., idx_channel][~mask]
limits = (np.min(known_points), np.max(known_points))
for idx_region in range(1, num_labels+1):
mask_region = mask_labeled == idx_region
_inpaint_biharmonic_single_channel(mask_region,
out[..., idx_channel], limits)
if not multichannel:
out = out[..., 0]
return out
def run_to_task():
import general_utils
from general_utils import RuntimeDeterminedEnviromentVars
tf.logging.set_verbosity(tf.logging.ERROR)
args = parser.parse_args()
imgs = args.im_name.split(',')
if args.task == 'ego_motion' and len(imgs) != 3:
raise ValueError('Wrong number of images, expecting 3 but got {}'.format(len(imgs)))
if args.task != 'ego_motion' and len(imgs) != 2:
raise ValueError('Wrong number of images, expecting 2 but got {}'.format(len(imgs)))
task = args.task
if task not in list_of_tasks:
raise ValueError('Task not supported')
cfg = generate_cfg(task)
input_img = np.empty((len(imgs),256,256,3), dtype=np.float32)
for i,imname in enumerate(imgs):
img = load_raw_image_center_crop( imname )
img = skimage.img_as_float(img)
scipy.misc.toimage(np.squeeze(img), cmin=0.0, cmax=1.0).save(imname)
img = cfg[ 'input_preprocessing_fn' ]( img, **cfg['input_preprocessing_fn_kwargs'] )
input_img[i,:,:,:] = img
input_img = input_img[np.newaxis, :]
print("Doing {task}".format(task=task))
general_utils = importlib.reload(general_utils)
tf.reset_default_graph()
training_runners = { 'sess': tf.InteractiveSession(), 'coord': tf.train.Coordinator() }
############## Set Up Inputs ##############
# tf.logging.set_verbosity( tf.logging.INFO )
setup_input_fn = utils.setup_input
inputs = setup_input_fn( cfg, is_training=False, use_filename_queue=False )
RuntimeDeterminedEnviromentVars.load_dynamic_variables( inputs, cfg )
RuntimeDeterminedEnviromentVars.populate_registered_variables()
start_time = time.time()
############## Set Up Model ##############
model = utils.setup_model( inputs, cfg, is_training=False )
m = model[ 'model' ]
model[ 'saver_op' ].restore( training_runners[ 'sess' ], cfg[ 'model_path' ] )
predicted, representation = training_runners['sess'].run(
[ m.decoder_output, m.encoder_output ], feed_dict={m.input_images: input_img} )
if args.store_rep:
s_name, file_extension = os.path.splitext(args.store_name)
with open('{}.npy'.format(s_name), 'wb') as fp:
np.save(fp, np.squeeze(representation))
if args.store_pred:
s_name, file_extension = os.path.splitext(args.store_name)
with open('{}_pred.npy'.format(s_name), 'wb') as fp:
np.save(fp, np.squeeze(predicted))
if task == 'ego_motion':
ego_motion(predicted, args.store_name)
return
if task == 'fix_pose':
cam_pose(predicted, args.store_name, is_fixated=True)
return
if task == 'non_fixated_pose':
cam_pose(predicted, args.store_name, is_fixated=False)
return
if task == 'point_match':
prediction = np.argmax(predicted, axis=1)
print('the prediction (1 stands for match, 0 for unmatch)is: ', prediction)
return
############## Clean Up ##############
training_runners[ 'coord' ].request_stop()
training_runners[ 'coord' ].join()
print("Done: {}".format(config_name))
############## Reset graph and paths ##############
tf.reset_default_graph()
training_runners['sess'].close()
return
def save_video_sidebyside(videofile,
percept,
savefile,
fps=30,
ffmpeg_path=None,
libav_path=None):
"""Saves both an input video and the percept to file, side-by-side.
This function creates a new video from an input video file and a
:py:class`~pulse2percept.stimuli.TimeSeries` object, assuming they
correspond to model input and model output, and plots them side-by-side.
Both input video and percept are resampled according to ``fps``.
The percept is resized to match the height of the input video.
Parameters
----------
videofile : str
File name of input video.
percept : :py:class:`~pulse2percept.stimuli.TimeSeries`
A TimeSeries object with dimension (M, N, C, T) or (M, N, T), where
T is the number of frames, M is the height, N is the width, and C is
the number of channels.
savefile : str
File name of output video.
fps : int, optional, default: 30
Desired frame rate of output video.
ffmpeg_path : str, optional, default: system's default path
Path to ffmpeg library.
libav_path : str, optional, default: system's default path
Path to libav library.
"""
if not has_skvideo:
raise ImportError("You do not have scikit-video installed. "
"You can install it via $ pip install sk-video.")
if not has_skimage:
raise ImportError("You do not have scikit-image installed. "
"You can install it via $ pip install scikit-image.")
if not isinstance(percept, TimeSeries):
raise TypeError("`percept` must be of type TimeSeries.")
# Set the path if necessary
_set_skvideo_path(ffmpeg_path, libav_path)
# Load video from file
video = load_video(videofile,
as_timeseries=True,
ffmpeg_path=ffmpeg_path,
libav_path=libav_path)
# Re-sample time series to new frame rate
new_tsample = 1.0 / float(fps)
video = video.resample(new_tsample)
percept = percept.resample(new_tsample)
# After re-sampling, both video and percept should have about the same
# length (up to some rounding error)
combined_len = np.minimum(video.shape[-1], percept.shape[-1])
if np.abs(video.shape[-1] - percept.shape[-1]) > 5:
raise ValueError('Could not resample percept, len(video)='
'%d != len(percept)=%d.' %
(video.shape[-1], percept.shape[-1]))
# Up-scale percept to fit video dimensions
pheight = video.shape[0]
pwidth = int(percept.shape[1] / float(percept.shape[0]) * video.shape[0])
# Show the two side-by-side
combined = np.zeros((combined_len, pheight, video.shape[1] + pwidth, 3))
combined = combined.astype(np.float32)
for i in range(combined_len):
vframe = skimage.img_as_float(video.data[..., i])
pframe = percept.data[..., i] / percept.data.max()
pframe = skimage.img_as_float(pframe)
pframe = sic.gray2rgb(
sit.resize(pframe, (pheight, pwidth), mode='reflect'))
combined[i, ...] = np.concatenate((vframe, pframe), axis=1)
save_video(combined,
savefile,
fps=fps,
ffmpeg_path=ffmpeg_path,
libav_path=libav_path)
_gaussian_blur_locals = util.TypeSignatureSet(
['input_img', 'output_img'])
_ignore_names = [
'_log_argtype_value', '_argtype_values', '_ignore_names'
]
_locals_typeconfig = dict([
(_k, util.CythonType.from_value(_v, None, error_variable=_k))
for (_k, _v) in locals().items() if _k not in _ignore_names
])
_gaussian_blur_locals.add(_locals_typeconfig)
input_img = 'small_temple_rgb.png'
input_img_rgb = skimage.io.imread(input_img)
input_img_rgb = skimage.img_as_float(input_img_rgb)
def test(input_img_rgb=input_img_rgb):
_exc = None
try:
def inner_func():
ans = gaussian_blur(input_img_rgb, np.zeros(input_img_rgb.shape))
return ans
ans = inner_func()
except Exception as _e:
_exc = _e
def save_video(data,
filename,
width=None,
height=None,
fps=30,
ffmpeg_path=None,
libav_path=None):
"""Saves a video to file.
This function stores a NumPy ndarray to file using Scikit-Video.
Parameters
----------
data : ndarray | TimeSeries
Video data as a NumPy ndarray must have dimension (T, M, N, C),
(T, M, N), (M, N, C), or (M, N), where T is the number of frames,
M is the height, N is the width, and C is the number of channels (must
be either 1 for grayscale or 3 for RGB).
Video data as a TimeSeries object must have dimension (M, N, C, T) or
(M, N, T). The sampling step will be used as the video's frame rate.
filename : str
Video file name.
width : int, optional
Desired width of the movie.
Default: Automatically determined based on ``height`` (without changing
the aspect ratio). If ``height`` is not given, the percept's original
width is used.
height : int, optional
Desired height of the movie.
Default: Automatically determined based on `width` (without changing
the aspect ratio). If ``width`` is not given, the percept's original
height is used.
fps : int, optional, default: 30
Desired frame rate of the video (frames per second).
ffmpeg_path : str, optional, default: system's default path
Path to ffmpeg library.
libav_path : str, optional, default: system's default path
Path to libav library.
Notes
-----
To distinguish between 3-D inputs of shape (T, M, N) and (M, N, C), the
last dimension is checked: If it is small (<= 4), it is most likely a
color channel - hence the input is interpreted as (M, N, C).
Else it is interpreted as (T, M, N).
"""
if not has_skvideo:
raise ImportError("You do not have scikit-video installed. "
"You can install it via $ pip install sk-video.")
if not has_skimage:
raise ImportError("You do not have scikit-image installed. "
"You can install it via $ pip install scikit-image.")
is_ndarray = is_timeseries = False
if isinstance(data, np.ndarray):
is_ndarray = True
elif isinstance(data, TimeSeries):
is_timeseries = True
else:
raise TypeError('Data to be saved must be either a NumPy ndarray '
'or a ``TimeSeries`` object')
# Set the path if necessary, then choose backend
_set_skvideo_path(ffmpeg_path, libav_path)
if skvideo._HAS_FFMPEG:
backend = 'ffmpeg'
else:
backend = 'libav'
if is_ndarray:
# Use Scikit-Video utility to interpret dimensions and convert to
# (T, M, N, C)
data = skvideo.utils.vshape(data)
oldheight = data.shape[1]
oldwidth = data.shape[2]
length = data.shape[0]
elif is_timeseries:
# Resample the percept to the given frame rate
new_tsample = 1.0 / float(fps)
d_s = 'old: tsample=%f' % data.tsample
d_s += ', shape=' + str(data.shape)
data = data.resample(new_tsample)
d_s = 'new: tsample=%f' % new_tsample
d_s += ', shape=' + str(data.shape)
oldheight = data.shape[0]
oldwidth = data.shape[1]
length = data.shape[-1]
# Calculate the desired height and width
if not height and not width:
height = oldheight
width = oldwidth
elif height and not width:
width = int(height * 1.0 / oldheight * oldwidth)
elif width and not height:
height = int(width * 1.0 / oldwidth * oldheight)
d_s = "Video scaled to (M, N, T) = (%d, %d, %d)." % (height, width, length)
# Reshape and scale the data
savedata = np.zeros((length, height, width, 3), dtype=np.float32)
for i in range(length):
if is_ndarray:
frame = skimage.img_as_float(data[i, ...])
elif is_timeseries:
frame = data.data[..., i] / float(data.data.max())
frame = skimage.img_as_float(frame)
# resize wants the data to be between 0 and 1
frame = sic.gray2rgb(sit.resize(frame, (height, width),
mode='reflect'))
savedata[i, ...] = frame * 255.0
# Set the input frame rate and frame size
inputdict = {}
inputdict['-r'] = str(int(fps))
inputdict['-s'] = '%dx%d' % (width, height)
# Set the output frame rate
outputdict = {}
outputdict['-r'] = str(int(fps))
# Save data to file
svio.vwrite(filename,
savedata,
inputdict=inputdict,
outputdict=outputdict,
backend=backend)
logging.getLogger(__name__).info("Saved video to file '%s'." % filename)
def cv2_image_to_caffe(image):
return skimage.img_as_float(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)).astype(
np.float32)
array = np.array([
-math.pi, math.pi, -math.pi / 2, -math.pi * 3 / 4, -math.pi / 4, 0,
math.pi / 4, math.pi / 2, math.pi * 3 / 4
])
idx = (np.abs(array - value)).argmin()
if (idx == 0 or idx == 1):
return 0.0
return array[idx]
filename = input("The file you want to test: ")
T_low = float(input("The low threshold: "))
T_high = float(input("The high threshold: "))
image = io.imread(filename)
image = skimage.img_as_float(image)
image_grey = rgb2grey(image)
T_high = 0.01
T_low = 0.005
gaussian_y = filter_x(3, 3)
gaussian_x = filter_y(3, 3)
image_x = convolve2d(image_grey, gaussian_x)
image_y = convolve2d(image_grey, gaussian_y)
image_F = np.zeros(image_grey.shape)
image_D = np.zeros(image_grey.shape)
for i in range(0, image.shape[0]):
for j in range(0, image.shape[1]):
image_F[i][j] = math.sqrt(image_x[i][j] * image_x[i][j] +
image_y[i][j] * image_y[i][j])
def reshape_image_and_convert_to_float(self, image_path, resize_int):
img = Image.open(image_path)
img = img.resize((resize_int, resize_int), PIL.Image.ANTIALIAS)
return skimage.img_as_float(img)
def test_float_float_all_ranges():
arr_in = np.array([[-10., 10., 1e20]], dtype=np.float32)
np.testing.assert_array_equal(img_as_float(arr_in), arr_in)
def predict_using_trained_model(self,
images_dir,
plot=False
): #, typepassedin1, typepassedin2):
all_images_directory = [
images_dir + "{}".format(i) for i in os.listdir(images_dir)
]
_, vals_R, vals_G, vals_B = self.create_lists(all_images_directory,
self.resize_int)
images_flattened_R = []
for image in vals_R:
images_flattened_R.append(np.array(image).flatten())
images_flattened_G = []
for image in vals_G:
images_flattened_G.append(np.array(image).flatten())
images_flattened_B = []
for image in vals_B:
images_flattened_B.append(np.array(image).flatten())
images_principal_components_R = self.pca_R.transform(
images_flattened_R)
images_principal_components_G = self.pca_G.transform(
images_flattened_G)
images_principal_components_B = self.pca_B.transform(
images_flattened_B)
# print(images_principal_components_R)
# images_principal_components_R_tans = self.pca_R.fit_transform(images_flattened_R)
# print(images_principal_components_R_tans)
X = []
for i in range(len(images_principal_components_R)):
X.append(
np.concatenate((images_principal_components_R[i],
images_principal_components_G[i],
images_principal_components_B[i])))
predictions = self.model.predict_classes(np.array(X))
predictions_to_return = []
for p in predictions:
if p == 0:
predictions_to_return.append(self.classnames[1])
else:
predictions_to_return.append(self.classnames[0])
if plot:
for i in range(len(predictions_to_return)):
print(predictions_to_return[i])
imgP = Image.open(all_images_directory[i])
imgP = imgP.resize((50, 50), PIL.Image.ANTIALIAS)
prediction_as_floats = skimage.img_as_float(imgP)
# display.display(Image.open(all_images_directory[i]))
plt.figure()
plt.imshow(prediction_as_floats)
plt.grid(False)
plt.show()
return predictions_to_return
def test_float32_passthrough():
x = np.array([-1, 1], dtype=np.float32)
y = img_as_float(x)
assert_equal(y.dtype, x.dtype)
import matplotlib.pyplot as plt
from skimage.restoration import (denoise_tv_chambolle, denoise_bilateral, denoise_wavelet, denoise_nl_means, denoise_tv_bregman, estimate_sigma)
from skimage import img_as_float
from skimage.util import random_noise
img = plt.imread("NoiseReduction.png")
img = img_as_float(img[100:250, 50:300])
fig, field = plt.subplots(nrows=4, ncols=3, figsize=(10, 7), sharex=True, sharey=True)
plt.gray()
sigma = 0.155
noisy = random_noise(img, var=sigma**2)
denoised_wavelet = denoise_wavelet(noisy, rescale_sigma=True, multichannel=True)
denoised_bilateral = denoise_bilateral(noisy, sigma_color=0.1, sigma_spatial=15, multichannel=True)
denoised_tv_chambolle = denoise_tv_chambolle(noisy, weight=0.5, multichannel=True)
denoised_nl_means = denoise_nl_means(noisy, multichannel=True)
denoised_tv_bregman = denoise_tv_bregman(noisy, weight=0.5)
field[0,0].axis('off')
field[0,1].axis('off')
field[0,1].set_title('Original')
field[0,1].imshow(img)
field[0,2].axis('off')
field[1,0].axis('off')
field[1,1].axis('off')
field[1,1].set_title('Noisy')
field[1,1].imshow(noisy)
field[1,2].axis('off')
In 2D, color images are often represented in RGB---3 layers of 2D arrays, where
the 3 layers represent (R)ed, (G)reen and (B)lue channels of the image. The
simplest way of getting a tinted image is to set each RGB channel to the
grayscale image scaled by a different multiplier for each channel. For example,
multiplying the green and blue channels by 0 leaves only the red channel and
produces a bright red image. Similarly, zeroing-out the blue channel leaves
only the red and green channels, which combine to form yellow.
"""
import matplotlib.pyplot as plt
from skimage import data
from skimage import color
from skimage import img_as_float
grayscale_image = img_as_float(data.camera()[::2, ::2])
image = color.gray2rgb(grayscale_image)
red_multiplier = [1, 0, 0]
yellow_multiplier = [1, 1, 0]
fig, (ax1, ax2) = plt.subplots(ncols=2,
figsize=(8, 4),
sharex=True,
sharey=True)
ax1.imshow(red_multiplier * image)
ax2.imshow(yellow_multiplier * image)
######################################################################
# In many cases, dealing with RGB values may not be ideal. Because of that,
# there are many other `color spaces`_ in which you can represent a color
if len(line) > 0:
line = sorted(line, key=lambda x: x[1])
lines.append(line)
return lines
true_K = [8, 5, 3, 3] # ground truth lines of texts
characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
test_y = [
"TODOLIST1MAKEATODOLIST2CHECKOFFTHEFIRSTTHINGONTODOLIST3REALIZEYOUHAVEALREADYCOMPLETED2THINGS4REWARDYOURSELFWITHANAP",
"ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890",
"HAIKUSAREEASYBUTSOMETIMESTHEYDONTMAKESENSEREFRIGERATOR",
"DEEPLEARNINGDEEPERLEARNINGDEEPESTLEARNING"
]
for i, img in enumerate(os.listdir('../images')):
im1 = skimage.img_as_float(
skimage.io.imread(os.path.join('../images', img)))
bboxes, bw = findLetters(im1)
plt.imshow(bw, cmap='gray')
for bbox in bboxes:
minr, minc, maxr, maxc = bbox
rect = matplotlib.patches.Rectangle((minc, minr),
maxc - minc,
maxr - minr,
fill=False,
edgecolor='red',
linewidth=2)
plt.gca().add_patch(rect)
plt.show()
# find the rows using..RANSAC, counting, clustering, etc.
lines = cluster(np.array(bboxes), true_K[i])
if sigma == 0: return kernels
gauss = op.gauss2d(sigma=(sigma, sigma),
order=(0, 0),
angle=0,
nstd=0.67,
normalize=True)
return [
correlate2d(np.array(ker), np.array(gauss), mode='full')
for ker in kernels
]
#############################################################################
# damaged image and mask
example_setup = img_as_float(imread('./data/image.png')[:, :, 0:3])
mask = np.zeros_like(example_setup[..., 0]).astype(np.bool)
for x, y in coo:
mask[y - 15:y + 16, x - 15:x + 16] = True
example_setup[mask, :] = 1.0
imsave(output_dir + "example_setup.png", example_setup)
# imsave("./data/mask.png", mask.astype(np.float) )
# exit()
# initialization
image = img_as_float(imread('./data/image.png')[:, :, 0:3])
init_image = image.copy()
init_image[mask, :] = resize(
pyramid_expand(pyramid_reduce(image, 10, multichannel=True),
10,
multichannel=True), image.shape)[mask, :]
