def _region_features_for(histone, dna, region):
    pixels0 = histone[region].ravel()
    pixels1 = dna[region].ravel()
    bin0 = pixels0 > histone.mean()
    bin1 = pixels1 > dna.mean()
    overlap = [np.corrcoef(pixels0, pixels1)[0, 1], (bin0 & bin1).mean(), (bin0 | bin1).mean()]

    spi = mh.sobel(histone, just_filter=1)
    sp = spi[mh.erode(region)]
    sdi = mh.sobel(dna, just_filter=1)
    sd = sdi[mh.erode(region)]
    sobels = [
        np.dot(sp, sp) / len(sp),
        np.abs(sp).mean(),
        np.dot(sd, sd) / len(sd),
        np.abs(sd).mean(),
        np.corrcoef(sp, sd)[0, 1],
        np.corrcoef(sp, sd)[0, 1] ** 2,
        sp.std(),
        sd.std(),
    ]

    return np.concatenate(
        [
            [region.sum()],
            haralick(histone * region, ignore_zeros=True).mean(0),
            haralick(dna * region, ignore_zeros=True).mean(0),
            overlap,
            sobels,
            haralick(mh.stretch(sdi * region), ignore_zeros=True).mean(0),
            haralick(mh.stretch(spi * region), ignore_zeros=True).mean(0),
        ]
    )
Exemple #2
0
def test_se_zeros():
    np.random.seed(35)
    f = np.random.random((128, 128)) > 0.9
    f2 = np.dstack([f, f, f])
    mahotas.erode(f, np.zeros((3, 3)))
    mahotas.dilate(f, np.zeros((3, 3)))
    mahotas.erode(f2[:, :, 1], np.zeros((3, 3)))
    mahotas.dilate(f2[:, :, 1], np.zeros((3, 3)))
Exemple #3
0
def test_close_holes_simple():
    img = np.zeros((64,64),bool)
    img[16:48,16:48] = True
    holed =  (img - mahotas.erode(mahotas.erode(img)))
    assert np.all( mahotas.close_holes(holed) == img)
    holed[12,12] = True
    img[12,12] = True
    assert np.all( mahotas.close_holes(holed) == img)
    assert sys.getrefcount(holed) == 2
def test_cerode():
    from mahotas.tests.pymorph_copy import erode as slow_erode
    from mahotas.tests.pymorph_copy import dilate as slow_dilate
    np.random.seed(334)
    f = np.random.random_sample((128,128))
    f = (f > .9)
    assert np.all(mahotas.erode(f) == mahotas.cerode(f, np.zeros_like(f)))
Exemple #5
0
def test_dilate_erode():
    A = np.zeros((128, 128), dtype=bool)
    Bc = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]], bool)
    A[32, 32] = True
    origs = []
    for i in range(12):
        origs.append(A.copy())
        A = mahotas.dilate(A, Bc)
    for i in range(12):
        A = mahotas.erode(A, Bc)
        assert np.all(A == origs[-i - 1])
Exemple #6
0
def test_fast_binary():
    # This test is based on an internal code decision: the fast code is only triggered for CARRAYs
    # Therefore, we test to see if both paths lead to the same result
    np.random.seed(34)
    for i in xrange(8):
        f = np.random.random((128,128)) > .9
        f2 = np.dstack([f,f,f])

        SEs = [
            np.ones((3,3)),
            np.ones((5,5)),
            np.array([
                    [0,1,0],
                    [0,0,0],
                    [0,0,0]]),
            np.array([
                    [0,0,0],
                    [1,0,0],
                    [0,0,0]]),
            np.array([
                    [1,0,0],
                    [1,0,0],
                    [0,0,0]]),
            np.array([
                    [1,1,1],
                    [1,1,1],
                    [1,1,0]]),
            np.array([
                    [1,1,1],
                    [0,1,1],
                    [1,1,0]]),
            ]
        for Bc in SEs:
            assert np.all(mahotas.erode(f,Bc=Bc) == mahotas.erode(f2[:,:,1],Bc=Bc))
            # For dilate, the border conditions are different;
            # This is not great, but it's actually the slow implementation
            # which has the most unsatisfactory behaviour:
            assert np.all(mahotas.dilate(f,Bc=Bc)[1:-1,1:-1] == mahotas.dilate(f2[:,:,1],Bc=Bc)[1:-1,1:-1])
def test_dilate_erode():
    A = np.zeros((100,100))
    Bc = np.array([
        [0, 1, 0],
        [1, 1, 1],
        [0, 1, 0]], bool)
    A[30,30] = 1
    A = (A!=0)
    orig = A.copy()
    for i in xrange(12):
        A = mahotas.dilate(A, Bc)
    for i in xrange(12):
        A = mahotas.erode(A, Bc)
    assert np.all(A == orig)
Exemple #8
0
def mahotas_clean_up_seg(input_jacobian,frame_num):
    import mahotas as mh
    dsk = mh.disk(7)
    thresh_r = 0.1
    thresh_g = 1
    size_cutoff = 200
    
    thresholded_jacobian = (np.int32(np.log(1+input_jacobian[frame_num][0])>thresh_r)+\
                            np.int32(np.log(1+input_jacobian[frame_num][1])>thresh_g))>0
    thresholded_jacobian = mh.close_holes(thresholded_jacobian)
    thresholded_jacobian = mh.erode(thresholded_jacobian,dsk)
    labeled = mh.label(thresholded_jacobian)[0]
    sizes = mh.labeled.labeled_size(labeled)
    too_small = np.where(sizes < size_cutoff)
    labeled = mh.labeled.remove_regions(labeled, too_small)
    thresholded_jacobian = labeled>0
    thresholded_jacobian = mh.dilate(thresholded_jacobian,dsk)
    return thresholded_jacobian
def test_grey_erode():
    from mahotas.tests.pymorph_copy import erode as slow_erode
    from mahotas.tests.pymorph_copy import dilate as slow_dilate
    np.random.seed(334)
    for i in range(8):
        f = np.random.random_sample((128,128))
        f *= 255
        f = f.astype(np.uint8)
        B = (np.random.random_sample((3,3))*255).astype(np.uint8)
        B //= 4
        fast = mahotas.erode(f,B)
        slow = slow_erode(f,B)
        # mahotas & pymorph use different border conventions.
        assert np.all(fast[1:-1,1:-1] == slow[1:-1,1:-1])

        fast = mahotas.dilate(f,B)
        slow = slow_dilate(f,B)
        # mahotas & pymorph use different border conventions.
        assert np.all(fast[1:-1,1:-1] == slow[1:-1,1:-1])
def create_membrane_and_background_images():
    for purpose in ['train','validate','test']:
        #img_search_string = '/media/vkaynig/NewVolume/IAE_ISBI2012/ground_truth/' + purpose + '/*.tif'
        img_search_string = '/media/vkaynig/Data1/Cmor_paper_data/labels/' + purpose + '/*.tif'
#        img_gray_search_string = '/media/vkaynig/NewVolume/IAE_ISBI2012/images/' + purpose + '/*.tif'
#        img_gray_search_string = '/media/vkaynig/NewVolume/Cmor_paper_data/images/' + purpose + '/*.tif'

        img_files = sorted( glob.glob( img_search_string ) )
#        img_gray_files = sorted( glob.glob( img_gray_search_string ) )
        
        for img_index in xrange(np.shape(img_files)[0]):
            print 'reading image ' + img_files[img_index] + '.'
            label_img = mahotas.imread(img_files[img_index])
            
#            gray_img =  mahotas.imread(img_gray_files[img_index])
            #boundaries = label_img==0
            boundaries = label_img == -1
            boundaries[0:-1,:] = np.logical_or(boundaries[0:-1,:], np.diff(label_img, axis=0)!=0)
            boundaries[:,0:-1] = np.logical_or(boundaries[:,0:-1], np.diff(label_img, axis=1)!=0)
            boundaries = 1-boundaries
            
            shrink_radius=10
            y,x = np.ogrid[-shrink_radius:shrink_radius+1, -shrink_radius:shrink_radius+1]
            disc = x*x + y*y <= (shrink_radius ** 2)
            background = boundaries

            membranes = 1-background
            #membranes = boundaries

            background = 1-(mahotas.erode(boundaries, disc) + 1)
            
            img_file_name = os.path.basename(img_files[img_index])
            #outputPath = '/media/vkaynig/NewVolume/IAE_ISBI2012/labels/'
            outputPath = '/media/vkaynig/Data1/Cmor_paper_data/labels/'
            
            print 'writing image' + img_file_name         
            mahotas.imsave(outputPath + 'background_nonDilate/' + purpose + '/' + img_file_name, np.uint8(background*255))
            mahotas.imsave(outputPath + 'membranes_nonDilate/' + purpose + '/' + img_file_name, np.uint8(membranes*255))
Exemple #11
0
def test_signed():
    A = np.array([0, 0, 1, 1, 1, 0, 0, 0], dtype=np.int32)
    B = np.array([0, 1, 0])
    assert np.min(mahotas.erode(A, B)) == -1
Exemple #12
0
def test_erode_slice():
    np.random.seed(30)
    for i in xrange(16):
        f = (np.random.random_sample((256, 256)) * 255).astype(np.uint8)
        assert np.all(
            mahotas.erode(f[:3, :3]) == mahotas.erode(f[:3, :3].copy()))
Exemple #13
0
    def fix_single_merge(cnn,
                         cropped_image,
                         cropped_prob,
                         cropped_binary,
                         N=10,
                         invert=True,
                         dilate=True,
                         border_seeds=True,
                         erode=False,
                         debug=False,
                         before_merge_error=None,
                         real_border=np.zeros((1, 1)),
                         oversampling=False,
                         crop=True):
        '''
    invert: True/False for invert or gradient image
    '''

        bbox = mh.bbox(cropped_binary)

        orig_cropped_image = np.array(cropped_image)
        orig_cropped_prob = np.array(cropped_prob)
        orig_cropped_binary = np.array(cropped_binary)

        speed_image = None
        if invert:
            speed_image = Util.invert(cropped_image, smooth=True, sigma=2.5)
        else:
            speed_image = Util.gradient(cropped_image)

        dilated_binary = np.array(cropped_binary, dtype=np.bool)
        if dilate:
            for i in range(20):
                dilated_binary = mh.dilate(dilated_binary)

        # Util.view(dilated_binary, large=True)

        borders = np.zeros(cropped_binary.shape)

        best_border_prediction = np.inf
        best_border_image = np.zeros(cropped_binary.shape)

        original_border = mh.labeled.border(cropped_binary,
                                            1,
                                            0,
                                            Bc=mh.disk(3))

        results_no_border = []
        predictions = []

        for n in range(N):
            ws = Util.random_watershed(dilated_binary,
                                       speed_image,
                                       border_seeds=border_seeds,
                                       erode=erode)

            if ws.max() == 0:
                continue

            ws_label1 = ws.max()
            ws_label2 = ws.max() - 1
            border = mh.labeled.border(ws, ws_label1, ws_label2)

            # Util.view(ws, large=True)

            # Util.view(border, large=True)

            # print i, len(border[border==True])

            #
            # remove parts of the border which overlap with the original border
            #

            ws[cropped_binary == 0] = 0

            # Util.view(ws, large=False, color=False)

            ws_label1_array = Util.threshold(ws, ws_label1)
            ws_label2_array = Util.threshold(ws, ws_label2)

            eroded_ws1 = np.array(ws_label1_array, dtype=np.bool)
            eroded_ws2 = np.array(ws_label2_array, dtype=np.bool)
            if erode:

                for i in range(5):
                    eroded_ws1 = mh.erode(eroded_ws1)

                # Util.view(eroded_ws, large=True, color=False)

                dilated_ws1 = np.array(eroded_ws1)
                for i in range(5):
                    dilated_ws1 = mh.dilate(dilated_ws1)

                for i in range(5):
                    eroded_ws2 = mh.erode(eroded_ws2)

                # Util.view(eroded_ws, large=True, color=False)

                dilated_ws2 = np.array(eroded_ws2)
                for i in range(5):
                    dilated_ws2 = mh.dilate(dilated_ws2)

                new_ws = np.zeros(ws.shape, dtype=np.uint8)
                new_ws[dilated_ws1 == 1] = ws_label1
                new_ws[dilated_ws2 == 1] = ws_label2

                ws = new_ws

                # Util.view(new_ws, large=True, color=True)

            # ws[original_border == 1] = 0

            prediction = Patch.grab_group_test_and_unify(
                cnn,
                cropped_image,
                cropped_prob,
                ws,
                ws_label1,
                ws_label2,
                oversampling=oversampling)

            if prediction == -1:
                # invalid
                continue

            # if (prediction < best_border_prediction):
            #   best_border_prediction = prediction
            #   best_border_image = border
            #   print 'new best', n, prediction

            best_border_image = border

            borders += (border * prediction)

            result = np.array(cropped_binary)
            best_border_image[result == 0] = 0
            result[best_border_image == 1] = 2

            result = skimage.measure.label(result)

            result_no_border = np.array(result)
            result_no_border[best_border_image == 1] = 0

            predictions.append(prediction)
            results_no_border.append(result_no_border)

        # result = np.array(cropped_binary)
        # best_border_image[result==0] = 0
        # result[best_border_image==1] = 2

        # result = skimage.measure.label(result)

        # result_no_border = np.array(result)
        # result_no_border[best_border_image==1] = 0
        # result_no_border = mh.croptobbox(result_no_border)

        # if before_merge_error == None:
        #   continue

        # print result_no_border.shape, before_merge_error.shape

        # if before_merge_error.shape[0] != result_no_border.shape[0] or before_merge_error.shape[1] != result_no_border.shape[1]:
        #   result_no_border = np.resize(result_no_border, before_merge_error.shape)

        # print 'vi', Util.vi(before_merge_error.astype(np.uint8), result_no_border.astype(np.uint8))

        #     if debug:
        #       Util.view(ws, text=str(i) + ' ' + str(prediction))

        result = np.array(cropped_binary)
        best_border_image[result == 0] = 0
        result[best_border_image == 1] = 2

        result = skimage.measure.label(result)

        result_no_border = np.array(result)
        result_no_border[best_border_image == 1] = 0

        return borders, best_border_image, result, result_no_border, results_no_border, predictions
orig_filtered = np.real(np.fft.ifft2((np.multiply(orig, expo))))
PST_Kernel_1 = np.multiply(np.dot(rho, W), np.arctan(np.dot(rho, W))) - 0.5 * np.log(1 + np.power(np.dot(rho, W), 2))
PST_Kernel = PST_Kernel_1 / np.max(PST_Kernel_1) * S
temp = np.multiply(np.fft.fftshift(np.exp(-1j * PST_Kernel)), np.fft.fft2(orig_filtered))
temp = np.multiply(np.fft.fftshift(np.exp(-1j * PST_Kernel)), np.fft.fft2(Image_orig_filtered))
orig_filtered_PST = np.fft.ifft2(temp)
PHI_features = np.angle(Image_orig_filtered_PST)
features = np.zeros((PHI_features.shape[0], PHI_features.shape[1]))
features[PHI_features > Threshold_max] = 1
features[PHI_features < Threshold_min] = 1
features[I < (np.amax(I) / 20)] = 0
out = features
out = mh.thin(out, 1)
out = mh.bwperim(out, 4)
out = mh.thin(out, 1)
out = mh.erode(out, np.ones((1, 1)))

def phase_stretch_transform(img, LPF, S, W, threshold_min, threshold_max, flag):
    L = 0.5
    x = np.linspace(-L, L, img.shape[0])
    y = np.linspace(-L, L, img.shape[1])
    [X1, Y1] = (np.meshgrid(x, y))
    X = X1.T
    Y = Y1.T
    theta, rho = cart2pol(X, Y)
    orig = ((np.fft.fft2(img)))
    expo = np.fft.fftshift(np.exp(-np.power((np.divide(rho, math.sqrt((LPF ** 2) / np.log(2)))), 2)))
    orig_filtered = np.real(np.fft.ifft2((np.multiply(orig, expo))))
    PST_Kernel_1 = np.multiply(np.dot(rho, W), np.arctan(np.dot(rho, W))) - 0.5 * np.log(
        1 + np.power(np.dot(rho, W), 2))
    PST_Kernel = PST_Kernel_1 / np.max(PST_Kernel_1) * S
Exemple #15
0
def segment_layer(filename, params):
    '''
	Segment one layer in a stack
	'''
    start = time.time()
    #extract pixel size in xy and z
    xsize, zsize = extract_zoom(params.folder)

    #load image
    img = tifffile.imread(params.inputfolder + params.folder + filename)

    #normalize image
    img = ndimage.median_filter(img, 3)
    img = img * 255. / img.max()

    ##segment kidney tissue

    sizefactor = 10.
    small = ndimage.interpolation.zoom(
        img, 1. / sizefactor)  #scale the image to a smaller size

    imgf = ndimage.gaussian_filter(small, 3. / xsize)  #Gaussian filter
    median = np.percentile(imgf, 40)  #40-th percentile for thresholding

    kmask = imgf > median * 1.5  #thresholding
    kmask = mahotas.dilate(kmask, mahotas.disk(5))
    kmask = mahotas.close_holes(kmask)  #closing holes
    kmask = mahotas.erode(kmask, mahotas.disk(5)) * 255

    #remove objects that are darker than 2*percentile
    l, n = ndimage.label(kmask)
    llist = np.unique(l)
    if len(llist) > 2:
        means = ndimage.mean(imgf, l, llist)
        bv = llist[np.where(means < median * 2)]
        ix = np.in1d(l.ravel(), bv).reshape(l.shape)
        kmask[ix] = 0

    kmask = ndimage.interpolation.zoom(kmask,
                                       sizefactor)  #scale back to normal size
    kmask = normalize(kmask)
    kmask = (kmask > mahotas.otsu(kmask.astype(
        np.uint8))) * 255.  #remove artifacts of interpolation

    #save indices of the kidney mask
    ind = np.where(kmask > 0)
    ind = np.array(ind)
    np.save(
        params.inputfolder + '../segmented/masks/kidney/' + params.folder +
        filename[:-4] + '.npy', ind)
    skimage.io.imsave(
        params.inputfolder + '../segmented/masks/kidney/' + params.folder +
        filename[:-4] + '.tif', (kmask > 0).astype(np.uint8) * 255)

    #segment glomeruli, if there is a kidney tissue
    if kmask.max() > 0:
        #remove all intensity variations larger than maximum radius of a glomerulus
        d = mahotas.disk(int(float(params.maxrad) / xsize))
        img = img - mahotas.open(img.astype(np.uint8), d)
        img = img * 255. / img.max()
        ch = img[np.where(kmask > 0)]

        #segment glomeruli by otsu thresholding	only if this threshold is higher than the 75-th percentile in the kidney mask
        t = mahotas.otsu(img.astype(np.uint8))

        if t > np.percentile(ch, 75) * 1.5:
            cells = img > t
            cells[np.where(kmask == 0)] = 0
            cells = mahotas.open(
                cells, mahotas.disk(int(float(params.minrad) / 2. / xsize)))

        else:
            cells = np.zeros_like(img)

    else:
        cells = np.zeros_like(img)

    #save indices of the glomeruli mask
    ind = np.where(cells > 0)
    ind = np.array(ind)
    np.save(
        params.inputfolder + '../segmented/masks/glomeruli/' + params.folder +
        filename[:-4] + '.npy', ind)
    skimage.io.imsave(
        params.inputfolder + '../segmented/masks/glomeruli/' + params.folder +
        filename[:-4] + '.tif', (cells > 0).astype(np.uint8) * 255)
Exemple #16
0
  def fix_single_merge(cnn, cropped_image, cropped_prob, cropped_binary, N=10, invert=True, dilate=True, 
                       border_seeds=True, erode=False, debug=False, before_merge_error=None,
                       real_border=np.zeros((1,1)), oversampling=False, crop=True):
    '''
    invert: True/False for invert or gradient image
    '''

    bbox = mh.bbox(cropped_binary)

    orig_cropped_image = np.array(cropped_image)
    orig_cropped_prob  = np.array(cropped_prob)
    orig_cropped_binary = np.array(cropped_binary)



    speed_image = None
    if invert:
      speed_image = Legacy.invert(cropped_image, smooth=True, sigma=2.5)
    else:
      speed_image = Legacy.gradient(cropped_image)

    Util.view(speed_image, large=False, color=False)


    dilated_binary = np.array(cropped_binary, dtype=np.bool)
    if dilate:
      for i in range(20):
          dilated_binary = mh.dilate(dilated_binary)      

    Util.view(dilated_binary, large=False, color=False)

    borders = np.zeros(cropped_binary.shape)

    best_border_prediction = np.inf
    best_border_image = np.zeros(cropped_binary.shape)

    original_border = mh.labeled.border(cropped_binary, 1, 0, Bc=mh.disk(3))

    results_no_border = []
    predictions = []
    borders = []
    results = []

    for n in range(N):
        ws = Legacy.random_watershed(dilated_binary, speed_image, border_seeds=border_seeds, erode=erode)
        
        if ws.max() == 0:
          continue

        ws_label1 = ws.max()
        ws_label2 = ws.max()-1
        border = mh.labeled.border(ws, ws_label1, ws_label2)

        # Util.view(ws, large=True)


        # Util.view(border, large=True)

        # print i, len(border[border==True])

        #
        # remove parts of the border which overlap with the original border
        #

        

        ws[cropped_binary == 0] = 0

        # Util.view(ws, large=False, color=False)        

        ws_label1_array = Util.threshold(ws, ws_label1)
        ws_label2_array = Util.threshold(ws, ws_label2)

        eroded_ws1 = np.array(ws_label1_array, dtype=np.bool)
        eroded_ws2 = np.array(ws_label2_array, dtype=np.bool)
        if erode:

          for i in range(5):
            eroded_ws1 = mh.erode(eroded_ws1)

          # Util.view(eroded_ws, large=True, color=False)

          dilated_ws1 = np.array(eroded_ws1)
          for i in range(5):
            dilated_ws1 = mh.dilate(dilated_ws1)


          for i in range(5):
            eroded_ws2 = mh.erode(eroded_ws2)

          # Util.view(eroded_ws, large=True, color=False)

          dilated_ws2 = np.array(eroded_ws2)
          for i in range(5):
            dilated_ws2 = mh.dilate(dilated_ws2)




          new_ws = np.zeros(ws.shape, dtype=np.uint8)
          new_ws[dilated_ws1 == 1] = ws_label1
          new_ws[dilated_ws2 == 1] = ws_label2


          ws = new_ws

          # Util.view(new_ws, large=True, color=True)

        # ws[original_border == 1] = 0
        
        prediction = Patch.grab_group_test_and_unify(cnn, cropped_image, cropped_prob, ws, ws_label1, ws_label2, oversampling=oversampling)
        
        if prediction == -1 or prediction >= .5:
          # invalid
          continue


        # here we have for one border
        # the border
        # the prediction
        # borders.append(border)
        # predictions.append(prediction)
        results.append((prediction, border))



    return results
                circle = plt.Circle((jj * b + dw / 2 + b / 2, ii * b + dh / 2 + b / 2), 1.0, color='r')
                fig.gca().add_artist(circle)

    plt.show()

svm = sklearn.svm.LinearSVC(class_weight = 'balanced')

print sklearn.cross_validation.cross_val_score(svm, desc, labels)

svm.fit(desc, labels)

#%%
plt.imshow(mahotas.distance(lg) > 80)
#%%
plt.imshow(im)
plt.imshow(mahotas.erode(mahotas.erode(mahotas.erode(mahotas.erode(mahotas.erode(mahotas.erode(lg[:, :])))))), alpha = 0.5)

#%%
for i in range(40, 60, 1):
    #im = skimage.io.imread('labeled/{0}.bmp'.format(i))
    im = skimage.io.imread('screencast_frames/videoframe{0:0>5d}.bmp'.format(i))
    im = im[:(im.shape[0] / b) * b, :(im.shape[1] / b) * b]
    tmp = time.time()
    descriptors, (nhd, nwd), (dh, dw) = build_descriptors(im, b)

    nlabels = svm.predict(descriptors)

    nlabels = nlabels.reshape((nhd, nwd))
    print 'time', time.time() - tmp
    #nlabels = numpy.tile(nlabels, [1, 1, b, b])
    #nlabels = nlabels.reshape(im.shape[0:2])
Exemple #18
0
            input_vol[:, :, zoffset] = normalize_image(
                mahotas.imread(
                    'D:\\dev\\datasets\\isbi\\train-input\\train-input_{0:04d}.tif'
                    .format(imgi - zrad + zoffset)))
            #input_vol[:,:,zoffset] = mahotas.imread('D:\\dev\\datasets\\isbi\\train-input\\train-input_{0:04d}.tif'.format(imgi - zrad + zoffset))

    blur_img = scipy.ndimage.gaussian_filter(input_img, gblur_sigma)

    boundaries = label_img == 0
    boundaries[0:-1, :] = np.logical_or(boundaries[0:-1, :],
                                        diff(label_img, axis=0) != 0)
    boundaries[:, 0:-1] = np.logical_or(boundaries[:, 0:-1],
                                        diff(label_img, axis=1) != 0)

    # erode to be sure we include at least one membrane
    inside = mahotas.erode(boundaries == 0, shrink_disc)

    #display = input_img.copy()
    #display[np.nonzero(inside)] = 0
    #figure(figsize=(20,20))
    #imshow(display, cmap=cm.gray)

    seeds = label_img.copy()
    seeds[np.nonzero(inside == 0)] = 0
    grow = mahotas.cwatershed(255 - blur_img, seeds)

    membrane = np.zeros(input_img.shape, dtype=uint8)
    membrane[0:-1, :] = diff(grow, axis=0) != 0
    membrane[:, 0:-1] = np.logical_or(membrane[:, 0:-1],
                                      diff(grow, axis=1) != 0)
Exemple #19
0
def multi_erode(img, x):
    img = img.astype(bool)
    for i in range(x):
        img = mh.erode(img)

    return img
Exemple #20
0
 
                 combined_distances = smooth_distances * smoothing_factor + \
                     gap_completion_distances * gap_completion_factor
                 combined_outflow = outflow_smooth * smoothing_factor + \
                     outflow_gap * gap_completion_factor
                 combined_inflow = inflow_smooth * smoothing_factor + \
                     inflow_gap * gap_completion_factor
 
 
                 # Find ignorable nodes - those where full 3x3 neighborhood has
                 # source_sink_cap > 0 and sum of source_sink_cap in
                 # neighborhood (except center) is greater than neighborhood
                 # outflow.  Similar for inflow.
                 hollow = np.ones((3, 3))
                 hollow[1, 1] = 0
                 ignorable = np.logical_and(mahotas.erode(source_sink_cap > 0, np.ones((3,3))),
                                            (mahotas.convolve(source_sink_cap, hollow, mode='ignore') >
                                             combined_outflow))
                 np.logical_or(ignorable,
                               np.logical_and(mahotas.erode(source_sink_cap < 0, np.ones((3,3))),
                                              (mahotas.convolve(source_sink_cap, hollow, mode='ignore') <
                                               - combined_inflow)),  # careful with signs
                               out=ignorable)
 
                 print "Can ignore {0} of {1}".format(np.sum(ignorable), ignorable.size)
 
                 ## Load the adjacency matrix
                 for di, direction in enumerate(directions[:4]):
                     dest_coords = shift_coords(coords, direction)
 
                     source_coords, dest_coords = validate_and_broadcast(coords, dest_coords)
Exemple #21
0
    def addCell(self, eventTuple):
        if self.maskOn:
            if self.data.ndim == 2:
                self.aveData = self.data.copy()
            else:
                self.aveData = self.data.mean(axis=2)

            x, y = eventTuple
            localValue = self.currentMask[x, y]
            print str(self.mode) + " " + "x: " + str(x) + ", y: " + str(y) + ", mask val: " + str(localValue)

            # ensure mask is uint16
            self.currentMask = self.currentMask.astype("uint16")

            sys.stdout.flush()

            ########## NORMAL MODE
            if self.mode is None:
                if localValue > 0 and localValue != self.currentMaskNumber:
                    print "we are altering mask at at %d, %d" % (x, y)

                    # copy the old mask
                    newMask = self.currentMask.copy()

                    # make a labeled image of the current mask
                    labeledCurrentMask = mahotas.label(newMask)[0]
                    roiNumber = labeledCurrentMask[x, y]

                    # set that ROI to zero
                    newMask[labeledCurrentMask == roiNumber] = self.currentMaskNumber
                    newMask = newMask.astype("uint16")

                    self.listOfMasks.append(newMask)
                    self.currentMask = self.listOfMasks[-1]
                elif localValue > 0 and self.data.ndim == 3:
                    # update info panel
                    labeledCurrentMask = mahotas.label(self.currentMask.copy())[0]
                    roiNumber = labeledCurrentMask[x, y]
                    self.updateInfoPanel(ROI_number=roiNumber)

                elif localValue == 0:

                    xmin = int(x - self.diskSize)
                    xmax = int(x + self.diskSize)
                    ymin = int(y - self.diskSize)
                    ymax = int(y + self.diskSize)

                    sub_region_image = self.aveData[xmin:xmax, ymin:ymax].copy()
                    # threshold = mahotas.otsu(self.data[xmin:xmax, ymin:ymax].astype('uint16'))

                    # do a gaussian_laplacian filter to find the edges and the center

                    g_l = nd.gaussian_laplace(
                        sub_region_image, 1
                    )  # second argument is a free parameter, std of gaussian
                    g_l = mahotas.dilate(mahotas.erode(g_l >= 0))
                    g_l = mahotas.label(g_l)[0]
                    center = g_l == g_l[g_l.shape[0] / 2, g_l.shape[0] / 2]
                    # edges = mahotas.dilate(mahotas.dilate(mahotas.dilate(center))) - center

                    newCell = np.zeros_like(self.currentMask)
                    newCell[xmin:xmax, ymin:ymax] = center
                    newCell = mahotas.dilate(newCell)

                    if self.useNMF:
                        modes, thresh_modes, fit_data, this_cell, is_cell, nmf_limits = self.doLocalNMF(x, y, newCell)

                        for mode, mode_thresh, t, i in zip(modes, thresh_modes, this_cell, is_cell):
                            # need to place it in the right place
                            # have x and y
                            mode_width, mode_height = mode_thresh.shape
                            mode_thresh_fullsize = np.zeros_like(newCell)
                            mode_thresh_fullsize[
                                nmf_limits[0] : nmf_limits[1], nmf_limits[2] : nmf_limits[3]
                            ] = mode_thresh

                            # need to add all modes belonging to this cell first,
                            # then remove the ones nearby.

                            if i:
                                if t:
                                    valid_area = np.logical_and(
                                        mahotas.dilate(
                                            mahotas.dilate(mahotas.dilate(mahotas.dilate(newCell.astype(bool))))
                                        ),
                                        mode_thresh_fullsize,
                                    )
                                    newCell = np.logical_or(newCell.astype(bool), valid_area)
                                else:
                                    newCell = np.logical_and(
                                        newCell.astype(bool), np.logical_not(mahotas.dilate(mode_thresh_fullsize))
                                    )

                        newCell = mahotas.close_holes(newCell.astype(bool))
                        self.excludePixels(newCell, 2)

                    newCell = newCell.astype(self.currentMask.dtype)

                    # remove all pixels in and near current mask and filter for ROI size
                    newCell[mahotas.dilate(self.currentMask > 0)] = 0
                    newCell = self.excludePixels(newCell, 10)

                    newMask = (newCell * self.currentMaskNumber) + self.currentMask
                    newMask = newMask.astype("uint16")

                    self.listOfMasks.append(newMask.copy())
                    self.currentMask = newMask.copy()

            elif self.mode is "OGB":
                # build structuring elements
                se = pymorph.sebox()
                se2 = pymorph.sedisk(self.cellRadius, metric="city-block")
                seJunk = pymorph.sedisk(max(np.floor(self.cellRadius / 4.0), 1), metric="city-block")
                seExpand = pymorph.sedisk(self.diskSize, metric="city-block")

                # add a disk around selected point, non-overlapping with adjacent cells
                dilatedOrignal = mahotas.dilate(self.currentMask.astype(bool), Bc=se)
                safeUnselected = np.logical_not(dilatedOrignal)

                # tempMask is
                tempMask = np.zeros_like(self.currentMask, dtype=bool)
                tempMask[x, y] = True
                tempMask = mahotas.dilate(tempMask, Bc=se2)
                tempMask = np.logical_and(tempMask, safeUnselected)

                # calculate the area we should add to this disk based on % of a threshold
                cellMean = self.aveData[tempMask == 1.0].mean()
                allMeanBw = self.aveData >= (cellMean * float(self.contrastThreshold))

                tempLabel = mahotas.label(np.logical_and(allMeanBw, safeUnselected).astype(np.uint16))[0]
                connMeanBw = tempLabel == tempLabel[x, y]

                connMeanBw = np.logical_and(np.logical_or(connMeanBw, tempMask), safeUnselected).astype(np.bool)
                # erode and then dilate to remove sharp bits and edges

                erodedMean = mahotas.erode(connMeanBw, Bc=seJunk)
                dilateMean = mahotas.dilate(erodedMean, Bc=seJunk)
                dilateMean = mahotas.dilate(dilateMean, Bc=seExpand)

                modes, thresh_modes, fit_data, this_cell, is_cell, limits = self.doLocaNMF(x, y)

                newCell = np.logical_and(dilateMean, safeUnselected)
                newMask = (newCell * self.currentMaskNumber) + self.currentMask
                newMask = newMask.astype("uint16")

                self.listOfMasks.append(newMask.copy())
                self.currentMask = newMask.copy()

            ########## SQUARE MODE
            elif self.mode is "square":
                self.modeData.append((x, y))
                if len(self.modeData) == 2:
                    square_mask = np.zeros_like(self.currentMask)
                    xstart = self.modeData[0][0]
                    ystart = self.modeData[0][1]

                    xend = self.modeData[1][0]
                    yend = self.modeData[1][1]

                    square_mask[xstart:xend, ystart:yend] = 1

                    # check if square_mask interfers with current mask, if so, abort
                    if np.any(np.logical_and(square_mask, self.currentMask)):
                        return None

                    # add square_mask to mask
                    newMask = (square_mask * self.currentMaskNumber) + self.currentMask
                    newMask = newMask.astype("uint16")

                    self.listOfMasks.append(newMask)
                    self.currentMask = self.listOfMasks[-1]

                    # clear current mode data
                    self.clearModeData()

            ########## CIRCLE MODE
            elif self.mode is "circle":
                # make a strel and move it in place to make circle_mask
                if self.diskSize < 1:
                    return None

                if self.diskSize is 1:
                    se = np.ones((1, 1))
                elif self.diskSize is 2:
                    se = pymorph.secross(r=1)
                else:
                    se = pymorph.sedisk(r=(self.diskSize - 1))

                se_extent = int(se.shape[0] / 2)
                circle_mask = np.zeros_like(self.currentMask)
                circle_mask[x - se_extent : x + se_extent + 1, y - se_extent : y + se_extent + 1] = se * 1.0
                circle_mask = circle_mask.astype(bool)

                # check if circle_mask interfers with current mask, if so, abort
                if np.any(np.logical_and(circle_mask, mahotas.dilate(self.currentMask.astype(bool)))):
                    return None

                # add circle_mask to mask
                newMask = (circle_mask * self.currentMaskNumber) + self.currentMask
                newMask = newMask.astype("uint16")

                self.listOfMasks.append(newMask)
                self.currentMask = self.listOfMasks[-1]

            ########## POLY MODE
            elif self.mode is "poly":
                self.modeData.append((x, y))

            sys.stdout.flush()
            self.makeNewMaskAndBackgroundImage()
Exemple #22
0
    def split_label(image, binary):

        bbox = mh.bbox(binary)

        sub_image = np.array(image[bbox[0]:bbox[1], bbox[2]:bbox[3]])
        sub_binary = np.array(binary[bbox[0]:bbox[1], bbox[2]:bbox[3]])

        sub_binary_border = mh.labeled.borders(sub_binary, Bc=mh.disk(3))

        sub_binary = mh.erode(sub_binary.astype(np.bool))
        for e in range(15):
            sub_binary = mh.erode(sub_binary)
        # # sub_binary = mh.erode(sub_binary)

        if sub_binary.shape[0] < 2 or sub_binary.shape[1] < 2:
            return np.zeros(binary.shape,
                            dtype=np.bool), np.zeros(binary.shape,
                                                     dtype=np.bool)

        #
        # smooth the image
        #
        sub_image = mh.gaussian_filter(sub_image, 3.5)

        grad_x = np.gradient(sub_image)[0]
        grad_y = np.gradient(sub_image)[1]
        grad = np.add(np.abs(grad_x), np.abs(grad_y))

        grad -= grad.min()
        grad /= grad.max()
        grad *= 255
        grad = grad.astype(np.uint8)

        coords = zip(*np.where(sub_binary == 1))

        if len(coords) < 2:
            # print 'STRAAAAANGE'
            return np.zeros(binary.shape,
                            dtype=np.bool), np.zeros(binary.shape,
                                                     dtype=np.bool)

        seed1 = random.choice(coords)
        seed2 = random.choice(coords)
        seeds = np.zeros(sub_binary.shape, dtype=np.uint64)
        seeds[seed1] = 1
        seeds[seed2] = 2

        for i in range(10):
            seeds = mh.dilate(seeds)

        ws = mh.cwatershed(grad, seeds)
        ws[sub_binary == 0] = 0

        #     ws_relabeled = skimage.measure.label(ws.astype(np.uint8))
        #     ws_relabeled[sub_binary==0] = 0
        #     max_label = ws_relabeled.max()
        #     plt.figure()
        #     imshow(ws)

        binary_mask = Util.threshold(ws, ws.max())
        border = mh.labeled.border(ws, ws.max(), ws.max() - 1, Bc=mh.disk(2))
        border[sub_binary_border == 1] = 0  # remove any "real" border pixels

        #     plt.figure()
        #     imshow(binary_mask)

        #     plt.figure()
        #     imshow(border)

        # at this point, there can be multiple borders and labels
        labeled_border = skimage.measure.label(border)
        labeled_binary_mask = skimage.measure.label(binary_mask)
        # .. and we are going to select only the largest
        largest_border_label = Util.get_largest_label(
            labeled_border.astype(np.uint16), True)
        largest_binary_mask_label = Util.get_largest_label(
            labeled_binary_mask.astype(np.uint16), True)
        # .. filter out everything else
        border[labeled_border != largest_border_label] = 0
        binary_mask[labeled_binary_mask != largest_binary_mask_label] = 0

        large_label = np.zeros(binary.shape, dtype=np.bool)
        large_border = np.zeros(binary.shape, dtype=np.bool)
        large_label[bbox[0]:bbox[1], bbox[2]:bbox[3]] = binary_mask
        large_border[bbox[0]:bbox[1], bbox[2]:bbox[3]] = border

        return large_label, large_border
Exemple #23
0
    def show_overlay(image,
                     segmentation,
                     borders=np.zeros((1, 1)),
                     labels=np.zeros((1, 1)),
                     mask=None):

        b = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8)
        c = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8)
        b[:, :, 0] = image[:]
        b[:, :, 1] = image[:]
        b[:, :, 2] = image[:]
        b[:, :, 3] = 255
        # from PIL import Image
        # def alpha_composite(src, dst):
        #     '''
        #     Return the alpha composite of src and dst.

        #     Parameters:
        #     src -- PIL RGBA Image object
        #     dst -- PIL RGBA Image object

        #     The algorithm comes from http://en.wikipedia.org/wiki/Alpha_compositing
        #     '''
        #     # http://stackoverflow.com/a/3375291/190597
        #     # http://stackoverflow.com/a/9166671/190597
        #     src = np.asarray(src)
        #     dst = np.asarray(dst)
        #     out = np.empty(src.shape, dtype = 'float')
        #     alpha = np.index_exp[:, :, 3:]
        #     rgb = np.index_exp[:, :, :3]
        #     src_a = src[alpha]/255.0
        #     dst_a = dst[alpha]/255.0
        #     out[alpha] = src_a+dst_a*(1-src_a)
        #     old_setting = np.seterr(invalid = 'ignore')
        #     out[rgb] = (src[rgb]*src_a + dst[rgb]*dst_a*(1-src_a))/out[alpha]
        #     np.seterr(**old_setting)
        #     out[alpha] *= 255
        #     np.clip(out,0,255)
        #     # astype('uint8') maps np.nan (and np.inf) to 0
        #     out = out.astype('uint8')
        #     out = Image.fromarray(out, 'RGBA')
        #     return out

        if not labels.shape[0] > 1:
            # c[segmentation==1] = (00,0,200,130)
            # c[segmentation==2] = (0,150,00,130)
            # c[mask!=0] = (0,0,200,130)
            c[segmentation == 1] = (0, 150, 0, 130)
            c[segmentation == 2] = (200, 0, 000, 130)
            c[segmentation == 3] = (100, 100, 00, 130)
            c[segmentation == 4] = (0, 0, 200, 130)
        if borders.shape[0] > 1:
            borders[mh.erode(mh.erode(mh.erode(segmentation))) == 0] = 0
            c[borders == borders.max()] = (0, 255, 0, 255)
            c[borders == borders.max() - 1] = (255, 0, 0, 255)
        elif labels.shape[0] > 1:
            c[mask != 0] = (0, 0, 200, 130)
            c[labels == 1] = (0, 150, 0, 130)
            c[labels == 2] = (200, 0, 000, 130)
            c[labels == 3] = (100, 100, 00, 130)
            c[labels == 4] = (0, 0, 200, 130)
        return b, c
def PST(I,
        LPF=0.21,
        Phase_strength=0.48,
        Warp_strength=12.14,
        Threshold_min=-1,
        Threshold_max=0.0019,
        Morph_flag=1):
    # I: image
    # Gaussian Low Pass Filter
    #	LPF = 0.21
    # PST parameters:
    # 	Phase_strength = 0.48
    #	Warp_strength = 12.14
    # Thresholding parameters (for post processing after the edge is computed)
    #	Threshold_min = -1
    #	Threshold_max = 0.0019
    # To compute analog edge, set Morph_flag = 0 and to compute digital edge, set Morph_flag = 1
    # 	Morph_flag = 1
    I_initial = I
    if (len(I.shape) == 3):
        I = I.mean(axis=2)

    L = 0.5
    x = np.linspace(-L, L, I.shape[0])
    y = np.linspace(-L, L, I.shape[1])
    [X1, Y1] = (np.meshgrid(x, y))
    X = X1.T
    Y = Y1.T
    [THETA, RHO] = cart2pol(X, Y)

    # Apply localization kernel to the original image to reduce noise
    Image_orig_f = ((np.fft.fft2(I)))
    expo = np.fft.fftshift(
        np.exp(-np.power((np.divide(RHO, math.sqrt((LPF**2) /
                                                   np.log(2)))), 2)))
    Image_orig_filtered = np.real(
        np.fft.ifft2((np.multiply(Image_orig_f, expo))))
    # Constructing the PST Kernel
    PST_Kernel_1 = np.multiply(
        np.dot(RHO, Warp_strength), np.arctan(np.dot(RHO, Warp_strength))
    ) - 0.5 * np.log(1 + np.power(np.dot(RHO, Warp_strength), 2))
    PST_Kernel = PST_Kernel_1 / np.max(PST_Kernel_1) * Phase_strength
    # Apply the PST Kernel
    temp = np.multiply(np.fft.fftshift(np.exp(-1j * PST_Kernel)),
                       np.fft.fft2(Image_orig_filtered))
    Image_orig_filtered_PST = np.fft.ifft2(temp)

    # Calculate phase of the transformed image
    PHI_features = np.angle(Image_orig_filtered_PST)

    if Morph_flag == 0:
        out = PHI_features
        return out
    else:
        #   find image sharp transitions by thresholding the phase
        features = np.zeros((PHI_features.shape[0], PHI_features.shape[1]))
        features[PHI_features > Threshold_max] = 1  # Bi-threshold decision
        features[
            PHI_features <
            Threshold_min] = 1  # as the output phase has both positive and negative values
        features[I < (
            np.amax(I) / 20
        )] = 0  # Removing edges in the very dark areas of the image (noise)

        # apply binary morphological operations to clean the transformed image
        out = features
        out = mh.thin(out, 1)
        out = mh.bwperim(out, 4)
        out = mh.thin(out, 1)
        out = mh.erode(out, np.ones((1, 1)))

        Overlay = mh.overlay(I, out)
        return (out, Overlay)
Exemple #25
0
def _classify(path, name, frames, channels, target, choices, CellObject):
    gnp.free_reuse_cache()
    #GPU TO USE, WE HAVE 2, I PREFER IF YOU'RE USING GPU 0
    #whole images take up a lot of memory so we need to coordinate this.
    # if you're not using the notebook or a script make sure to shutdown or restart the notebook
    # you can use nvidia-smi in terminal to see what process are running on the GPU
    gnp._useGPUid = 0
    #protein localization categories
    localizationTerms = [
        'ACTIN', 'BUDNECK', 'BUDTIP', 'CELLPERIPHERY', 'CYTOPLASM', 'ENDOSOME',
        'ER', 'GOLGI', 'MITOCHONDRIA', 'NUCLEARPERIPHERY', 'NUCLEI',
        'NUCLEOLUS', 'PEROXISOME', 'SPINDLE', 'SPINDLEPOLE',
        'VACUOLARMEMBRANE', 'VACUOLE'
    ]

    #normalization values (don't need to change)
    norm_vals = np.load(
        '/home/morphology/mpg4/OrenKraus/Data_Sets/Yeast_Protein_Localization/Yolanda_Chong/overal_mean_std_for_single_cell_crops_based_on_Huh.npz'
    )

    #may change to better model (constatly training bgnumpy.track_memory_usage=Trueetter networks)
    model_path = '/home/okraus/mil_models_backup/mil_models/Yeast_Protein_Localization/Yeast_NAND_a_10_scratch_Dropout_v5_MAP_early_stopping_best_model.npz'

    #load model and set evaluation type (MIL convolves across whole images)
    #change size

    curImages, sizes = getImageData(path, frames, channels)
    curImages = normalize_by_constant_values(curImages, norm_vals['means'],
                                             norm_vals['stdevs'])

    sizeX = sizes[1]
    sizeY = sizes[0]

    nn = modelEvalFunctions.loadResizedModel(model_path, sizeY, sizeX)
    model = modelEvalFunctions.evaluateModel_MIL(nn,
                                                 localizationTerms,
                                                 outputLayer='loc')

    nn.ForwardProp({'X0': gnp.garray(curImages)})

    # GET RATIOS OF CLASSES
    #values of prediction maps above
    pred_maps = nn._layers['MIL_pool'].Z[target - 1].as_numpy_array()
    #calculate relative activation of each map
    area = pred_maps.sum(1).sum(1) / pred_maps.sum()
    #calculate absolute area of each map (optional)
    area2 = pred_maps.sum(1).sum(1) / (pred_maps.shape[1] * pred_maps.shape[2])
    #plot relative activations per class, use area or area2
    area_lib = {}

    jacobian = getJacobian(nn, frames)
    plt.imshow(jacobian[target - 1, 0])
    loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0] +
              "_FULL0")
    save(loc)

    mahotas_segmentation = mahotas_clean_up_seg(jacobian, target - 1)
    plt.imshow(mahotas_segmentation)
    loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0] +
              "_FULL1")
    save(loc)

    show_segmentation_boundaries(curImages, mahotas_segmentation, target - 1,
                                 sizeX, sizeY)
    loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0] +
              "_FULL2")
    save(loc)

    top5indices = np.argsort(area)[::-1][:5]
    del jacobian
    del mahotas_segmentation

    for i in range(len(localizationTerms)):
        if i in top5indices:
            area_lib[localizationTerms[i]] = area[i]
            jacobian_per_class = getJacobian_per_class(nn, i, frames)
            im2show = mahotas_clean_up_seg(jacobian_per_class, target - 1)
            overlay(curImages, im2show, target - 1, sizeX, sizeY)
            loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0] +
                      "_" + localizationTerms[i])
            save(loc)
            np.save(loc, im2show)
            continue
        if localizationTerms[i] not in choices:
            continue
        area_lib[localizationTerms[i]] = area[i]
        jacobian_per_class = getJacobian_per_class(nn, i, frames)[target - 1]
        im2show = np.int8(
            np.log(1 + jacobian_per_class[0]) > 0.1 +
            np.int8(np.log(1 + jacobian_per_class[1]) > 1)) > 0
        im2show = mh.dilate(
            mh.dilate(mh.dilate(mh.erode(mh.erode(mh.erode(im2show > 0))))))
        overlay(curImages, im2show, target - 1, sizeX, sizeY)
        loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0] +
                  "_" + localizationTerms[i])
        save(loc)
        np.save(loc, im2show)
    del nn
    del model
    gnp.free_reuse_cache()
    f = [['Class', 'Area']]
    for key in area_lib:
        f.append([str(key), area_lib[key]])
    CellObject.activations = f
    CellObject.save()
    from openpyxl import Workbook
    wb = Workbook()
    ws = wb.active
    for arr in f:
        ws.append(arr)
    wb.save(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0] + '.xlsx')
    if CellObject.email != '':
        send_mail(
            'Deep Cell Vision',
            'Your image has been classified. Go to http://deepcellvision.com/results/'
            + CellObject.name + ' to see your results',
            '*****@*****.**', [CellObject.email],
            fail_silently=False)
    return
    def predict(self, filenames_list):
        if not isinstance(filenames_list, list):
            raise Exception('Input list of files is not a list actually')

        rectangles = []
        for filename in filenames_list:
            img_rgb = imread(filename)
            img_hsv = rgb2hsv(img_rgb)
            img_nrgb = color.normalize_RGBratio(img_rgb)
            img_lab = rgb2lab(img_rgb)

            img_h = img_hsv[:, :, 0]
            img_h[img_h < 0.4] = 1 - img_h[img_h < 0.4]

            # TODO add normalized RGB and opposite RGB
            channel = {
                'r': img_rgb[:, :, 0],
                'g': img_rgb[:, :, 1],
                'b': img_rgb[:, :, 2],
                'h': img_hsv[:, :, 0],
                's': img_hsv[:, :, 1],
                'v': img_hsv[:, :, 2],
                'nr': img_nrgb[:, :, 0],
                'ng': img_nrgb[:, :, 1],
                'nb': img_nrgb[:, :, 2],
                'l': img_lab[:, :, 0],
                'a': img_lab[:, :, 1],
                'b': img_lab[:, :, 2]
            }

            ### Selects best channel
            if self.combine:
                chan = 1.
                for x in self.candidates:
                    chan *= color.scaler(channel[x])
            else:
                chan = noise.least_noise([channel[x] for x in self.candidates])
            (h, w) = chan.shape

            chan = color.scaler(chan)
            ### Executes further denoising, which helps later on
            #chan = noise.denoise(chan, mode=self.denoise_mode)
            chan = gaussian(chan, 5)

            ### Finding binary edges in the smoothed image
            #chan = rank.gradient(chan, disk(int(h*w/55756.)))
            chan = color.scaler(chan)
            if self.threshold == 'otsu':
                chan = chan > threshold_otsu(chan)
            elif self.threshold == 'gauss':
                n_dist = 3 if channel['s'].std() > 0.05 else 4
                chan = chan > gauss.threshold_gauss(chan, n_dist)
            elif self.threshold == 'kmeans':
                n_dist = 3 if channel['s'].std() > 0.05 else 4
                chan = chan > gauss.threshold_kmeans(chan, n_dist)

            ### Transforming contours into shapes at last by closing gaps
            # For sample3.jpg, these are the total time for each function:
            # skimage's dilation: 11 s
            # scipy's dilation: 7 s
            # mahota's dilation: 3 s
            chan = mahotas.dilate(chan, disk(h / 46))
            chan = mahotas.erode(chan, disk(h / 46))

            chan = ndi.binary_fill_holes(chan)

            ### Selects largest contour, supposedly to be the whale
            label_objects, nb_labels = ndi.label(chan)
            sizes = np.bincount(label_objects.ravel())
            mask_sizes = sizes == np.sort(sizes)[-2]
            chan = mask_sizes[label_objects]

            ### Draw boundary rectangle
            rectangles.append(blob.bound_rect(chan))

        return rectangles
def test_signed():
    A = np.array([0,0,1,1,1,0,0,0], dtype=np.int32)
    B = np.array([0,1,0])
    assert np.min(mahotas.erode(A,B)) == -1
Exemple #28
0
  def split_new(image, binary):
    '''
    '''

    bbox = mh.bbox(binary)
    
    sub_image = np.array(image[bbox[0]:bbox[1], bbox[2]:bbox[3]])
    sub_binary = np.array(binary[bbox[0]:bbox[1], bbox[2]:bbox[3]])

    sub_binary_border = mh.labeled.borders(sub_binary, Bc=mh.disk(3))    
    
    sub_binary = mh.erode(sub_binary.astype(np.bool))
    for e in range(5):
      sub_binary = mh.erode(sub_binary)
    # sub_binary = mh.erode(sub_binary)    
    

    if sub_image.shape[0] < 2 or sub_image.shape[1] < 2:
      return np.zeros(binary.shape, dtype=np.bool), np.zeros(binary.shape, dtype=np.bool)

    #
    # smooth the image
    #
    sub_image = mh.gaussian_filter(sub_image, 3.5)

    grad_x = np.gradient(sub_image)[0]
    grad_y = np.gradient(sub_image)[1]
    grad = np.add(np.abs(grad_x), np.abs(grad_y))

    grad -= grad.min()
    grad /= grad.max()
    grad *= 255
    grad = grad.astype(np.uint8)
    
    coords = zip(*np.where(sub_binary==1))

    if len(coords) < 2:
      print 'STRAAAAANGE'
      return np.zeros(binary.shape, dtype=np.bool), np.zeros(binary.shape, dtype=np.bool)

    seed1 = random.choice(coords)
    seed2 = random.choice(coords)
    seeds = np.zeros(sub_binary.shape, dtype=np.uint64)
    seeds[seed1] = 1
    seeds[seed2] = 2

    for i in range(10):
      seeds = mh.dilate(seeds)

    ws = mh.cwatershed(grad, seeds)
    ws[sub_binary==0] = 0

#     ws_relabeled = skimage.measure.label(ws.astype(np.uint8))
#     ws_relabeled[sub_binary==0] = 0
#     max_label = ws_relabeled.max()
#     plt.figure()
#     imshow(ws)

    binary_mask = Util.threshold(ws, ws.max())
    border = mh.labeled.border(ws, ws.max(), ws.max()-1, Bc=mh.disk(2))
#     border[sub_binary_border == 1] = 0 # remove any "real" border pixels
    
#     plt.figure()
#     imshow(binary_mask)

#     plt.figure()
#     imshow(border)

    
    large_label = np.zeros(binary.shape, dtype=np.bool)
    large_border = np.zeros(binary.shape, dtype=np.bool)
    large_label[bbox[0]:bbox[1], bbox[2]:bbox[3]] = binary_mask
    large_border[bbox[0]:bbox[1], bbox[2]:bbox[3]] = border
    
    return large_label, large_border
def test_erode_slice():
    np.random.seed(30)
    for i in range(16):
        f = (np.random.random_sample((256,256))*255).astype(np.uint8)
        assert np.all(mahotas.erode(f[:3,:3]) == mahotas.erode(f[:3,:3].copy()))
Exemple #30
0
def _classify(path, name, frames, channels, target, choices, CellObject):
    gnp.free_reuse_cache()
    #GPU TO USE, WE HAVE 2, I PREFER IF YOU'RE USING GPU 0
    #whole images take up a lot of memory so we need to coordinate this. 
    # if you're not using the notebook or a script make sure to shutdown or restart the notebook
    # you can use nvidia-smi in terminal to see what process are running on the GPU
    gnp._useGPUid = 0
    #protein localization categories
    localizationTerms=['ACTIN', 'BUDNECK', 'BUDTIP', 'CELLPERIPHERY', 'CYTOPLASM',
       'ENDOSOME', 'ER', 'GOLGI', 'MITOCHONDRIA', 'NUCLEARPERIPHERY',
       'NUCLEI', 'NUCLEOLUS', 'PEROXISOME', 'SPINDLE', 'SPINDLEPOLE',
       'VACUOLARMEMBRANE', 'VACUOLE']
    
    #normalization values (don't need to change)
    norm_vals = np.load('/home/morphology/mpg4/OrenKraus/Data_Sets/Yeast_Protein_Localization/Yolanda_Chong/overal_mean_std_for_single_cell_crops_based_on_Huh.npz')

    #may change to better model (constatly training bgnumpy.track_memory_usage=Trueetter networks)
    model_path = '/home/okraus/mil_models_backup/mil_models/Yeast_Protein_Localization/Yeast_NAND_a_10_scratch_Dropout_v5_MAP_early_stopping_best_model.npz'

    #load model and set evaluation type (MIL convolves across whole images)
    #change size
   

    curImages, sizes = getImageData(path, frames, channels)
    curImages = normalize_by_constant_values(curImages,norm_vals['means'],norm_vals['stdevs'])
    
    sizeX=sizes[1]
    sizeY=sizes[0]

    nn = modelEvalFunctions.loadResizedModel(model_path,sizeY,sizeX)
    model = modelEvalFunctions.evaluateModel_MIL(nn,localizationTerms,outputLayer='loc')

    
    nn.ForwardProp({'X0':gnp.garray(curImages)})

    # GET RATIOS OF CLASSES
    #values of prediction maps above
    pred_maps = nn._layers['MIL_pool'].Z[target-1].as_numpy_array()
    #calculate relative activation of each map
    area = pred_maps.sum(1).sum(1) / pred_maps.sum()
    #calculate absolute area of each map (optional)
    area2 = pred_maps.sum(1).sum(1) / (pred_maps.shape[1]*pred_maps.shape[2])
    #plot relative activations per class, use area or area2
    area_lib = {}

    jacobian = getJacobian(nn,frames)
    plt.imshow(jacobian[target-1,0])
    loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0]+"_FULL0")
    save(loc)
    
    mahotas_segmentation = mahotas_clean_up_seg(jacobian,target-1)
    plt.imshow(mahotas_segmentation)
    loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0]+"_FULL1")
    save(loc)

    show_segmentation_boundaries(curImages,mahotas_segmentation,target-1,sizeX, sizeY)
    loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0]+"_FULL2")
    save(loc)

    top5indices = np.argsort(area)[::-1][:5]
    del jacobian
    del mahotas_segmentation

    for i in range(len(localizationTerms)):
        if i in top5indices:
            area_lib[localizationTerms[i]] = area[i]
            jacobian_per_class = getJacobian_per_class(nn,i,frames)
            im2show = mahotas_clean_up_seg(jacobian_per_class, target-1)
            overlay(curImages,im2show,target-1,sizeX, sizeY)
            loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0]+"_"+localizationTerms[i])
            save(loc)
            np.save(loc, im2show)
            continue
        if localizationTerms[i] not in choices:
            continue
        area_lib[localizationTerms[i]] = area[i]
        jacobian_per_class = getJacobian_per_class(nn,i,frames)[target-1]
        im2show = np.int8(np.log(1+jacobian_per_class[0])>0.1+np.int8(np.log(1+jacobian_per_class[1])>1))>0
        im2show = mh.dilate(mh.dilate(mh.dilate(mh.erode(mh.erode(mh.erode(im2show>0))))))
        overlay(curImages,im2show,target-1,sizeX, sizeY)
        loc = str(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0]+"_"+localizationTerms[i])
        save(loc)
        np.save(loc, im2show)
    del nn
    del model
    gnp.free_reuse_cache()
    f = [['Class', 'Area']]
    for key in area_lib:
        f.append([str(key), area_lib[key]])
    CellObject.activations = f
    CellObject.save()
    from openpyxl import Workbook
    wb = Workbook()
    ws = wb.active
    for arr in f:
        ws.append(arr)
    wb.save(settings.MEDIA_ROOT + '/classes/' + name.split('.')[0] + '.xlsx')
    if CellObject.email != '':
        send_mail('Deep Cell Vision', 'Your image has been classified. Go to http://deepcellvision.com/results/' +CellObject.name + ' to see your results' , '*****@*****.**',
    [CellObject.email], fail_silently=False)
    return
Exemple #31
0
    def doLocalNMF(self, x, y, roi, n_comp=7, diskSizeMultiplier=3):
        # do NMF decomposition
        n = NMF(n_components=n_comp, tol=1e-1)

        xmin_nmf = max(0, int(x - self.diskSize * diskSizeMultiplier))
        xmax_nmf = min(int(x + self.diskSize * diskSizeMultiplier), self.data.shape[0])
        ymin_nmf = max(0, int(y - self.diskSize * diskSizeMultiplier))
        ymax_nmf = min(int(y + self.diskSize * diskSizeMultiplier), self.data.shape[1])

        xcenter_nmf = (xmax_nmf - xmin_nmf) / 2
        ycenter_nmf = (ymax_nmf - ymin_nmf) / 2

        reshaped_sub_region_data = self.data_white[xmin_nmf:xmax_nmf, ymin_nmf:ymax_nmf, :].reshape(
            xmax_nmf - xmin_nmf * ymax_nmf - ymin_nmf, self.data.shape[2]
        )
        n.fit(reshaped_sub_region_data - reshaped_sub_region_data.min())
        transformed_sub_region_data = n.transform(reshaped_sub_region_data - reshaped_sub_region_data.min())
        modes = transformed_sub_region_data.reshape(xmax_nmf - xmin_nmf, ymax_nmf - ymin_nmf, n_comp).copy()

        modes = [m for m in np.rollaxis(modes, 2, 0)]
        params = []
        this_cell = []
        is_cell = []
        thresh_modes = []
        fit_data = []
        for i, mode in enumerate(modes):
            # threshold mode
            uint16_mode = (mode / mode.max() * 2 ** 16).astype("uint16")
            uint16_mode = mahotas.dilate(mahotas.erode(uint16_mode))
            uint16_mode = nd.gaussian_filter(uint16_mode, 1)
            thresh_mode = uint16_mode > mahotas.otsu(uint16_mode)
            # exclude all pixels less than 75% of typical size
            smallest_roi = 0.75 * self.diskSize * self.diskSize * np.pi
            thresh_mode = self.excludePixels(thresh_mode, smallest_roi).astype(int)

            thresh_modes.append(thresh_mode)
            #            thresh_mode = (mode.astype('uint16') > mahotas.otsu(mode.astype('uint16'))).astype(int)

            # fit thresholded mode
            fit_parameters = self.fitgaussian(thresh_mode)
            fit_height, fit_xcenter, fit_ycenter, fit_xwidth, fit_ywidth = fit_parameters
            params.append(fit_parameters)

            # is cell-like?
            if 1 <= np.abs(fit_xwidth) <= 2 * self.diskSize and 1 <= np.abs(fit_ywidth) <= 2 * self.diskSize:
                if 0.02 <= thresh_mode.sum() / float(thresh_mode.size) <= 0.40:
                    is_cell.append(True)
                else:
                    is_cell.append(False)
            else:
                is_cell.append(False)

            # is this cell?
            if (
                np.linalg.norm(np.array([xcenter_nmf, ycenter_nmf]) - np.array([fit_xcenter, fit_ycenter]))
                < self.diskSize * 1.5
            ):
                this_cell.append(True)
            else:
                this_cell.append(False)

            fit_gaussian = self.gaussian(*fit_parameters)
            xcoords = np.mgrid[0 : xmax_nmf - xmin_nmf, 0 : ymax_nmf - ymin_nmf][0]
            ycoords = np.mgrid[0 : xmax_nmf - xmin_nmf, 0 : ymax_nmf - ymin_nmf][1]
            fit_data.append(fit_gaussian(xcoords, ycoords))

        #       print 'this cell', this_cell
        #       print 'is cell', is_cell
        #       print ' '

        return (
            modes,
            thresh_modes,
            fit_data,
            np.array(this_cell),
            np.array(is_cell),
            (xmin_nmf, xmax_nmf, ymin_nmf, ymax_nmf),
        )
    #ilastik_filename = img_filename.replace('.png', '.png_processed.h5')
    #prob_file = h5py.File('Thousands_mito_em_s1152.png_processed (1).h5', 'r')
    #label_index = 1
    #mito_prob = prob_file['/volume/prediction'][0,0,:,:,label_index]
    #prob_file.close()
    
    # load the results
    
    ilastik_filename = img_filename.replace('.png', '.png_processed.h5')
    prob_file = h5py.File('Thousands_mito_em_s1150.png_processed.h5', 'r')
    label_index = 1
    mito_prob = prob_file['/volume/prediction'][0,0,:,:,label_index]
    prob_file.close()
    blur_img = scipy.ndimage.gaussian_filter(mito_prob, 13)
    mito_pred2 = blur_img<.85
    mito_pred2 = mahotas.erode(mito_pred2, disc)

    
    prob_file2 = h5py.File('Thousands_mito_em_s1151.png_processed.h5', 'r')
    label_index = 1
    mito_prob2 = prob_file2['/volume/prediction'][0,0,:,:,label_index]
    prob_file2.close()
    blur_img2 = scipy.ndimage.gaussian_filter(mito_prob2, 13)
    mito_pred22 = blur_img2<.85
    mito_pred22 = mahotas.erode(mito_pred22, disc)

    
    prob_file3 = h5py.File('Thousands_mito_em_s1152.png_processed.h5', 'r')
    label_index = 1
    mito_prob3 = prob_file3['/volume/prediction'][0,0,:,:,label_index]
    prob_file3.close()
	input_vol = zeros((input_img.shape[0], input_img.shape[1], zd), dtype=uint8)
	for zoffset in range (zd):
		if zd == zrad:
			input_vol[:,:,zoffset] = input_img
		else:
			input_vol[:,:,zoffset] = normalize_image(mahotas.imread('D:\\dev\\datasets\\isbi\\train-input\\train-input_{0:04d}.tif'.format(imgi - zrad + zoffset)))
			#input_vol[:,:,zoffset] = mahotas.imread('D:\\dev\\datasets\\isbi\\train-input\\train-input_{0:04d}.tif'.format(imgi - zrad + zoffset))

	blur_img = scipy.ndimage.gaussian_filter(input_img, gblur_sigma)

	boundaries = label_img==0;
	boundaries[0:-1,:] = np.logical_or(boundaries[0:-1,:],  diff(label_img, axis=0)!=0);
	boundaries[:,0:-1] = np.logical_or(boundaries[:,0:-1], diff(label_img, axis=1)!=0);

	# erode to be sure we include at least one membrane
	inside = mahotas.erode(boundaries == 0, shrink_disc)

	#display = input_img.copy()
	#display[np.nonzero(inside)] = 0
	#figure(figsize=(20,20))
	#imshow(display, cmap=cm.gray)

	seeds = label_img.copy()
	seeds[np.nonzero(inside==0)] = 0
	grow = mahotas.cwatershed(255-blur_img, seeds)

	membrane = np.zeros(input_img.shape, dtype=uint8)
	membrane[0:-1,:] = diff(grow, axis=0) != 0;
	membrane[:,0:-1] = np.logical_or(membrane[:,0:-1], diff(grow, axis=1) != 0);

	#display[np.nonzero(membrane)] = 2
    
    # Values for the erode/dilate functions

    radius = 1.5
    y,x = np.ogrid[-radius:radius+1, -radius:radius+1]
    disc = x*x + y*y <= radius*radius

   

    
    
  
    
   
##  # Erode makes everything smaller and removes small objects
    mito_pred2 = mahotas.erode(mito_pred2, disc)
##  # Dilate makes everything bigger and removes small holes
    # mito_pred2 = mahotas.dilate(mito_pred2, disc)

    # Predictions
    pylab.imshow(mito_pred2)
    pylab.gray()
    pylab.show()

    # Display the target output
    pylab.imshow(mito_img)
    pylab.gray()
    pylab.show()

    # Measure the result
    true_positives_h5 = np.sum(np.logical_and(mito_pred2 > 0, mito_img > 0))