Exemplo n.º 1
0
def detectOpticDisc(image):
    kernel = octagon(10, 10)
    thresh = threshold_otsu(image[:,:,1])
    binary = image > thresh
    print binary.dtype
    luminance = convertToHLS(image)[:,:,2]
    t = threshold_otsu(luminance)
    t = erosion(luminance, kernel)
    
    
    labels = segmentation.slic(image[:,:,1], n_segments = 3)
    out = color.label2rgb(labels, image[:,:,1], kind='avg')
    skio.imshow(out)
    
    x, y = computeCentroid(t)
    print x, y
    rows, cols, _ = image.shape
    p1 = closing(image[:,:,1],kernel)
    p2 = opening(p1, kernel)
    p3 = reconstruction(p2, p1, 'dilation')
    p3 = p3.astype(np.uint8)
    #g = dilation(p3, kernel)-erosion(p3, kernel)
    #g = rank.gradient(p3, disk(5))
    g = cv2.morphologyEx(p3, cv2.MORPH_GRADIENT, kernel)
    #markers = rank.gradient(p3, disk(5)) < 10
    markers = drawCircle(rows, cols, x, y, 85)
    #markers = ndimage.label(markers)[0]
    #skio.imshow(markers)
    g = g.astype(np.uint8)
    #g = cv2.cvtColor(g, cv2.COLOR_GRAY2RGB)
    w = watershed(g, markers)
    print np.max(w), np.min(w)
    w = w.astype(np.uint8)
    #skio.imshow(w)
    return w
Exemplo n.º 2
0
def run(args):
    logging.basicConfig(level=logging.INFO)

    slide = openslide.OpenSlide(args.wsi_path)

    # note the shape of img_RGB is the transpose of slide.level_dimensions
    img_RGB = np.transpose(np.array(slide.read_region((0, 0),
                           args.level,
                           slide.level_dimensions[args.level]).convert('RGB')),
                           axes=[1, 0, 2])

    img_HSV = rgb2hsv(img_RGB)

    background_R = img_RGB[:, :, 0] > threshold_otsu(img_RGB[:, :, 0])
    background_G = img_RGB[:, :, 1] > threshold_otsu(img_RGB[:, :, 1])
    background_B = img_RGB[:, :, 2] > threshold_otsu(img_RGB[:, :, 2])
    tissue_RGB = np.logical_not(background_R & background_G & background_B)
    tissue_S = img_HSV[:, :, 1] > threshold_otsu(img_HSV[:, :, 1])
    min_R = img_RGB[:, :, 0] > args.RGB_min
    min_G = img_RGB[:, :, 1] > args.RGB_min
    min_B = img_RGB[:, :, 2] > args.RGB_min

    tissue_mask = tissue_S & tissue_RGB & min_R & min_G & min_B

    np.save(args.npy_path, tissue_mask)
 def evaluate(self,img):
   img = cv2.medianBlur(img,5)
   if self.auto_thresh:
     self.thresh = threshold_otsu(img)
   if self.white_spots:
     bw = (img > self.thresh).astype(np.uint8)
   else:
     bw = (img <= self.thresh).astype(np.uint8)
   #cv2.imshow(self.name,bw*255)
   #cv2.waitKey(5)
   if not .1* img.size < np.count_nonzero(bw) < .8*img.size:
     print("reevaluating threshold!!")
     print("Ratio:",np.count_nonzero(bw)/img.size)
     print("old:",self.thresh)
     self.thresh = threshold_otsu(img)
     print("new:",self.thresh)
   m = cv2.moments(bw)
   r = {}
   try:
     r['x'] = m['m10']/m['m00']
     r['y'] = m['m01']/m['m00']
   except ZeroDivisionError:
     return -1
   x,y,w,h = cv2.boundingRect(bw)
   #if (h,w) == img.shape:
   #  return -1
   r['bbox'] = y,x,y+h,x+w
   return r
Exemplo n.º 4
0
 def duel(frame):
     threshold = threshold_otsu(frame)
     binary1 = frame > threshold
     frame = frame - binary1 * frame
     threshold = threshold_otsu(frame)
     binary2 = frame > threshold
     binary = binary1 & binary2
     return binary
Exemplo n.º 5
0
    def CleanImgage(self, thresh = 30):

        # Image processing

        footprint = np.array([[-1,-1,-1],[-1,8,-1], [-1,-1,-1]])
        self.clean_image = cv2.medianBlur(self.image, 5)
        self.clean_image = cv2.filter2D(self.clean_image,-1,footprint)
        self.clean_image = cv2.medianBlur(self.clean_image, 5)
        self.markers = np.zeros_like(self.image)
        self.markers[self.clean_image < threshold_otsu(self.image)] = 1
        self.markers[self.clean_image >= ((threshold_otsu(self.image)*thresh)/100)] = 2
        self.markers[self.clean_image >= ((threshold_otsu(self.image)*50)/100)] = 3
def watershed_counter(path_image):
    # load the image and convert it to a floating point data type
    rgb_image = img_as_float(io.imread(path_image))
    image = rgb2grey(rgb_image)

    bin_image = image > threshold_otsu(image)
    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(8, 2.5))
    ax1.imshow(image, cmap=plt.cm.gray)
    ax1.set_title('Original Image')
    ax1.axis('off')

    ax2.hist(image)
    ax2.set_title('Otsu Thresholded Histogram')
    ax2.axvline(threshold_otsu(image), color='r')

    ax3.imshow(bin_image, cmap=plt.cm.gray)
    ax3.set_title('Thresholded Image')
    ax3.axis('off')

    # Now we want to separate the two objects in image
    # Generate the markers as local maxima of the distance to the background

    distance = ndi.distance_transform_edt(bin_image)
    local_maxi = peak_local_max(distance, indices=False, footprint=np.ones((3, 3)), labels=bin_image)
    markers = ndi.label(local_maxi)[0]
    labels = watershed(distance, markers, mask=bin_image)

    regions = regionprops(labels)
    regions = [r for r in regions if r.area > 50]
    num = len(regions)

    fig, axes = plt.subplots(ncols=4, figsize=(8, 2.7))
    ax0, ax1, ax2, ax3 = axes

    ax0.imshow(image, cmap=plt.cm.gray, interpolation='nearest')
    ax0.set_title('Overlapping objects')
    ax1.imshow(-distance, cmap=plt.cm.jet, interpolation='nearest')
    ax1.set_title('Distances')
    ax2.imshow(labels, cmap=plt.cm.spectral, interpolation='nearest')
    ax2.set_title(str(num) + ' Total Objects')
    ax3.imshow(rgb_image, cmap=plt.cm.gray, interpolation='nearest')
    ax3.contour(labels, [0.5], linewidths=1.2, colors='y')
    ax3.axis('off')

    for ax in axes:
        ax.axis('off')

    fig.subplots_adjust(hspace=0.01, wspace=0.01, top=1, bottom=0, left=0,
                        right=1)

    print num

    plt.show()
Exemplo n.º 7
0
 def initial_segmentation(self, emphasized):
     binary_img = np.zeros(emphasized.shape)
     for z in range(0, emphasized.shape[0]):
         th = threshold_otsu(emphasized[z, :, :])
         binary_img[z, :, :] = emphasized[z, :, :] > th
         tmp = np.multiply(emphasized[z, :, :], binary_img[z, :, :])
         tmp[tmp < 0] = 0
         th = threshold_otsu(tmp)
         binary_img[z, :, :] = tmp > th
         binary_img[z, :, :] = remove_small_objects(binary_img[z, :, :].astype(bool), 5)
     binary_img = binary_img.astype('i4')
     return binary_img
def load_data(size):
    """
    Loads data from /chars and /notChars to train binary Classifier
    """
    char_files = glob.glob("/users/derekjanni/pyocr/chars/*")
    non_files = glob.glob("/users/derekjanni/pyocr/notChars/*")
    # pre-process character data
    X_char = []
    for i in char_files:
        img = Image.open(i)
        img = img.convert("L")
        img = img.resize((size, size))
        image = np.asarray(img).astype("int32")
        image.setflags(write=True)
        thresh = threshold_otsu(image)
        binary = image > thresh
        X_char.append(binary)

    Y_char = [1 for i in range(len(X_char))]
    # pre-process non-char data
    X_non = []
    for i in char_files:
        img = Image.open(i)
        img = img.convert("L")
        img = img.resize((size, size))
        image = np.asarray(img).astype("int32")
        image.setflags(write=True)
        thresh = threshold_otsu(image)
        binary = image > thresh
        X_non.append(binary)

    # add 1000 circles of varying radius and position
    for i in range(1000):
        radius = np.random.randint(10, 15) + np.random.randint(5)
        offset = np.random.randint(-5, 5)
        img = np.ones((size, size), dtype=np.int32)
        cv2.circle(img, ((offset + size) / 2, (offset + size) / 2), radius, (0, 0, 0), -1)
        X_non.append(img)

    Y_non = [0 for i in range(len(X_non))]
    X = np.asarray(X_char + X_non).reshape(-1, 1, 50, 50).astype(np.float32)
    Y = np.asarray(Y_char + Y_non).astype(np.int32)
    # some trickery to emulate a train-test split
    indices = list(zip(X, Y))  # name to indicate what's going on here, not the actual data struct
    random.shuffle(indices)
    X, Y = zip(*indices)
    X = np.asarray(X)
    Y = np.asarray(Y)
    return X, Y
def read_input_otsu():
	print("Otsu")
	alphabet=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
	#alphabet=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,17,19,20,21,2]
	n=70
	train_data=[]
	train_solutions=[]
	for i in range(n):
		for letter in alphabet:
			image = imread("chars74k-lite/chars74k-lite/"+letter+"/"+letter+"_"+str(i)+".jpg")
			img = np.asarray(image)
			img.setflags(write=True)
			thresh = threshold_otsu(img)
			binary = image > thresh
			binary = np.reshape(binary,(1,400))
			train_data.append(np.asarray(binary[0]).astype(float))
			#
			t=[0]*26#init all vectors to zero
			t[ord(letter)-97] = 1
			t = np.asarray(t)
			train_solutions.append(t)
	#print(train_data[0])
	#train_data = threshold_otsu(train_data)
	#print(train_data[0])
	#
	m=88
	test_data=[]
	test_solutions=[]
	for j in range(n,m):
		for letter in alphabet:
			image = imread("chars74k-lite/chars74k-lite/"+letter+"/"+letter+"_"+str(j)+".jpg")
			img = np.asarray(image)
			img.setflags(write=True)
			thresh = threshold_otsu(img)
			binary = image > thresh
			binary = np.reshape(binary,(1,400))
			test_data.append(np.asarray(binary[0]).astype(float))
			#
			t=[0]*26#init all vectors to zero
			t[ord(letter)-97] = 1
			t = np.asarray(t)
			test_solutions.append(t)
	#
	'''print(len(train_data))
	print(len(train_solutions))
	print(len(test_data))
	print(len(test_solutions))'''
	return train_data, train_solutions, test_data, test_solutions
Exemplo n.º 10
0
def nln(src_image):
    orig_image = io.imread(src_image, 0)
    if len(orig_image.shape) == 3:
        image = (orig_image.sum(axis=2) / 3).astype('ubyte')
    else:
        image = orig_image
    h, w = image.shape
    thresh = filters.threshold_otsu(image)
    binary = (image < thresh).astype('ubyte') # 二值化,黑色为1
    sum_of_black_pixels = np.sum(binary)
    if sum_of_black_pixels == 0:
        raise Exception("white or black image.")
    binary_line = binary.sum(axis=0) # 在X轴上投影
    hx = binary_line / (sum_of_black_pixels * 1.0)
    binary_line_v = binary.sum(axis=1) # 在Y轴上投影
    hy = binary_line_v / (sum_of_black_pixels * 1.0)

    H = 32
    W = 32
    binary_new = np.zeros( (H, W) )
    for y in range(h):
        for x in range(w):
            if binary[y,x] == 1:
                x2 = int((W-1) * np.sum(hx[0:x+1]))
                y2 = int((H-1) * np.sum(hy[0:y+1]))
                x2_end = int((W - 1) * np.sum(hx[0:x + 2]))
                y2_end = int((H - 1) * np.sum(hy[0:y + 2]))
                if y == h - 1:
                    y2 = H - 1
                    y2_end = H
                if x == w - 1:
                    x2 = W - 1
                    x2_end = W
                binary_new[y2:y2_end, x2:x2_end] = binary[y,x]
    return binary_new.astype('ubyte')
def skeletonize_mitochondria(mch_channel):
    mch_collector = np.max(mch_channel, axis=0)  # TODO: check max projection v.s. sum
    skeleton_labels = np.zeros(mch_collector.shape, dtype=np.uint8)

    # thresh = np.max(mch_collector)/2.
    thresh = threshold_otsu(mch_collector)
    # use adaptative threshold? => otsu seems to be sufficient in this case

    skeleton_labels[mch_collector > thresh] = 1
    skeleton2 = skeletonize(skeleton_labels)
    skeleton, distance = medial_axis(skeleton_labels, return_distance=True)
    active_threshold = np.mean(mch_collector[skeleton_labels]) * 5

    # print active_threshold
    transform_filter = np.zeros(mch_collector.shape, dtype=np.uint8)
    transform_filter[np.logical_and(skeleton > 0, mch_collector > active_threshold)] = 1
    skeleton = transform_filter * distance

    skeleton_ma = np.ma.masked_array(skeleton, skeleton > 0)
    skeleton_convolve = ndi.convolve(skeleton_ma, np.ones((3, 3)), mode='constant', cval=0.0)
    divider_convolve = ndi.convolve(transform_filter, np.ones((3, 3)), mode='constant', cval=0.0)
    skeleton_convolve[divider_convolve > 0] = skeleton_convolve[divider_convolve > 0] / \
                                              divider_convolve[divider_convolve > 0]
    new_skeleton = np.zeros_like(skeleton)
    new_skeleton[skeleton2] = skeleton_convolve[skeleton2]
    skeleton = new_skeleton

    return skeleton_labels, mch_collector, skeleton, transform_filter
def get_monograms_otsu(img, cropped):
    otsu_img = img_as_ubyte(np.copy(np.asarray(cropped.convert('L'))))

    try:
        threshold_global_otsu = threshold_otsu(otsu_img)
    except TypeError:
        print 'Something weird happened'
        return None, None, None
    global_otsu = np.array(otsu_img >= threshold_global_otsu).astype(np.int64)

    hist = np.zeros(global_otsu.shape[1])
    for col in range(global_otsu.shape[1]):
        max_white = 0
        white = 0
        for row in range(global_otsu.shape[0]):
            white += 1 if global_otsu[row, col] == 1 else 0
            max_white = max(white, max_white)
        hist[col] = max_white
    hist = np.convolve(hist, 5 * [1 / 5.], 'same') / 25

    for idx in range(1, len(hist) - 1):
        if hist[idx] == hist[idx + 1] and hist[idx - 1] < hist[idx]:
            hist[idx] = (hist[idx + 1] + hist[idx - 1]) / 2

    maxes = argrelextrema(hist, np.greater)
    cuts = maxes[0]
    monograms = []

    for idx, cut in enumerate(cuts):
        for next in cuts[idx + 1:]:
            if 10 < next - cut < 60:
                monograms.append(N_gram(img[:, cut:next], cut, next))

    return monograms, cuts[0], cuts[-1]
Exemplo n.º 13
0
def find_single_seed(image_filename, output_filename):

    image = Image.from_file(image_filename)

    w, h = 500, 500
    tube_section = image[1024-w:1024+w,1024-h:1024+h]

    threshold = threshold_otsu(tube_section)

    thresholded = tube_section > threshold

    x, y, r = find_inner_circle_parameters(thresholded, 400, 500)

    # FIXME - think routine is finding outer circle

    stripped = strip_outside_circle(thresholded, (x, y), 300)

    eroded = binary_erosion(stripped, structure=np.ones((10, 10)))

    float_coords = map(np.mean, np.where(eroded > 0))
    ix, iy = map(int, float_coords)

    w, h = 100, 100
    selected = tube_section[ix-w:ix+w,iy-h:iy+h]

    with open(output_filename, 'wb') as f:
        f.write(selected.view(Image).png())
Exemplo n.º 14
0
def im_proc(im):
    """Apply series of morphological procedures on image."""
    th = threshold_otsu(im)
    im_bin = im > th
    return(ndi.binary_fill_holes(
                morphology.closing(
                im_bin,np.ones((3,3)))))
Exemplo n.º 15
0
def thresholding(image, threshold):
	if isinstance(threshold,int) or isinstance(threshold,float):
		thresh = threshold
	elif isinstance(threshold,str):
		# Assume its Ok to use the same threshold for each layer.
		parsestr = threshold.split(" ")
		parsestr = [i.lower() for i in parsestr]
		parsestr = set(parsestr)
		if "otsu" in parsestr:
			if "global" in parsestr:
				ind = np.argmax([np.mean(i) for i in image])
				thresh = filters.threshold_otsu(image[ind])
				print thresh, ind
			elif "local" in parsestr:
				radius = int(parsestr[2])
				mask = morphology.disk(radius)
				thresh = filters.rank.otsu(image,mask)
		if "li" in parsestr:
			thresh = filters.threshold_li(image)
		if "yen" in parsestr:
			thresh = filters.threshold_yen(image)

	threshinds = image<thresh
	binimg =  np.ones(image.shape)
	binimg[threshinds] = 0
	return binimg, thresh
def segment_Image(im,depth):
    
    ## Setting lower threshold using Otsu method.
    thresh_l = 0.8*threshold_otsu(im)
    print thresh_l
    img = sitk.GetImageFromArray(im)

    ## Smoothing image.  
    imgSmooth = sitk.CurvatureFlow(image1=img,
                                    timeStep=0.125,
                                    numberOfIterations=10)
    lstSeeds=[]

    for i in range(0, im.shape[1]-1, 10 ):
        for j in range (0, im.shape[0]-1, 10 ):
            if im[j][i]>0:
             seed = [int(i), int(j)]
             lstSeeds.append( seed )
    
    ## Segmenting image.
    imgWhiteMatter = sitk.ConnectedThreshold(image1=imgSmooth, 
                                              seedList=lstSeeds, 
                                              lower=thresh_l, 
                                              upper=255,
                                              replaceValue=255)
    nda = sitk.GetArrayFromImage(imgWhiteMatter)
    
    nda.astype(bool)
    nda1=remove_small_objects(nda,150,connectivity=3)
    nda1.astype(int)
    newdepth = depth
    
    return nda1,newdepth
Exemplo n.º 17
0
def cont(imagen, depth=2**16, gaussian=3, screenpercent=0.7,t=0):

    imagen = gaussian_filter(imagen, gaussian)

    if t==0:
        otsu = threshold_otsu(imagen, depth)
    elif t==1:
        otsu = filters.threshold_isodata(imagen, depth)
    else:
        otsu = filters.threshold_li(imagen)
    imagen = binarizar(imagen, otsu)
    imagen = gaussian_filter(imagen, gaussian)

    contours = measure.find_contours(imagen, 1)
    centro = np.asanyarray([1280*0.5, 960*0.5])
    while len(contours) > 1:
        if sum(np.abs(centro - contours[1].mean(axis=0)) < [1280*screenpercent*0.5, 960*screenpercent*0.5]) != 2:
            del contours[1]
        elif sum(np.abs(centro - contours[0].mean(axis=0)) < [1280*screenpercent*0.5, 960*screenpercent*0.5]) != 2:
            del contours[0]
        else:
            if contours[1].size < contours[0].size:
                del contours[1]
            else:
                del contours[0]
    return imagen, contours[0]
Exemplo n.º 18
0
    def locate(i):
        """
        Median subtract each hologram, convolve with Mexican hat kernel,
        then smooth the absolute value of the convolution, and use
        Otsu's thresholding to segment the image into specimens.
        Record the time, x and y centroids, and some intensity features
        within each segment.
        """
        median_sub_holo = hologram_cube[i, ...] - median_holo
        conv_holo = convolve_fft(median_sub_holo,
                                 MexicanHat2DKernel(convolution_kernel_radius),
                                 fftn=fft2, ifftn=ifft2)
        smooth_abs_conv = gaussian_filter(np.abs(conv_holo),
                                          gaussian_kernel_radius)

        thresh = threshold_otsu(smooth_abs_conv - np.median(smooth_abs_conv))
        # thresh = threshold_yen(smooth_abs_conv - np.median(smooth_abs_conv))

        masked = np.ones_like(smooth_abs_conv)
        masked[smooth_abs_conv <= thresh] = 0

        label_image = label(masked)
        regions = regionprops(label_image, smooth_abs_conv)
        for region in regions:
            centroid = region.weighted_centroid
            pos = (i, centroid[0], centroid[1],
                   region.max_intensity, region.mean_intensity)
            positions.append(pos)
Exemplo n.º 19
0
def mouse_centroid(im, previous_centroid):
    """
    Find mouse's centroid in a single image
    
    Parameters:
        im = image of analyze (numpy array)
        
        previous_centroid = coordinates of the mouse in the previous frame
        
    Returns:
        Coordinates of the mouse's centroid
    """
    original = copy(im)
    im = im < filters.threshold_otsu(im) * 0.2
    distance = ndimage.distance_transform_edt(im)
    centers = (distance > 0.8 * distance.max())
    if len(centers) == 0:
        return previous_centroid
    labels = label(centers)
    centroids = [r.weighted_centroid for r in regionprops(labels, original)]
    if len(centroids) == 1:
        return list(centroids[0])
    elif len(centroids) > 1:
        d = lambda a, b: ((a[0] - b[0])**2 + (a[1] - b[1])**2)**0.5
        dists = [d(c, previous_centroid) for c in centroids]
        d_idx = np.array(dists == np.min(dists))
        return list(np.array(centroids)[d_idx][0])
    def read_img_bw(self, image_file, array_type="one_zero"):
        '''
        Read an image from a file and return its matrix
        inputs:
            image_file: full path to the image file including extension
            array_type: String with two values:
                "one_zero": matrix is uint8 with only 1s and 0s
                "bool": matrix is bool with True and False
        '''
        #read image and convert to matrix
        image = Image.open(image_file).convert('L')
#         image = image.resize((100,100), Image.LANCZOS)
        image_array = image.getdata()
               
        image_array = numpy.array(image_array).astype(numpy.uint8).reshape((image.size[0],image.size[1]))
#         print image_array.shape
        
        #Threshold the image according to array_type parameter
        if array_type == "bool":
            thresh = threshold_otsu(image_array)
            image_array = image > thresh
            image_array = ~image_array
        else:
            image_array[image_array < 128] = 1
            image_array[image_array >= 128] = 0
            image_array[image_array == 1] = 255
#         plt.imshow(image_array)
#         plt.show()
        return image_array
Exemplo n.º 21
0
    def plot_preprocessed_image(self):
        """
        plots pre-processed image. The plotted image is the same as obtained at the end
        of the get_text_candidates method.
        """
        image = restoration.denoise_tv_chambolle(self.image, weight=0.1)
        thresh = threshold_otsu(image)
        bw = closing(image > thresh, square(2))
        cleared = bw.copy()

        label_image = measure.label(cleared)
        borders = np.logical_xor(bw, cleared)

        label_image[borders] = -1
        image_label_overlay = label2rgb(label_image, image=image)

        fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(12, 12))
        ax.imshow(image_label_overlay)

        for region in regionprops(label_image):
            if region.area < 10:
                continue

            minr, minc, maxr, maxc = region.bbox
            rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
                                      fill=False, edgecolor='red', linewidth=2)
            ax.add_patch(rect)

        plt.show()
Exemplo n.º 22
0
def label_stack(z_stack, parameters):
    '''
    Apply an automated threshold and a watershed algorithm to
    label cells in each planes of the stack

    Parameters:
    -----------
    z_stack: 3d array of shape (nz, nx, ny)

    Returns:
    --------
    labeled_stack: 3d array of the same shape as z_stack,
    with each detected region labeled
    '''
    segment_method = parameters['segment_method']
    correction = parameters['correction']
    labeled_stack = np.zeros(z_stack.shape, dtype=np.uint8)
    max_int_proj = z_stack.max(axis=0)
    thresh = None

    if segment_method == 'otsu':
        thresh = threshold_otsu(max_int_proj) * correction
    elif segment_method == 'naive':
        thresh = max_int_proj.max() * correction
    else:
        err_string = ('Segmentation method {}'
                      'is not implemented'.format(segment_method))
        raise NotImplementedError(err_string)
    while thresh > z_stack.max():
        log.warning('''Reducing threshold''')
        thresh *= 0.9
    for n, frame in enumerate(z_stack):
        labeled_stack[n] = label_from_thresh(frame, thresh, parameters)
    return labeled_stack
Exemplo n.º 23
0
def isolate_single_seed(stack_path, output_path):
    """Load stack then isolate seed."""

    sigma = 10
    iterations = 1

    raw_stack = Image3D.from_path(stack_path)

    print raw_stack.shape

    smoothed = gaussian_filter(raw_stack, sigma).view(Image3D)

    edges = sobel_magnitude_nd(smoothed).view(Image3D)

    #edges.save('edges')

    labels = np.zeros(raw_stack.shape)
    cx, cy, cz = map(lambda x: x/2, raw_stack.shape)
    labels[cx, cy, cz] = 1

    threshold = threshold_otsu(smoothed)
    thresholded = smoothed > threshold

    #thresholded.view(Image3D).save('thresh')

    segmentation = watershed(edges, markers=labels, mask=thresholded)

    #segmentation.view(Image3D).save('seg')

    dilated = binary_dilation(segmentation, iterations=iterations)

    isolate = np.multiply(raw_stack, dilated)

    isolate.view(Image3D).save(output_path)
Exemplo n.º 24
0
def image_prep(img):
	# apply filters for better contrast and noise removal
	img_gamma = adjust_gamma(img, 0.7)
	img_median = median(img_gamma, disk(1))

	# apply threshold
	val =  threshold_otsu(img_median)
	img_otsu = img_median > val

	# label image regions
	label_image = label(img_otsu)

	candidates = []
	for region in regionprops(label_image):
		minr, minc, maxr, maxc = region.bbox
		if (maxr - minr > maxc - minc):
			candidates.append(region)

	# find numbers
	areas = []
	for candidate in candidates:
		areas.append(candidate.area)
	areas.sort()
	areas.reverse()

	n = 1
	v = []
	for candidate in candidates:
		if (candidate.area == areas[0] or candidate.area == areas[1] or candidate.area == areas[2]):
			v.append(candidate.image)
			imsave('num%d.png' % n, candidate.image)
			n += 1
	return v
Exemplo n.º 25
0
def save_img(img, filename, shape):
    
    img = deprocess_img(img)
    img = img.numpy()
    img *= 255
    img = img.clip(0, 255)
    img = np.transpose(img, (1, 2, 0))
    img = imresize(img, (shape[0], shape[1], 1))

    img=rgb2gray(img)
    thresh = threshold_otsu(img)

    img= img > thresh

    img = img.astype(np.uint8)
    img=img*255
    kernel = np.ones((3,3),np.uint8)
    img = cv2.erode(img,kernel,iterations = 1)

    # png.from_array(img[:], 'L').save(filename)
    # filename=filename.split('.jpg')[0]
    # filename = filename + '.png'
    imsave(filename, img)
    # imshow(img)
    print ("Image saved as {}".format(filename))
Exemplo n.º 26
0
def max_mask_iter(fns, offset=0, close_radius=0, erode_radius=0):
    """Find masks for a set of images having brightness artifacts.

    Parameters
    ----------
    fns : list of string
        The images being examined.
    offset : int, optional
        Offset the threshold automatically found.
    close_radius : int, optional
        Perform a morphological closing of the mask of this radius.
    erode_radius : int, optional
        Perform a morphological erosion of the mask, after any closing,
        of this radius.

    Returns
    -------
    maxes : iterator of bool array
        The max mask image corresponding to each input image.
    """
    ms = maxes(fns)
    t = imfilter.threshold_otsu(ms)
    ims = it.imap(io.imread, fns)
    masks = ((im < t + offset) for im in ims)
    if close_radius > 0:
        masks = (morphop(mask, 'close', close_radius) for mask in masks)
    if erode_radius > 0:
        masks = (morphop(mask, 'erode', erode_radius) for mask in masks)
    return masks
def create_binary(img):
    """ Create global binary """

    global_thresh = threshold_otsu(img)
    binary_global = img > global_thresh
    
    return(binary_global)
def k_means_classifier(image):
        n_clusters = 8

        # blur and take local maxima
        blur_image = gaussian(image, sigma=8)
        blur_image = ndi.maximum_filter(blur_image, size=3)

        # get texture features
        feats = local_binary_pattern(blur_image, P=40, R=5, method="uniform")
        feats_r = feats.reshape(-1, 1)

        # cluster the texture features
        km = k_means(n_clusters=n_clusters, batch_size=500)
        clus = km.fit(feats_r)

        # copy relevant attributes
        labels = clus.labels_
        clusters = clus.cluster_centers_

        # reshape label arrays
        labels = labels.reshape(blur_image.shape[0], blur_image.shape[1])

        # segment shadow
        img = blur_image.ravel()
        shadow_seg = img.copy()
        for i in range(0, n_clusters):
            # set up array of pixel indices matching cluster
            mask = np.nonzero((labels.ravel() == i) == True)[0]
            if len(mask) > 0:
                thresh = threshold_otsu(img[mask])
                shadow_seg[mask] = shadow_seg[mask] < thresh
        shadow_seg = shadow_seg.reshape(*image.shape)

        return shadow_seg
Exemplo n.º 29
0
def gen(nb):
    X_out = np.empty((nb, c, w, h))
    for i in range(nb):
        while True:
            img = np.random.choice(collection)
            ch = min(img.shape[0], h_crop)
            cw = min(img.shape[1], w_crop)
            crop_pos_y = np.random.randint(0, img.shape[0] - ch + 1)
            crop_pos_x = np.random.randint(0, img.shape[1] - cw + 1)
            x = crop_pos_x
            y = crop_pos_y
            im = img[y:y+ch, x:x+cw]
            im = im / 255.
            im = 1 - im
            #im = pad(im, 15, 'constant', constant_values=(0, 0))
            im = resize(im, (w, h))
            thresh = threshold_otsu(im)
            im = im > thresh
            im = im.astype(np.float32)
            if im.sum() > 500 and im.sum() < 2000:
                break
        X_out[i, 0] = im
    X_out = X_out.reshape((X_out.shape[0], -1))
    X_out = X_out.astype(np.float32)
    return X_out
Exemplo n.º 30
0
def testSkimage2():
    img = Image.open('../img/1.png')
    # img = Image.open('../img/2.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)
    camera = imggray
    # camera = data.camera()
    val = filters.threshold_otsu(camera)

    hist, bins_center = exposure.histogram(camera)

    plt.figure(figsize=(9, 4))
    plt.subplot(131)
    plt.imshow(camera, cmap='gray', interpolation='nearest')
    plt.axis('off')
    plt.subplot(132)
    plt.imshow(camera < val, cmap='gray', interpolation='nearest')
    plt.axis('off')
    plt.subplot(133)
    plt.plot(bins_center, hist, lw=2)
    plt.axvline(val, color='k', ls='--')

    plt.tight_layout()
    plt.show()
    return
Exemplo n.º 31
0
def basicProcessing(volume, sigma, order, output, mode, truncate):
    """This function shows an example of processing a volume.

    Parameters
    ----------
    volume : array
        Array in which different processing will be applied.

    sigma : int or sequence of int
        Standard deviation for Gaussian kernel.

    order : int or sequence of int
        An order of 0 corresponds to convolution with a Gaussian kernel. An order of 1, 2, or 3 corresponds to
        convolution with the first, second or third derivatives of a Gaussian. Higher order derivatives are
        not implemented.

    output : array or dtype
        The array in which to place the output, or the dtype of the returned array. By default an array of
        the same dtype as input will be created.

    mode : str
        The mode parameter determines how the input array is extended when the filter overlaps a border.

    truncate : float
        Truncate the filter at this many standard deviations. Default is 4.0.
    """


    #### Filters ###

    result = gaussian_filter(input=volume, sigma=sigma, order=order, output=output, mode=mode, truncate=truncate)

    val = threshold_otsu(result)
    print("val : {}".format(val))

    mask = np.zeros(volume.shape, dtype=np.int8)
    mask[volume > val] = 1
    #mask = mask.astype(int)

    print("mask shape: {}".format(mask.shape))
    print(mask)


    #### Morphological Operation ###

    # Opening removes small objects
    r1 = binary_opening(mask, structure=np.ones((3, 3, 3))).astype(np.int8)

    # Closing removes small holes
    r2 = binary_closing(r1, structure=np.ones((3, 3, 3))).astype(np.int8)


    # 3x3x3 structuring element with connectivity 4 or 8
    struct1 = generate_binary_structure(3, 1)   # no diagonal elements
    #struct1 = generate_binary_structure(3, 2)  # with diagonal elements
    ############struct1 = struct1.astype(int)
    print (struct1)


    #r3 = binary_dilation(r2).astype(int)
    r3 = binary_dilation(r2, structure=struct1).astype(int)    # using a structure element

    # Erosion removes objects smaller than the structure
    r4 = binary_erosion(r3, structure=np.ones((3, 3, 3))).astype(np.int8)


    #### Measurements ###

    struct2 = np.ones((3, 3, 3), dtype=np.int8)
    labeled_array, num_features = label(r4, structure=struct2)

    #print(labeled_array)
    print(num_features)

    return labeled_array, num_features
Exemplo n.º 32
0
def otsu(image_array_loss1,image_array_loss2, H, W,date1,date2,parameters,paths,loss_arrays,loss_arrays_otsu,changes=None):

    patch_size = parameters.get("patch_size")
    epoch_nb = parameters.get("epoch_nb")
    batch_size = parameters.get("batch_size")
    learning_rate = parameters.get("learning_rate")
    weighted = parameters.get("weighted")
    sigma = parameters.get("sigma")
    shuffle = parameters.get("shuffle")
    sampleTrue = parameters.get("sampleTrue")
    threshold = parameters.get("threshold")
    
    patient = paths.get("patient")
    path_results = paths.get("path_results")
    path_models = paths.get("path_models")
    path_models_finetuned = paths.get("path_models_finetuned")
    path_diff = paths.get("path_diff")
    path_bcm = paths.get("path_bcm")
    path_loss = paths.get("path_loss")
    path_reconstructed = paths.get("path_reconstructed")

    # We calculate the average reconstruction error image
    image_array_loss = np.divide((image_array_loss1+image_array_loss2), 2)
    #normalize loss for visual
    image_array_loss = normalize(image_array_loss)*255
#     for loss and diff comparaison
    loss_arrays.append(image_array_loss)
    
    # We rescale the image values to 8 bits so it works with the functions from skimage
#     max_ = np.nanmax(image_array_loss)
#     coef = max_/256
#     image_array_loss = image_array_loss/coef
#     image_array_loss = np.asarray(image_array_loss, dtype=int)

    # THIS IS VERY IMPORTANT VALUE
    # Otsu threshold is automatic, however before applying it, we exclude 0.5% of the highest reconstruction error values as they ae considered to be outliers
    # This parameter can be modified if needed
#     threshold = 1
#     threshold = 0.995
    # image_array_loss[~np.isnan(image_array_loss)].flatten() car on fait le threshold sans les nan
    a=image_array_loss[~np.isnan(image_array_loss)].flatten()
    
    val = filters.threshold_otsu(np.sort(a)[0:int(a.shape[0]*threshold)]) # Obtained threshold value
    
    del a

    # We get binary change map (1 - changes, 0 - no changes) using the threshold and write it to tiff and shp
    image_array_outliers = np.zeros(H*W)
    image_array_outliers[image_array_loss.flatten() > val] = 1
    outliers_image_mean = path_bcm+"BCM_"+date1+'_to_'+date2+"_threshold_" +str(threshold)+"_otsu_"+str(val)+'.png'
    
    image_array_outliers = np.reshape(image_array_outliers, (H, W))
    image_array_outliers=image_array_outliers.astype('uint8')
    image_array_outliers=image_array_outliers*255
#     image_gray = cv2.cvtColor(image_array_outliers, cv2.COLOR_BGR2GRAY)
    cv2.imwrite(outliers_image_mean,image_array_outliers)
    
    loss_arrays_otsu.append([image_array_outliers,val])

    
    # We calculate the stats if the ground truth is available for this couple of images
    # if changes is not None:
    #     # path of ground truth image, I have only 2 GT
    #     path_cm = '/home/user/Dropbox/IJCNN/images/' + changes
    #     cm_truth_name = "mask_changes_small1"
    #     if changes=="changes_2004_2005":
    #         cm_predicted = (np.reshape(image_array_outliers, (H, W))[0:600, 600:1400]).flatten()
    #     if changes == "changes_2006_2008":
    #         cm_predicted = (np.reshape(image_array_outliers, (H, W))[100:370, 1000:1320]).flatten()

    #     cm_truth, _, _, _, _, _ = open_tiff(path_cm, cm_truth_name)
    #     cm_truth = cm_truth.flatten()
    #     cm_truth[cm_truth==255]=0
    #     #Different stats takenthreshold = 0.995 from scikit
    #     print(classification_report(cm_truth, cm_predicted, target_names=["no changes", "changes"]))
    #     print(accuracy_score(cm_truth, cm_predicted))
    #     print(cohen_kappa_score(cm_truth, cm_predicted))
    #     conf = confusion_matrix(cm_truth, cm_predicted)
    #     print(confusion_matrix(cm_truth, cm_predicted))
    #     omission = conf[1][0]/sum(conf[1])
    #     print (omission)
    
    return image_array_outliers
Exemplo n.º 33
0
from skimage.transform import resize
from PIL import Image


car_image = imread("car6.jpg", as_grey=True)
# it should be a 2 dimensional array
print(car_image.shape)

# the next line is not compulsory however, a grey scale pixel
# in skimage ranges between 0 & 1. multiplying it with 255
# will make it range between 0 & 255 (something we can relate better with

gray_car_image = car_image * 255
fig, (ax1, ax2) = plt.subplots(1, 2)
ax1.imshow(gray_car_image, cmap="gray")
threshold_value = threshold_otsu(gray_car_image)
binary_car_image = gray_car_image > threshold_value
ax2.imshow(binary_car_image, cmap="gray")
plt.show()

label_image = measure.label(binary_car_image)

# getting the maximum width, height and minimum width and height that a license plate can be
plate_dimensions = (0.06*label_image.shape[0], 0.2*label_image.shape[0], 0.15*label_image.shape[1], 0.4*label_image.shape[1])
min_height, max_height, min_width, max_width = plate_dimensions
plate_objects_cordinates = []
plate_like_objects = []
fig, (ax1) = plt.subplots(1)
ax1.imshow(gray_car_image, cmap="gray");

# regionprops creates a list of properties of all the labelled regions
Exemplo n.º 34
0
from skimage.filters import threshold_otsu
from skimage.color import rgb2gray
from matplotlib import pyplot as plt

chess_pieces = plt.imread('images/bw.jpg')
chess_pieces_gray = rgb2gray(chess_pieces)

thresh = threshold_otsu(chess_pieces_gray)
binary = chess_pieces_gray > thresh

plt.imshow(chess_pieces, cmap="gray")
plt.show()

plt.imshow(chess_pieces_gray, cmap="gray")
plt.show()

plt.imshow(binary, cmap="gray")
plt.show()
Exemplo n.º 35
0

path_list=['plantA_39.jpg','plantB_26.jpg','plantC_15.jpg',\
           'plantA_23.jpg','plantB_51.jpg','plantC_44.jpg']

for i in path_list:
    im = imageio.imread(i)
    img = color.rgb2gray(im)

    #grayscale
    plt.imshow(img, cmap=plt.cm.gray, interpolation='nearest')
    plt.axis('off')
    plt.savefig('(a)%s_grayscale.png'%i)
    
    #B&W
    threshold = filters.threshold_otsu(img)
    binary_img = img > threshold
    
    plt.imshow(binary_img, cmap=plt.cm.gray, interpolation='nearest')
    plt.axis('off')
    plt.savefig('(b)%s_b&w.png'%i)
    
    #edges
    edges = feature.canny(img, sigma=1)

    plt.imshow(edges, cmap=plt.cm.gray, interpolation='nearest')
    plt.axis('off')
    plt.savefig('(c)%s_edges.png'%i)
    
    #contours
    threshold = filters.threshold_otsu(img)
Exemplo n.º 36
0
def find_somas(volume: np.ndarray, res: list) -> Tuple[int, np.ndarray, np.ndarray]:
    r"""Find bright neuron somas in an input volume.

    This simple soma detector assumes that somas are brighter than the
    rest of the objects contained in the input volume.

    To detect somas, these steps are performed:

    #. **Check input volume shape.** This detector requires the `x` and `y` dimensions of the input volumes to be larger than `20` pixels.

    #. **Zoom volume.** We found that this simple soma detector works best when then input volume has size `160 x 160 x 50`. We use `ndimage.zoom <https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.zoom.html>`_ to scale the input volume size to the desired shape.

    #. **Binarize volume.** We use `Otsu thresholding <https://scikit-image.org/docs/dev/api/skimage.filters.html#skimage.filters.threshold_otsu>`_ to binarize the image.

    #. **Erode the binarized image.** We erode the binarized image with a structuring element which size is directly proportional to the maximum zoom factor applied to the input volume.

    #. **Remove unreasonable connected components.** After erosion, we compute the equivalent diameter `d` of each connected component, and only keep those ones such that `5\mu m \leq d < 21 \mu m`

    #. **Find relative centroids.** Finally, we compute the centroids of the remaining connected components. The centroids are in voxel units, relative to the input volume.

    Parameters
    ----------
    volume : numpy.ndarray
        The 3D image array to run the detector on.

    res : list
        A `1 x 3` list containing the resolution of each voxel in `nm`.

    Returns
    -------
    label : bool
        A boolean value indicating whether the detector found any somas in the input volume.

    rel_centroids : numpy.ndarray
        A `N x 3` array containing the relative voxel positions of the detected somas.

    out : numpy.ndarray
        A `160 x 160 x 50` array containing the detection mask.

    Examples
    --------
    >>> # download a volume
    >>> dir = "s3://open-neurodata/brainlit/brain1"
    >>> dir_segments = "s3://open-neurodata/brainlit/brain1_segments"
    >>> volume_keys = "4807349.0_3827990.0_2922565.75_4907349.0_3927990.0_3022565.75"
    >>> mip = 1
    >>> ngl_sess = NeuroglancerSession(
    >>>     mip=mip, url=dir, url_segments=dir_segments, use_https=False
    >>> )
    >>> res = ngl_sess.cv_segments.scales[ngl_sess.mip]["resolution"]
    >>> volume_coords = np.array(os.path.basename(volume_keys).split("_")).astype(float)
    >>> volume_vox_min = np.round(np.divide(volume_coords[:3], res)).astype(int)
    >>> volume_vox_max = np.round(np.divide(volume_coords[3:], res)).astype(int)
    >>> bbox = Bbox(volume_vox_min, volume_vox_max)
    >>> img = ngl_sess.pull_bounds_img(bbox)
    >>> # apply soma detector
    >>> label, rel_centroids, out = find_somas(img, res)
    """

    check_type(volume, np.ndarray)
    check_iterable_type(volume.flatten(), np.uint16)
    volume_dim = volume.ndim
    if volume_dim != 3:
        raise ValueError("Input volume must be three-dimensional")
    if volume.shape[0] < 20 or volume.shape[1] < 20:
        raise ValueError("Input volume is too small")

    check_type(res, list)
    check_iterable_type(res, (int, float))
    if len(res) != 3:
        raise ValueError("Resolution must be three-dimensional")
    if np.any([el == 0 for el in res]):
        raise ValueError("Resolution must be non-zero at every position")

    desired_size = np.array([160, 160, 50])
    zoom_factors = np.divide(desired_size, volume.shape)
    res = np.divide(res, zoom_factors)
    out = ndimage.zoom(volume, zoom=zoom_factors)
    out = out / np.max(out.flatten())
    # 1) binarize volume using Otsu's method
    t = filters.threshold_otsu(out)
    out = out > t
    # 2) erode with structuring element proportional to zoom factors
    selem_size = np.amax(np.ceil(zoom_factors)).astype(int)
    clean_selem = morphology.octahedron(selem_size)
    out = morphology.erosion(out, clean_selem)
    # 3) identify connected components
    out, num_labels = morphology.label(out, background=0, return_num=True)
    # 4) remove connected components with diameter not in reasonable range, find centroids of candidate regions
    properties = ["label", "equivalent_diameter"]
    props = measure.regionprops_table(out, properties=properties)
    df_props = pd.DataFrame(props)
    rel_centroids = []
    for _, row in df_props.iterrows():
        l = row["label"]
        d = row["equivalent_diameter"]
        dmu = d * np.mean(res[:1]) / 1000
        if dmu < 5 or dmu >= 21:
            out[out == l] = 0
            num_labels -= 1
        else:
            ids = np.where(out == l)
            centroid = np.round([np.median(u) for u in ids]).astype(int)
            centroid = np.divide(centroid, zoom_factors)
            rel_centroids.append(centroid)
    return num_labels > 0, np.array(rel_centroids), out
Exemplo n.º 37
0
plt.hist(red_channel.ravel(), bins= 256)

# Set title and show
plt.title('Red Histogram')
plt.show()

--------------------------------------------------
# Exercise_4 
# Import the otsu threshold function
from skimage.filters import threshold_otsu

# Make the image grayscale using rgb2gray
chess_pieces_image_gray = rgb2gray(chess_pieces_image)

# Obtain the optimal threshold value with otsu
thresh = threshold_otsu(chess_pieces_image_gray)

# Apply thresholding to the image
binary = chess_pieces_image_gray > thresh

# Show the image
show_image(binary, 'Binary image')

--------------------------------------------------
# Exercise_5 
#1
# Import the otsu threshold function
from skimage.filters import threshold_otsu

# Obtain the optimal otsu global thresh value
global_thresh = threshold_otsu(page_image)
Exemplo n.º 38
0
import matplotlib.pyplot as plt
from skimage import filters
from skimage import exposure
import cv2
import numpy as np
from skimage.exposure import histogram

img = cv2.imread('dew on roses.tif', 0)
val = filters.threshold_otsu(img)
#mult = skimage.filters.threshold_multiotsu
print(val)
'''
hist, bins_center = exposure.histogram(img)

plt.figure(figsize=(9, 4))
plt.subplot(131)
plt.imshow(img, cmap='gray', interpolation='nearest')
plt.axis('off')

# otsu threshold
plt.subplot(132)
plt.imshow(img < val, cmap='gray', interpolation='nearest')
plt.axis('off')

# histogram
plt.subplot(133)
plt.plot(bins_center, hist, lw=2)
plt.axvline(val, color='k', ls='--')

plt.tight_layout()
plt.show()
def main(_):
    ground_truth = get_ground_truth(images_dir=FLAGS.images_dir,
                                    subdir_name=FLAGS.subdir_name,
                                    target_dir=None)

    contours = overlay_contours(images_dir=FLAGS.images_dir,
                                subdir_name=FLAGS.subdir_name,
                                target_dir=None)

    masks = overlay_masks(images_dir=FLAGS.images_dir,
                          subdir_name=FLAGS.subdir_name,
                          target_dir=None)


    ############################
    # Problem 1 -> dirty masks
    ############################
    idx = 5
    dirty = masks[idx], contours[idx], ground_truth[idx]
    plot_list(images=[dirty[0], dirty[1]],
              labels=[dirty[2]])

    #################################
    # Problem 2 -> dirty at border
    #################################
    idx = 44
    dirty_at_border = masks[idx], contours[idx], ground_truth[idx]
    plot_list(images=[dirty_at_border[0], dirty_at_border[1]],
              labels=[dirty_at_border[2]])

    ################
    # Approach V1
    ################
    m, c, t = dirty

    ########################################################################
    #  Let's put it all together in a function - def clean_mask_v1(m,c)
    #
    #  m, c, t = dirty
    #  m_ = clean_mask_v1(m,c)
    #  plot_list(images = [m,c,m_], labels = [t])
    #
    ########################################################################
    # let's proceed to cleaning.
    # First we binarize both the mask and contours using global, otsu thresholding method:
    m_b = m > threshold_otsu(m)
    c_b = c > threshold_otsu(c)
    plot_list(images=[m_b, c_b], labels=[])

    # combine binarized masks and contours
    m_ = np.where(m_b | c_b, 1, 0)
    plot_list(images=[m_], labels=[])

    # fill the holes that remained
    m_ = ndi.binary_fill_holes(m_)
    plot_list(images=[m_], labels=[])

    # Now that we filled the holes in the cells we can detach them again because we have the contour information
    m_ = np.where(c_b & (~m_b), 0, m_)
    plot_list(images=[m_], labels=[])

    # We are left with artifacts. Let's use binary_openning to drop them.
    area, radius = mean_blob_size(m_b)
    m_ = morph.binary_opening(m_, selem=morph.disk(0.25 * radius))
    plot_list(images=[m_], labels=[])



    # It works to a certain extend but it removes things that
    # where not connected and/or things around borders

    ################
    # Approach V2
    ################
    # Let's start by binarizing and filling the holes again
    m, c, t = dirty_at_border

    ########################################################################
    #  Let's put it all together in one function - def clean_mask_v2(m,c)
    #
    #  m,c,t = dirty_at_border
    #  m_ = clean_mask_v2(m,c)
    #
    #  plot_list(images = [m,c,m_], labels = [t])
    #
    ########################################################################

    # threshold
    m_b = m > threshold_otsu(m)
    c_b = c > threshold_otsu(c)

    # combine contours and masks and fill the cells
    m_ = np.where(m_b | c_b, 1, 0)
    m_ = ndi.binary_fill_holes(m_)
    plot_list(images=[m_], labels=[])


    # Now we will use binary_closing to fill what wasn't closed with fill holes.
    # We will need two helper functions pad_mask and crop_mask to deal with problems around the edges

    # close what wasn't closed before
    area, radius = mean_blob_size(m_b)
    struct_size = int(1.25 * radius)
    struct_el = morph.disk(struct_size)
    m_padded = pad_mask(m_, pad=struct_size)
    m_padded = morph.binary_closing(m_padded, selem=struct_el)
    m_ = crop_mask(m_padded, crop=struct_size)
    plot_list(images=[m_], labels=[])

    # we closed everything but it is way more than we wanted.
    # Let's now cut it with our contours and see what we get
    m_ = np.where(c_b & (~m_b), 0, m_)
    plot_list(images=[m_], labels=[])

    # we can use binary_openning with a larger structural element. Let's try that
    area, radius = mean_blob_size(m_b)
    struct_size = int(0.75 * radius)
    struct_el = morph.disk(struct_size)
    m_padded = pad_mask(m_, pad=struct_size)
    m_padded = morph.binary_opening(m_padded, selem=struct_el)
    m_ = crop_mask(m_padded, crop=struct_size)
    plot_list(images=[m_, m], labels=[t])

    # join the connected cells with what we had at the beginning
    m_ = np.where(m_b | m_, 1, 0)
    m_ = ndi.binary_fill_holes(m_)
    plot_list(images=[m_, m], labels=[t])

    m_ = drop_artifacts(m_, m_b, min_coverage=0.25)
    plot_list(images=[m_, m, c], labels=[t])


    ############################################
    # Problem 3 -> not everything gets filled
    ############################################

    ############################################
    # Problem 4 -> some cells get connected
    #
    # Ideas:
    # - work more with dilation
    # - do better around borders
    # - drop some cells after watershed with drop_artifact function
    #
    # TODO: clean_mask_V3 would be dev...
    # Go ahead and try to improve it. The floor is yours
    #
    # def clean_mask_v3(m,c):
    #     return
    #
    ############################################


    ###################
    # Good Markers
    ###################
    # In this approach we will simply cut the masks with the contours and use that as markers.
    # Simple but really effective.
    for idx in range(5):
        print(idx)
        mask = masks[idx]
        contour = contours[idx]
        cleaned_mask = clean_mask_v2(mask, contour)
        good_markers = good_markers_v1(mask, contour)
        gt = ground_truth[idx]

        plot_list(images=[mask, contour, cleaned_mask, good_markers], labels=[gt])

    # Problem 1 -> building markers on initial mask when we have better mask
    for idx in range(5):
        print(idx)
        mask = masks[idx]
        contour = contours[idx]
        cleaned_mask = clean_mask_v2(mask, contour)
        good_markers = good_markers_v2(cleaned_mask, contour)
        gt = ground_truth[idx]

        plot_list(images=[mask, contour, cleaned_mask, good_markers], labels=[gt])

    # Problem 2 some markers are to large and connected
    m, c, t = dirty
    cleaned_mask = clean_mask_v2(m, c)
    c_b = c > threshold_otsu(c)
    mk_ = np.where(c_b, 0, cleaned_mask)
    plot_list(images=[m, c, mk_], labels=[])

    # For instance the two markers at the top left are still connected and will be treated
    # as a single marker by the watershed And nowe lets erode the markers
    area, radius = mean_blob_size(m_b)
    struct_size = int(0.25 * radius)
    struct_el = morph.disk(struct_size)
    m_padded = pad_mask(mk_, pad=struct_size)
    m_padded = morph.erosion(m_padded, selem=struct_el)
    mk_ = crop_mask(m_padded, crop=struct_size)
    plot_list(images=[m, c, mk_], labels=[])

    # we now compare those markers with the labels we get the following
    mk_, _ = ndi.label(mk_)
    plot_list(images=[cleaned_mask], labels=[mk_, t])


    #########################################################
    # So the markers and cleaned mask look really good!
    #########################################################
    for idx in range(5):
        print(idx)
        mask = masks[idx]
        contour = contours[idx]
        cleaned_mask = clean_mask_v2(mask, contour)
        good_markers = good_markers_v3(cleaned_mask, contour)
        gt = ground_truth[idx]

        plot_list(images=[mask, contour, cleaned_mask], labels=[good_markers, gt])



    # Problem 3 -> still some barely connected markers are left¶
    for idx in [25, 27]:
        print(idx)
        mask = masks[idx]
        contour = contours[idx]
        cleaned_mask = clean_mask_v2(mask, contour)
        good_markers = good_markers_v3(cleaned_mask, contour)
        gt = ground_truth[idx]

        plot_list(images=[mask, contour, cleaned_mask], labels=[good_markers, gt])

    #########################################################################
    # Problem 4 -> we are dropping markers on many images with small cells
    #
    # Ideas
    # - play with binary closing/opening
    # - involve contours and/or centers in this
    # - we will asume that lost markers are in facet small cells that don't need to be divided and
    #   we will get back all the cells that were dropped in watershed
    # - use local maxima on distance transform
    #
    # TODO: good_markers_v4 need to be dev...
    # def good_markers_v4(m_b,c):
    #     return
    #
    #########################################################################

    #####################
    # Good distance
    #####################
    # Here I have no better idea than to use the binary distance from the background.
    # Feel free to improve on that!
    #
    # Idea
    # - investigate imposing some gradients on original image or good clean mask
    #
    for idx in range(5):
        print(idx)
        mask = masks[idx]
        contour = contours[idx]
        cleaned_mask = clean_mask_v2(mask, contour)
        good_markers = good_markers_v3(cleaned_mask, contour)
        good_distance = good_distance_v1(cleaned_mask)
        gt = ground_truth[idx]

        plot_list(images=[cleaned_mask, good_distance], labels=[good_markers, gt])


    ########################
    # Watershed
    ########################
    for idx in range(5):
        print(idx)
        mask = masks[idx]
        contour = contours[idx]
        cleaned_mask = clean_mask_v2(mask, contour)
        good_markers = good_markers_v3(cleaned_mask, contour)
        good_distance = good_distance_v1(cleaned_mask)

        water = watershed_v1(mask, contour)

        gt = ground_truth[idx]

        plot_list(images=[cleaned_mask, good_distance], labels=[good_markers, water, gt])


    # Problem 1 -> some cells are dumped

    # Problem 2 -> some artifacts from mask_cleaning remain
    # Unfortunatelly some cells are dropped, some cells are oversegmented and
    # some artifacts from the mask cleaning still remain.
    # The good thing is we can deal with some of those problems by using ideas we have already tried.
    for idx in range(5):
        print(idx)
        mask = masks[idx]
        contour = contours[idx]
        cleaned_mask = clean_mask_v2(mask, contour)
        good_markers = good_markers_v3(cleaned_mask, contour)
        good_distance = good_distance_v1(cleaned_mask)

        water = watershed_v2(mask, contour)

        gt = ground_truth[idx]

        plot_list(images=[cleaned_mask, good_distance], labels=[good_markers, water, gt])


    # Problem 3 -> some cells are oversemgmented and small cell chunks remain
    # Now some small pieces of cells may remain at this point or the cells could get oversegmented.
    # We will deal with that by dropping to small to be a cell blobs.
    for idx in range(5):
        print(idx)
        mask = masks[idx]
        contour = contours[idx]
        cleaned_mask = clean_mask_v2(mask, contour)
        good_markers = good_markers_v3(cleaned_mask, contour)
        good_distance = good_distance_v1(cleaned_mask)

        water = watershed_v3(mask, contour)

        gt = ground_truth[idx]

        plot_list(images=[cleaned_mask, good_distance], labels=[good_markers, water, gt])

    idx = 0
    train_dir = os.path.join(FLAGS.images_dir, FLAGS.subdir_name)
    for filename in tqdm(glob.glob('{}/*'.format(train_dir))):

        imagename = filename.split("/")[-1]

        mask = masks[idx]
        contour = contours[idx]

        water = watershed_v3(mask, contour)
        img = Image.fromarray(water.astype('uint8'))
        water_path = (filename + '/water/')
        if not os.path.exists(water_path):
            os.makedirs(water_path)
        img.save(os.path.join(water_path, imagename + '.png'))

        '''
        cleaned_mask = clean_mask_v2(mask, contour)
        img = Image.fromarray(cleaned_mask.astype('uint8'))
        cleaned_mask_path = (filename + '/cleaned_mask/')
        if not os.path.exists(cleaned_mask_path):
            os.makedirs(cleaned_mask_path)
        img.save(os.path.join(cleaned_mask_path, imagename + '.png'))

        good_markers = good_markers_v3(cleaned_mask, contour)
        img = Image.fromarray(good_markers)
        good_markers_path = (filename + '/good_markers/')
        if not os.path.exists(good_markers_path):
            os.makedirs(good_markers_path)
        img.save(os.path.join(good_markers_path, imagename + '.png'))

        good_distance = good_distance_v1(cleaned_mask)
        img = Image.fromarray(good_distance.astype('uint8'))
        good_distance_path = (filename + '/good_distance/')
        if not os.path.exists(good_distance_path):
            os.makedirs(good_distance_path)
        img.save(os.path.join(good_distance_path, imagename + '.png'))
        '''
        idx = idx + 1
Exemplo n.º 40
0
        #     pic = erosion(pic, disk(1))

        # thresh = threshold_otsu(pic)*1.0
        thresh = 0.5 * pic.max()  #0.95 * pic.max()

        mask = pic
        h = thresh
        seed = pic - h
        dilated = reconstruction(seed, mask, method='dilation')
        pic = pic - dilated

        if show_plots:
            plt.imshow(pic)
            plt.show()

        thresh = threshold_otsu(pic)
        bin = pic > thresh
        # bin = pic > np.max(pic)/2

        if do_erosion[f]:
            pic = erosion(pic, disk(5))
            pic = erosion(pic, disk(3))
            pic = erosion(pic, disk(1))

        if show_plots:
            plt.imshow(bin)
            plt.show()

        fig = plt.figure()
        plt.imshow(bin)
        plt.savefig(savedir + file + '.png', dpi=600)
Exemplo n.º 41
0
plt.imshow(img, cmap = 'gray', interpolation = 'none')
for c in cts:
  plt.plot(c[:,0], c[:,1])
plt.xlim(0, 151); plt.ylim(0,151)
plt.axis('off')

fig.savefig('pipeline_contour.png', facecolor = 'white')


#curvature
import numpy as np
from skimage.filters import threshold_otsu
from scipy.interpolate import splev, splprep

threshold_factor = 0.95
level = threshold_factor * threshold_otsu(img);
pts = wgeo.detect_contour(img, level)[0];

ncontour = 100
smooth = 1.0
cinterp, u = splprep(pts.T, u = None, s = smooth, per = 1) 
us = np.linspace(u.min(), u.max(), ncontour)
x, y = splev(us[:-1], cinterp, der = 0)

dx, dy = splev(us[:-1], cinterp, der = 1)
d2x, d2y = splev(us[:-1], cinterp, der = 2)
k = (dx * d2y - dy * d2x)/np.power(dx**2 + dy**2, 1.5);

from signalprocessing.peak_detection import find_peaks
nextra = 20;
delta = 0.3
Exemplo n.º 42
0
def otsu(image):
   assert image.ndim == 2
            
   return image >= threshold_otsu(image)
Exemplo n.º 43
0
def register_bands(image, template_band=1, ECC_criterion=True):
    """
    Fix chromatic abberation in images by calculating and applying an affine
    transformation. Chromatic abberation is a result of uneven refraction of light
    of different wavelengths. It shows up as systematic blue and red edges in
    high-contrast areas.

    This should be done before other processing to minimize artifacts.

    Parameters
    ----------
    image : ndarray
        3- or 4-channel image, probably RGB.
    template : int
        Band to which to align the other bands. Usually G in RGB.
    ECC_criterion : bool
        Use ECC criterion to find optimal warp? Improves results, but increases
        processing time 5x.

    Returns
    -------
    An ndarray of `image.size`

    Notes
    -----
    Uses `skimage.filters.scharr` to find edges in each band, then finds and
    applies an affine transformation to register the images using
    `cv2.estimateRigidTransform` and `cv2.warpAffine`. If `ECC_criterion=True`,
    the matrix from `estimateRigidTransform` is updated using `cv2.findTransformECC`.
    """

    #find dimensions
    height, width, depth = image.shape

    #define bands to analyze
    analyze = []
    for i in range(depth):
        if i != template_band:
            analyze.append(i)

    # Extract bands, find edges
    bands = img_split(image)
    edges = [np.ones_like(i) for i in bands]
    for i in range(len(bands)):
        sigma_val = 0.25
        edge_val = 1
        while edge_val > 0.1 and sigma_val < 10:
            temp = filters.gaussian(bands[i], sigma=sigma_val)
            scharr = filters.scharr(temp)
            temp = scharr > filters.threshold_otsu(scharr)
            edge_val = np.sum(temp) / np.sum(np.ones_like(temp))
            sigma_val = 2 * sigma_val
        edges[i] = img_as_ubyte(scharr * temp)

    #make output image
    out = np.zeros((height, width, depth), dtype=np.uint8)
    out[:, :, template_band] = bands[template_band]

    try:
        for i in analyze:
            # Estimate transformation
            warp_matrix = np.array(cv2.estimateRigidTransform(
                edges[template_band], edges[i], fullAffine=False),
                                   dtype=np.float32)

            if ECC_criterion == True:
                # Optimize using ECC criterion and default settings
                warp_matrix = cv2.findTransformECC(edges[template_band],
                                                   edges[i],
                                                   warpMatrix=warp_matrix)[1]
            # transform
            aligned = cv2.warpAffine(
                bands[i],
                warp_matrix,
                (width, height),
                flags=cv2.INTER_LINEAR + cv2.
                WARP_INVERSE_MAP,  # otherwise the transformation goes the wrong way
                borderMode=cv2.BORDER_CONSTANT)

            # add to color image
            out[:, :, i] = aligned

    except:
        # Probably few objects, so no smoothing and no thresholding to have as much info as possible
        edges = [img_as_ubyte(filters.scharr(i)) for i in edges]

        for i in analyze:
            # Estimate transformation
            warp_matrix = np.array(cv2.estimateRigidTransform(
                edges[template_band], edges[i], fullAffine=False),
                                   dtype=np.float32)

            if ECC_criterion == True:
                # Optimize using ECC criterion and default settings
                warp_matrix = cv2.findTransformECC(edges[template_band],
                                                   edges[i],
                                                   warpMatrix=warp_matrix)[1]
            # transform
            aligned = cv2.warpAffine(
                bands[i],
                warp_matrix,
                (width, height),
                flags=cv2.INTER_LINEAR + cv2.
                WARP_INVERSE_MAP,  # otherwise the transformation goes the wrong way
                borderMode=cv2.BORDER_CONSTANT)

            # add to color image
            out[:, :, i] = aligned

    return (img_as_ubyte(out))
Exemplo n.º 44
0
def Workflow_npm1_SR(struct_img,
                     rescale_ratio,
                     output_type,
                     output_path,
                     fn,
                     output_func=None):
    ##########################################################################
    # PARAMETERS:
    #   note that these parameters are supposed to be fixed for the structure
    #   and work well accross different datasets

    intensity_norm_param = [0.05, 32]
    gaussian_smoothing_sigma = 2
    gaussian_smoothing_truncate_range = 3.0
    dot_2d_sigma = 3
    dot_2d_sigma_extra = 1
    dot_2d_cutoff = 0.025
    minArea = 8
    low_level_min_size = 3000
    ##########################################################################

    out_img_list = []
    out_name_list = []

    ###################
    # PRE_PROCESSING
    ###################
    # intenisty normalization (min/max)
    struct_img = intensity_normalization(struct_img,
                                         scaling_param=intensity_norm_param)

    out_img_list.append(struct_img.copy())
    out_name_list.append('im_norm')

    # rescale if needed
    if rescale_ratio > 0:
        struct_img = resize(struct_img, [1, rescale_ratio, rescale_ratio],
                            method="cubic")
        struct_img = (struct_img - struct_img.min() +
                      1e-8) / (struct_img.max() - struct_img.min() + 1e-8)
        gaussian_smoothing_truncate_range = gaussian_smoothing_truncate_range * rescale_ratio

    # smoothing with gaussian filter
    structure_img_smooth = image_smoothing_gaussian_3d(
        struct_img,
        sigma=gaussian_smoothing_sigma,
        truncate_range=gaussian_smoothing_truncate_range)

    out_img_list.append(structure_img_smooth.copy())
    out_name_list.append('im_smooth')

    ###################
    # core algorithm
    ###################

    # step 1: low level thresholding
    global_tri = threshold_triangle(structure_img_smooth)
    global_median = np.percentile(structure_img_smooth, 50)

    th_low_level = (global_tri + global_median) / 2
    bw_low_level = structure_img_smooth > th_low_level
    bw_low_level = remove_small_objects(bw_low_level,
                                        min_size=low_level_min_size,
                                        connectivity=1,
                                        in_place=True)
    bw_low_level = dilation(bw_low_level, selem=ball(2))

    # step 2: high level thresholding
    local_cutoff = 0.333 * threshold_otsu(structure_img_smooth)
    bw_high_level = np.zeros_like(bw_low_level)
    lab_low, num_obj = label(bw_low_level, return_num=True, connectivity=1)
    for idx in range(num_obj):
        single_obj = (lab_low == (idx + 1))
        local_otsu = threshold_otsu(structure_img_smooth[single_obj])
        if local_otsu > local_cutoff:
            bw_high_level[np.logical_and(
                structure_img_smooth > 0.98 * local_otsu, single_obj)] = 1

    out_img_list.append(bw_high_level.copy())
    out_name_list.append('bw_coarse')

    response_bright = dot_slice_by_slice(structure_img_smooth,
                                         log_sigma=dot_2d_sigma)

    response_dark = dot_slice_by_slice(1 - structure_img_smooth,
                                       log_sigma=dot_2d_sigma)
    response_dark_extra = dot_slice_by_slice(1 - structure_img_smooth,
                                             log_sigma=dot_2d_sigma_extra)

    holes = np.logical_or(response_dark > dot_2d_cutoff,
                          response_dark_extra > dot_2d_cutoff)

    bw_extra = response_bright > dot_2d_cutoff
    bw_extra[~bw_low_level] = 0

    bw_final = np.logical_or(bw_extra, bw_high_level)
    bw_final[holes] = 0

    ###################
    # POST-PROCESSING
    ###################
    seg = remove_small_objects(bw_final,
                               min_size=minArea,
                               connectivity=1,
                               in_place=True)

    # output
    seg = seg > 0
    seg = seg.astype(np.uint8)
    seg[seg > 0] = 255

    out_img_list.append(seg.copy())
    out_name_list.append('bw_fine')

    if output_type == 'default':
        # the default final output
        save_segmentation(seg, False, output_path, fn)
    elif output_type == 'AICS_pipeline':
        # pre-defined output function for pipeline data
        save_segmentation(seg, True, output_path, fn)
    elif output_type == 'customize':
        # the hook for passing in a customized output function
        output_fun(out_img_list, out_name_list, output_path, fn)
    elif output_type == 'array':
        return seg
    elif output_type == 'array_with_contour':
        return (seg, generate_segmentation_contour(seg))
    else:
        # the hook for pre-defined RnD output functions (AICS internal)
        img_list, name_list = NPM1_output(out_img_list, out_name_list,
                                          output_type, output_path, fn)
        if output_type == 'QCB':
            return img_list, name_list
# reading multiple images for the same wound at different times
# calculating the healing rate and other stats
from skimage import io
from matplotlib import pyplot as plt
import numpy as np
from skimage.filters.rank import entropy
from skimage.morphology import disk
from skimage.filters import threshold_otsu
import glob
from scipy.stats import linregress

time = 0
time_list = []
area_list = []
path = "ImageProcessing/Images/Wounds/*"

for img_file in glob.glob(path):
    img = io.imread(img_file, as_gray=True)
    entropy_img = entropy(img, disk(40))
    thresh = threshold_otsu(entropy_img)  # auto thresholding method
    binary = entropy_img <= thresh
    scratch_area = np.sum(binary == True)
    print(time, scratch_area)
    time_list.append(time)
    area_list.append(scratch_area)
    time += 1
print(time_list, area_list)
plt.plot(time_list, area_list, 'ro')
print(linregress(time_list, area_list))
plt.show()
import matplotlib.pyplot as plt

os.chdir('/home/sambeet/data/kaggle/carvana/')

image_list = os.listdir('train_resized/')

x = misc.imread('train_resized/' + image_list[0],flatten = True)
hist = np.histogram(x, bins=np.arange(0, 256))
plt.plot(hist[1][:-1], hist[0], lw=2)
z = filters.scharr((x/255.))
#z = filters.gaussian(z,1.)
z = canny(z,1)
z = ndi.binary_closing(z,structure=np.ones((3,3)))
z = ndi.binary_fill_holes(z,np.ones((3,3)))
io.imshow(z)
z = filters.prewitt((x-127.5)/255.)
z = filters.scharr((x-127.5)/255.)
x = abs(x - 127.5)/127.5
threshold_li = filters.threshold_yen((x))
threshold_li = filters.threshold_otsu(x)
threshold_li = filters.threshold_isodata(x)
z = x > threshold_li
io.imshow(z)
x = misc.imread('train/' + image_list[0],flatten = True)
x = abs(x - 127.5)/127.5
#x_rgb = misc.imread('train/' + image_list[0])
threshold_li = filters.try_all_threshold(z1)
z = x > threshold_li
io.imshow((z -.5))
z1 = filters.rank.autolevel((x-127.5)/127.5,disk(20))
Exemplo n.º 47
0
def binarize(image):
    thresh = threshold_otsu(image)
    binary = image <= thresh
    return binary
Exemplo n.º 48
0
# .. [4] http://en.wikipedia.org/wiki/Otsu's_method

from skimage.filters.rank import otsu
from skimage.filters import threshold_otsu

p8 = data.page()

radius = 10
selem = disk(radius)

# t_loc_otsu is an image
t_loc_otsu = otsu(p8, selem)
loc_otsu = p8 >= t_loc_otsu

# t_glob_otsu is a scalar
t_glob_otsu = threshold_otsu(p8)
glob_otsu = p8 >= t_glob_otsu

fig, axes = plt.subplots(2, 2, sharex=True, sharey=True)
ax = axes.ravel()

fig.colorbar(ax1.imshow(p8, cmap=plt.cm.gray), ax=ax1)
ax[0].set_title('Original')

fig.colorbar(ax[1].imshow(t_loc_otsu, cmap=plt.cm.gray), ax=ax2)
ax[1].set_title('Local Otsu ($r=%d$)' % radius)

ax[2].imshow(p8 >= t_loc_otsu, cmap=plt.cm.gray)
ax[2].set_title('Original >= local Otsu' % t_glob_otsu)

ax[3].imshow(glob_otsu, cmap=plt.cm.gray)
               mode='constant',
               preserve_range=True))

# This will be our final dataframe
df = pd.DataFrame(columns=["ImageID", "EncodedPixels"])

j = 0
# RLE encode the test data
for n, id_ in tqdm(enumerate(test_ids), total=len(test_ids)):

    image_id = id_
    image_label = preds_test_upsampled[j]

    #CONVERT PROBABILISTIC PREDICTION TO BINARY
    from skimage.filters import threshold_otsu
    thresh_val = threshold_otsu(image_label)
    newmask = np.where(image_label > thresh_val, 1, 0)

    add_to_df = RLE_mask(newmask, image_id, df)
    df = df.append(add_to_df, ignore_index=True)
    j += 1

print(df)
df.to_csv('CNNsubmission.csv', index=False)

#See stuff
image_label = preds_test_upsampled[0]

#CONVERT PROBABILISTIC PREDICTION TO BINARY
from skimage.filters import threshold_otsu
thresh_val = threshold_otsu(image_label)
###########################################################
#Entropy
#Entropy quantifies disorder.
#Since cell region has high variation in pixel values the entropy would be
#higher compared to scratch region
from skimage.filters.rank import entropy
from skimage.morphology import disk

entropy_img = entropy(img, disk(3))
plt.imshow(entropy_img)

#Scratch Analysis - single image
#Now let us use otsu to threshold high vs low entropy regions.
plt.hist(entropy_img.flat, bins=100,
         range=(0, 5))  #.flat returns the flattened numpy array (1D)

thresh = threshold_otsu(entropy_img)

#Now let us binarize the entropy image
binary = entropy_img <= thresh
plt.imshow(binary)

#Sum all pixels in the scratch region (values =1)
scratch_area = np.sum(binary == 1)
print("Scratched area is: ", scratch_area, "Square pixels")

scale = 0.45  # microns/pixel
print("Scratched area in sq. microns is: ", scratch_area * ((scale)**2),
      "Square pixels")
   x=x_train,
   y=y_train,
   batch_size=BATCH_SIZE_GLOBAL,
   epochs=NUMERO_EPOCAS_GLOBAL,
   callbacks=callbacks, 
   validation_data=(x_val, y_val),
)

fim = time.time()
tempo_processamento = fim-inicio
print("TEMPO DE PROCESSAMENTO: ",tempo_processamento)

###### TESTA
predicoes = model.predict(x_test)

predicoes= (np.asarray(predicoes)> threshold_otsu(np.asarray(predicoes)))

# calcular metricas do teste
sensitivity,specificity,accuracy,auc,dice,jaccard = calc_metric(y_test,predicoes[:,:,:,0])


print("############## RESULTADO FINAL ##############")
print("sensitivity:",sensitivity)
print("specificity:",specificity)
print("accuracy:",accuracy)
print("auc:",auc)
print("dice:",dice)
print("jaccard:",jaccard)
print(PASTA_DE_TESTES)

# SALVAR RESULTADOS
Exemplo n.º 52
0
#carrega a base de dados
digitsdb = datasets.load_digits()

#armazena as imagens e os rótulos em estruturas distintas
digits = np.array(digitsdb.images, 'int16')
targets = np.array(digitsdb.target)

#inicializa vetores que irão armazenar os descritores
d0 = []
d1 = []

#para cada imagem, extrai descritores
for image in digits:

    #forma de binarização 1
    thresh = threshold_otsu(image)
    binary = image > thresh
    #forma de binarização 2
    #binary = image != 0  ## << Tire este comentário para fazer o exercício!

    label_img = label(binary)

    #se quiser ver as figuras
    #plt.figure(1, figsize=(3, 3))
    #plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    #plt.show()

    regions = regionprops(label_img, coordinates='xy')

    for props in regions:
        d0.append(props.eccentricity)
Exemplo n.º 53
0
# scaler = StandardScaler()
scaler = MinMaxScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

knn = KNN(X_train, X_test, y_train, y_test)
msv = SVM(X_train, X_test, y_train, y_test)

for name in glob.glob('placas/*'):
    car_image = imread(name)
    gray = cv2.cvtColor(car_image, cv2.COLOR_BGR2GRAY)

    color = cv2.cvtColor(car_image, cv2.COLOR_BGR2RGB)

    threshold_value = threshold_otsu(gray)
    binary_car_image = gray > threshold_value
    # fig, (ax1, ax2) = plt.subplots(1, 2)
    # ax1.imshow(gray, cmap="gray")
    # ax2.imshow(binary_car_image, cmap="gray")

    # this gets all the connected regions and groups them together
    label_image = measure.label(binary_car_image)

    plate_dimensions = (0.06 * label_image.shape[0],
                        0.1 * label_image.shape[0],
                        0.06 * label_image.shape[1],
                        0.09 * label_image.shape[1])

    min_height, max_height, min_width, max_width = plate_dimensions
    plate_objects_cordinates = []
Exemplo n.º 54
0
def convertHatchedImageToSTL(imageurl):
    image = cv2.imread(imageurl)
    ''''
    # generate copy of original image
    im1 = image.copy()
    # decrease contrast to emboss lines
    ob = preprocess(im1)
    # decrease contrast to emboss lines
    im1 = ob.ChangeContrast(0.5)
    # blur to emboss edges
    im1 = ob.Blur()
    # define kernel for dilate
    kernel = np.ones((5, 5), np.uint8)
    # morphology operations for separating outer lines
    opening = cv2.morphologyEx(im1, cv2.MORPH_OPEN, kernel)
    # detect edges for dilation
    edges = cv2.Canny(opening, 100, 150)

    # img = np.array(image, dtype=np.uint8)
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Perform 'closing' morphological operation on the image
    kernel = np.ones((1, 1), np.uint8)
    gray_image = cv2.morphologyEx(gray_image, cv2.MORPH_CLOSE, kernel)

    # Figure out the scaling parameter according to original size and then scale
    scale = prop.get_scaling_factor()
    gray_image = cv2.resize(gray_image, (0, 0), fx=scale, fy=scale)

    # Normalize all pixels to assume values from 0 to 1
    gray_image = gray_image / 255.0
    gray_image = np.subtract(1.0, gray_image)

    # Find the threshold to separate foreground from background using OTSU's thresholding method
    threshold = threshold_otsu(gray_image)
    (rows, cols) = gray_image.shape
    '''
    textons = Textons(image, 3, 10, 1)
    tex = textons.textons()
    show = np.zeros_like(image)
    colors = np.unique(tex)
    show[tex == colors[1]] = [0, 0, 255]
    show[tex == colors[2]] = [0, 255, 255]
    show = cv2.medianBlur(show, 5)

    cv2.imwrite('temp.jpg', show)

    distinct_colors = color_extractor.get_top_colors_hsv(show, 10)

    ui.assign_height_to_colors(distinct_colors, 'temp.jpg')

    hsv_image = color_converter.get_hsv_from_bgr_image(show)
    gray_image = convert_from_colored_to_gray(hsv_image, distinct_colors)

    gray_image = cv2.medianBlur(gray_image, 3)

    # Perform 'closing' morphological operation on the image
    kernel = np.ones((1, 1), np.uint8)
    gray_image = cv2.morphologyEx(gray_image, cv2.MORPH_CLOSE, kernel)

    # Figure out the scaling parameter according to original size and then scale
    scale = prop.get_scaling_factor()
    gray_image = cv2.resize(gray_image, (0, 0), fx=scale, fy=scale)

    # Find the threshold to separate foreground from background using OTSU's thresholding method
    threshold = threshold_otsu(gray_image)
    (rows, cols) = gray_image.shape
    '''
    Create a 3D voxel data from the image
    The top-most (#1) and bottom-most (#13) layer will contain all zeros
    The middle 10 layers (#3 to #12) contain the same pixel values as the gray scale image
    There is an additional layer(#2) for the base of the model 
    '''
    layers = 13
    rows += 2
    cols += 2
    voxel = np.zeros((rows, cols, layers))
    voxel[:, :, 1] = np.ones((rows, cols)).astype('float32')

    # making the boundary voxel values to be zero, for the marching cubes algorithm to work correctly
    voxel[0, :, :] = np.zeros((cols, layers)).astype('float32')
    voxel[(rows - 1), :, :] = np.zeros((cols, layers)).astype('float32')

    voxel[:, 0, :] = np.zeros((rows, layers)).astype('float32')
    voxel[:, (cols - 1), :] = np.zeros((rows, layers)).astype('float32')
    '''
    Create the middle 10 layers from the image
    Based on the pixel values the layers are created to assign different heights to different regions in the image
    '''
    for level in range(1, 10):
        level_threshold = level * 0.1
        for j in range(0, rows - 2):
            for k in range(0, cols - 2):
                pixel_value = gray_image[j][k]
                if pixel_value > level_threshold:
                    voxel[j + 1][k + 1][level + 1] = pixel_value
    '''
    Run the marching cubes algorithm to extract surface mesh from 3D volume. Params:
        volume : (M, N, P) array of doubles
            Input data volume to find isosurfaces. Will be cast to `np.float64`.
        level : float
            Contour value to search for isosurfaces in `volume`. If not
            given or None, the average of the min and max of vol is used.
        spacing : length-3 tuple of floats
            Voxel spacing in spatial dimensions corresponding to numpy array
            indexing dimensions (M, N, P) as in `volume`.
        gradient_direction : string
            Controls if the mesh was generated from an isosurface with gradient
            descent toward objects of interest (the default), or the opposite.
            The two options are:
            * descent : Object was greater than exterior
            * ascent : Exterior was greater than object
    '''
    verts, faces, normals, values = measure.marching_cubes_lewiner(
        volume=voxel,
        level=threshold,
        spacing=(1., 1., 1.),
        gradient_direction='descent')

    # Export the mesh as stl
    mymesh = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))

    for i, f in enumerate(faces):
        for j in range(3):
            mymesh.vectors[i][j] = verts[f[j], :]

    file_utils.save_mesh_to_file(imageurl, mymesh)
Exemplo n.º 55
0
except:
    print("File doesn't exists - Terminating process")
    exit(0)

# Load the car image with license plate
car_img = imread("./output/frame%d.jpg" % (count - 1), as_gray=True)
# Normalizing the pixles
gray_img = car_img * 255
# Defining subplots
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle('Processed Images')
ax1.imshow(gray_img, cmap='gray')
ax1.set_title('Gray Image')
# Performing Otsu Thresholding (To separate foreground / background)
# Read more : https://en.wikipedia.org/wiki/Otsu%27s_method
threshold_val = threshold_otsu(gray_img)
# Each pixel of binary image is True (1) if the corresponding pixel in
# gray image has intensity value greater than thrrshold_val
binary_img = gray_img > threshold_val
ax2.imshow(binary_img, cmap='gray')
ax2.set_title('Binary Image')
plt.show()


def predict():
    license_plate = binary_img
    # license_plate = SegmentChars.DetectPlateImage.plate_objects[0] # For image processing
    plate = pytesseract.image_to_string(license_plate).strip(
        ' !@#$%^&*()_+{\\}\\[];/><,.-')
    print("License plate is :{}".format(plate))
    print("\n\n\n")
Exemplo n.º 56
0
def Base_Datos():
    Momentos = []
    Etiquetas = []
    for name in glob.glob('test_train/*'):
        car_image = imread(name)

        gray = cv2.cvtColor(car_image, cv2.COLOR_BGR2GRAY)
        gray = cv2.GaussianBlur(gray, (1, 1), 0)
        color = cv2.cvtColor(car_image, cv2.COLOR_BGR2RGB)
        ret, binaria = cv2.threshold(gray, 0, 255,
                                     cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

        threshold_value = threshold_otsu(gray)
        binary_car_image = gray > threshold_value

        license_plate = np.invert(binary_car_image)
        labelled_plate = measure.label(license_plate)
        character_dimensions = (0.3 * license_plate.shape[0],
                                0.55 * license_plate.shape[0],
                                0.1 * license_plate.shape[1],
                                0.25 * license_plate.shape[1])
        min_height, max_height, min_width, max_width = character_dimensions

        fig, ax1 = plt.subplots(1)
        ax1.imshow(license_plate, cmap="gray")

        characters = []
        counter = 11
        for regions in regionprops(labelled_plate):
            y0, x0, y1, x1 = regions.bbox
            y0 -= 1
            region_height = y1 - y0
            region_width = x1 - x0

            if region_height > min_height and region_height < max_height and region_width > min_width and region_width < max_width:
                roi = binaria[y0:y1, x0:x1]

                rect_border = patches.Rectangle((x0, y0),
                                                x1 - x0,
                                                y1 - y0,
                                                edgecolor="red",
                                                linewidth=2,
                                                fill=False)
                ax1.add_patch(rect_border)

                # resize the characters to 20X20 and then append each character into the characters list
                resized_char = resize(roi, (20, 20))
                characters.append(resized_char)
                Etiquetas.append(name[counter])
                counter += 1

        plt.show()

        for x in range(len(characters)):

            # Tradon = radon(characters[x], theta=np.arange(0,210,30), circle=True).flatten()
            Firma = characters[x].flatten()
            # Hu = cv2.HuMoments(cv2.moments(characters[x])).flatten()
            # Momentos.append(np.concatenate((Tradon, Firma,Hu), axis=None))

            Momentos.append(Firma)
            if x == 0:
                fig, ax1 = plt.subplots(1)
                ax1.imshow(characters[x], cmap="binary_r")

    letters = [
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
        'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
        'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
    ]
    nums = [
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35
    ]
    for letra in range(len(Etiquetas)):
        for x in range(len(letters)):
            if Etiquetas[letra] == letters[x]:
                Etiquetas[letra] = nums[x]

    X = np.array(Momentos)
    Y = np.array(Etiquetas)
    return X, Y
except IndexError:
    entrada = 'img_entrada.tif'

try:
    saida = sys.argv[2]
except IndexError:
    saida = 'img_saida.tif'

# Faz a leitura da imagem
img_entrada = misc.imread(entrada)

# Converte os pixels em float, com valores entre 0 e 1
img_entrada = img_as_float(img_entrada.astype(np.uint8))

# Limiar de Otsu
l_otsu = filters.threshold_otsu(img_entrada)

# Segmenta a imagem por limiarização
img_saida = img_entrada < l_otsu

# Faz o salvamento das imagens de saída após o processamento
misc.imsave(saida, img_saida.astype(np.uint8))

# Organiza o plote das imagens
plt.figure()
plt.subplot(221)
plt.imshow(img_entrada, cmap='gray', interpolation='nearest')
plt.title('img_entrada')
plt.subplot(222)
plt.imshow(img_saida, cmap='gray', interpolation='nearest')
plt.title('img_saida')
def find_patches_from_slide(slide_path, filter_non_tissue=True):
    """Returns a dataframe of all patches in slide
    input: slide_path: path to WSI file
    output: samples: dataframe with the following columns:
        slide_path: path of slide
        is_tissue: sample contains tissue
        is_tumor: truth status of sample
        tile_loc: coordinates of samples in slide
        
    
    option: base_truth_dir: directory of truth slides
    option: filter_non_tissue: Remove samples no tissue detected
    """

    #sampletotal = pd.DataFrame([])
    #base_truth_dir = Path(BASE_TRUTH_DIR)
    #anno_path = Path(anno_path)
    #slide_contains_tumor = osp.basename(slide_paths[i]).startswith('tumor_')
    print(slide_path)

    dimensions = []

    with openslide.open_slide(slide_path) as slide:
        dtotal = (slide.dimensions[0] / 224, slide.dimensions[1] / 224)
        thumbnail = slide.get_thumbnail((dtotal[0], dtotal[1]))
        thum = np.array(thumbnail)
        ddtotal = thum.shape
        dimensions.extend(ddtotal)
        hsv_image = cv2.cvtColor(thum, cv2.COLOR_BGR2HSV)
        h, s, v = cv2.split(hsv_image)
        hthresh = threshold_otsu(h)
        sthresh = threshold_otsu(s)
        vthresh = threshold_otsu(v)
        # be min value for v can be changed later
        minhsv = np.array([hthresh, sthresh, 70], np.uint8)
        maxhsv = np.array([180, 255, vthresh], np.uint8)
        thresh = [minhsv, maxhsv]
        #extraction the countor for tissue

        rgbbinary = cv2.inRange(hsv_image, thresh[0], thresh[1])
        _, contours, _ = cv2.findContours(rgbbinary, cv2.RETR_EXTERNAL,
                                          cv2.CHAIN_APPROX_SIMPLE)
        bboxtcols = ['xmin', 'xmax', 'ymin', 'ymax']
        bboxt = pd.DataFrame(columns=bboxtcols)
        for c in contours:
            (x, y, w, h) = cv2.boundingRect(c)
            bboxt = bboxt.append(pd.Series([x, x + w, y, y + h],
                                           index=bboxtcols),
                                 ignore_index=True)
            bboxt = pd.DataFrame(bboxt)

        xxmin = list(bboxt['xmin'].get_values())
        xxmax = list(bboxt['xmax'].get_values())
        yymin = list(bboxt['ymin'].get_values())
        yymax = list(bboxt['ymax'].get_values())

        xxxmin = np.min(xxmin)
        xxxmax = np.max(xxmax)
        yyymin = np.min(yymin)
        yyymax = np.max(yymax)

        dcoord = (xxxmin, xxxmax, yyymin, yyymax)

        dimensions.extend(dcoord)

        # bboxt = math.floor(np.min(xxmin)*256), math.floor(np.max(xxmax)*256), math.floor(np.min(yymin)*256), math.floor(np.max(yymax)*256)

        samplesnew = pd.DataFrame(
            pd.DataFrame(np.array(thumbnail.convert('L'))))
        print(samplesnew)
        # very critical: y value is for row, x is for column
        samplesforpred = samplesnew.loc[yyymin:yyymax, xxxmin:xxxmax]

        dsample = samplesforpred.shape

        dimensions.extend(dsample)

        np.save(
            'dimensions_%s' % (osp.splitext(osp.basename(slide_paths[i]))[0]),
            dimensions)

        print(samplesforpred)

        samplesforpredfinal = pd.DataFrame(samplesforpred.stack())

        print(samplesforpredfinal)

        samplesforpredfinal['tile_loc'] = list(samplesforpredfinal.index)

        samplesforpredfinal.reset_index(inplace=True, drop=True)

        samplesforpredfinal['slide_path'] = slide_paths[i]

        print(samplesforpredfinal)

    return samplesforpredfinal
Exemplo n.º 59
0
#            T. Y. Zhang and C. Y. Suen, Communications of the ACM,
#            March 1984, Volume 27, Number 3.
#
# .. [Lee94] T.-C. Lee, R.L. Kashyap and C.-N. Chu, Building skeleton models
#            via 3-D medial surface/axis thinning algorithms.
#            Computer Vision, Graphics, and Image Processing, 56(6):462-478,
#            1994.

import matplotlib.pyplot as plt
from skimage.morphology import skeletonize, skeletonize_3d
from skimage.io import imread
from skimage.filters import threshold_otsu

data = imread('CharImage/hangul_882.jpeg')

global_thresh = threshold_otsu(data)
binary_global = data > global_thresh

data = binary_global

skeleton = skeletonize(data)
skeleton3d = skeletonize_3d(data)

fig, axes = plt.subplots(1, 3, figsize=(8, 4), sharex=True, sharey=True)
ax = axes.ravel()

ax[0].imshow(data, cmap=plt.cm.gray, interpolation='nearest')
ax[0].set_title('original')
ax[0].axis('off')

ax[1].imshow(skeleton, cmap=plt.cm.gray, interpolation='nearest')
Exemplo n.º 60
0
x_pixel = 6556
y_pixel = 4227

distance = 100

# plt.imsave(r'C:\Users\owner\Desktop\dataset\test.jpg',
#            image[y_pixel - 20:y_pixel + 20, x_pixel - 20:x_pixel + 20, :])
#
# cc=filters.threshold_otsu(image[:,:,0])

cell_matrix = image[:, :, 0][y_pixel - distance:y_pixel + distance, x_pixel - distance:x_pixel + distance]
# plt.imsave("check.jpg",image[y_pixel - distance:y_pixel + distance, x_pixel - distance:x_pixel + distance,:])
x,y=cell_matrix.shape
print("image mean is : ", cell_matrix[cell_matrix>0].mean())
pixel_to_mictoMeter=0.203125
val = filters.threshold_otsu(cell_matrix[cell_matrix>0])
plt.figure(figsize=(20, 20))
plt.subplot(141)
plt.title("histogram")
ax = plt.gca()
range=cell_matrix.max()
plt.hist(cell_matrix.ravel(),range,[0,range])
# print ("threshold whole image is : "+ str(cc))
#
# print (cell_matrix.std())
#
# threshold=val+1*cell_matrix.std()
#
# print("threshold=",threshold)
# plt.imshow(cell_matrix>threshold, cmap='gray')
# print("ostu threshold is :",val)