def handle(self, *args, **options):
better_thans = BetterThan.objects.all() #.filter(pk__lte=50)
ds = SupervisedDataSet(204960, 1)
for better_than in better_thans:
bt = imread(better_than.better_than.image.file)
wt = imread(better_than.worse_than.image.file)
better_than.better_than.image.file.close()
better_than.worse_than.image.file.close()
bt = filters.sobel(bt)
wt = filters.sobel(wt)
bt_input_array = np.reshape(bt, (bt.shape[0] * bt.shape[1]))
wt_input_array = np.reshape(wt, (wt.shape[0] * wt.shape[1]))
input_1 = np.append(bt_input_array, wt_input_array)
input_2 = np.append(wt_input_array, bt_input_array)
ds.addSample(np.append(bt_input_array, wt_input_array), [-1])
ds.addSample(np.append(wt_input_array, bt_input_array), [1])
net = buildNetwork(204960, 2, 1)
train_ds, test_ds = ds.splitWithProportion(options['train_test_split'])
_, test_ds = ds.splitWithProportion(options['test_split'])
trainer = BackpropTrainer(net, ds)
avgerr = trainer.testOnData(dataset=test_ds)
print 'untrained avgerr: {0}'.format(avgerr)
trainer.train()
avgerr = trainer.testOnData(dataset=test_ds)
print 'trained avgerr: {0}'.format(avgerr)
def nrOfEdgePixels(rgbimage, intensityImage):
redEdges = sobel(rgbimage[:,:,0])
grayEdges = sobel(intensityImage)
t = redEdges - grayEdges
t[t < 0.05] = 0
t[t >= 0.05] = 1
return convolve2d(t, np.ones((17,17)), mode="same")
def getSubImages(img, pixels, size):
subImages = []
originals = []
for i in range(len(img)):
subImageRow = []
originalRow = []
for j in range(len(img[i])):
if i % pixels == 0 and j % pixels == 0 and i+size-1 < len(img) and j+size-1 < len(img[i]):
subImage = []
for k in range(i, i+size, int(size/20)):
line = []
for l in range(j, j+size, int(size/20)):
line.append(img[k][l])
subImage.append(line)
originalRow.append(subImage)
if preprocess == preprocessing.SOBEL:
subImage = denoise_bilateral(subImage, sigma_range=0.1, sigma_spatial=15)
subImage = sobel(subImage)
elif preprocess == preprocessing.HOG:
subImage = useHoG(subImage)
else:
subImage = denoise_bilateral(subImage, sigma_range=0.1, sigma_spatial=15)
subImage = sobel(subImage)
subImage = useHoG(subImage)
subImageRow.append(subImage)
if len(subImageRow) > 0:
subImages.append(subImageRow)
originals.append(originalRow)
return subImages, originals
def sobel(data, sliceId=2):
edges = np.zeros(data.shape)
if sliceId == 2:
for idx in range(data.shape[2]):
edges[:, :, idx] = skifil.sobel(data[:, :, idx])
elif sliceId == 0:
for idx in range(data.shape[0]):
edges[idx, :, :] = skifil.sobel(data[idx, :, :])
return edges
def color_edge():
image=data.astronaut()
r=np.abs(filters.sobel(image[:,:,0]))
r=np.uint8(r/r.max()*255)
io.imsave('astronautedger.png',r)
g=np.abs(filters.sobel(image[:,:,1]))
g=np.uint8(g/g.max()*255)
io.imsave('astronautedgeg.png',g)
b=np.abs(filters.sobel(image[:,:,2]))
b=np.uint8(b/b.max()*255)
io.imsave('astronautedgeb.png',b)
def transform(self,X):
imgs = []
for x in X:
if x.ndim == 3:
x =self.rgb2gray(x)
imgs.append(sobel(x).ravel())
return np.vstack(imgs)
def _calc_crispness(self, grey_array):
"""Calculate three measures of the crispness of an channel.
PARAMETERS
----------
grey_array : 2D numpy array
Raw data for the grey channel.
PRODUCES
--------
crispnesses : list
Three measures of the crispness in the grey channel of types:
- ``sobel``, ``canny``, and ``laplace``
"""
grey_array = grey_array/255
sobel_var = filters.sobel(grey_array).var()
canny_array = feature.canny(grey_array, sigma=1).var()
canny_ratio = np.sum(canny_array == True)/float(
len(canny_array.flatten()))
laplace_var = filters.laplace(grey_array, ksize=3).var()
self.feature_data.extend([sobel_var, canny_ratio, laplace_var])
if self.columns_out:
self.column_names.extend(['crisp_sobel', 'crisp_canny',
'crisp_laplace'])
def main():
"""Load image, apply sobel (to get x/y gradients), plot the results."""
img = data.camera()
sobel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])
sobel_x = np.rot90(sobel_y) # rotates counter-clockwise
# apply x/y sobel filter to get x/y gradients
img_sx = signal.correlate(img, sobel_x, mode="same")
img_sy = signal.correlate(img, sobel_y, mode="same")
# combine x/y gradients to gradient magnitude
# scikit-image's implementation divides by sqrt(2), not sure why
img_s = np.sqrt(img_sx ** 2 + img_sy ** 2) / np.sqrt(2)
# create binarized image
threshold = np.average(img_s)
img_s_bin = np.zeros(img_s.shape)
img_s_bin[img_s > threshold] = 1
# generate ground truth (scikit-image method)
ground_truth = skifilters.sobel(data.camera())
# plot
util.plot_images_grayscale(
[img, img_sx, img_sy, img_s, img_s_bin, ground_truth],
[
"Image",
"Sobel (x)",
"Sobel (y)",
"Sobel (magnitude)",
"Sobel (magnitude, binarized)",
"Sobel (Ground Truth)",
],
)
def op_vs_ip(subid, image_types, imagepaths, op_direc, overlays):
img_data_group=[]
img_shape_group=[]
ol_data_group=[]
ol_shape_group=[]
for i, path in enumerate(imagepaths):
axial_slice, cor_slice, sag_slice, img_aspect_axial, img_aspect_cor, img_aspect_sag = pull_midslices(path)
if os.path.isfile(overlays[i]):
axial_slice_ol, cor_slice_ol, sag_slice_ol, img_aspect_axial_ol, img_aspect_cor_ol, img_aspect_sag_ol = pull_midslices(overlays[i])
ol_data_group.append([axial_slice_ol, cor_slice_ol, sag_slice_ol])
ol_shape_group.append([img_aspect_axial_ol, img_aspect_cor_ol, img_aspect_sag_ol])
else:
ol_data_group.append(['null','null','null'])
ol_shape_group.append(['null','null','null'])
## Append to Matrices
img_data_group.append([axial_slice, cor_slice, sag_slice])
img_shape_group.append([img_aspect_axial,img_aspect_cor,img_aspect_sag])
my_cmap=plt.cm.gray
fig, axarr = plt.subplots(ncols=np.shape(img_shape_group)[1], nrows=np.shape(img_shape_group)[0], figsize=(np.shape(img_shape_group)[0]*5,np.shape(img_shape_group)[1]*5))
plt.suptitle(subid+' File Comparison', fontsize=20)
titlearray=['Axial', 'Coronal', 'Saggital']
for x in range(0,np.shape(img_shape_group)[0]):
for y in range(0,np.shape(img_shape_group)[1]):
im = axarr[x, y].imshow(img_data_group[x][y], cmap=my_cmap, aspect=img_shape_group[x][y])
axarr[x, y].set_xlabel('(Right) Radiological Convention (Left)', fontsize=10)
axarr[x, y].set_title(image_types[x]+' '+titlearray[y])
#divider = make_axes_locatable(axarr[x, y])
#cax_ = divider.append_axes("right", size="5%", pad=0.05)
#cbar = plt.colorbar(im, cax=cax_, ticks=MultipleLocator(round(np.max(img_data_group[x][y])/5, 1)))
axarr[x, y].xaxis.set_visible(False)
axarr[x, y].yaxis.set_visible(False)
if os.path.isfile(overlays[x]):
if x == 1:
thresh=0.25
if x == 2:
thresh=0.4
sl=np.array(ol_data_group[x][y]).astype(np.float64)
sl=filters.sobel(sl)
sl=preprocessing.binarize(sl, np.max(sl)*thresh)
sl[sl < 1] = 'Nan'
axarr[x, y].imshow(sl, cmap='autumn', aspect=ol_shape_group[x][y])
#plt.show()
plt.tight_layout()
plt.autoscale()
plt.savefig(op_direc)
def filter_bank(img, coeff_resolution):
"""
Calculates the responses of an image to M filters.
Returns 2-d array of the vectorial responses
"""
h, w = img.shape
im = np.reshape(img, (h*w, 1))
e1 = np.reshape(entropy(img, disk(coeff_resolution*5)), (h*w, 1))
e2 = np.reshape(entropy(img, disk(coeff_resolution*8)), (h*w, 1))
e3 = np.reshape(entropy(img, disk(coeff_resolution*10)), (h*w, 1))
g1 = np.reshape(gradient(img, disk(1)), (h*w, 1))
g2 = np.reshape(gradient(img, disk(coeff_resolution*3)), (h*w, 1))
g3 = np.reshape(gradient(img, disk(coeff_resolution*5)), (h*w, 1))
m1 = np.reshape(ndi.maximum_filter(256-img, size=coeff_resolution*2, mode='constant'), (h*w, 1))
m2 = np.reshape(ndi.maximum_filter(256-img, size=coeff_resolution*4, mode='constant'), (h*w, 1))
m3 = np.reshape(ndi.maximum_filter(256-img, size=coeff_resolution*7, mode='constant'), (h*w, 1))
#c = np.reshape(canny(img), (h*w, 1))
s = np.reshape(sobel(img), (h*w, 1))
return np.column_stack((im, e1, e2, e3, g1, g2, g3, m1, m2, m3, s))
def number_nucleus(image):
elevation_map = sobel(image)
markers = np.zeros_like(image)
markers[image < 250] = 1
markers[image > 2000] = 2
segmentation = watershed(elevation_map, markers)
label_img = label(segmentation)
prop = regionprops(label_img)
width, height = plt.rcParams['figure.figsize']
plt.rcParams['image.cmap'] = 'gray'
image_label_overlay = label2rgb(label_img, image=image)
fig, (ax1, ax2) = plt.subplots(ncols=2, nrows=1, figsize=(15, 8))
ax1.imshow(image_label_overlay)
ax2.imshow(image, cmap=plt.cm.gray, interpolation='nearest')
# create list of region with are < 1000
image_labeled = [region for region in prop if region.area > 5000]
return len(image_labeled)
def filter(data,filtType,par):
if filtType == "sobel": filt_data = sobel(data)
elif filtType == "roberts": filt_data = roberts(data)
elif filtType == "canny": filt_data = canny(data)
elif filtType == "lowpass_avg":
from scipy import ndimage
p=int(par)
kernel = np.ones((p,p),np.float32)/(p*p)
filt_data = ndimage.convolve(data, kernel)
elif filtType == "highpass_avg":
from scipy import ndimage
p=int(par)
kernel = np.ones((p,p),np.float32)/(p*p)
lp_data = ndimage.convolve(data, kernel)
filt_data = data - lp_data
elif filtType == "lowpass_gaussian":
filt_data = gaussian(data, sigma=float(par))
elif filtType == "highpass_gaussian":
lp_data = gaussian(data, sigma=float(par))
filt_data = data - lp_data
#elif filtType == "gradient":
return filt_data
def testSkimage():
img = Image.open('../img/1.png')
img = np.array(img)
imggray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# (thresh, imgbw) = cv2.threshold(imggray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
# canny detector
# from skimage.feature import canny
# edges = canny(imggray/ 255.)
from scipy import ndimage as ndi
# fill_imgbw = ndi.binary_fill_holes(edges)
# label_objects, nb_labels = ndi.label(fill_imgbw)
# sizes = np.bincount(label_objects.ravel())
# mask_sizes = sizes > 20
# mask_sizes[0] = 0
# cleaned_imgbw = mask_sizes[label_objects]
markers = np.zeros_like(imggray)
markers[imggray < 120] = 1
markers[imggray > 150] = 2
from skimage.filters import sobel
elevation_map = sobel(imggray)
from skimage.morphology import watershed
segmentation = watershed(elevation_map, markers)
# from skimage.color import label2rgb
# segmentation = ndi.binary_fill_holes(segmentation - 10)
# labeled_coins, _ = ndi.label(segmentation)
# image_label_overlay = label2rgb(labeled_coins, image=imggray)
plt.imshow(segmentation, cmap='gray')
plt.show()
return
def pestFeatureExtraction(filename):
selem = disk(8)
image = data.imread(filename,as_grey=True)
thresh = threshold_otsu(image)
elevation_map = sobel(image)
markers = np.zeros_like(image)
if ((image<thresh).sum() > (image>thresh).sum()):
markers[image < thresh] = 1
markers[image > thresh] = 2
else:
markers[image < thresh] = 2
markers[image > thresh] = 1
segmentation = morphology.watershed(elevation_map, markers)
segmentation = dilation(segmentation-1, selem)
segmentation = ndimage.binary_fill_holes(segmentation)
segmentation = np.logical_not(segmentation)
image[segmentation]=0;
hist = np.histogram(image.ravel(),256,[0,1])
hist = list(hist[0])
hist[:] = [float(x) / (sum(hist) - hist[0]) for x in hist]
hist.pop(0)
features = np.empty( (1, len(hist)), 'float' )
a = np.array(list(hist))
f = a.astype('float')
features[0,:]=f[:]
return features
def prepare(img):
"""
Pre-process the image before translation detection, here we transform to black and white and use edge-detection.
:param img: An image (as numpy array)
:return: The preprocessed image (as numpy array)
"""
return sobel(rgb2gray(img))
def _segment_watershed(image): elevation_map = sobel(image) markers = np.zeros(image.shape) # initialize markers as zero array # determine thresholds for markers sorted_pixels = np.sort(image, axis=None) max_int = np.mean(sorted_pixels[-10:]) min_int = np.mean(sorted_pixels[:10]) #max_int = np.max(orig_image) #min_int = np.min(orig_image) alpha_min = 0.01 alpha_max = 0.4 thresh_background = (1-alpha_min)*min_int + alpha_min*max_int thresh_spots = (1-alpha_max)*min_int + alpha_max*max_int markers[image < thresh_background] = 1 # mark background markers[image > thresh_spots] = 2 # mark background segmentation = watershed(elevation_map, markers) segmentation = segmentation-1 segmentation = ndi.binary_fill_holes(segmentation) # fill holes return segmentation
def test_sobel_vertical():
"""Sobel on a vertical edge should be a vertical line."""
i, j = np.mgrid[-5:6, -5:6]
image = (j >= 0).astype(float)
result = filters.sobel(image) * np.sqrt(2)
j[np.abs(i) == 5] = 10000
assert (np.all(result[j == 0] == 1))
assert (np.all(result[np.abs(j) > 1] == 0))
def __init__(self):
self.logo = scipy_logo.ScipyLogo(radius=self.radius)
self.mask_1 = self.logo.get_mask(self.image.shape, 'upper left')
self.mask_2 = self.logo.get_mask(self.image.shape, 'lower right')
edges = np.array([sobel(img) for img in self.image.T]).T
# truncate and stretch intensity range to enhance contrast
self.edges = rescale_intensity(edges, in_range=(0, 0.4))
def getContourImage(imageFile):
planeImage = data.imread(imageFile,True)
imageArray = np.asarray(planeImage)
averageColor = np.mean(imageArray)
imageArray = getBlackAndWhiteImage(imageArray,averageColor*0.85)
imageArray = filters.sobel(imageArray)
imageArray = morphology.dilation(imageArray,morphology.disk(3))
return imageArray
def sobel(frame):
"""
return the sobel importance of an rgb image
"""
frame = grayscale(frame)
frame = filters.sobel(frame)
# print(frame.max())
return normalize(frame)
def main():
from skimage import data, io, filters
testfolder='/Users/davidgreenfield/Downloads/pics_boots/'
testimage='B00A0GVP8A.jpg'
image = io.imread(testfolder+testimage,flatten=True) # or any NumPy array!
edges = filters.sobel(image)
io.imshow(edges)
io.show()
def analyse(self, **kwargs):
image_object = kwargs['image']
if image_object is None:
raise RuntimeError()
# Read the image
image = cv2.imread(self.image_utils.getOutputFilename(image_object.id))
if image is None:
print('File not found')
return
# Work on green channel
gray = image[:, :, 1]
# Apply otsu thresholding
thresh = filters.threshold_otsu(gray)
gray[gray < thresh] = 0
# Apply histogram equalization
gray = exposure.equalize_adapthist(gray) * 255
# Create elevation map
elevation_map = filters.sobel(gray)
gray = gray.astype(int)
# Create cell markers
markers = numpy.zeros_like(gray)
markers[gray < 100] = 2 # seen as white in plot
markers[gray > 150] = 1 # seen as black in plot
# Segment with watershed using elevation map
segmentation = morphology.watershed(elevation_map, markers)
segmentation = ndi.binary_fill_holes(segmentation - 1)
# labeled_image, n = ndi.label(segmentation)
# Watershed with distance transform
kernel = numpy.ones((5, 5), numpy.uint8)
distance = ndi.distance_transform_edt(segmentation)
distance2 = cv2.erode(distance, kernel)
distance2 = cv2.dilate(distance2, kernel)
local_max = peak_local_max(distance2, num_peaks=1, indices=False, labels=segmentation)
markers2 = ndi.label(local_max)[0]
labels = morphology.watershed(-distance2, markers2, mask=segmentation)
# Extract regions (caching signifies more memory use)
regions = regionprops(labels, cache=True)
# Filter out big wrong regions
regions = [region for region in regions if region.area < 2000]
# Set result
result = str(len(regions))
return result
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 test_sobel_horizontal():
"""Sobel on a horizontal edge should be a horizontal line."""
i, j = np.mgrid[-5:6, -5:6]
image = (i >= 0).astype(float)
result = filters.sobel(image) * np.sqrt(2)
# Fudge the eroded points
i[np.abs(j) == 5] = 10000
assert_allclose(result[i == 0], 1)
assert (np.all(result[np.abs(i) > 1] == 0))
def updateCMap(self):
self.mplwidget.axes.clear()
self.cmapType=str(self.cmap.currentText())
self.mplwidget.axes.imshow(self.Img1,cmap=self.cmapType,alpha=0.5)
edge_sobel = sobel(self.Img1)
self.mplwidget.axes.hold(True)
self.mplwidget.axes.imshow(edge_sobel,cmap='gray',alpha=0.5)
self.mplwidget.draw()
def test_hsv_value_with_non_float_output():
# Since `rgb2hsv` returns a float image and the result of the filtered
# result is inserted into the HSV image, we want to make sure there isn't
# a dtype mismatch.
filtered = edges_hsv_uint(COLOR_IMAGE)
filtered_value = color.rgb2hsv(filtered)[:, :, 2]
value = color.rgb2hsv(COLOR_IMAGE)[:, :, 2]
# Reduce tolerance because dtype conversion.
assert_allclose(filtered_value, filters.sobel(value), rtol=1e-5, atol=1e-5)
def sobel_triple(frame):
"""
compute horizontal/ vertical sobel intensities and convert to red/ blue values. green channel
will get the un-directed sobel filter. very pleasing effect.
"""
output = np.zeros(frame.shape, dtype=np.uint8)
frame = grayscale(frame)
output[:, :, 0] = normalize(np.abs(filters.sobel_h(frame)))
output[:, :, 1] = normalize(filters.sobel(frame))
output[:, :, 2] = normalize(np.abs(filters.sobel_v(frame)))
return output
def segmentize(image):
# make segmentation using edge-detection and watershed
edges = sobel(image)
markers = np.zeros_like(image)
foreground, background = 1, 2
markers[image == 0] = background
markers[image == 1] = foreground
ws = watershed(edges, markers)
return ndi.label(ws == foreground)
def updateCMap2(self):
#self.pyramid2.axes.clear()
self.cmapType2=str(self.cmap2.currentText())
self.pyramid2.axes.imshow(self.Img2,cmap=self.cmapType2,alpha=0.5)
edge_sobel = sobel(self.Img2)
self.pyramid2.axes.hold(True)
self.pyramid2.axes.imshow(edge_sobel,cmap='gray',alpha=0.5)
self.pyramid2.axes.hold(True)
self.pyramid2.axes.set_xlabel('Pixel No. A-B')
self.pyramid2.axes.set_ylabel('Pixel No. T-G')
self.pyramid2.draw()
def _get_edges(self):
img_edg, mask = self.processed_image
if self.edge_detection_method == 'canny':
img_edg = canny(img_edg, sigma=self.canny_sigma,
low_threshold=self.canny_low,
high_threshold=self.canny_high)
elif self.edge_detection_method == 'roberts':
img_edg = roberts(img_edg)
elif self.edge_detection_method == 'sobel':
img_edg = sobel(img_edg)
img_edg = img_edg > 0.0
return img_edg
from scipy import ndimage,misc
from skimage import filters
from PIL import Image
import scipy
a = Image.open('images/moon.jpg')
b = filters.sobel(a)
b = scipy.misc.toimage(b)
b.save('images/moon_sobel.jpg')
# -*- coding: utf-8 -*-
import cv2
from skimage.filters import sobel
image1 = cv2.imread('plane.jpg') #讀取圖片
image2 = cv2.imread('insect.png') #讀取圖片
gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY) #獲得灰階圖片
eq1 = cv2.equalizeHist(gray1) #獲得均值灰階圖片
cv2.imshow("Gray1", gray1) #輸出灰階圖片
cv2.imshow("Histogram Equalization1", eq1) #輸出均值灰階圖片
sobel1 = sobel(gray1) #獲得邊界圖片
cv2.imshow("Sobel operator1", sobel1) #輸出邊界圖片
##################################################以下同上
gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
eq2 = cv2.equalizeHist(gray2)
cv2.imshow("Gray2", gray2)
cv2.imshow("Histogram Equalization2", eq2)
sobel2 = sobel(gray2)
cv2.imshow("Sobel operator2", sobel2)
##################################################
cv2.waitKey() #防止畫面卡死
cv2.destroyAllWindows() #防止畫面卡死
exitStr = "(applying canny-edge)"
img = img_as_ubyte(
canny(img, float(transform[1]), float(transform[2]),
float(transform[3])))
#io.imshow(img)
#io.show()
elif transform[0].lower() == "rank-order":
exitStr = "(applying rank_order)"
img, _ = rank_order(img)
#io.imshow(img)
#io.show()
#elif transform[0].lower() == "resize":
# img = resize(img, <tuple>)
elif transform[0].lower() == "sobel":
exitStr = "(applying sobel)"
img = img_as_ubyte(sobel(img))
#io.imshow(img)
#io.show()
elif transform[0].lower() == "erosion":
exitStr = "(applying erosion)"
img = img_as_ubyte(erosion(img, square(int(transform[1]))))
#io.imshow(img)
#io.show()
elif transform[0].lower() == "threshold-adaptive":
exitStr = "(applying threshold_adaptive)"
img = img_as_ubyte(
threshold_adaptive(img, int(transform[1]), transform[2]))
#io.imshow(img)
#io.show()
elif transform[0].lower() == "radon":
theta = np.linspace(0., 180., max(img.shape), endpoint=False)
def load_validation_dataset(car_ids_list):
min_mask = np.ones((16, 320, 480))
max_mask = np.zeros((16, 320, 480))
for angle_id in range(0, 16):
min_mask[angle_id] = misc.imread(
'min_and_max_masks/' + 'min_' + str(angle_id) + '.jpg',
flatten=True) / 255.
max_mask[angle_id] = misc.imread(
'min_and_max_masks/' + 'max_' + str(angle_id) + '.jpg',
flatten=True) / 255.
i = 0
X = np.empty((len(car_ids_list) * 16, 320, 480, 12), dtype=np.float32)
Y = np.empty((len(car_ids_list) * 16, 320, 480, 1), dtype=np.float32)
for car_id in car_ids_list:
for angle in [
'01', '02', '03', '04', '05', '06', '07', '08', '09', '10',
'11', '12', '13', '14', '15', '16'
]:
image_rgb = misc.imread('resized_data/val/' + car_id + '_' +
angle + '.jpg') / 255.
image_bw = misc.imread(
'resized_data/val/' + car_id + '_' + angle + '.jpg',
flatten=True) / 255.
image_all_mask = misc.imread(
'train_all_angle_masks_resized/' + car_id + '.jpg',
flatten=True) / 255.
image_mask = misc.imread(
'train_masks_resized/' + car_id + '_' + angle + '_mask.jpg',
flatten=True).astype(int) / 255.
image_mask = np.reshape(image_mask, (320, 480, 1))
X[i, ..., :3] = image_rgb
X[i, ..., 3] = image_all_mask
X[i, ..., 4] = min_mask[int(angle) - 1]
X[i, ..., 5] = max_mask[int(angle) - 1]
high_contrast = filters.rank.enhance_contrast(
image_bw, np.ones((10, 10)))
high_contrast = filters.sobel(high_contrast)
high_contrast = canny(high_contrast)
high_contrast = ndi.binary_closing(high_contrast,
structure=np.ones((5, 5)))
high_contrast = ndi.binary_fill_holes(high_contrast, np.ones(
(3, 3)))
X[i, ..., 6] = high_contrast
normal_contrast = filters.sobel(image_bw)
normal_contrast = canny(normal_contrast)
normal_contrast = ndi.binary_closing(normal_contrast,
structure=np.ones((5, 5)))
X[i, ..., 7] = ndi.binary_fill_holes(normal_contrast,
np.ones((3, 3)))
threshold_otsu_val = filters.threshold_otsu(image_bw)
threshold_otsu = image_bw > threshold_otsu_val
X[i, ..., 8] = threshold_otsu
image_index = np.where(image_bw >= 0)
df = pd.DataFrame()
df['l1_dist_y'] = abs((image_index[0] - 159.5) / 159.5)
df['l1_dist_x'] = abs((image_index[1] - 239.5) / 239.5)
df['l2_dist'] = np.sqrt((df['l1_dist_x'])**2 +
(df['l1_dist_y'])**2) / np.sqrt(2)
X[i, ..., 9] = df.l2_dist.reshape((320, 480))
X[i, ..., 10] = df.l1_dist_x.reshape((320, 480))
X[i, ..., 11] = df.l1_dist_y.reshape((320, 480))
Y[i, ...] = image_mask
i = i + 1
return X, Y
cv2.waitKey() # In[716]: #plot the histogram of the grayscale image and obtain the quantile histogram values hist = np.histogram(gray, bins=np.arange(0, 256)) plt.plot(hist[1][:-1], hist[0], lw=2) x = np.quantile(hist[0], 0.25, axis=0) print(x) y = np.quantile(hist[0], 0.75, axis=0) print(y) # In[717]: #apply sobel operator elevation_map = sobel(gray) plt.imshow(elevation_map, cmap=plt.cm.gray, interpolation='nearest') plt.show() # In[718]: #Pepare masks based on the histogram quantile values and display the result markers = np.zeros_like(gray) markers[gray < 34] = 1 markers[gray > 158] = 2 plt.imshow(markers, cmap=plt.cm.gray, interpolation='nearest') plt.show() # In[719]: #Apply wateshed algorithm and display the image
def test_sobel_zeros():
"""Sobel on an array of all zeros."""
result = filters.sobel(np.zeros((10, 10)), np.ones((10, 10), bool))
assert (np.all(result == 0))
def train_data_generator(batch_size):
image_list = os.listdir('resized_data/train/')
np.random.shuffle(image_list)
min_mask = np.ones((16, 320, 480))
max_mask = np.zeros((16, 320, 480))
for angle_id in range(0, 16):
min_mask[angle_id] = misc.imread(
'min_and_max_masks/' + 'min_' + str(angle_id) + '.jpg',
flatten=True) / 255.
max_mask[angle_id] = misc.imread(
'min_and_max_masks/' + 'max_' + str(angle_id) + '.jpg',
flatten=True) / 255.
while 1:
for batch_num in range(len(image_list) // batch_size):
batch_images = image_list[batch_num *
batch_size:(batch_num * batch_size) +
(batch_size)]
X = np.empty((batch_size, 320, 480, 12), dtype=np.float64)
Y = np.empty((batch_size, 320, 480, 1), dtype=np.float64)
for i, image_name in zip(range(batch_size), batch_images):
image_rgb = misc.imread('resized_data/train/' +
image_name) / 255.
image_bw = misc.imread('resized_data/train/' + image_name,
flatten=True) / 255.
image_all_mask = misc.imread('train_all_angle_masks_resized/' +
image_name.split('_')[0] + '.jpg',
flatten=True) / 255.
image_mask = misc.imread(
'train_masks_resized/' + image_name.split('.')[0] +
'_mask.jpg',
flatten=True) / 255.
image_mask = np.reshape(image_mask, (320, 480, 1))
X[i, ..., :3] = image_rgb
X[i, ..., 3] = image_all_mask
X[i, ...,
4] = min_mask[int(image_name.split('.')[0].split('_')[1]) -
1]
X[i, ...,
5] = max_mask[int(image_name.split('.')[0].split('_')[1]) -
1]
high_contrast = filters.rank.enhance_contrast(
image_bw, np.ones((10, 10)))
high_contrast = filters.sobel(high_contrast)
high_contrast = canny(high_contrast)
high_contrast = ndi.binary_closing(high_contrast,
structure=np.ones((5, 5)))
high_contrast = ndi.binary_fill_holes(high_contrast,
np.ones((3, 3)))
X[i, ..., 6] = high_contrast
normal_contrast = filters.sobel(image_bw)
normal_contrast = canny(normal_contrast)
normal_contrast = ndi.binary_closing(normal_contrast,
structure=np.ones((5, 5)))
X[i, ..., 7] = ndi.binary_fill_holes(normal_contrast,
np.ones((3, 3)))
threshold_otsu_val = filters.threshold_otsu(image_bw)
threshold_otsu = image_bw > threshold_otsu_val
X[i, ..., 8] = threshold_otsu
image_index = np.where(image_bw >= 0)
df = pd.DataFrame()
df['l1_dist_y'] = abs((image_index[0] - 159.5) / 159.5)
df['l1_dist_x'] = abs((image_index[1] - 239.5) / 239.5)
df['l2_dist'] = np.sqrt((df['l1_dist_x'])**2 +
(df['l1_dist_y'])**2) / np.sqrt(2)
X[i, ..., 9] = df.l2_dist.reshape((320, 480))
X[i, ..., 10] = df.l1_dist_x.reshape((320, 480))
X[i, ..., 11] = df.l1_dist_y.reshape((320, 480))
Y[i, ...] = image_mask
i = i + 1
yield X, Y
def Applysobel(im):
curr_im = im.astype('uint8')
curr_im = filters.sobel(color.rgb2gray(im))
return curr_im
def edg(img):
res = np.zeros_like(img, dtype=np.float)
for i in range(img.shape[2]):
res[:, :, i] = sobel(img[:, :, i])
res = norm(np.linalg.norm(res, axis=2))
return res
s = step(img, mark1d, pts, s, level, up, nbs)
conner = [[v>>i&1 for i in range(ndim)] for v in range(2**ndim)]
con1 = np.array(conner, dtype=np.int8)-1
con2 = np.array(conner, dtype=np.int8)*3-2
mark[tuple(con1.T)] = mark[tuple(con2.T)]
erose(mark1d)
return mark
if __name__ == '__main__':
import matplotlib.pyplot as plt
from skimage.filters import sobel
from skimage.data import coins
coins = coins()
dem = sobel(coins)
markers = np.zeros_like(coins, dtype=np.uint16)
markers[coins < 30] = 1
markers[coins > 150] = 2
plt.imshow(markers)
plt.show()
watershed(dem, markers)
plt.imshow(markers)
plt.show()
'''
from scipy.misc import imread
import matplotlib.pyplot as plt
from time import time
dem = imread('ice.png')
mark = imread('mark.png')
# ax.imshow(fill_coins, cmap=plt.cm.gray)
# ax.set_title('filling the holes')
# ax.axis('off')
from skimage import morphology
coins_cleaned = morphology.remove_small_objects(fill_coins, 21)
# fig, ax = plt.subplots(figsize=(4, 3))
# ax.imshow(coins_cleaned, cmap=plt.cm.gray)
# ax.set_title('removing small objects')
# ax.axis('off')
from skimage.filters import sobel
elevation_map = sobel(coins)
# fig, ax = plt.subplots(figsize=(4, 3))
# ax.imshow(elevation_map, cmap=plt.cm.gray)
# ax.set_title('elevation map')
# ax.axis('off')
markers = np.zeros_like(coins)
markers[coins < 30] = 1
markers[coins > 150] = 2
# fig, ax = plt.subplots(figsize=(4, 3))
# ax.imshow(markers, cmap=plt.cm.nipy_spectral)
# ax.set_title('markers')
# ax.axis('off')
# tophat edges
print("Black tophat edge detection")
tophat = morph.black_tophat(GRAY, selem=morph.selem.disk(1))
tophat = tophat < np.percentile(tophat, tophat_th)
tophat = morph.remove_small_holes(tophat, area_threshold=cutoff, connectivity=2)
foo = func.featAND_fast(MASK, tophat)
MASK = np.logical_and(foo, MASK)
# canny edges
print("Canny edge detection")
canny = feat.canny(GRAY, sigma=canny_sig)
canny = np.invert(canny)
foo = func.featAND_fast(MASK, canny)
MASK = np.logical_and(foo, MASK)
# sobel edges
print("Sobel edge detection")
sobel = filt.sobel(GRAY)
sobel = sobel < np.percentile(sobel, sobel_th)
sobel = morph.remove_small_holes(sobel, area_threshold=cutoff, connectivity=2)
sobel = morph.thin(np.invert(sobel))
sobel = np.invert(sobel)
foo = func.featAND_fast(MASK, sobel)
MASK = np.logical_and(foo, MASK)
# find the remaining pixels in the mask
idx = np.where(MASK == True)
# skip if there's only a small number of pixels left
# as this will lead to errors if the number of k-means clusters
# becomes greater than the number of pixels
if len(idx[0]) < 100:
print("\nEmpty window, skipping\n")
def get_segmented_image(array, marker_lower, marker_upper):
markers = np.zeros_like(array)
markers[array < marker_lower] = 1
markers[array > marker_upper] = 2
elevation_map = sobel(array)
return watershed(elevation_map, markers)
def GSfilter(image, sigma, mode):
"""Combine a Sobel and a Gaussian filter"""
return filters.sobel(filters.gaussian(image, sigma=sigma, mode=mode))
def setup(self):
try:
filters.sobel(np.ones((8, 8, 8)))
except ValueError:
raise NotImplementedError("3d sobel unavailable")
self.image3d = data.binary_blobs(length=256, n_dim=3).astype(float)
def extract_binary_masks_blob(
A,
neuron_radius: float,
dims: Tuple[int, ...],
num_std_threshold: int = 1,
minCircularity: float = 0.5,
minInertiaRatio: float = 0.2,
minConvexity: float = .8) -> Tuple[np.array, np.array, np.array]:
"""
Function to extract masks from data. It will also perform a preliminary selectino of good masks based on criteria like shape and size
Args:
A: scipy.sparse matrix
contains the components as outputed from the CNMF algorithm
neuron_radius: float
neuronal radius employed in the CNMF settings (gSiz)
num_std_threshold: int
number of times above iqr/1.349 (std estimator) the median to be considered as threshold for the component
minCircularity: float
parameter from cv2.SimpleBlobDetector
minInertiaRatio: float
parameter from cv2.SimpleBlobDetector
minConvexity: float
parameter from cv2.SimpleBlobDetector
Returns:
masks: np.array
pos_examples:
neg_examples:
"""
params = cv2.SimpleBlobDetector_Params()
params.minCircularity = minCircularity
params.minInertiaRatio = minInertiaRatio
params.minConvexity = minConvexity
# Change thresholds
params.blobColor = 255
params.minThreshold = 0
params.maxThreshold = 255
params.thresholdStep = 3
params.minArea = np.pi * ((neuron_radius * .75)**2)
params.filterByColor = True
params.filterByArea = True
params.filterByCircularity = True
params.filterByConvexity = True
params.filterByInertia = True
detector = cv2.SimpleBlobDetector_create(params)
masks_ws = []
pos_examples = []
neg_examples = []
for count, comp in enumerate(A.tocsc()[:].T):
logging.debug(count)
comp_d = np.array(comp.todense())
gray_image = np.reshape(comp_d, dims, order='F')
gray_image = (gray_image - np.min(gray_image)) / \
(np.max(gray_image) - np.min(gray_image)) * 255
gray_image = gray_image.astype(np.uint8)
# segment using watershed
markers = np.zeros_like(gray_image)
elevation_map = sobel(gray_image)
thr_1 = np.percentile(gray_image[gray_image > 0], 50)
iqr = np.diff(np.percentile(gray_image[gray_image > 0], (25, 75)))
thr_2 = thr_1 + num_std_threshold * iqr / 1.35
markers[gray_image < thr_1] = 1
markers[gray_image > thr_2] = 2
edges = watershed(elevation_map, markers) - 1
# only keep largest object
label_objects, _ = scipy.ndimage.label(edges)
sizes = np.bincount(label_objects.ravel())
if len(sizes) > 1:
idx_largest = np.argmax(sizes[1:])
edges = (label_objects == (1 + idx_largest))
edges = scipy.ndimage.binary_fill_holes(edges)
else:
logging.warning('empty component')
edges = np.zeros_like(edges)
masks_ws.append(edges)
keypoints = detector.detect((edges * 200.).astype(np.uint8))
if len(keypoints) > 0:
pos_examples.append(count)
else:
neg_examples.append(count)
return np.array(masks_ws), np.array(pos_examples), np.array(neg_examples)
def test_sobel_mask():
"""Sobel on a masked array should be zero."""
result = filters.sobel(np.random.uniform(size=(10, 10)),
np.zeros((10, 10), dtype=bool))
assert (np.all(result == 0))
def sobel_watershed_method(img, op="disc", veins=False, test=False):
if op == "disc" or op == "cup":
to_plot = []
img_red = img[:, :, 0]
if test:
to_plot.append(("Red Channel", img_red))
img_red = skimage.util.img_as_ubyte(img_red)
img_red = skimage.filters.gaussian(img_red, 0.1)
if test:
to_plot.append(("Gaussian Filter", img_red))
img_red = enhance_contrast(img_red, disk(6))
if test:
to_plot.append(("Enhace Contrast", img_red))
elevation_map = sobel(img_red)
if test:
to_plot.append(("gradientes", elevation_map))
markers = np.zeros_like(img_red)
s2 = f.target_set_mean(img_red, 8.5)
markers[img_red < 150] = 1
markers[img_red > s2] = 2
seg_img = segmentation.watershed(elevation_map, markers)
mask = (seg_img - 1) > 0
if test:
to_plot.append(("Sobel + WaterShed", seg_img))
mask = binary_opening(mask, disk(2))
mask = skimage.morphology.remove_small_objects(mask, 400)
if test:
to_plot.append(("Removing small objects", th.apply(img_red, mask)))
mask = binary_closing(mask, disk(6))
if test:
to_plot.append(("Closing Region", th.apply(img[:, :, 0], mask)))
mask = skimage.morphology.remove_small_objects(mask, 1700)
if test:
to_plot.append(
("Removing Big Objects", th.apply(img[:, :, 0], mask)))
mask = binary_closing(mask, disk(6))
mask = msr.closest_prop(img[:, :, 0], mask)
if test:
to_plot.append(
("Removing non brighter region", th.apply(img[:, :, 0], mask)))
mask = binary_dilation(mask, disk(3))
mask = binary_closing(mask, disk(12))
if test:
to_plot.append(
("Dilate result region", th.apply(img[:, :, 0], mask)))
props = msr.props(img_red, mask)[0]
minr, minc, maxr, maxc = props.bbox
img_cut = img[minr:maxr, minc:maxc]
if test:
vi.plot_multy(to_plot, 3, 4, 'Sobel Watershed')
if op == "cup":
minr, minc, maxr, maxc = props.bbox
img_green = img[minr:maxr, minc:maxc, 1]
to_plot = []
columns = 1
if test:
to_plot.append(("green channel", img_green))
if not veins:
columns = 4
v_mask, _ = segment_veins(img_green, test)
img_aux = closing(img_green, disk(6))
img_aux = dilation(img_aux, disk(6))
img_aux2 = dilation(img_green, disk(3))
if test:
to_plot.append(("closed + dilated", img_aux))
to_plot.append(("dilated", img_aux2))
img_v_closed = th.apply(img_aux, v_mask)
img_t_dilated = th.apply(img_aux2, v_mask == False)
if test:
to_plot.append(("veins part", img_v_closed))
to_plot.append(("target part", img_t_dilated))
img_green = img_v_closed + img_t_dilated
if test:
to_plot.append(("without veins", img_green))
img_green = dilation(img_green, disk(6))
img_green = enhance_contrast(img_green, disk(10))
elevation_map = sobel(img_green)
markers = np.zeros_like(img_green)
s2 = f.target_set_mean(img_green, 8.5)
markers[img_green < 150] = 1
markers[img_green > s2] = 2
seg_img = segmentation.watershed(elevation_map, markers)
mask = (seg_img - 1) > 0
if test:
to_plot.append(("P-tile", th.apply(img_green, mask)))
mask1 = mask
mask = np.zeros(img[:, :, 1].shape)
mask[minr:maxr, minc:maxc] = mask1
if test:
vi.plot_multy(to_plot, 2, columns, 'cup')
return (mask, img_cut, props)
plt.show()
# Clear Borders
# Imadjust
#image_imadjust = Imadjust.imadjust(img)
#image_contrast = mahotas.stretch(img)
image_imadjust = exposure.rescale_intensity(img)
#cv2.imshow( "imadjust", image_imadjust );
print("imadjust")
plt.imshow(image_imadjust)
plt.show()
# Gradient Sobel
sobel = filters.sobel(image_imadjust)
#cv2.imshow( "gradient (sobel)", sobel );
print("gradient (sobel)")
plt.imshow(sobel)
plt.show()
# opening-by-reconstruction
erosion = cv2.erode(image_imadjust, disk(1))
Image_by_reconstruction_opening = reconstruction(erosion, image_imadjust)
Image_by_reconstruction_opening_uint8 = Image_by_reconstruction_opening.astype(
np.uint8)
#cv2.imshow( "erosion", Image_by_reconstruction_opening_uint8 );
print("erosion")
plt.imshow(Image_by_reconstruction_opening_uint8)
plt.show()
def contrast_tenengrad(self):
sobel_img = sobel(self.cv2_img_bw)**2
feature_value = np.sqrt(
np.sum(sobel_img)) / self.cv2_img_bw.size * 10000
self.extracted_features.update({'contrast_tenengrad': feature_value})
def show_pred_mask(num):
image_rgb = misc.imread('resized_data/val/' + image_list[num]) / 255.
image_all_mask = misc.imread('train_all_angle_masks_resized/' +
image_list[num].split('_')[0] + '.jpg',
flatten=True) / 255.
image_bw = misc.imread('resized_data/val/' + image_list[num],
flatten=True) / 255.
angle_id = int(image_list[num].split('.')[0].split('_')[1])
min_mask = misc.imread(
'min_and_max_masks/' + 'min_' + str(int(angle_id) - 1) + '.jpg',
flatten=True) / 255.
max_mask = misc.imread(
'min_and_max_masks/' + 'max_' + str(int(angle_id) - 1) + '.jpg',
flatten=True) / 255.
X = np.empty((1, 320, 480, 12), dtype=np.float32)
X[0, ..., :3] = image_rgb
X[0, ..., 3] = image_all_mask
X[0, ..., 4] = min_mask
X[0, ..., 5] = max_mask
high_contrast = filters.rank.enhance_contrast(image_bw, np.ones((10, 10)))
high_contrast = filters.sobel(high_contrast)
high_contrast = canny(high_contrast)
high_contrast = ndi.binary_closing(high_contrast,
structure=np.ones((5, 5)))
high_contrast = ndi.binary_fill_holes(high_contrast, np.ones((3, 3)))
X[0, ..., 6] = high_contrast
normal_contrast = filters.sobel(image_bw)
normal_contrast = canny(normal_contrast)
normal_contrast = ndi.binary_closing(normal_contrast,
structure=np.ones((5, 5)))
X[0, ..., 7] = ndi.binary_fill_holes(normal_contrast, np.ones((3, 3)))
threshold_otsu_val = filters.threshold_otsu(image_bw)
threshold_otsu = image_bw > threshold_otsu_val
X[0, ..., 8] = threshold_otsu
image_index = np.where(image_bw >= 0)
df = pd.DataFrame()
df['l1_dist_y'] = abs((image_index[0] - 159.5) / 159.5)
df['l1_dist_x'] = abs((image_index[1] - 239.5) / 239.5)
df['l2_dist'] = np.sqrt((df['l1_dist_x'])**2 +
(df['l1_dist_y'])**2) / np.sqrt(2)
X[0, ..., 9] = df.l2_dist.reshape((320, 480))
X[0, ..., 10] = df.l1_dist_x.reshape((320, 480))
X[0, ..., 11] = df.l1_dist_y.reshape((320, 480))
pred_mask = model.predict(X).reshape((320, 480))
pred_mask[pred_mask >= 0.5] = 1.
pred_mask[pred_mask < 0.5] = 0.
pred_mask = ndi.binary_closing(pred_mask, np.ones((1, 1))).astype(int)
pred_mask = ndi.binary_fill_holes(pred_mask, np.ones((10, 10))).astype(int)
pred_mask = morphology.binary_opening(pred_mask, np.ones((10, 10)))
act_mask = misc.imread(
'train_masks_resized/' + image_list[num].split('.')[0] + '_mask.jpg',
flatten=True) / 255.
z = skm.confusion_matrix(
act_mask.astype(int).flatten(),
pred_mask.astype(int).flatten())
dice_coeff = 2 * (z[1][1]) / float(2 * z[1][1] + z[0][1] + z[1][0])
print 'Dice Coeff: ' + str(dice_coeff)
fig = plt.figure(figsize=(13, 13))
ax1 = fig.add_subplot(121)
io.imshow(act_mask - pred_mask)
ax2 = fig.add_subplot(221)
io.imshow(image_rgb)
plt.show()
count = count_src + count_dst
return {
'count': count,
'weight': (count_src * weight_src + count_dst * weight_dst)/count
}
def merge_boundary(graph, src, dst):
"""Call back called before merging 2 nodes.
In this case we don't need to do any computation here.
"""
pass
img = data.coffee()
edges = filters.sobel(color.rgb2gray(img))
labels = segmentation.slic(img, compactness=30, n_segments=400)
g = graph.rag_boundary(labels, edges)
graph.show_rag(labels, g, img)
plt.title('Initial RAG')
labels2 = graph.merge_hierarchical(labels, g, thresh=0.08, rag_copy=False,
in_place_merge=True,
merge_func=merge_boundary,
weight_func=weight_boundary)
graph.show_rag(labels, g, img)
plt.title('RAG after hierarchical merging')
plt.figure()
def run(image_path,
fft_pass,
delta_px,
delta_mm,
bg_subtract=True,
to_keep=None,
return_plot_outputs=False):
"""
todo: clean up this documentation
Parameters
----------
image_path
fft_pass : list or tuple or np.array
list of:
[0] - angular reject band
reject base angle +/- angular reject band
[1] - safe radius
radius about center where band reject is ignored
Returns
-------
"""
# read in image
img_base = load_image(image_path)
if bg_subtract:
img_base -= gaussian_filter(img_base, 30)
img_base = image.grayscale(img_base)
# get power spectral density
psd = image.calc_psd(img_base)
# get x,y positions and angles for each pixel
xc, yc = image.get_center(psd)
psd_x, psd_y = image.get_xy(psd)
psd_x_img = image.ax_to_img_coords(psd_x, xc)
psd_y_img = -image.ax_to_img_coords(psd_y, yc)
rad = image.get_radius(psd_x_img, psd_y_img)
ang = image.get_angle(psd_x_img, psd_y_img)
# build and apply FFT mask
reject_band = 20
reject_mask = image.get_reject_mask(ang, rad, [0, 90, 180, 270],
reject_band, fft_pass[1])
fft = np.fft.fftshift(np.fft.fft2(img_base))
psd_masked = image.grayscale(reject_mask * psd) # reject only
r_max = 250 # cut down on useless calcs by only looking at middle of psd
best_angle_0 = image.find_best_angle(
psd_masked[xc - r_max:xc + r_max, yc - r_max:yc + r_max],
(reject_band, 90 - reject_band))
best_angle_1 = image.find_best_angle(
psd_masked[xc - r_max:xc + r_max, yc - r_max:yc + r_max],
(90 + reject_band, 180 - reject_band))
pass_mask = image.get_pass_mask(
ang, rad,
[best_angle_0, best_angle_1, 180 + best_angle_1, 180 + best_angle_0],
fft_pass[0], fft_pass[1])
psd_masked = image.grayscale(pass_mask * psd) # pass only
filtered = image.grayscale(
np.real(np.fft.ifft2(np.fft.ifftshift(pass_mask * fft))), )
# apply sobel filter
edges = image.grayscale(sobel(filtered))
# get edge detected PSD and recalculate best angles
psd_final = image.calc_psd(edges)
best_angle_0 = image.find_best_angle(
psd_final[xc - r_max:xc + r_max, yc - r_max:yc + r_max],
(reject_band, 90 - reject_band))
best_angle_1 = image.find_best_angle(
psd_final[xc - r_max:xc + r_max, yc - r_max:yc + r_max],
(90 + reject_band, 180 - reject_band))
# perform radial intensity scan
radius_0, int_radius_0 = image.get_radial_intensity(
psd_final,
best_angle_0,
)
radius_1, int_radius_1 = image.get_radial_intensity(
psd_final,
best_angle_1,
)
# find peaks
dist_mask_0 = (radius_0 > 0)
idx_pks_0 = argrelmax(int_radius_0[dist_mask_0])[0]
dist_mask_1 = (radius_1 > 0)
idx_pks_1 = argrelmax(int_radius_1[dist_mask_1])[0]
# collect, filter and rescale measurements
df_cells_0 = get_measurements_from_radial_scan(
radius_0[dist_mask_0][idx_pks_0],
int_radius_0[dist_mask_0][idx_pks_0],
delta_px,
delta_mm,
best_angle_0,
psd_final.shape[0],
to_keep=to_keep,
save_original=True)
df_cells_0["Theta"] = best_angle_0
df_cells_1 = get_measurements_from_radial_scan(
radius_1[dist_mask_1][idx_pks_1],
int_radius_1[dist_mask_1][idx_pks_1],
delta_px,
delta_mm,
best_angle_1,
psd_final.shape[0],
to_keep=to_keep,
save_original=True)
df_cells_1["Theta"] = best_angle_1
df_cells = pd.concat((df_cells_0, df_cells_1)).reset_index(drop=True)
df_cells["Relative Energy"] = rescale_energy(df_cells["Intensity"])
if return_plot_outputs:
out = [
df_cells.sort_values(["Relative Energy"],
ascending=False).reset_index(drop=True),
dict(
image_filtering=[
img_base,
psd,
psd_masked,
filtered,
edges,
psd_final,
],
measurements=[(radius_0[dist_mask_0], radius_1[dist_mask_1]),
(int_radius_0[dist_mask_0],
int_radius_1[dist_mask_1]), df_cells, to_keep],
)
]
else:
out = df_cells.sort_values(["Relative Energy"],
ascending=False).reset_index(drop=True)
return out
from skimage import data, io, filters
from skimage import img_as_ubyte
for x in range(1, 4000):
#print("Processing image" + str(x))
image = io.imread("./images_jpg/"+ str(x) + ".jpg")
# ... or any other NumPy array!
edges = img_as_ubyte(filters.sobel(image[:,:,0]))
#io.imshow(edges)
io.imsave(("./result/"+ str(x)+".jpg"), edges)
def process_IN_CREATE(self,event):
f = open(r"/home/wangxinhua/level1/Level1rev04/json.txt",'r')
para = json.load(f)
f.close()
f = open(r'/home/wangxinhua/flag.txt','r')
path = f.readline()
f.close()
path = path+'/HA'#"/home/wangxinhua/20190518/HA"
redrive = para['redrive']#"/home/wangxinhua/nvst"
darked_path = para['darked_path']
rcxsize = int(para['rcxsize'])
rcysize = int(para['rcysize'])
corstart = re.findall('\d+',para['corstart'])
corstart = [int(i) for i in corstart]
corsize = re.findall('\d+',para['corsize'])
corsize = [int(i) for i in corsize]
sobel = int(para['sobel'])
only_align_no_luckyimage = int(para['only_align_no_luckyimage'])
redrive = para['redrive']
only_align_no_luckyimage_path = para['only_align_no_luckyimage_path']
pfstart = re.findall('\d+',para['pfstart'])
pfstart = [int(i) for i in pfstart]
pfsize = re.findall('\d+',para['pfsize'])
pfsize = [int(i) for i in pfsize]
lucky_align_path = para['lucky_align_path']
win=xyy.win_gpu(int(pfsize[0]),int(pfsize[1]),0.5,winsty='hann') #----窗函数
diameter = float(para['diameter'])
wavelen = float(para['wavelen'])
pixsca = float(para['pixsca'])
fsp = float(para['fsp'])
srstx = int(para['srstx'])
srsty = int(para['srsty'])
srxsize = int(para['srxsize'])
srysize = int(para['srysize'])
postprocess_flag = int(para['postprocess_flag'])
srsize = int(para['srsize'])
winsr=xyy.win_gpu(srsize,srsize, 0.5, winsty='hann')
diaratio = float(para['diaratio'])
start_r0 = float(para['start_r0'])
step_r0 = float(para['step_r0'])
maxfre=wavelen*10.0**(-10.0)/(2.0*diameter*pixsca)*(180.0*3600.0/np.pi)
filename = para['filename']
sitfdata=cp.array(fits.getdata(filename),'<f4')
gussf=xyy.gaussf2d_gpu(rcxsize,rcysize,1.5)
infrq=(pfsize[0]//2)*0.05/maxfre
otfrq=(pfsize[0]//2)*0.10/maxfre
datapath, flatpath, darkpath = xyy.path_paser(path)
new_path = event.pathname
if_has_next_folder = new_path[:-6]
a = 1
while a:
time_new =[int(i) for i in os.listdir(if_has_next_folder)}]
if np.where(int(new_path[-6:])<time_new,1,0):
#the fold is full
dark =
flat =
datafits = os.listdir(new_path)
a = 0
numb = len(datafits)
cube = cp.empty([numb,rcxsize,rcysize],dtype='float32')
t = 0
for i in datafits:
data = xyy.readfits(os.path.join(new_path,i))[0]
cube[t,:,:] = cp.array((data-dark)/(flat-dark)*np.max(flat-dark),dtype='<f4')[0:rcxsize,0:rcysize]
t += 1
ini = cubedata[0,:,:]
initmp = ini[corstart[0]:corstart[0]+corsize[0],corstart[1]:corstart[1]+corsize[1]]
#initmp_gpu = cp.asarray(initmp)
print('basefile:'+ data_dir_fitstmp)
if sobel == 1:
initmp = filters.sobel(filters.gaussian(initmp,5.0))
t = 0
#align
head=fits.getheader(os.path.join(i,data_path_fits[0]))
for j in range(1,numb):
data = cubedata[j,:,:]
datatmp = data[corstart[0]:corstart[0]+corsize[0],corstart[1]:corstart[1]+corsize[1]]
if sobel == 1:
datatmp = filters.sobel(filters.gaussian(datatmp,5.0))
#datatmp_gpu = cp.asarray(datatmp)
cc,corr = xyy.corrmaxloc_gpu(initmp,datatmp)
tmp = xyy.imgshift_gpu(data,[-cc[0],-cc[1]])#对齐后的图
if only_align_no_luckyimage == 1:
#不选帧，直接叠加
print('不选帧对齐模式')
ini += tmp
else:
#print('选帧后对齐模式')
#100,1024,1028
cubedata[j,:,:] = tmp[0:rcxsize,0:rcysize]
cubepf=cubedata[:,pfstart[0]:pfstart[0]+pfsize[0],pfstart[1]:pfstart[1]+pfsize[1]]
cubemean=cp.mean(cubepf, axis=0)
psdcube = cp.empty([numb,pfsize[0],pfsize[1]], dtype=cp.float32)
for nn in range(numb):
tmp=cubepf[nn,:,:].copy()
meantmp=cp.mean(tmp)
tmp=(tmp-meantmp)*win+meantmp
psd=cp.abs(cp.fft.fftshift(cp.fft.fft2(tmp)))**2
psd=(psd/psd[pfsize[0]//2,pfsize[1]//2]).astype(cp.float32)
psdcube[nn,:,:]=psd
psdmean=cp.mean(psdcube, axis=0)
psdcube=psdcube/psdmean
[Y,X]=cp.meshgrid(cp.arange(pfsize[1]),cp.arange(pfsize[0]))
dist=((X-pfsize[0]//2)**2.0+(Y-pfsize[1]//2)**2.0)**0.5
ring=cp.where((dist>=infrq)&(dist<=otfrq), 1.0, 0.0).astype(cp.float32)
psdcube=psdcube*ring
ringcube=cp.mean(cp.mean(psdcube, axis=1),axis=1)
index0=cp.argsort(ringcube)[::-1]
#---------------------------------------------------------------------------------------
#-------------------------------- 取排序前**帧, 再次相关对齐，叠加
#################
#cube = cp.asnumpy(cube)
#index0 = cp.asnumpy(index0)
#################
#cubesort0=cube.copy()[index0][0:int(fsp*numb),:,:]
cubesort0=cubedata.copy()[index0][0:int(fsp*numb),:,:]
########################
#cubesort0 = cp.array(cubesort0)
#cube = cp.array(cube,dtype='<f4')
########################
ini=cp.mean(cubesort0, axis=0).astype(cp.float32)
initmp=ini[corstart[0]:corstart[0]+corsize[0],corstart[1]:corstart[1]+corsize[1]]
if sobel==1:
initmp=filters.sobel(filters.gaussian(cp.asnumpy(initmp),5.0))
# ---------------------- 对齐
for nn in range(cubesort0.shape[0]):
data=cubesort0[nn,:,:].copy()
datatmp=data[corstart[0]:corstart[0]+corsize[0],corstart[1]:corstart[1]+corsize[1]]
if sobel==1:
datatmp=filters.sobel(filters.gaussian(cp.asnumpy(datatmp),5.0))
#datatmp_gpu=cp.asarray(datatmp)
cc,corr=xyy.corrmaxloc_gpu(initmp, datatmp)
#cc,corr = xyy.corrmaxloc(initmp,datatmp)
####cc,corr=xyy.corrmaxloc(initmp, datatmp)
tmp=xyy.imgshift_gpu(data,[-cc[0],-cc[1]])
cubesort0[nn,:,:]=tmp
#print(tmp)
averg=cp.mean(cubesort0, axis=0).astype(cp.float32)#叠加
if only_align_no_luckyimage == 1:
averg = ini/t
#---------------------------- 选帧（1计算功率谱，2环带积分，3排序）
#.................................................
aligned_path = '/home/wangxinhua/Desktop/align'+'/'.join(path.split('/')[path.split('/').index('Desktop')+1:])+'/aligned'
try:
print('location of aligned:'+path+os.path.splitdrive(aligned_path)[1])
except Exception as e:
print('location of aligned:'+aligned_path)
if only_align_no_luckyimage == 1:
try:
os.mkdir(path+os.path.splitdrive(aligned_path)[1])
except Exception as e:
print('warning:'+aligned_path+'existed')
xyy.writefits(path+os.path.splitdrive(aligned_path)[1]+'/'+'aligned.fits',cp.asnumpy(initmp/len(data_path_fits)))
else:
try:
os.mkdir(path+os.path.splitdrive(aligned_path)[1])
except Exception as e:
#print(path+aligned_path+'existed')
xyy.mkdir(aligned_path)
xyy.writefits(aligned_path+'/'+'aligned.fits',cp.asnumpy(averg))
#退卷积
if postprocess_flag == 1:
cubesr=cubedata[:,srstx:srstx+srxsize,srsty:srsty+srysize]
try:
r0,index=xyy.cubesrdevr0_gpu(cubesr,srsize,winsr,sitfdata,diameter,diaratio,maxfre,0.00,0.06,start_r0,step_r0)
except Exception as e:
#print(cube)
print(cubesr)
sys.exit()
sitf=xyy.GetSitf_gpu(sitfdata,maxfre,rcxsize,index)
img=xyy.ImgPSDdeconv_gpu(averg,sitf)
head['CODE2'] = r0
result=xyy.ImgFilted_gpu(img,gussf)
result=result/np.median(cp.asnumpy(result))*np.median(cp.asnumpy(averg))
try:
fitsname = redrive+os.path.splitdrive(aligned_path)[1]+'/'+'post_aligned.fits'
xyy.mkdir(redrive+os.path.splitdrive(aligned_path)[1])
except Exception as e:
xyy.mkdir(os.path.join(redrive,i,'aligned'))
fitsname = os.path.join(redrive,i,'aligned','post_aligned.fits')
xyy.writefits(fitsname,cp.asnumpy(result).astype(np.float32),head)
#plt.imshow(result)'''
# print('align is over')
else:
a = 1
#from skimage import io
from skimage import io #, data, filters #data, io, filters
#import scikit.image.io
#import scipy #.image.io
import cv2
# loop over the image URLs
#for url in urls:
# download the image using scikit-image
#print "downloading %s" % (url)
url = r"http://twenkid.com/img/saitut-se-risuva.gif"
image = io.imread(url)
cv2.imshow("Incorrect", image)
cv2.imshow("Correct", cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
from skimage import data, filters
image = data.coins()
# ... or any other NumPy array!
edges = filters.sobel(image)
io.imshow(edges)
io.show()
cv2.waitKey(0)
def make_merge_plot(mask, input_data):
boarders = sobel(mask)
boarders[boarders > 0] = 1
merge_plot = 1-input_data/np.max(input_data) + ( boarders) * 0.3
return merge_plot
def time_sobel(self):
filters.sobel(self.image)
markers[photo_grey_nobg <= 110] = 1
markers[photo_grey_nobg > 110] = 0
if magnification is 50:
markers[photo_grey_nobg <= 95] = 1
markers[photo_grey_nobg > 95] = 0
if magnification is 115:
markers[photo_grey_nobg <= 95] = 1
markers[photo_grey_nobg > 95] = 0
markers_fill = ndi.morphology.binary_fill_holes(markers)
labeled_particles, _ = ndi.label(markers_fill)
#Create a mask of insides of the particles, identify edges from sobel filter and mask out the inside of particles
#Need to mask out center of particles so edges are not detected on the interior of the particle (only want to detect particles whose outside edges are sharp).
particle_erode = morphology.erosion(markers_fill, selem = morphology.disk(1))
elevation_map = sobel(photo_grey_nobg)
elevation_map[particle_erode==True]=0
##Identify sharpest edges from the sobel filter##
#Also need to change the threshold of what is concidered "sharp" as magnification increases because more difficult to get crisp images as you zoom in(especially on a rocking ship)
edges = np.zeros_like(photo_grey_nobg)
if magnification is 7 or magnification is 20:
edges[elevation_map > 10] = 255
if magnification is 50:
edges[elevation_map > 8] = 255
if magnification is 115:
edges[elevation_map > 7] = 255
labeled_edges , _ = ndi.label(edges)
##Identify only in-focus particles by particle indexes that overlap with edge indexes##
infocus_object_img = np.zeros_like(labeled_particles)
def transform_segmap(imgs, segmap, sigma=2, truncate=4.0):
"""
imgs : list of img in different bands as numpy arrays
segmap : the segmap from which labels can be drawn
sigma : passed as sigma to scipy.ndimage.filters.gaussian_filter
truncate: passed as truncate to scipy.ndimage.filters.gaussian_filter
Uses Gaussian to blur input images and broaden passed in segmap
"""
union_segmap = np.zeros_like(segmap)
# create blurred segmaps
for img in imgs:
img = gaussian_filter(_cap_at_1(img), sigma=sigma, truncate=truncate)
img_map = sobel(img)
y, x = np.histogram(img, bins=100)
split_idx = _get_split_idx(y)
markers = np.zeros_like(img)
markers[img < x[split_idx]] = 1
markers[img > x[split_idx + 1]] = 2
new_segmap = morphology.watershed(img_map, markers)
union_segmap = _cap_at_1(union_segmap + (new_segmap - 1))
# merge and label with passed in segmap
dim1 = segmap.shape[0]
dim2 = segmap.shape[1]
for i in range(dim1):
for j in range(dim2):
# if the pixel has a value in the given segmap then give it that value
if segmap[i, j] > 0:
union_segmap[i, j] = segmap[i, j]
# if our new segmap has a value that isn't in the given segmap then
# find the closest label and assign it
elif union_segmap[i, j] > 0:
# NAIVE IMPLEMENTATION FIND A BETTER ALGORITHM!!!!!
coords = None
min_dist = hypot(dim1, dim2)
for k in range(dim1):
for l in range(dim2):
if segmap[k, l] > 0 and hypot(i - k, j - l) < min_dist:
coords = (k, l)
min_dist = hypot(i - k, j - l)
union_segmap[i, j] = segmap[coords[0], coords[1]]
# TODO confirm that this logic will always be true
img_id = segmap[dim1 // 2, dim2 // 2]
# TODO integrate this into the loop above above to
for i in range(dim1):
vals = np.unique(union_segmap[i, :])
# are there two sources in the row and is one of them the central source
if len(vals) > 2 and img_id in np.unique(union_segmap[i, :]):
for j in range(dim2):
if union_segmap[i, j] > 0 and union_segmap[i, j] != img_id:
_replace_overlapping_sources((i, j), union_segmap, img_id)
return union_segmap
