Example #1
0
def count_bubble(image_filename, ref_filename, plot_show = 0):
    
    image = io.imread(gv.__DIR__ + gv.__TrainImageDir__ + \
                      image_filename)
    ref_image = io.imread(gv.__DIR__ + gv.__TrainImageDir__ + \
                      ref_filename)

    image_gray = rgb2gray(image)
    ref_gray = rgb2gray(ref_image)

    # Constants
    Window_Size = 5
           
    pre_image = pre.noise_reduction(image_gray,
                                    ref_gray,
                                    Window_Size,
                                    mode = 0)
    seg_image = segmentation(pre_image,'self_design')
    perimeters = perimeter_exaction(seg_image, image, image_filename)
    if(plot_show == 1):
        fig, ax = plt.subplots(1,3)
        ax[0].imshow(image)
        ax[0].set_title('Original')
        ax[1].imshow(seg_image, cmap=plt.cm.gray)
        ax[1].set_title('Segmentation')
        result = io.imread(gv.__DIR__ + gv.cu__image_dir + image_filename)
        ax[2].imshow(result)
        ax[2].set_title('Result')
        plt.show()
       
    return perimeters
Example #2
0
def main():
    try:
        # Default Parameters
        if len(sys.argv) <= 1:
            print 'Error: Filename Required'  
        if len(sys.argv) == 2:
            print 'Error: Background Filename Required'
        if len(sys.argv) >= 3:

            # Constants
            Radius_Template        = 25
            Sigma_Gaussian_Filter  = 2
            Sigma_Canny_Filter     = 5
            Window_Size            = 5
            Combine_Thre           = 15
            
            # Load Image
            start_time = time.time()
            print 'Reading the image: %s' % sys.argv[1]
            
            image_name = sys.argv[1]
            ref_name   = sys.argv[2]
            
            image = rgb2gray(io.imread(sys.argv[1]))
            ref = rgb2gray(io.imread(sys.argv[2]))
        
            elapse_time = (time.time()-start_time)
            print 'Pre Processing .. %s' % elapse_time
            
            
            part_image, region, angle = \
                 pre.interest_region(image, plot_image = 0)
            ref_rotate = rotate(ref,angle)
            part_ref = ref_rotate[region[0]:region[1], region[2]:region[3]]
            
            pre_image = pre.noise_reduction(part_image, part_ref, \
                                            Window_Size, mode = 0)

            seg_image=segmentation(part_image,'self_design')
            
            edge =  canny(part_image, sigma = 3)
        
            contours = measure.find_contours(seg_image, 0)
            perimeters = perimeter_exaction(seg_image, part_image, \
                                            plot_show = 0)
            perimeters = combine_circle(perimeters,Combine_Thre)
        
            fig, ax = plt.subplots(2,3)
            ax[0,0].imshow(image,cmap=plt.cm.gray)
            ax[0,0].set_title('Original Image')
            ax[0,1].imshow(part_image,cmap=plt.cm.gray)
            ax[0,1].set_title('Object Extaction')
            ax[0,2].imshow(pre_image,cmap=plt.cm.gray)
            ax[0,2].set_title('Median Filter and Denosing')
            ax[1,0].imshow(seg_image,cmap=plt.cm.gray)
            ax[1,0].set_title('Segmentation')
            for n, contour in enumerate(contours):
                ax[1,1].plot(contour[:,1],contour[:,0],color='black')
            ax[1,1].axis('equal')
            ax[1,1].invert_yaxis()
            ax[1,1].set_title('Edges')
            ax[1,2].imshow(part_image,cmap=plt.cm.gray)
            ax[1,2].set_title('Circle Recognition')
            for i in range(0,len(perimeters)):
                [x, y, r] = perimeters[i]
                c = plt.Circle((x, y), r, color='red', linewidth=2, fill=False) 
                ax[1,2].add_patch(c)
            plt.show()
            print 'Succesfully Analized Image File: %s' % sys.argv[1]

    except KeyboardInterrupt:
        print "Shutdown requested... exiting"
    except Exception:
        traceback.print_exc(file=sys.stdout)
    sys.exit(0)