def saver(stepName, img, dbg=None, mode=mode):
path = (processedDir / str(imgName)).with_suffix(".{}.png".format(stepName) if stepName else ".png")
if mode == 'cache' and processedDir and imgName:
mode = 'save'
if path.exists():
print("Loading cached image:", path)
img = ski.img_as_ubyte(io.imread(str(path)))
mode = 'done'
elif isinstance(img,type(None)):
print("Caching image:", path)
img = ski.img_as_ubyte(io.imread(str(imgName)))
assert not isinstance(img,type(None))
if mode == 'save' and processedDir and imgName:
try:
print("Saving:", img.shape, img.dtype, path.name, flush=True, )
pil_img = PIL.Image.fromarray(img_as_ubyte(img))
pil_img.save(str(path))
if dbg:
dbg.saved_path = path
except Exception as err:
print("Error Saving:",path, err, flush=True, )
elif mode == 'plot':
plt.imshow(img)
plt.suptitle(stepName+" "+imgName.name)
plt.show(block=True)
plt.close()
return img
def _apply(func8, func16, image, selem, out, mask, shift_x, shift_y):
selem = img_as_ubyte(selem > 0)
image = np.ascontiguousarray(image)
if mask is None:
mask = np.ones(image.shape, dtype=np.uint8)
else:
mask = np.ascontiguousarray(mask)
mask = img_as_ubyte(mask)
if image is out:
raise NotImplementedError("Cannot perform rank operation in place.")
is_8bit = image.dtype in (np.uint8, np.int8)
if func8 is not None and (is_8bit or func16 is None):
out = _apply8(func8, image, selem, out, mask, shift_x, shift_y)
else:
image = img_as_uint(image)
if out is None:
out = np.zeros(image.shape, dtype=np.uint16)
bitdepth = find_bitdepth(image)
if bitdepth > 11:
image = image >> 4
bitdepth = find_bitdepth(image)
func16(image, selem, shift_x=shift_x, shift_y=shift_y, mask=mask,
bitdepth=bitdepth + 1, out=out)
return out
def color_check(plugin, fmt='png'):
"""Check roundtrip behavior for color images.
All major input types should be handled as ubytes and read
back correctly.
"""
img = img_as_ubyte(data.chelsea())
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)
testing.assert_allclose(r3, 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_ubyte(img4))
img5 = img_as_uint(img)
r5 = roundtrip(img5, plugin, fmt)
testing.assert_allclose(r5, img)
def _handle_input(image, selem, out, mask, out_dtype=None):
if image.dtype not in (np.uint8, np.uint16):
image = img_as_ubyte(image)
selem = np.ascontiguousarray(img_as_ubyte(selem > 0))
image = np.ascontiguousarray(image)
if mask is None:
mask = np.ones(image.shape, dtype=np.uint8)
else:
mask = img_as_ubyte(mask)
mask = np.ascontiguousarray(mask)
if out is None:
if out_dtype is None:
out_dtype = image.dtype
out = np.empty_like(image, dtype=out_dtype)
if image is out:
raise NotImplementedError("Cannot perform rank operation in place.")
is_8bit = image.dtype in (np.uint8, np.int8)
if is_8bit:
max_bin = 255
else:
max_bin = max(4, image.max())
bitdepth = int(np.log2(max_bin))
if bitdepth > 10:
warnings.warn("Bitdepth of %d may result in bad rank filter "
"performance due to large number of bins." % bitdepth)
return image, selem, out, mask, max_bin
def worker(input_file_path, queue):
int_values = []
path_sections = input_file_path.split("/")
for string in path_sections:
if re.search(r'\d+', string) is not None:
int_values.append(int(re.search(r'\d+', string).group()))
file_count = int_values[-1]
image = cv2.imread(input_file_path, cv2.CV_LOAD_IMAGE_GRAYSCALE)
edges = img_as_ubyte(canny(image, sigma=canny_sigma))
img_bw = cv2.threshold(edges, 250, 255, cv2.THRESH_BINARY)[1]
point = _find_bottom_edge(img_bw)
try:
distance = len(img_bw) - point[1]
except TypeError:
try:
edges = img_as_ubyte(canny(image, sigma=canny_sigma_closeup))
img_bw = cv2.threshold(edges, 250, 255, cv2.THRESH_BINARY)[1]
distance = len(img_bw) - point[1]
except TypeError:
distance = 0
output = str(file_count) + ":" + str(distance) + "\n"
queue.put(output)
return output
def define_matrix(image, number_of_iterations = 5000, termination_eps = 1e-10, warp = 'Affine'):
warp_mode_dct = {
'Translation' : cv2.MOTION_TRANSLATION,
'Affine' : cv2.MOTION_AFFINE,
'Euclidean' : cv2.MOTION_EUCLIDEAN,
'Homography' : cv2.MOTION_HOMOGRAPHY
}
img = oib.image_reorder(image)
color1 = img_as_ubyte(img[0,0,:,:,0])
color2 = img_as_ubyte(img[0,0,:,:,1])
warp_mode = warp_mode_dct.pop('%s' % warp)
if warp_mode == cv2.MOTION_HOMOGRAPHY :
warp_matrix = np.eye(3, 3, dtype=np.float32)
else :
warp_matrix = np.eye(2, 3, dtype=np.float32)
number_of_iterations = number_of_iterations
termination_eps = termination_eps
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, number_of_iterations, termination_eps)
(cc, warp_matrix) = cv2.findTransformECC (color1,color2,warp_matrix, warp_mode, criteria)
return warp_matrix
def dilation(image, selem=None, out=None, shift_x=False, shift_y=False):
"""Return greyscale morphological dilation of an image.
Morphological dilation sets a pixel at (i,j) to the maximum over all pixels
in the neighborhood centered at (i,j). Dilation enlarges bright regions
and shrinks dark regions.
Parameters
----------
image : ndarray
Image array.
selem : ndarray, optional
The neighborhood expressed as a 2-D array of 1's and 0's.
If None, use cross-shaped structuring element (connectivity=1).
out : ndarray, optional
The array to store the result of the morphology. If None, is
passed, a new array will be allocated.
shift_x, shift_y : bool, optional
shift structuring element about center point. This only affects
eccentric structuring elements (i.e. selem with even numbered sides).
Returns
-------
dilated : uint8 array
The result of the morphological dilation.
Notes
-----
For `uint8` (and `uint16` up to a certain bit-depth) data, the lower
algorithm complexity makes the `skimage.filter.rank.maximum` function more
efficient for larger images and structuring elements.
Examples
--------
>>> # Dilation enlarges bright regions
>>> import numpy as np
>>> from skimage.morphology import square
>>> bright_pixel = np.array([[0, 0, 0, 0, 0],
... [0, 0, 0, 0, 0],
... [0, 0, 1, 0, 0],
... [0, 0, 0, 0, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> dilation(bright_pixel, square(3))
array([[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
"""
if image is out:
raise NotImplementedError("In-place dilation not supported!")
image = img_as_ubyte(image)
selem = img_as_ubyte(selem)
return cmorph._dilate(image, selem, out=out,
shift_x=shift_x, shift_y=shift_y)
def dynamic_masking(image,method='edges',filter_size=7,threshold=0.005):
""" Dynamically masks out the objects in the PIV images
Parameters
----------
image: image
a two dimensional array of uint16, uint8 or similar type
method: string
'edges' or 'intensity':
'edges' method is used for relatively dark and sharp objects, with visible edges, on
dark backgrounds, i.e. low contrast
'intensity' method is useful for smooth bright objects or dark objects or vice versa,
i.e. images with high contrast between the object and the background
filter_size: integer
a scalar that defines the size of the Gaussian filter
threshold: float
a value of the threshold to segment the background from the object
default value: None, replaced by sckimage.filter.threshold_otsu value
Returns
-------
image : array of the same datatype as the incoming image with the object masked out
as a completely black region(s) of zeros (integers or floats).
Example
--------
frame_a = openpiv.tools.imread( 'Camera1-001.tif' )
imshow(frame_a) # original
frame_a = dynamic_masking(frame_a,method='edges',filter_size=7,threshold=0.005)
imshow(frame_a) # masked
"""
imcopy = np.copy(image)
# stretch the histogram
image = exposure.rescale_intensity(img_as_float(image), in_range=(0, 1))
# blur the image, low-pass
blurback = img_as_ubyte(gaussian_filter(image,filter_size))
if method is 'edges':
# identify edges
edges = sobel(blurback)
blur_edges = gaussian_filter(edges,21)
# create the boolean mask
bw = (blur_edges > threshold)
bw = img_as_ubyte(binary_fill_holes(bw))
imcopy -= blurback
imcopy[bw] = 0.0
elif method is 'intensity':
background = gaussian_filter(median_filter(image,filter_size),filter_size)
imcopy[background > threshold_otsu(background)] = 0
return imcopy #image
def preprocess(filename):
image = img_as_ubyte(io.imread(filename, as_grey = True))
if image.shape[0] != 768:
print(image.shape)
print("WARN: Resizing image to old iPad Size. TODO> Move forward to retina images!")
return img_as_ubyte(transform.resize(image, (768, 1024)))
return image
def test_threshold_minimum():
camera = skimage.img_as_ubyte(data.camera())
threshold = threshold_minimum(camera)
assert_equal(threshold, 76)
astronaut = skimage.img_as_ubyte(data.astronaut())
threshold = threshold_minimum(astronaut)
assert_equal(threshold, 114)
def test_divide_and_reassemble(self):
pic = img_as_ubyte(io.imread("./kitteh.jpg"))
pic = resize(pic, (500,500), mode='nearest')
pic = img_as_ubyte(pic)
print "size "+str(pic.shape)
for shape in [(10,10),(10,20),(30,30),(33,48)]:
print shape
parts = divide_into_parts(pic,*shape)
pic2 = assemble_from_parts(parts, False, False)
self.assertTrue((pic==pic2).all())
def open_image(address):
image = imread(address)
gray_image = rgb2gray(image)
r = image[:,:,0]
g = image[:,:,1]
b = image[:,:,2]
#
# m,n,_ = image.shape
#
# gray_image = img_as_ubyte(gray_image)
return img_as_ubyte(gray_image), img_as_ubyte(r), img_as_ubyte(g), img_as_ubyte(b)
def test_threshold_minimum():
camera = skimage.img_as_ubyte(data.camera())
threshold = threshold_minimum(camera)
assert threshold == 76
threshold = threshold_minimum(camera, bias='max')
assert threshold == 77
astronaut = skimage.img_as_ubyte(data.astronaut())
threshold = threshold_minimum(astronaut)
assert threshold == 117
def load_disp_image(self, img_name,j,display_only=False):
print ("Setting image: %s" % str(img_name))
try:
temp_img = img_as_ubyte(imread(img_name))
except:
print("Error reading file, setting zero image")
h_img=self.exp1.active_params.m_params.imx
v_img=self.exp1.active_params.m_params.imy
temp_img = img_as_ubyte(np.zeros((h_img,v_img)))
if not display_only:
ptv.py_set_img(temp_img,j)
if len(temp_img)>0:
self.camera_list[j].update_image(temp_img)
def dilation(image, selem, out=None, shift_x=False, shift_y=False):
"""Return greyscale morphological dilation of an image.
Morphological dilation sets a pixel at (i,j) to the maximum over all pixels
in the neighborhood centered at (i,j). Dilation enlarges bright regions
and shrinks dark regions.
Parameters
----------
image : ndarray
Image array.
selem : ndarray
The neighborhood expressed as a 2-D array of 1's and 0's.
out : ndarray
The array to store the result of the morphology. If None, is
passed, a new array will be allocated.
shift_x, shift_y : bool
shift structuring element about center point. This only affects
eccentric structuring elements (i.e. selem with even numbered sides).
Returns
-------
dilated : uint8 array
The result of the morphological dilation.
Examples
--------
>>> # Dilation enlarges bright regions
>>> import numpy as np
>>> from skimage.morphology import square
>>> bright_pixel = np.array([[0, 0, 0, 0, 0],
... [0, 0, 0, 0, 0],
... [0, 0, 1, 0, 0],
... [0, 0, 0, 0, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> dilation(bright_pixel, square(3))
array([[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
"""
if image is out:
raise NotImplementedError("In-place dilation not supported!")
image = img_as_ubyte(image)
selem = img_as_ubyte(selem)
return cmorph._dilate(image, selem, out=out,
shift_x=shift_x, shift_y=shift_y)
def noise_reduction(image, background, window_size = 5, mode = 0): # GrayScale image use mode = 0 # mode = 0: dealing RGB image with each channel # mode!= 0: dealing RGB image with HSV value if(mode == 0): med_image = median_each(image, disk(window_size)) med_bckg = median_each(background, disk(window_size)) else : med_image = img_as_ubyte(median_hsv(image, disk(window_size))) med_bckg = img_as_ubyte(median_hsv(background, disk(window_size))) norm_image = np.true_divide(med_image, (med_bckg/255*254+1))/255 return norm_image
def _merge_images(img_top, img_bottom, mask=0):
"""
Function to combine two images with mask by replacing all pixels of img_bottom which
equals to mask by pixels from img_top.
:param img_top: greyscale image which will replace masked pixels
:param img_bottom: greyscale image which pixels will be replace
:param mask: pixel value to be used as mask (int)
:return: combined greyscale image
"""
img_top = skimage.img_as_ubyte(img_top)
img_bottom = skimage.img_as_ubyte(img_bottom)
merge_layer = img_top == mask
img_top[merge_layer] = img_bottom[merge_layer]
return img_top
def get_textural_features(img, isMultidirectional=False, distance=1):
'''Extract GLCM feature vector from image
Args:
img: input image.
isMultidirectional: Controls whether co-occurence should be calculated
in other directions (ie 45 degrees, 90 degrees and 135 degrees).
distance: Distance between pixels for co-occurence.
Returns:
features: if isMultidirectional=False, this is a 4 element vector of
[dissimilarity, correlation,homogeneity, energy]. If not it is a 16
element vector containing each of the above properties in each direction.
'''
if(isMultidirectional):
img = img_as_ubyte(rgb2gray(img))
glcm = greycomatrix(img, [distance], [0, 0.79, 1.57, 2.36], 256, symmetric=True, normed=True)
dissimilarity_1 = greycoprops(glcm, 'dissimilarity')[0][0]
dissimilarity_2 = greycoprops(glcm, 'dissimilarity')[0][1]
dissimilarity_3 = greycoprops(glcm, 'dissimilarity')[0][2]
dissimilarity_4 = greycoprops(glcm, 'dissimilarity')[0][3]
correlation_1 = greycoprops(glcm, 'correlation')[0][0]
correlation_2 = greycoprops(glcm, 'correlation')[0][1]
correlation_3 = greycoprops(glcm, 'correlation')[0][2]
correlation_4 = greycoprops(glcm, 'correlation')[0][3]
homogeneity_1 = greycoprops(glcm, 'homogeneity')[0][0]
homogeneity_2 = greycoprops(glcm, 'homogeneity')[0][1]
homogeneity_3 = greycoprops(glcm, 'homogeneity')[0][2]
homogeneity_4 = greycoprops(glcm, 'homogeneity')[0][3]
energy_1 = greycoprops(glcm, 'energy')[0][0]
energy_2 = greycoprops(glcm, 'energy')[0][1]
energy_3 = greycoprops(glcm, 'energy')[0][2]
energy_4 = greycoprops(glcm, 'energy')[0][3]
feature = np.array([dissimilarity_1, dissimilarity_2, dissimilarity_3,\
dissimilarity_4, correlation_1, correlation_2, correlation_3, correlation_4,\
homogeneity_1, homogeneity_2, homogeneity_3, homogeneity_4, energy_1,\
energy_2, energy_3, energy_4])
return feature
else:
img = img_as_ubyte(rgb2gray(img))
glcm = greycomatrix(img, [distance], [0], 256, symmetric=True, normed=True)
dissimilarity = greycoprops(glcm, 'dissimilarity')[0][0]
correlation = greycoprops(glcm, 'correlation')[0][0]
homogeneity = greycoprops(glcm, 'homogeneity')[0][0]
energy = greycoprops(glcm, 'energy')[0][0]
feature = np.array([dissimilarity, correlation, homogeneity, energy])
return feature
def didClickSubmitButton(self, event):
print(self.imageFilePath)
img = img_as_ubyte(io.imread(CLUSTER_IMAGE_FILENAME))
roi_img = spectral_roi.extract_roi(img, gui_checkbox_handlers.getSelectedClusters())
roi_img_filename = "{}.png".format(Helper.generate_random_id())
io.imsave(roi_img_filename, roi_img)
Display.show_image(roi_img, roi_img_filename)
def __init__(self, path=None, array=None, xy_array=None):
self._modified = False
self.scale = 1
self._path = None
self._format = None
n_args = len([a for a in [path, array, xy_array] if a is not None])
if n_args != 1:
msg = "Must provide a single keyword arg (path, array, xy_array)."
ValueError(msg)
elif path is not None:
if not is_url(path):
path = os.path.abspath(path)
self._path = path
with file_or_url_context(path) as context:
self.array = img_as_ubyte(io.imread(context))
self._format = imghdr.what(context)
elif array is not None:
self.array = array
elif xy_array is not None:
self.xy_array = xy_array
# Force RGBA internally (use max alpha)
if self.array.shape[-1] == 3:
self.array = np.insert(self.array, 3, values=255, axis=2)
def test_equalize_ubyte():
with expected_warnings(['precision loss']):
img = skimage.img_as_ubyte(test_img)
img_eq = exposure.equalize_hist(img)
cdf, bin_edges = exposure.cumulative_distribution(img_eq)
check_cdf_slope(cdf)
def height_texture(z, colormap = 'viridis'):
"""Create a texture corresponding to the heights in z and the given colormap."""
from matplotlib import cm
from skimage import img_as_ubyte
import numpy as np
colormap = cm.get_cmap(colormap)
im = z.copy()
# rescale to be in [0,1], scale nan to be the smallest value
im -= np.nanmin(im)
im /= np.nanmax(im)
im = np.nan_to_num(im)
import warnings
with warnings.catch_warnings():
# ignore the precision warning that comes from converting floats to uint8 types
warnings.filterwarnings('ignore',
message='Possible precision loss when converting from',
category=UserWarning,
module='skimage.util.dtype')
rgba_im = img_as_ubyte(colormap(im)) # convert the values to rgba image using the colormap
rgba_list = list(rgba_im.flat) # make a flat list
return DataTexture(data=rgba_list, format='RGBAFormat', width=z.shape[1], height=z.shape[0])
def transformation(image, q): imagesize = image.shape newpixels = np.zeros(shape=imagesize) print q log255 = m.log(255) Rlog = np.zeros(shape=(imagesize[0], imagesize[1])) Glog = np.zeros(shape=(imagesize[0], imagesize[1])) Blog = np.zeros(shape=(imagesize[0], imagesize[1])) Rlog[:,:] = -((255.0*np.log(image[:,:,0]+1)/255)/log255) Glog[:,:] = -((255.0*np.log(image[:,:,1]+1)/255)/log255) Blog[:,:] = -((255.0*np.log(image[:,:,2]+1)/255)/log255) for i in (0,1,2): Rscaled = Rlog[:,:]*q[(i-1)*3+1] Gscaled = Glog[:,:]*q[(i-1)*3+2] Bscaled = Blog[:,:]*q[i*3] output = np.exp(-((Rscaled+Gscaled+Bscaled)-255)*np.log(255)/255) output [output > 255] = 255 newpixels[:,:,i] = np.floor(output+0.5) print newpixels.shape return img_as_ubyte(newpixels)
def _apply8(func8, image, selem, out, mask, shift_x, shift_y):
if out is None:
out = np.zeros(image.shape, dtype=np.uint8)
image = img_as_ubyte(image)
func8(image, selem, shift_x=shift_x, shift_y=shift_y,
mask=mask, out=out)
return out
def test_li_astro_image():
image = skimage.img_as_ubyte(data.astronaut())
threshold = threshold_li(image)
ce_actual = _cross_entropy(image, threshold)
assert 64 < threshold < 65
assert ce_actual < _cross_entropy(image, threshold + 1)
assert ce_actual < _cross_entropy(image, threshold - 1)
def test_color_gmm():
print 'Entering: test_color'
dataset = data_loader.ColorizeImageNet(
root, split='val', set='tiny',
bins='soft', num_hc_bins=16,
gmm_path=GMM_PATH, mean_l_path=MEAN_L_PATH)
img, labels = dataset.__getitem__(0)
gmm = dataset.gmm
labels = labels.numpy()
img = img.squeeze().numpy()
labels = labels.astype(gmm.means_.dtype)
img = img.astype(gmm.means_.dtype)
# expectation over GMM centroids
hc_means = gmm.means_.astype(labels.dtype)
im_hc = np.tensordot(labels, hc_means, (2,0))
im_l = img + dataset.mean_l.astype(img.dtype)
im_rgb = dataset.hue_chroma_to_rgb(im_hc, im_l)
low, high = np.min(im_rgb), np.max(im_rgb)
im_rgb = (im_rgb - low) / (high - low)
im_out = img_as_ubyte(im_rgb)
skimage.io.imsave("tests/output.png", im_out)
img_file = dataset.files['val'][0]
im_orig = skimage.io.imread(img_file)
skimage.io.imsave("tests/orig.png", im_orig)
def preProcessing(imGrayLevel):
#Escopo de algumas Operações básicas utilizadas no pré-processamento:
#..............................................
h = ia.iahistogram(imGrayLevel) #Equalização...
n = imGrayLevel.size
T = 255./n * np.cumsum(h)
T = T.astype(uint8)
#..............................................
T1 = np.arange(256) # função identidade
T2 = ia.ianormalize(np.log(T1+30)) # logaritmica - realce partes escuras
#T5 = ia.ianormalize(T1/50) # reduz o número de níveis de cinza
#..................................................
ax1.imshow(imRGB)
ax1.set_title('rgb')
ax2.imshow(imGrayLevel, vmin=0, vmax=255, cmap=plt.cm.gray)
ax2.set_title('gray level')
imGrayLevel = denoise_tv_chambolle(imGrayLevel, weight=0.1, multichannel=True)
imGrayLevel = img_as_ubyte(imGrayLevel)#Conversão de Float para UINT-8
ax3.imshow(imGrayLevel, vmin=0, vmax=255, cmap=plt.cm.gray) #Filtro de suavização de textura
ax3.set_title('tv signal filter')
realceNucleos = T2[T[imGrayLevel]] #Realce de partes escuras da imagem equalizada
ax4.imshow(realceNucleos, vmin=0, vmax=255, cmap=plt.cm.gray)
ax4.set_title('logaritimica')
return realceNucleos
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 get_tight_mean_var():
data = []
for img_path in sorted(os.listdir(args.data_dir), key=lambda x: int(x.split('.')[0])):
img = skio.imread(os.path.join(args.data_dir, img_path))
if len(img.shape) < 3:
img = np.dstack((img, img, img))
img = resize(img, (args.ylen, args.xlen))
img = skimage.img_as_ubyte(img)
data.append(img)
data = np.array(data)
data = data[args.sequence_time_start:args.sequence_time_end]
t, ylen, xlen, c = data.shape
small_mean = np.mean(data, axis=0)
norm_data = data - small_mean
small_mean = np.zeros((ylen, xlen, c))
small_var = np.zeros((ylen, xlen, c, c))
for x in range(xlen):
print(x)
for y in range(ylen):
H, edges = np.histogramdd(data[:, y, x], bins=(24,) * 3,
range=((0, 255), (0, 255), (0, 255)))
bin_idx = np.unravel_index(np.argmax(H), H.shape)
mean = np.array([(edges[i][bin_idx[i]] + edges[i][bin_idx[i] + 1]) \
/ 2 for i in range(len(edges))])
small_mean[y, x] = mean
cov = norm_data[:, y, x].T.dot(norm_data[:, y, x]) / (t - 1)
if np.linalg.det(cov) < 1e-2:
cov = np.eye(3)
small_var[y, x] = cov
return small_mean.reshape(xlen * ylen, c), small_var.flatten()
def test_li_camera_image():
image = skimage.img_as_ubyte(data.camera())
threshold = threshold_li(image)
ce_actual = _cross_entropy(image, threshold)
assert 62 < threshold_li(image) < 63
assert ce_actual < _cross_entropy(image, threshold + 1)
assert ce_actual < _cross_entropy(image, threshold - 1)
# fig, ax = ski.filters.try_all_threshold(img, figsize=(10,8), verbose = False)
# plt.show()
thresh = ski.filters.threshold_otsu(img)
img = (img > thresh) * 255
# Blur/Sharpen if necessary
if blur > 0:
img = ski.filters.gaussian(img, sigma=blur)
# Sharpening TBD
#if sharpen > 0:
# img = img - 0.3*ski.filters.gaussian(img, sigma=sharpen)
# Convert image to 8-bit
img = ski.img_as_ubyte(img)
# Save image to output path
if maskname is None:
(input_filename, ext) = path.splitext(path.basename(imgpath))
output_filename = 'mask_' + input_filename + '.tif'
else:
output_filename = maskname + '.tif'
if maskpath is None:
outputdir = path.dirname(imgpath)
else:
outputdir = maskpath
outputpath = path.join(outputdir, output_filename)
ski.io.imsave(outputpath, img)
def showSegmentation(rgbfile,
labelfile,
pixelClasses=horsePixelClasses,
crfmodel=horseCRF,
visualizeSegmentation=True):
start_time = time.time()
# Read RGB and label image
image = img_as_float(skimageIO.imread(rgbfile))
bgrImage = cv2.imread(rgbfile, cv2.IMREAD_COLOR)
#bgrImage = cv2.fastNlMeansDenoisingColored(bgrImage)
#bgrImage = exposure.adjust_sigmoid(bgrImage)
if len(image.shape) == 2:
image = color.gray2rgb(image)
# Resize
#image = resize(image,(120,120), preserve_range=True )
#bgrImage = resize(bgrImage,(120,120), preserve_range=True)
# Derive superpixels and get their average RGB component
segments = slic(image, n_segments=500, sigma=1.0)
rgb_segments = img_as_ubyte(mark_boundaries(image, segments))
avg_rgb = color.label2rgb(segments, image, kind='avg')
if labelfile is not None:
labelImage = img_as_float(skimageIO.imread(labelfile))
#labelImage = resize(labelImage,(120,120), preserve_range=True)
#thresh = threshold_otsu(image)
#labelImage = labelImage > thresh
if len(labelImage.shape) == 2:
labelImageRGB = color.gray2rgb(labelImage)
else:
labelImageRGB = labelImage
label_segments = img_as_ubyte(mark_boundaries(labelImageRGB, segments))
avg_label = color.label2rgb(segments, labelImageRGB, kind='avg')
# Create graph of superpixels and compute their centers
vertices, edges = imagesegmentation.make_graph(segments)
gridx, gridy = numpy.mgrid[:segments.shape[0], :segments.shape[1]]
centers = dict()
for v in vertices:
centers[v] = [gridy[segments == v].mean(), gridx[segments == v].mean()]
# compute for features
xInstance = []
yInstance = []
n_features = []
n_labels = []
edge_features = []
for v in vertices:
# unary feature - average rgb of superpixel
avg_rgb2 = avg_rgb[int(centers[v][1])][int(centers[v][0])]
hist, hogFeatures = imagesegmentation.getHistogramFeatures(
bgrImage,
int(centers[v][1]),
int(centers[v][0]),
forUnaryFeature=True)
node_feature = numpy.concatenate([avg_rgb2, hist, hogFeatures])
n_features.append(node_feature)
# label
if labelfile is not None:
minEuclideanDistance = numpy.inf # simulate infinity
pixelClass = -1
for i in range(0, len(pixelClasses)):
# set the label of the superpixel to the pixelClass with minimum euclidean distance
dist = numpy.linalg.norm(
avg_label[int(centers[v][1])][int(centers[v][0])] -
pixelClasses[i])
if dist < minEuclideanDistance:
pixelClass = i
minEuclideanDistance = dist
n_labels.append(pixelClass)
histogramCache = {}
for e in edges:
# pairwise feature - euclidean distance of adjacent superpixels
dist = numpy.linalg.norm(
avg_rgb[int(centers[e[0]][1])][int(centers[e[0]][0])] -
avg_rgb[int(centers[e[1]][1])][int(centers[e[1]][0])])
if e[0] not in histogramCache:
hist1, lbphist1 = imagesegmentation.getHistogramFeatures(
bgrImage, int(centers[e[0]][1]), int(centers[e[0]][0]))
histogramCache[e[0]] = {'hist': hist1, 'lbphist': lbphist1}
else:
hist1 = histogramCache[e[0]]['hist']
lbphist1 = histogramCache[e[0]]['lbphist']
if e[1] not in histogramCache:
hist2, lbphist2 = imagesegmentation.getHistogramFeatures(
bgrImage, int(centers[e[1]][1]), int(centers[e[1]][0]))
histogramCache[e[1]] = {'hist': hist2, 'lbphist': lbphist2}
else:
hist2 = histogramCache[e[1]]['hist']
lbphist2 = histogramCache[e[1]]['lbphist']
histogramDist = cv2.compareHist(hist1, hist2,
3) # Bhattacharyya distance
textureSimilarity = imagesegmentation.kullback_leibler_divergence(
lbphist1, lbphist2) # KL divergence
pairwise_feature = numpy.array(
[dist, histogramDist, textureSimilarity])
edge_features.append(pairwise_feature)
xInstance.append((numpy.array(n_features), numpy.array(edges),
numpy.array(edge_features)))
yInstance.append(numpy.array(n_labels))
# Create superpixeled image
if labelfile is not None:
labeledSuperPixeledRGB = numpy.zeros(labelImageRGB.shape)
labeledSuperPixeled = numpy.zeros(labelImage.shape)
#print labeledSuperPixeled.shape
#print labelImageRGB.shape
for i in range(0, labeledSuperPixeledRGB.shape[0]):
for j in range(0, labeledSuperPixeledRGB.shape[1]):
labeledSuperPixeledRGB[i][j] = pixelClasses[n_labels[
segments[i][j]]]
labeledSuperPixeled[i][j] = n_labels[segments[i][j]]
# Predict with CRF and build image label
y_pred = crfmodel.predict(numpy.array(xInstance))
labeledPredictionRGB = numpy.zeros(image.shape)
labeledPrediction = numpy.zeros((image.shape[0], image.shape[1]))
#print labeledPrediction.shape
for i in range(0, labeledPredictionRGB.shape[0]):
for j in range(0, labeledPredictionRGB.shape[1]):
labeledPredictionRGB[i][j] = pixelClasses[y_pred[0][segments[i]
[j]]]
labeledPrediction[i][j] = y_pred[0][segments[i][j]]
# Print performance
if labelfile is not None:
pixelwise_accuracy = accuracy_score(
labelImage.flatten().flatten(),
labeledPrediction.flatten().flatten())
pixelwise_precision = precision_score(
labelImage.flatten().flatten(),
labeledPrediction.flatten().flatten())
pixelwise_recall = recall_score(labelImage.flatten().flatten(),
labeledPrediction.flatten().flatten())
pixelwise_f1 = f1_score(labelImage.flatten().flatten(),
labeledPrediction.flatten().flatten())
pixelwise_so = foregroundQualityScore(
labelImage.flatten().flatten(),
labeledPrediction.flatten().flatten())
# comment on f1 score
if pixelwise_f1 >= 0.9:
comment = ' <------------ HIGH!'
elif pixelwise_f1 <= 0.8:
comment = ' <------------ LOW!'
else:
comment = ''
print ''
print 'Segmentation completed in ' + str(time.time() -
start_time) + ' seconds.'
print 'Total Pixels: ' + str(labelImage.flatten().flatten().shape[0])
print 'SLIC Pixelwise Accuracy: ' + str(
accuracy_score(labelImage.flatten().flatten(),
labeledSuperPixeled.flatten().flatten()))
print ''
print 'Pixelwise Accuracy: ' + str(pixelwise_accuracy)
print 'Pixelwise Precision: ' + str(pixelwise_precision)
print 'Pixelwise Recall: ' + str(pixelwise_recall)
print 'Pixelwise F1: ' + str(pixelwise_f1) + comment
print 'Pixelwise S0: ' + str(pixelwise_so)
else:
'There is no label image hence no performance stats...'
# Show the Images
if visualizeSegmentation:
fig, ax = plt.subplots(2, 3)
fig.canvas.set_window_title('Image Segmentation')
ax[0, 0].imshow(image)
ax[0, 0].set_title("Original Image")
ax[0, 1].imshow(rgb_segments)
ax[0, 1].set_title("Super Pixels")
if labelfile is not None:
ax[0, 2].imshow(label_segments)
ax[1, 0].imshow(labelImageRGB)
ax[1, 1].imshow(labeledSuperPixeledRGB)
ax[0, 2].set_title("Segmented Ground Truth")
ax[1, 0].set_title("Ground truth")
ax[1, 1].set_title("Labeled Super Pixels")
ax[1, 2].imshow(labeledPredictionRGB)
ax[1, 2].set_title("Prediction")
for a in ax.ravel():
a.set_xticks(())
a.set_yticks(())
plt.show()
# Save result
#skimageIO.imsave('slic-' + ntpath.basename(rgbfile) , rgb_segments)
#skimageIO.imsave('slicground-' + ntpath.basename(rgbfile) , label_segments)
#skimageIO.imsave('result-' + ntpath.basename(rgbfile) , labeledPredictionRGB)
# Return metrics
if labelfile is not None:
return pixelwise_accuracy, pixelwise_precision, pixelwise_recall, pixelwise_f1, pixelwise_so
else:
return
def _compute_epicflow(I1, I2, edgefile=None, matchfile=None, preset='sintel'):
""" Internal function to compute EPIC flow.
Moved into a separate function to be able to use caching.
"""
path_sed = os.path.join(PATH_EPIC, 'sed', 'release')
path_toolbox = os.path.join(PATH_EPIC, 'sed', 'toolbox')
path_deepmatching = os.path.join(PATH_EPIC, 'deepmatching/deepmatching_1.2.2_c++')
path_epic_bin = os.path.join(PATH_EPIC, 'EpicFlow_v1.00')
tempdir = tempfile.mkdtemp()
if matchfile is None:
matchfile = os.path.join(tempdir, 'matches.txt')
if edgefile is None:
edgefile = os.path.join(tempdir, 'edges.dat')
# Save images into temp dir
if type(I1) == str:
path_I1 = I1
else:
path_I1 = os.path.join(tempdir, 'image1.png')
sio.imsave(path_I1, img_as_ubyte(I1))
if type(I2) == str:
path_I2 = I2
else:
path_I2 = os.path.join(tempdir, 'image2.png')
sio.imsave(path_I2, img_as_ubyte(I2))
# We need an output file for epic flow.
path_flow = os.path.join(tempdir, 'flow.flo')
#
# Compute edges
#
if (not os.path.isfile(edgefile)) or os.path.getsize(edgefile) < 10:
sys.stdout.write('\nComputing edges...')
sys.stdout.flush()
te0 = time.time()
call = ['matlab',
'-nodesktop',
'-nojvm',
'-r', "addpath('{0}'); addpath(genpath('{1}')); load('{2}/modelFinal.mat'); I = uint8(imread('{3}')); if size(I,3)==1, I = cat(3,I,I,I); end; edges = edgesDetect(I, model); fid=fopen('{4}','wb'); fwrite(fid,transpose(edges),'single'); fclose(fid); exit".format(path_sed, path_toolbox, path_epic_bin, path_I1, edgefile)]
with open(os.devnull, 'w') as dnull:
#subprocess.call(call, stdout=dnull,stderr=subprocess.STDOUT)
subprocess.call(call)
te1 = time.time()
sys.stdout.write('done. Took {} sec'.format(te1-te0))
sys.stdout.flush()
assert(os.path.isfile(edgefile))
else:
print('Using edges from {}'.format(edgefile))
#
# Compute deep matches
#
if (not os.path.isfile(matchfile)) or os.path.getsize(matchfile) < 10:
sys.stdout.write('\nComputing matches...')
sys.stdout.flush()
tm0 = time.time()
call = [os.path.join(path_deepmatching, 'deepmatching'),
path_I1,
path_I2]
with open(matchfile, 'w') as mfile:
subprocess.call(call, stdout=mfile)
tm1 = time.time()
sys.stdout.write('done. Took {} sec'.format(tm1-tm0))
sys.stdout.flush()
assert (os.path.isfile(matchfile))
else:
print('Using matches from {}'.format(matchfile))
#
# Compute EPIC Flow
#
sys.stdout.write('\nComputing flow...')
sys.stdout.flush()
if preset == 'sintel':
pflag = '-sintel'
elif preset == 'kitti':
pflag = '-kitti'
tf0 = time.time()
call = [os.path.join(path_epic_bin, 'epicflow'),
path_I1,
path_I2,
edgefile,
matchfile,
path_flow,
pflag]
subprocess.call(call)
tf1 = time.time()
sys.stdout.write('done. Took {} sec'.format(tf1-tf0))
sys.stdout.flush()
assert (os.path.isfile(path_flow))
# Finally, read the flow back again and return.
u,v = flow_read(path_flow)
# Delete temp dir
#shutil.rmtree(tempdir)
return u,v
out_path = './patch_extract/' + basename(img_path).replace('.svs', '.png')
GT_path = os.path.join(fold, 'gt_thumbnails/' + basename(img_path).replace('.svs', '.png'))
scan = openslide.OpenSlide(img_path)
last_dim_n = len(scan.level_dimensions) - 1
last_dim = scan.level_dimensions[last_dim_n]
last_dim_inv = (last_dim[1], last_dim[0])
whole_img = scan.read_region((0,0), last_dim_n, last_dim)
whole_img = np.array(whole_img)[:,:,0:3]
small_img = resize(whole_img, (500, 500))
small_img = img_as_ubyte(small_img)
mask = ROI_binary_mask(small_img, ticket=(80,80,80))
mask = mask.astype('uint8')
mask[mask > 0] = 255
mask_tissue = resize(mask, last_dim_inv, order=0)
mask_tissue = img_as_ubyte(mask_tissue)
mask_tissue[mask_tissue > 0] = 255
GT_file = imread(GT_path)
GT_file[GT_file > 0] = 255
Red_area = GT_file[:,:,0]
Red_area = img_as_ubyte(resize(Red_area, last_dim_inv, order=0))
Green_area = GT_file[:,:,1]
Green_area = img_as_ubyte(resize(Green_area, last_dim_inv, order=0))
Blue_area = GT_file[:,:,2]
Blue_area = img_as_ubyte(resize(Blue_area, last_dim_inv, order=0))
from csv-file read RGB image
'''
R_array = np.array(df.query('band == "73"'))
R_array = R_array.reshape(-1, 1)
G_array = np.array(df.query('band == "46"'))
G_array = G_array.reshape(-1, 1)
B_array = np.array(df.query('band == "15"'))
B_array = B_array.reshape(-1, 1)
color_img = np.hstack([R_array, G_array, B_array])
color_img = color_img.reshape(1101, 960, 3)
# print(color_img)
# color_img = img_as_float(color_img)
# print(color_img)
color_img = color_img / 256
color_img = color_img.astype(np.uint8)
color_img = img_as_ubyte(color_img)
'''
from csv-file read gray image
'''
gray_img = df.query('band == "169"')
gray_img = img_as_float(gray_img)
gray_img = exposure.rescale_intensity(gray_img)
gray_img = gray_img * 256
while exposure.is_low_contrast(gray_img):
gray_img = exposure.adjust_gamma(gray_img, 0.8)
gray_img = gray_img.astype(np.uint8)
gray_img = img_as_ubyte(gray_img)
'''cv2 median filter-->>Reduce Noise'''
'''Optional:cv2 gaussian filter-->>cv2.GaussianBlur'''
gray_img = cv2.medianBlur(gray_img, 3)
def save_to_png(file_name, array):
"""Save the given numpy array as a PNG file."""
# from skimage._shared._warnings import expected_warnings
# with expected_warnings(['precision']):
imsave(file_name, img_as_ubyte(array))
images_to_generate = 36 #you can change this value according to your requirement
i = 1 # variable to iterate till images_to_generate
while i <= images_to_generate:
image = random.choice(images)
original_image = io.imread(image)
transformed_image = None
# print(i)
n = 0 #variable to iterate till number of transformation to apply
transformation_count = random.randint(
1, len(transformations)
) #choose random number of transformation to apply on the image
while n <= transformation_count:
key = random.choice(
list(transformations)) #randomly choosing method to call
transformed_image = transformations[key](original_image)
n = n + 1
new_image_path = "%s/augmented_image_%s.png" % (augmented_path, i)
transformed_image = img_as_ubyte(
transformed_image
) #Convert an image to unsigned byte format, with values in [0, 255].
transformed_image = cv2.cvtColor(
transformed_image,
cv2.COLOR_BGR2RGB) #convert image to RGB before saving it
cv2.imwrite(new_image_path,
transformed_image) # save transformed image to path
i = i + 1
m.bias.data.zero_()
# network
size = 128
G = generator(size)
G.cuda()
if os.path.exists("MNIST_DCGAN_results/iter/best_state_" + str(size) + ".pkl"):
checkpoint = torch.load("MNIST_DCGAN_results/iter/best_state_" +
str(size) + ".pkl")
G.load_state_dict(checkpoint['G'])
z_ = torch.randn((1000, 100)).view(-1, 100, 1, 1)
z_ = Variable(z_.cuda(), volatile=True)
G.eval()
test_images = G(z_)
images_numpy = test_images.cpu().data.numpy()
path_G = 'MNIST_DCGAN_results/RGB/G_' + str(size)
if not os.path.isdir(path_G):
os.mkdir(path_G)
for i in range(0, 1000):
src = skimage.transform.resize(images_numpy[i][0], (64, 64))
imageio.imwrite("temp.jpg", skimage.img_as_ubyte(src))
src = cv2.imread("temp.jpg", 0)
src_RGB = cv2.cvtColor(src, cv2.COLOR_GRAY2RGB)
cv2.imwrite(path_G + '/' + str(i) + ".jpg", src_RGB)
def main(input_dir='database',
output_dir='database_aligned',
image_size=182,
margin=44,
gpu_memory_fraction=1,
random_order=False):
sleep(random.random())
output_dir = os.path.expanduser(output_dir)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Store some git revision info in a text file in the log directory
# src_path, _ = os.path.split(os.path.realpath(__file__))
cwd = os.getcwd()
facenet.store_revision_info(cwd, output_dir, ' '.join(sys.argv))
dataset = facenet.get_dataset(input_dir)
print('Creating networks and loading parameters')
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=gpu_memory_fraction) # noqa: E501
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, None)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
# Add a random key to the filename to allow alignment using multiple
# processes
random_key = np.random.randint(0, high=99999)
bounding_boxes_filename = os.path.join(
output_dir, 'bounding_boxes_%05d.txt' % random_key) # noqa: E501
with open(bounding_boxes_filename, "w") as text_file:
nrof_images_total = 0
nrof_successfully_aligned = 0
if random_order:
random.shuffle(dataset)
for cls in dataset:
output_class_dir = os.path.join(output_dir, cls.name)
if not os.path.exists(output_class_dir):
os.makedirs(output_class_dir)
if random_order:
random.shuffle(cls.image_paths)
for image_path in cls.image_paths:
nrof_images_total += 1
filename = os.path.splitext(os.path.split(image_path)[1])[0]
output_filename = os.path.join(output_class_dir,
filename + '.png')
print(image_path)
if not os.path.exists(output_filename):
try:
img = imageio.imread(image_path)
except (IOError, ValueError, IndexError) as e:
errorMessage = '{}: {}'.format(image_path, e)
print(errorMessage)
else:
if img.ndim < 2:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
continue
if img.ndim == 2:
img = facenet.to_rgb(img)
img = img[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
img, minsize, pnet, rnet, onet, threshold,
factor) # noqa: E501
nrof_faces = bounding_boxes.shape[0]
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(img.shape)[0:2]
if nrof_faces > 1:
bounding_box_size = (det[:, 2] - det[:, 0]) * (
det[:, 3] - det[:, 1]) # noqa: E501
img_center = img_size / 2
offsets = np.vstack([
(det[:, 0] + det[:, 2]) / 2 -
img_center[1],
(det[:, 1] + det[:, 3]) / 2 - img_center[0]
]) # noqa: E501
offset_dist_squared = np.sum(
np.power(offsets, 2.0), 0) # noqa: E501
index = np.argmax(
bounding_box_size -
offset_dist_squared * 2.0
) # noqa: E501 # some extra weight on the centering
det = det[index, :]
det = np.squeeze(det)
bb = np.zeros(4, dtype=np.int32)
bb[0] = np.maximum(det[0] - margin / 2, 0)
bb[1] = np.maximum(det[1] - margin / 2, 0)
bb[2] = np.minimum(det[2] + margin / 2,
img_size[1])
bb[3] = np.minimum(det[3] + margin / 2,
img_size[0])
cropped = img[bb[1]:bb[3], bb[0]:bb[2], :]
scaled = resize(cropped, (image_size, image_size),
mode='constant')
nrof_successfully_aligned += 1
# convert image to uint8 before saving
imageio.imwrite(output_filename,
img_as_ubyte(scaled))
text_file.write('%s %d %d %d %d\n' %
(output_filename, bb[0], bb[1],
bb[2], bb[3])) # noqa: E501
else:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
print('Total number of images: %d' % nrof_images_total)
print('Number of successfully aligned images: %d' %
nrof_successfully_aligned) # noqa: E501
newsize = int(size * 2.5)
fps = 30
squirm_video = make_squirming_video(newsize,
T=1,
fps=fps,
w=8,
bg=(255, ) * image.shape[-1])
print('Video Generated: squirm_video')
rotating_video = rotate_video(np.concatenate((squirm_video, ) * 3))
print('Video Generated: rotating_video')
result = []
for i in enumerate(rotating_video):
frame = i[1]
angle = 360 * i[0] / len(rotating_video)
result.append(
overlap_image(rotate(raw_image, -angle),
frame, (newsize // 2, newsize // 2),
center=True))
if i[0] % 3 == 0:
print(end='.', flush=True)
print()
path = 'generated.mp4'
imageio.mimsave(path, [img_as_ubyte(frame) for frame in result], fps=fps)
print(f'Video Saved at {path}')
input('Press ENTER to exit...')
def getColumns(paper):
thresh = img_as_ubyte(threshold_adaptive(paper, 15, offset=5))
(_, cnts, hierarchy) = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# cv2.imshow("debug", cv2.drawContours(cv2.cvtColor(thresh.copy(), cv2.COLOR_GRAY2BGR), cnts, -1, (255,0,0), 1))
cnts = contours.sort_contours(cnts, method="top-to-bottom")[0]
(_, cnts, hierarchy) = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
validHierarchy, validCnts = [[]], []
markerCnts = []
i = 0
removedIDs = [-1]
for c in cnts:
(x, y, w, h) = cv2.boundingRect(c)
ar = w / float(h)
if ar >= 0.75 and ar <= 1.25 and len(
cv2.approxPolyDP(c, 0.1 * cv2.arcLength(c, True), True)) == 4:
validCnts.append(c)
validHierarchy[0].append(hierarchy[0][i])
else:
removedIDs.append(i)
i += 1
i = 0
for c in validCnts:
if validHierarchy[0][i][3] not in removedIDs:
markerCnts.append(c)
i += 1
markerCnts = sorted(markerCnts, key=cv2.contourArea, reverse=True)[:6]
display = cv2.cvtColor(thresh.copy(), cv2.COLOR_GRAY2BGR)
cv2.drawContours(display, markerCnts, -1, (0, 255, 0), -1)
cv2.line(display, (len(display[0]) // 2, 0),
((len(display[0]) // 2), len(display)), (0, 0, 255), 3)
# cv2.imshow("current markers", display)
if len(markerCnts):
markerCnts = contours.sort_contours(markerCnts, method="left-to-right")
leftCnts = markerCnts[0][:4]
rightCnts = markerCnts[0][2:]
if len(leftCnts) and len(rightCnts):
# print(len(markerCnts[0]))
# 1 2
#
#
# 3 4
cL1 = contours.sort_contours(leftCnts[:2],
method="top-to-bottom")[0][0]
cL2 = contours.sort_contours(leftCnts[2:],
method="top-to-bottom")[0][0]
cL3 = contours.sort_contours(leftCnts[2:],
method="top-to-bottom")[0][1]
cL4 = contours.sort_contours(leftCnts[:2],
method="top-to-bottom")[0][1]
pL1 = list(max(cL1, key=(lambda c: c[0][0] + c[0][1]))[0])
pL2 = list(max(cL2, key=(lambda c: c[0][1] - c[0][0]))[0])
pL3 = list(min(cL3, key=(lambda c: c[0][0] + c[0][1]))[0])
pL4 = list(max(cL4, key=(lambda c: c[0][0] - c[0][1]))[0])
cR1 = contours.sort_contours(rightCnts[:2],
method="top-to-bottom")[0][0]
cR2 = contours.sort_contours(rightCnts[2:],
method="top-to-bottom")[0][0]
cR3 = contours.sort_contours(rightCnts[2:],
method="top-to-bottom")[0][1]
cR4 = contours.sort_contours(rightCnts[:2],
method="top-to-bottom")[0][1]
pR1 = list(max(cR1, key=(lambda c: c[0][0] + c[0][1]))[0])
pR2 = list(max(cR2, key=(lambda c: c[0][1] - c[0][0]))[0])
pR3 = list(min(cR3, key=(lambda c: c[0][0] + c[0][1]))[0])
pR4 = list(max(cR4, key=(lambda c: c[0][0] - c[0][1]))[0])
bubbleThresh = img_as_ubyte(
threshold_adaptive(paper, 257, offset=20))
leftBox = np.array([pL1, pL2, pL3, pL4])
rightBox = np.array([pR1, pR2, pR3, pR4])
print(leftBox)
left = four_point_transform(bubbleThresh, leftBox)
right = four_point_transform(bubbleThresh, rightBox)
# notesThresh = img_as_ubyte(threshold_adaptive(paper, 13, offset = 2.5))
# notes = paper[pN[1]:]
# clahe = cv2.createCLAHE(clipLimit=4.0, tileGridSize=(4,4))
# notes = clahe.apply(notes)
# cv2.imshow("notes", notes)
display = cv2.cvtColor(paper.copy(), cv2.COLOR_GRAY2BGR)
cv2.line(display, tuple(pL1), tuple(pL2), (0, 0, 255), 3)
cv2.line(display, tuple(pL2), tuple(pL3), (0, 0, 255), 3)
cv2.line(display, tuple(pL3), tuple(pL4), (0, 0, 255), 3)
cv2.line(display, tuple(pL4), tuple(pL1), (0, 0, 255), 3)
cv2.line(display, tuple(pR1), tuple(pR2), (255, 0, 0), 3)
cv2.line(display, tuple(pR2), tuple(pR3), (255, 0, 0), 3)
cv2.line(display, tuple(pR3), tuple(pR4), (255, 0, 0), 3)
cv2.line(display, tuple(pR4), tuple(pR1), (255, 0, 0), 3)
cv2.imshow("OUTPUT", display)
return (left, right)
return None
def _deprocess_image(self, img):
return img_as_ubyte((img + 1) / 2)
idealLowPass = D <= D0
idealHighPass = 1 - idealLowPass
# Filter our small grayscale image with the ideal lowpass filter
# 1. DFT of image
print(grayImg.dtype)
FTgraySmall = np.fft.fft2(grayImg.astype(float))
# 2. Butterworth filter is already defined in Fourier space
# 3. Elementwise product in Fourier space (notice fftshift of the filter)
FTgraySmallFiltered = FTgraySmall * np.fft.fftshift(idealLowPass)
# FTgraySmallFiltered = FTgraySmall * np.fft.fftshift(idealHighPass)
# 4. Inverse DFT to take filtered image back to the spatial domain
graySmallFiltered = np.abs(np.fft.ifft2(FTgraySmallFiltered))
# idealHighPass = ski.img_as_ubyte(idealHighPass / idealHighPass.max())
idealLowPass = ski.img_as_ubyte(idealLowPass / idealLowPass.max())
graySmallFiltered = ski.img_as_ubyte(graySmallFiltered /
graySmallFiltered.max())
cv2.imwrite("C:/Users/ciezcm15/Documents/Project1/idealLowPass.jpg",
idealLowPass)
# cv2.imwrite("C:/Users/ciezcm15/Documents/Project1/idealHighPass.jpg", idealHighPass)
cv2.imwrite(
"C:/Users/ciezcm15/Documents/Project1/grayImageIdealLowpassFiltered.jpg",
graySmallFiltered)
# Plot the ideal filter and then create and plot Butterworth filters of order
# n = 1, 2, 3, 4
plt.plot(xval,
idealLowPass[int(idealLowPass.shape[0] / 2), :],
'c--',
def pro(img,
mask,
draw_rect1=True,
draw_rect2=True,
draw_lines=True,
draw_mask=True):
copy = img.copy()
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = detector(gray, 0)
for face in faces:
x1 = face.left()
y1 = face.top()
x2 = face.right()
y2 = face.bottom()
landmarks = predector(gray, face)
size = copy.shape
#2D image points. If you change the image, you need to change vector
image_points = np.array(
[
(landmarks.part(33).x, landmarks.part(33).y), # Nose tip
(landmarks.part(8).x, landmarks.part(8).y), # Chin
(landmarks.part(36).x,
landmarks.part(36).y), # Left eye left corner
(landmarks.part(45).x,
landmarks.part(45).y), # Right eye right corne
(landmarks.part(48).x,
landmarks.part(48).y), # Left Mouth corner
(landmarks.part(54).x, landmarks.part(54).y
) # Right mouth corner
],
dtype="double")
# 3D model points.
model_points = np.array([
(0.0, 0.0, 0.0), # Nose tip
(0.0, -330.0, -65.0), # Chin
(-225.0, 170.0, -135.0), # Left eye left corner
(225.0, 170.0, -135.0), # Right eye right corne
(-150.0, -150.0, -125.0), # Left Mouth corner
(150.0, -150.0, -125.0) # Right mouth corner
])
# Camera internals
focal_length = size[1]
center = (size[1] / 2, size[0] / 2)
camera_matrix = np.array([[focal_length, 0, center[0]],
[0, focal_length, center[1]], [0, 0, 1]],
dtype="double")
dist_coeffs = np.zeros((4, 1)) # Assuming no lens distortion
(success, rotation_vector,
translation_vector) = cv2.solvePnP(model_points, image_points,
camera_matrix, dist_coeffs)
(b1, jacobian) = cv2.projectPoints(np.array([(350.0, 270.0, 0.0)]),
rotation_vector, translation_vector,
camera_matrix, dist_coeffs)
(b2, jacobian) = cv2.projectPoints(np.array([(-350.0, -270.0, 0.0)]),
rotation_vector, translation_vector,
camera_matrix, dist_coeffs)
(b3, jacobian) = cv2.projectPoints(np.array([(-350.0, 270, 0.0)]),
rotation_vector, translation_vector,
camera_matrix, dist_coeffs)
(b4, jacobian) = cv2.projectPoints(np.array([(350.0, -270.0, 0.0)]),
rotation_vector, translation_vector,
camera_matrix, dist_coeffs)
(b11, jacobian) = cv2.projectPoints(np.array([
(450.0, 350.0, 400.0)
]), rotation_vector, translation_vector, camera_matrix, dist_coeffs)
(b12,
jacobian) = cv2.projectPoints(np.array([(-450.0, -350.0, 400.0)]),
rotation_vector, translation_vector,
camera_matrix, dist_coeffs)
(b13, jacobian) = cv2.projectPoints(np.array([
(-450.0, 350, 400.0)
]), rotation_vector, translation_vector, camera_matrix, dist_coeffs)
(b14, jacobian) = cv2.projectPoints(np.array([
(450.0, -350.0, 400.0)
]), rotation_vector, translation_vector, camera_matrix, dist_coeffs)
b1 = (int(b1[0][0][0]), int(b1[0][0][1]))
b2 = (int(b2[0][0][0]), int(b2[0][0][1]))
b3 = (int(b3[0][0][0]), int(b3[0][0][1]))
b4 = (int(b4[0][0][0]), int(b4[0][0][1]))
b11 = (int(b11[0][0][0]), int(b11[0][0][1]))
b12 = (int(b12[0][0][0]), int(b12[0][0][1]))
b13 = (int(b13[0][0][0]), int(b13[0][0][1]))
b14 = (int(b14[0][0][0]), int(b14[0][0][1]))
if draw_rect1 == True:
cv2.line(copy, b1, b3, (255, 255, 0), 10)
cv2.line(copy, b3, b2, (255, 255, 0), 10)
cv2.line(copy, b2, b4, (255, 255, 0), 10)
cv2.line(copy, b4, b1, (255, 255, 0), 10)
if draw_rect2 == True:
cv2.line(copy, b11, b13, (255, 255, 0), 10)
cv2.line(copy, b13, b12, (255, 255, 0), 10)
cv2.line(copy, b12, b14, (255, 255, 0), 10)
cv2.line(copy, b14, b11, (255, 255, 0), 10)
if draw_lines == True:
cv2.line(copy, b11, b1, (0, 255, 0), 10)
cv2.line(copy, b13, b3, (0, 255, 0), 10)
cv2.line(copy, b12, b2, (0, 255, 0), 10)
cv2.line(copy, b14, b4, (0, 255, 0), 10)
if draw_mask == True:
pt = np.float32([b11, b13, b14, b12])
ty = add_photo(copy, pt, mask)
tb = img_as_ubyte(ty)
for i in range(0, ty.shape[0]):
for j in range(0, ty.shape[1]):
k = ty[i, j]
if k[0] != -1 and k[1] != -1 and k[2] != -1:
copy[i, j] = tb[i, j]
return copy
def dataExtractorForTraining(patchesPerImage,
nbImages,
nbBins=4,
filename_to_save='FeaturesForTraining'):
"""Create a file "features.csv" containing glcm features and colors feature extracted from all patches of the
"patchesDataSet" folder. This file is saved in the "patchesDataSet folder.
# Arguments :
patchesPerImage: The amount of patches wanted for each image.
nbImages: Int. The amout of images from the PH2Dataset used to extract features.
nbBins: Int. The number of bins wanted for color histogram. For example, 4 bins means the color
histogram will be divided into 4 parts.
filename_to_save: String or None.
# Outputs :
Only save the "features.csv" file.
"""
dissimilarityLista = []
correlationLista = []
energyLista = []
contrastLista = []
homogeneityLista = []
dissimilarityListb = []
correlationListb = []
energyListb = []
contrastListb = []
homogeneityListb = []
lists = list_creator(nbBins)
resultList = []
for patchCount in range(0, nbImages * patchesPerImage):
crit = patchCount // int(patchesPerImage / 2)
if crit % 2 == 0:
patch_a, patch_b = load_patches(patchCount, subdir='Similar')
reda = patch_a[:, :, 0]
greena = patch_a[:, :, 1]
bluea = patch_a[:, :, 2]
patch_a = rgb2gray(patch_a)
patch_a = img_as_ubyte(patch_a)
redb = patch_b[:, :, 0]
greenb = patch_b[:, :, 1]
blueb = patch_b[:, :, 2]
patch_b = rgb2gray(patch_b)
patch_b = img_as_ubyte(patch_b)
# Compute glcm features extraction
glcma = greycomatrix(patch_a, [2], [0])
glcmb = greycomatrix(patch_b, [2], [0])
dissimilaritya = greycoprops(glcma, 'dissimilarity')[0, 0]
correlationa = greycoprops(glcma, 'correlation')[0, 0]
energya = greycoprops(glcma, 'energy')[0, 0]
contrasta = greycoprops(glcma, 'contrast')[0, 0]
homogeneitya = greycoprops(glcma, 'homogeneity')[0, 0]
dissimilarityb = greycoprops(glcmb, 'dissimilarity')[0, 0]
correlationb = greycoprops(glcmb, 'correlation')[0, 0]
energyb = greycoprops(glcmb, 'energy')[0, 0]
contrastb = greycoprops(glcmb, 'contrast')[0, 0]
homogeneityb = greycoprops(glcmb, 'homogeneity')[0, 0]
dissimilarityLista.append(dissimilaritya)
correlationLista.append(correlationa)
energyLista.append(energya)
contrastLista.append(contrasta)
homogeneityLista.append(homogeneitya)
dissimilarityListb.append(dissimilarityb)
correlationListb.append(correlationb)
energyListb.append(energyb)
contrastListb.append(contrastb)
homogeneityListb.append(homogeneityb)
# Compute colors feature extraction (color histograms)
histo_ra = histogram(reda)
histo_ga = histogram(greena)
histo_ba = histogram(bluea)
histo_rb = histogram(redb)
histo_gb = histogram(greenb)
histo_bb = histogram(blueb)
numPixelsReda = [0] * 256
cReda = 0
for index in histo_ra[1]:
numPixelsReda[index] = histo_ra[0][cReda]
cReda += 1
for k in range(0, nbBins):
lists[k].append(
sum(numPixelsReda[k * int(256 / nbBins):(k + 1) *
int(256 / nbBins) - 1]))
numPixelsGreena = [0] * 256
cGreena = 0
for index in histo_ga[1]:
numPixelsGreena[index] = histo_ga[0][cGreena]
cGreena += 1
for k in range(nbBins, 2 * nbBins):
lists[k].append(
sum(numPixelsGreena[(k - nbBins) *
int(256 / nbBins):(k + 1 - nbBins) *
int(256 / nbBins) - 1]))
numPixelsBluea = [0] * 256
cBluea = 0
for index in histo_ba[1]:
numPixelsBluea[index] = histo_ba[0][cBluea]
cBluea += 1
for k in range(2 * nbBins, 3 * nbBins):
lists[k].append(
sum(numPixelsBluea[(k - 2 * nbBins) *
int(256 / nbBins):(k + 1 - 2 * nbBins) *
int(256 / nbBins) - 1]))
numPixelsRedb = [0] * 256
cRedb = 0
for index in histo_rb[1]:
numPixelsRedb[index] = histo_rb[0][cRedb]
cRedb += 1
for k in range(3 * nbBins, 4 * nbBins):
lists[k].append(
sum(numPixelsRedb[(k - 3 * nbBins) *
int(256 / nbBins):(k + 1 - 3 * nbBins) *
int(256 / nbBins) - 1]))
numPixelsGreenb = [0] * 256
cGreenb = 0
for index in histo_gb[1]:
numPixelsGreenb[index] = histo_gb[0][cGreenb]
cGreenb += 1
for k in range(4 * nbBins, 5 * nbBins):
lists[k].append(
sum(numPixelsGreenb[(k - 4 * nbBins) *
int(256 /
nbBins):(k + 1 - 4 * nbBins) *
int(256 / nbBins) - 1]))
numPixelsBlueb = [0] * 256
cBlueb = 0
for index in histo_bb[1]:
numPixelsBlueb[index] = histo_bb[0][cBlueb]
cBlueb += 1
for k in range(5 * nbBins, 6 * nbBins):
lists[k].append(
sum(numPixelsBlueb[(k - 5 * nbBins) *
int(256 / nbBins):(k + 1 - 5 * nbBins) *
int(256 / nbBins) - 1]))
resultList.append(1)
else:
patch_a, patch_b = load_patches(patchCount, subdir='nonSimilar')
reda = patch_a[:, :, 0]
greena = patch_a[:, :, 1]
bluea = patch_a[:, :, 2]
patch_a = rgb2gray(patch_a)
patch_a = img_as_ubyte(patch_a)
redb = patch_b[:, :, 0]
greenb = patch_b[:, :, 1]
blueb = patch_b[:, :, 2]
patch_b = rgb2gray(patch_b)
patch_b = img_as_ubyte(patch_b)
# Compute glcm features extraction
glcma = greycomatrix(patch_a, [2], [0])
glcmb = greycomatrix(patch_b, [2], [0])
dissimilaritya = greycoprops(glcma, 'dissimilarity')[0, 0]
correlationa = greycoprops(glcma, 'correlation')[0, 0]
energya = greycoprops(glcma, 'energy')[0, 0]
contrasta = greycoprops(glcma, 'contrast')[0, 0]
homogeneitya = greycoprops(glcma, 'homogeneity')[0, 0]
dissimilarityb = greycoprops(glcmb, 'dissimilarity')[0, 0]
correlationb = greycoprops(glcmb, 'correlation')[0, 0]
energyb = greycoprops(glcmb, 'energy')[0, 0]
contrastb = greycoprops(glcmb, 'contrast')[0, 0]
homogeneityb = greycoprops(glcmb, 'homogeneity')[0, 0]
dissimilarityLista.append(dissimilaritya)
correlationLista.append(correlationa)
energyLista.append(energya)
contrastLista.append(contrasta)
homogeneityLista.append(homogeneitya)
dissimilarityListb.append(dissimilarityb)
correlationListb.append(correlationb)
energyListb.append(energyb)
contrastListb.append(contrastb)
homogeneityListb.append(homogeneityb)
# Compute color feature extraction
histo_ra = histogram(reda)
histo_ga = histogram(greena)
histo_ba = histogram(bluea)
histo_rb = histogram(redb)
histo_gb = histogram(greenb)
histo_bb = histogram(blueb)
numPixelsReda = [0] * 256
cReda = 0
for index in histo_ra[1]:
numPixelsReda[index] = histo_ra[0][cReda]
cReda += 1
for k in range(0, nbBins):
lists[k].append(
sum(numPixelsReda[k * int(256 / nbBins):(k + 1) *
int(256 / nbBins) - 1]))
numPixelsGreena = [0] * 256
cGreena = 0
for index in histo_ga[1]:
numPixelsGreena[index] = histo_ga[0][cGreena]
cGreena += 1
for k in range(nbBins, 2 * nbBins):
lists[k].append(
sum(numPixelsGreena[(k - nbBins) *
int(256 / nbBins):(k + 1 - nbBins) *
int(256 / nbBins) - 1]))
numPixelsBluea = [0] * 256
cBluea = 0
for index in histo_ba[1]:
numPixelsBluea[index] = histo_ba[0][cBluea]
cBluea += 1
for k in range(2 * nbBins, 3 * nbBins):
lists[k].append(
sum(numPixelsBluea[(k - 2 * nbBins) *
int(256 / nbBins):(k + 1 - 2 * nbBins) *
int(256 / nbBins) - 1]))
numPixelsRedb = [0] * 256
cRedb = 0
for index in histo_rb[1]:
numPixelsRedb[index] = histo_rb[0][cRedb]
cRedb += 1
for k in range(3 * nbBins, 4 * nbBins):
lists[k].append(
sum(numPixelsRedb[(k - 3 * nbBins) *
int(256 / nbBins):(k + 1 - 3 * nbBins) *
int(256 / nbBins) - 1]))
numPixelsGreenb = [0] * 256
cGreenb = 0
for index in histo_gb[1]:
numPixelsGreenb[index] = histo_gb[0][cGreenb]
cGreenb += 1
for k in range(4 * nbBins, 5 * nbBins):
lists[k].append(
sum(numPixelsGreenb[(k - 4 * nbBins) *
int(256 /
nbBins):(k + 1 - 4 * nbBins) *
int(256 / nbBins) - 1]))
numPixelsBlueb = [0] * 256
cBlueb = 0
for index in histo_bb[1]:
numPixelsBlueb[index] = histo_bb[0][cBlueb]
cBlueb += 1
for k in range(5 * nbBins, 6 * nbBins):
lists[k].append(
sum(numPixelsBlueb[(k - 5 * nbBins) *
int(256 / nbBins):(k + 1 - 5 * nbBins) *
int(256 / nbBins) - 1]))
resultList.append(0)
df = pd.DataFrame({
"Dissimilarity a": dissimilarityLista,
"Correlation a": correlationLista,
"Energy a": energyLista,
"Contrast a": contrastLista,
"Homogeneity a": homogeneityLista,
"Dissimilarity b": dissimilarityListb,
"Correlation b": correlationListb,
"Energy b": energyListb,
"Contrast b": contrastListb,
"Homogeneity b": homogeneityListb
})
for k in range(0, len(lists)):
if k < nbBins:
df["red " + str(k + 1) + "/" + str(nbBins) + " a"] = lists[k]
elif k >= nbBins and k < 2 * nbBins:
df["green " + str(k + 1 - nbBins) + "/" + str(nbBins) +
" a"] = lists[k]
elif k >= 2 * nbBins and k < 3 * nbBins:
df["blue " + str(k + 1 - 2 * nbBins) + "/" + str(nbBins) +
" a"] = lists[k]
elif k >= 3 * nbBins and k < 4 * nbBins:
df["red " + str(k + 1 - 3 * nbBins) + "/" + str(nbBins) +
" b"] = lists[k]
elif k >= 4 * nbBins and k < 5 * nbBins:
df["green " + str(k + 1 - 4 * nbBins) + "/" + str(nbBins) +
" b"] = lists[k]
else:
df["blue " + str(k + 1 - 5 * nbBins) + "/" + str(nbBins) +
" b"] = lists[k]
df["Result"] = resultList
if filename_to_save:
df.to_csv(
f"{package_path()}/data/patchesDataSet/{filename_to_save}.csv")
return df
def process(self):
"""Perform the model warping and output an image grid"""
if self.getPropertyByIdentifier("off").value:
print("Image warping is currently turned off")
return 1
start_time = time.time()
if self.getPropertyByIdentifier("display_input").value:
im_data = []
for name in INPORT_LIST:
im_data.append(self.getInport(name).getData())
out_image = Image(OUT_SIZE, DTYPE)
out = resize(im_data[0].colorLayers[0].data.transpose(1, 0, 2),
OUT_SIZE_LIST)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
inter_out = img_as_ubyte(out)
out_image.colorLayers[0].data = inter_out
self.getOutport("outport").setData(out_image)
return 1
if model is None:
print("No model for synthesis")
return -1
cam = inviwopy.app.network.EntryExitPoints.camera
im_data = []
for name in INPORT_LIST:
im_data.append(self.getInport(name).getData())
for im in im_data:
if not (im_data[0].dimensions == im.dimensions):
print("Operation is incompatible with images of different size")
print("Size 1: ", im_data[0].dimensions)
print("Size 2: ", im.dimensions)
return -1
out_image = Image(OUT_SIZE, DTYPE)
sample_image = Image(SAMPLE_SIZE, DTYPE)
im_colour = []
for idx, name in enumerate(INPORT_LIST):
im_colour.append(im_data[idx].colorLayers[0].data[:, :, :3].transpose(
1, 0, 2))
im_depth = []
near = cam.nearPlane
far = cam.farPlane
baseline = 0.5
focal_length = cam.projectionMatrix[0][0]
fov = cam.fov.value
for idx, name in enumerate(INPORT_LIST):
im_depth.append(
conversions.depth_to_pixel_disp(
im_data[idx].depth.data.transpose(1, 0),
near=near,
far=far,
baseline=baseline,
focal_length=focal_length,
fov=fov,
image_pixel_size=float(im_data[0].dimensions[0])))
sample = {
'depth': torch.tensor(im_depth[0], dtype=torch.float32).unsqueeze_(0),
'colour': torch.tensor(im_colour[0],
dtype=torch.float32).unsqueeze_(0),
'grid_size': GRID_SIZE
}
warped = data_transform.transform_inviwo_to_warped(sample)
warped = data_transform.stack(warped, 65)
im_input = warped['inputs'].unsqueeze_(0)
if cuda:
im_input = im_input.cuda()
model.eval()
output = model(im_input)
im_input = im_input[:, :-3]
output += im_input
output = torch.clamp(output, 0.0, 1.0)
end_time = time.time() - start_time
print("Grid light field rendered in {:4f}".format(end_time))
out_unstack = data_transform.torch_unstack(output[0])
out_colour = cnn_utils.transform_lf_to_torch(out_unstack)
output_grid = vutils.make_grid(out_colour,
nrow=8,
range=(0, 1),
normalize=False,
padding=2,
pad_value=1.0)
output_grid = resize(output_grid.cpu().detach().numpy().transpose(1, 2, 0),
OUT_SIZE_LIST)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
inter_out = img_as_ubyte(output_grid)
#inter_out = denormalise_lf(output_grid)
#inter_out = inter_out.cpu().detach().numpy().astype(np.uint8).transpose(1, 2, 0)
# Add an alpha channel here
shape = tuple(OUT_SIZE_LIST) + (4, )
final_out = np.full(shape, 255, np.uint8)
final_out[:, :, :3] = inter_out
shape = tuple(SAMPLE_SIZE_LIST) + (4, )
sample_out = np.full(shape, 255, np.uint8)
sample_out[:, :, :3] = np.around(
data_transform.denormalise_lf(
out_unstack).cpu().detach().numpy()).astype(
np.uint8)[self.getPropertyByIdentifier("sample_num").value]
# Inviwo expects a uint8 here
out_image.colorLayers[0].data = final_out
sample_image.colorLayers[0].data = sample_out
self.getOutport("outport").setData(out_image)
self.getOutport("sample").setData(sample_image)
end_time = time.time() - start_time
print("Overall render time was {:4f}".format(end_time))
def int_img(img):
return img_as_ubyte(img)
result = result[borderh:height_ - borderh, borderw:width_ - borderw]
return result
im = cv2.imread("B638_EP_C2_Mar13.png")
img = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
h, w = img.shape[:2]
bkg = np.array([
np.mean(im[:h / 7, :, 0]),
np.mean(im[:h / 7, :, 1]),
np.mean(im[:h / 7, :, 2])
])
img_contrast = np.sum(np.abs(im - bkg), axis=2)
img_contrast /= np.max(img_contrast)
img_contrast = img_as_ubyte(img_contrast)
img_contrast_rot = rotateImage(img_as_ubyte(img_contrast), 1.60)
plt.imshow(img_contrast_rot)
plt.show()
plt.clf()
tl = np.array([365, 440])
br = tl + np.array([340, 360])
plt.imsave('ScubaEP_template.png',
img_contrast_rot[tl[1]:br[1], tl[0]:br[0]],
cmap=plt.cm.gray)
cv2.rectangle(img_contrast_rot, (tl[0], tl[1]), (br[0], br[1]), 255, 5)
cv2.circle(img_contrast_rot, (tl[0] + 170, tl[1] + 240), 10, (255), 10)
continue
# # Load image and ground truth data
# image, image_meta, gt_class_id, gt_bbox, gt_mask =\
# modellib.load_image_gt(dataset, inference_config,
# image_id, use_mini_mask=False)
# molded_images = np.expand_dims(modellib.mold_image(image, inference_config), 0)
# # Run object detection
# results = model.detect([image], verbose=0)
# r = results[0]
# # Compute AP
# AP, precisions, recalls, overlaps =\
# utils.compute_ap(gt_bbox, gt_class_id, gt_mask,
# r["rois"], r["class_ids"], r["scores"], r['masks'])
# APs.append(AP)
image = skimage.img_as_ubyte(
plt.imread(os.path.join(dataset_dir, file)))
results = model.detect([image], verbose=1)
fig, ax = get_ax()
r = results[0]
encountered_ids = []
filtered_inds = []
target_ids = [1, 2]
for i, box in enumerate(r['rois']):
# ROIs are sorted after confidence, if one was registered discard lower confidence detections to avoid double counting
class_id = r['class_ids'][i]
print(class_id)
if class_id not in target_ids or class_id in encountered_ids:
continue
encountered_ids.append(class_id)
# all_visual_features_unordered.append(r['roi_features'][i])
def save_image(path, name, img):
imageio.imsave(path + '/' + name + '.png', img_as_ubyte(img))
In this example, we will see how to filter a gray-level image using some of the
linear and non-linear filters available in skimage. We use the ``camera`` image
from ``skimage.data`` for all comparisons.
.. [1] Pierre Soille, On morphological operators based on rank filters, Pattern
Recognition 35 (2002) 527-535.
"""
import numpy as np
import matplotlib.pyplot as plt
from skimage import img_as_ubyte
from skimage import data
noisy_image = img_as_ubyte(data.camera())
hist = np.histogram(noisy_image, bins=np.arange(0, 256))
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.imshow(noisy_image, interpolation='nearest', cmap=plt.cm.gray)
ax1.axis('off')
ax2.plot(hist[1][:-1], hist[0], lw=2)
ax2.set_title('Histogram of grey values')
######################################################################
#
# Noise removal
# =============
#
# Some noise is added to the image, 1% of pixels are randomly set to 255, 1%
# are randomly set to 0. The **median** filter is applied to remove the
def filter_image(in_image, out_dir, pallet, generate_id=False):
# print(in_image)
image_m = {}
parts = in_image.split('/')
if generate_id:
img_id = str(uuid.uuid4()).replace('-', '')[:8]
else:
img_id = parts[-1:][0].split('-')[0]
image_m['id'] = img_id
p_colors = get_colors(pallet)
c_name = p_colors[0].attrib['name']
img_rgb = img_as_float64(io.imread(in_image))
grayscale_image = color.rgb2gray(img_rgb)
# # Create a mask selecting regions with interesting texture.
# noisy = rank.entropy(img_rgb, np.ones((9, 9)))
# textured_regions = noisy > 4.25
# # Note that using `colorize` here is a bit more difficult, since `rgb2hsv`
# # expects an RGB image (height x width x channel), but fancy-indexing returns
# # a set of RGB pixels (# pixels x channel).
color_multiplier_0 = randomize_color(get_color_by_index(p_colors, 0))
color_multiplier_1 = randomize_color(get_color_by_index(p_colors, 1))
color_multiplier_2 = randomize_color(get_color_by_index(p_colors, 2))
color_multiplier_3 = randomize_color(get_color_by_index(p_colors, 3))
color_multiplier_4 = randomize_color(get_color_by_index(p_colors, 4))
image_m['colors'] = [
color_multiplier_0, color_multiplier_1, color_multiplier_2,
color_multiplier_3, color_multiplier_4
]
thresh = skimage.filters.threshold_otsu(grayscale_image)
binary = grayscale_image <= thresh
noisy = rank.threshold(grayscale_image, square(9))
n_max = noisy.mean()
textured_regions_0 = noisy < (n_max * .1)
textured_regions_1 = np.all([noisy >= (n_max * .1), noisy <= (n_max * .3)])
textured_regions_2 = np.all([noisy >= (n_max * .3), noisy <= (n_max * .5)])
textured_regions_3 = np.all([noisy >= (n_max * .6), noisy <= (n_max * .8)])
textured_regions_4 = noisy >= (n_max * .8)
masked_image = img_rgb.copy()
masked_image[textured_regions_0, :] *= color_multiplier_0
masked_image[textured_regions_1, :] *= color_multiplier_1
masked_image[textured_regions_2, :] *= color_multiplier_2
masked_image[textured_regions_3, :] *= color_multiplier_3
masked_image[textured_regions_4, :] *= color_multiplier_4
masked_image[binary, :] *= color_multiplier_0
out_img = '{}/{}.png'.format(out_dir, image_m['id'])
io.imsave(out_img, img_as_ubyte(masked_image))
print('out:{} pallete:{}'.format(out_img, c_name))
image_m['out_img'] = out_img
return image_m
output.append(skimage.io.imread(class2))
output.append(skimage.io.imread(class3))
conc=0
paperino=0
l_verme=100
b2, F, G, H=0, 0, 0, 0
def adapt_input(im, size):
h, w = im.shape[0:2]
sz = min(h, w)
im=im[(h//2-sz//2):(h//2+sz//2),(w//2-sz//2):(w//2+sz//2),:]
im = skimage.transform.resize(im, (size, size, 3), mode='reflect')
return im
for i in range(len(special_input)):
special_input2.append(adapt_input(skimage.io.imread(special_input[i]), 64))
special_input3.append(skimage.img_as_ubyte(adapt_input(skimage.io.imread(special_input[i])[:,:,::-1], 80)))
special_input4.append(skimage.img_as_ubyte(adapt_input(skimage.io.imread(special_input[i])[:,:,::-1], 120)))
inputtino, inputtinob, inputtinod=special_input2[0], special_input3[0], special_input4[0]
neuron, neuronb=[],[]
for i in range(128):
neuron.append(adapt_input(skimage.io.imread("IMAGES/NEURONS/neuron%d.jpg" %(i+1)), 64))
neuronb.append(skimage.img_as_ubyte(adapt_input(skimage.io.imread("IMAGES/NEURONS/neuron%d.jpg"%(i+1))[:,:,::-1], 80)))
for i in range(3):
neuron.append(adapt_input(skimage.io.imread("IMAGES/NEURONS/output%d.jpg" %(i+1)), 64))
neuronb.append(skimage.img_as_ubyte(adapt_input(skimage.io.imread("IMAGES/NEURONS/output%d.jpg"%(i+1))[:,:,::-1], 80)))
get = K.function([model.layers[0].input], [model.layers[13].output])
get2=[]*11
for i in range(11):
get2.append(K.function([model.layers[0].input], [model.layers[i].output]))
def lsr_feature(image_name,
output,
block,
scale,
mag_threshold=20,
lsr_threshold=20,
distance_threshold=8,
orientation_threshold=22.5):
assert (type(block) != None and type(scale) != None)
ds = gdal.Open(image_name)
image = ds.ReadAsArray()
geotran = ds.GetGeoTransform()
ulx = geotran[0]
uly = geotran[3]
in_cell_width = geotran[1]
in_cell_height = geotran[5]
ds = None
# block and scale parameters are in meters
# convert meters to image space (number of pixels)
# the conversion is very crude at the moment, should really
# be using projected data
if "wv2" in image_name:
cell_width = 0.46
if "wv3" in image_name:
cell_width = 0.31
# in number of pixels relative to the input data GSD
block = int(block / cell_width)
scale = int(scale / cell_width)
out_srs = osr.SpatialReference()
out_srs.ImportFromEPSG(4326)
out_srs_wkt = out_srs.ExportToWkt()
out_cell_width = block * in_cell_width
out_cell_height = block * in_cell_height
image = np.moveaxis(image, 0,
-1) # expects an image in rows, columns, channels
with expected_warnings(['precision']):
image = skimage.img_as_ubyte(rgb2gray(image))
lsr_im = line_support_regions(image)
for i in range(0, lsr_im.shape[0], block):
outrow = []
for j in range(0, lsr_im.shape[1], block):
center_i = int(i + block / 2.)
center_j = int(j + block / 2.)
if center_i - int(scale / 2.) < 0:
top = 0
else:
top = center_i - int(scale / 2.)
if center_i + int(scale / 2.) > lsr_im.shape[0]:
bot = lsr_im.shape[0]
else:
bot = center_i + int(scale / 2.)
if center_j - int(scale / 2.) < 0:
left = 0
else:
left = center_j - int(scale / 2.)
if center_j + int(scale / 2.) > lsr_im.shape[1]:
right = lsr_im.shape[1]
else:
right = center_j + int(scale / 2.)
scale_arr = lsr_im[top:bot + 1, left:right + 1]
feat_vec = __lsr_hist_feature(scale_arr)
outrow.append(feat_vec)
out_image.append(outrow)
out_image = np.moveaxis(out_image, -1, 0)
if output:
out_geotran = (ulx, out_cell_width, 0, uly, 0, out_cell_height)
write_geotiff(output, out_image, out_geotran, out_srs_wkt)
return np.array(out_image)
from skimage import img_as_ubyte
from skimage.io import imread, imsave
import numpy as np
img = imread('img.png')
img = img_as_ubyte(img)
h = np.zeros(256, np.uint32)
for v in img.flatten():
h[v] += 1
cdf = np.zeros(256, np.uint32)
for v in range(256):
cdf[v] = cdf[v - 1] + h[v]
min_sum = 99999
for val in cdf:
if val != 0 and val < min_sum:
min_sum = val
p = len(img.flatten())
res = img.copy()
for y in range(img.shape[0]):
for x in range(img.shape[1]):
pixel = img[y][x]
res[y][x] = round((cdf[pixel] - min_sum) / (p - 1) * 255)
imsave('out_img.png', res)
def random_crop(sample, lambda_scale_frac, lambda_shift_frac, min_scale,
max_scale):
image, bb = sample['image'], sample['bb']
image = img_as_ubyte(image)
if (len(image.shape) == 2):
image = np.repeat(image[..., None], 3, axis=2)
im = Image.fromarray(image)
cols = image.shape[1]
rows = image.shape[0]
width = bb[2] - bb[0]
height = bb[3] - bb[1]
center_x = bb[0] + width / 2
center_y = bb[1] + height / 2
# motion smoothness model
# adapted from Held's implementation - https://github.com/davheld/GOTURN/
kMaxNumTries = 10
kContextFactor = 2.
new_width = -1
num_tries_width = 0
# get new width
while ((new_width < 0 or new_width > cols - 1)
and num_tries_width < kMaxNumTries):
width_scale_factor = max(
min_scale, min(max_scale, sample_exp_two_sided(lambda_scale_frac)))
new_width = width * (1 + width_scale_factor)
new_width = max(1.0, min(cols - 1, new_width))
num_tries_width = num_tries_width + 1
new_height = -1
num_tries_height = 0
# get new height
while ((new_height < 0 or new_height > rows - 1)
and num_tries_height < kMaxNumTries):
height_scale_factor = max(
min_scale, min(max_scale, sample_exp_two_sided(lambda_scale_frac)))
new_height = height * (1 + height_scale_factor)
new_height = max(1.0, min(rows - 1, new_height))
num_tries_height = num_tries_height + 1
first_time_x = True
new_center_x = -1
num_tries_x = 0
# get new center X
while ((first_time_x
or new_center_x < center_x - width * kContextFactor / 2
or new_center_x > center_x + width * kContextFactor / 2
or new_center_x - new_width / 2 < 0
or new_center_x + new_width / 2 > cols)
and num_tries_x < kMaxNumTries):
new_x_temp = center_x + width * sample_exp_two_sided(lambda_shift_frac)
new_center_x = min(cols - new_width / 2, max(new_width / 2,
new_x_temp))
first_time_x = False
num_tries_x = num_tries_x + 1
first_time_y = True
new_center_y = -1
num_tries_y = 0
# get new center Y
while ((first_time_y
or new_center_y < center_y - height * kContextFactor / 2
or new_center_y > center_y + height * kContextFactor / 2
or new_center_y - new_height / 2 < 0
or new_center_y + new_height / 2 > rows)
and num_tries_y < kMaxNumTries):
new_y_temp = center_y + height * sample_exp_two_sided(
lambda_shift_frac)
new_center_y = min(rows - new_height / 2,
max(new_height / 2, new_y_temp))
first_time_y = False
num_tries_y = num_tries_y + 1
box = [
new_center_x - new_width / 2, new_center_y - new_height / 2,
new_center_x + new_width / 2, new_center_y + new_height / 2
]
box = [int(math.floor(x)) for x in box]
return box
def cleanRemoveImg(imgdata):
result = img_as_ubyte(rgb2gray(deepcopy(imgdata)))
del (imgdata)
return result
def calc_line_support_regions(image_name,
mag_threshold=20,
lsr_threshold=20,
distance_threshold=8,
orientation_threshold=22.5,
output_lsr_shapefile=False):
"""
Parameters:
------------
image_name: str
the image filename
mag_threshold: int or float
pixels with magnitude above mag_threshold are considered for line support regions
lsr_threshold: int or float
threshold for the smallest line support region
distance_threshold: int or float
the size of the kernel used for counting the number of pixels contributing to
a line support region
orientation_threshold: int or float
the number of degrees (+ or -) that is allowed when determining if pixels are in the same
line support region
Returns:
--------
lsf_raster: ndarray (3 bands, n rows, m cols)
lsf_raster[0] is line length values (in pixels)
lsf_raster[1] is line orientation values (in degrees)
lsf_raster[2] is line contrast values
geotran: gdal geotransform
"""
ds = gdal.Open(image_name)
image = ds.ReadAsArray()
geotran = ds.GetGeoTransform()
ulx = geotran[0]
uly = geotran[3]
in_cell_width = geotran[1]
in_cell_height = geotran[5]
ds = None
out_srs = osr.SpatialReference()
out_srs.ImportFromEPSG(4326)
out_srs_wkt = out_srs.ExportToWkt()
lsf_raster = np.ones(
shape=(image.shape)) * -1 # output lsf_raster is 3 band.
image = np.moveaxis(image, 0,
-1) # expects an image in rows, columns, channels
with expected_warnings(['precision']):
image = skimage.img_as_ubyte(rgb2gray(image))
# calculate gradient orientation and magnitude
mag, ang, dx, dy = __calc_mag_ang(image)
mag *= 0.001
# tmp(edmim<magThreshold)=-1;
temp = np.where(
mag < mag_threshold, -1,
ang) # set pixels to -1 if magnitude is below the mag_threshold
data_ob = __label_regions(temp, distance_threshold, orientation_threshold)
lsr_m = data_ob.labeled_regions
line_idx = np.unique(lsr_m)
# lsfarr = zeros(max(lsrM(:)),5);
lsf_arr = np.zeros(shape=(np.max(lsr_m), 5))
count = 0
l = 1
for l in range(1, np.max(line_idx)):
# idx=find(lsrM==l);
idx = np.argwhere(lsr_m.ravel() == l) # returns an array of indices
# eim = zeros(size(im));
eim = np.zeros(shape=temp.shape)
# eim(idx) = 1;
eim = np.where(lsr_m == l, 1, eim)
# if (sum(eim(:)) <= lsrThreshold)
if np.sum(eim) <= lsr_threshold: # ignore small line support region
continue
# ix_wi = dx(idx)
# iy_wi = dy(idx)
Ix_wi = dx.ravel()[
idx] # extract elements in dx at index locations where lsr_m == l
Iy_wi = dy.ravel()[idx]
grd_wi = mag.ravel()[idx]
# find major orientation
ST = [[np.sum(Ix_wi**2), np.sum(Ix_wi * Iy_wi)],
[np.sum(Ix_wi * Iy_wi), np.sum(Iy_wi**2)]]
# V, D = eig(ST)
# matlab returns returns diagonal matrix D of eigenvalues and matrix V whose columns are the corresponding right eigenvectors, so that A*V = V*D.
D, V = np.linalg.eig(ST) # python's return of D is a 1D array,
D = np.diag(
D) # make D on the diagonal to conform to matlab's procedure
# if D(1,1)<D(2,2)
# lorn=atan(V(2,1)/V(1,1));
# else
# lorn=atan(V(2,2)/V(1,2));
# end
if D[0][0] < D[1][1]:
# lorn=atan(V(2,1)/V(1,1));
lorn = np.arctan(V[1][0] / V[0][0])
else:
# lorn=atan(V(2,2)/V(1,2));
lorn = np.arctan(V[1][1] / V[0][1])
# vote for r
# [Ytmp,Xtmp]=ind2sub(size(im),idx);
Ytmp, Xtmp = np.unravel_index(idx, temp.shape)
Ytmp += 1 # indices need += 1 for some indexing weirdness...
Xtmp += 1
# Raccm=round(Xtmp.*cos(lorn-pi/2)+Ytmp.*sin(lorn-pi/2));
Raccm = np.round(Xtmp * math.cos(lorn - (math.pi / 2)) +
Ytmp * math.sin(lorn - (math.pi / 2)))
rng = np.arange(Raccm.min(), Raccm.max() + 1)
accm = np.zeros(shape=(len(rng)))
for k in range(len(idx)):
rc = np.round(Xtmp[k] * math.cos(lorn - math.pi / 2) +
Ytmp[k] * math.sin(lorn - math.pi / 2))
accm[np.where(rng == rc)] = accm[np.where(rng == rc)] + grd_wi[k]
mxid = np.argmax(accm)
Xmx = max(Xtmp[np.where(Raccm == rng[mxid])])
Xmn = min(Xtmp[np.where(Raccm == rng[mxid])])
Ymx = max(Ytmp[np.where(Raccm == rng[mxid])])
Ymn = min(Ytmp[np.where(Raccm == rng[mxid])])
lmx = ((Xmx + Xmn) / 2) - 1
lmy = ((Ymx + Ymn) / 2) - 1
llen = math.sqrt((Xmx - Xmn)**2 + (Ymx - Ymn)**2)
lsf_arr[count][0] = llen
lsf_arr[count][1] = lmx
lsf_arr[count][2] = lmy
lsf_arr[count][3] = lorn
lcon = np.mean(grd_wi[(np.where(Raccm == rng[mxid]))])
lsf_arr[count][4] = lcon
lsf_raster[0][int(lmy)][int(lmx)] = llen
lsf_raster[1][int(lmy)][int(lmx)] = np.rad2deg(lorn) + 180
lsf_raster[2][int(lmy)][int(lmx)] = lcon
count += 1
lsf_arr = lsf_arr[0:count, :]
#lsf_arr[:,1] = ulx + lsf_arr[:,1] * in_cell_width
#lsf_arr[:,2] = uly + lsf_arr[:,2] * in_cell_height
if output_lsr_shapefile:
write_lsr_shapefile(
lsf_arr,
os.path.join(os.path.dirname(image_name),
os.path.basename(image_name)[:-4]) + "_lsr_MT" +
str(mag_threshold) + "_LT" + str(lsr_threshold) + "_DT" +
str(distance_threshold) + "_OT" + str(orientation_threshold) +
".shp", geotran)
return lsf_raster
import numpy as np
import matplotlib.pyplot as plt
import skimage
from matplotlib import image
# from scipy.io import loadmat
from scipy import misc
from skimage import io
from Kmeans import Kmeans
img = image.imread('image.png')
print(img.shape)
image1 = img.reshape(img.shape[0] * img.shape[1], 3)
a = Kmeans(image1, 256)
Centroids, Output = a.fit(20)
image2 = []
for i in range(img.shape[0] * img.shape[1]):
image2.append(Centroids[Output[i]])
image_compressed = np.asarray(image2)
print(image_compressed)
image_compressed2 = image_compressed.reshape(img.shape[0], img.shape[1], 3)
print(image_compressed2)
i10 = skimage.img_as_ubyte(image_compressed2, force_copy=False)
plt.title(' image_compressed 256 colors')
plt.imshow(i10)
plt.show()
io.imsave('image_compressed_K256.png', i10)
# import scipy.misc
# misc.imsave('tiger_small.jpg', image_compressed)
def to_skeleton(img_binary):
m = morphology.skeletonize(img_binary > 0)
cv_image = img_as_ubyte(m)
return cv_image
