Exemple #1
0
def logglobal(img,
              holder,
              DEBRISAREA=50,
              MAXSIZE=1000,
              OPENING=2,
              NUCRAD=10,
              magnitude=2,
              SHRINK=0,
              REGWSHED=10,
              HPASS=2.5,
              GLAP=3,
              CIRC_THRESH=0.8):
    logimg = np.log(img)
    highpassImg = highpassfilter(logimg, NUCRAD * HPASS)
    sharpLogimg = logimg + magnitude * highpassImg
    lapSharpLogimg = gaussian_laplace(sharpLogimg, NUCRAD / GLAP)
    lapSharpLogimg = lapSharpLogimg - lapSharpLogimg.min()
    lapSharpLogimg = lapSharpLogimg.max() - lapSharpLogimg
    img = lapSharpLogimg
    global_thresh = skifilter.threshold_otsu(img)
    bw = img > global_thresh
    bw = sizefilterandopen(bw, DEBRISAREA, MAXSIZE, OPENING)
    if SHRINK > 0:
        bw = binary_erosion(bw, np.ones((SHRINK, SHRINK)))
    label = devide_and_label_objects(bw, REGWSHED)
    label = sizefilter_for_label(label, DEBRISAREA, MAXSIZE, OPENING)
    label = circularity_thresh(label, CIRC_THRES)
    label = skilabel(clear_border(label, buffer_size=2))
    return label
Exemple #2
0
def lapgauss_adaptive(img,
                      holder,
                      RATIO=3.0,
                      FILTERINGSIZE=50,
                      SIGMA=2.5,
                      DEBRISAREA=50,
                      MAXSIZE=1000,
                      OPENING=2,
                      SHRINK=0,
                      REGWSHED=10,
                      COPEN=1,
                      THINERODE=4,
                      CIRC_THRES=0.8):
    bw = extract_foreground_adaptive(img, RATIO, FILTERINGSIZE)
    cimg = calc_lapgauss(img, SIGMA)
    bw[cimg > 0] = 0
    bw = binary_fill_holes(bw)
    bw = skimorph.remove_small_objects(bw, DEBRISAREA, connectivity=4)
    bw = binary_opening(bw, np.ones((int(COPEN), int(COPEN))))
    bw = remove_thin_objects(bw, THINERODE)
    bw = sizefilterandopen(bw, DEBRISAREA, MAXSIZE, OPENING)
    if SHRINK > 0:
        bw = binary_erosion(bw, np.ones((SHRINK, SHRINK)))
    label = devide_and_label_objects(bw, REGWSHED)
    label = sizefilter_for_label(label, DEBRISAREA, MAXSIZE, OPENING)
    label = circularity_thresh(label, CIRC_THRES)
    label = skilabel(clear_border(label, buffer_size=2))
    return label
Exemple #3
0
def lapgauss_constant(img,
                      holder,
                      SIGMA=2.5,
                      DEBRISAREA=50,
                      MAXSIZE=1000,
                      OPENING=2,
                      SHRINK=0,
                      REGWSHED=10,
                      THRES=0.3,
                      COPEN=1,
                      THINERODE=4,
                      CIRC_THRES=0.8):
    cimg = calc_lapgauss(img, SIGMA)
    bw = cimg > THRES
    bw = binary_fill_holes(bw)
    bw = skimorph.remove_small_objects(bw, DEBRISAREA, connectivity=4)
    bw = binary_opening(bw, np.ones((COPEN, COPEN)))
    bw = remove_thin_objects(bw, THINERODE)
    bw = sizefilterandopen(bw, DEBRISAREA, MAXSIZE, OPENING)
    if SHRINK > 0:
        bw = binary_erosion(bw, np.ones((SHRINK, SHRINK)))
    label = devide_and_label_objects(bw, REGWSHED)
    label = sizefilter_for_label(label, DEBRISAREA, MAXSIZE, OPENING)
    label = circularity_thresh(label, CIRC_THRES)
    label = skilabel(clear_border(label, buffer_size=2))
    return label
def logadaptivegauss(img,
                     holder,
                     DEBRISAREA=50,
                     MAXSIZE=1000,
                     OPENING=2,
                     magnitude=2,
                     NUCRAD=10,
                     FILTERINGSIZE=100,
                     T=10,
                     SHRINK=0,
                     REGWSHED=10,
                     GLAP=3,
                     HPASS=2.5):
    logimg = np.log(img)
    highpassImg = highpassfilter(logimg, NUCRAD * HPASS)
    sharpLogimg = logimg + magnitude * highpassImg
    lapSharpLogimg = gaussian_laplace(sharpLogimg, NUCRAD / GLAP)
    lapSharpLogimg = lapSharpLogimg - lapSharpLogimg.min()
    lapSharpLogimg = lapSharpLogimg.max() - lapSharpLogimg
    img = lapSharpLogimg

    fim = gaussian_filter(img, FILTERINGSIZE)
    bw = img > fim * (1. + T / 100.)
    bw = sizefilterandopen(bw, DEBRISAREA, MAXSIZE, OPENING)
    if SHRINK > 0:
        bw = binary_erosion(bw, np.ones((SHRINK, SHRINK)))
    label = devide_and_label_objects(bw, REGWSHED)
    label = sizefilter_for_label(label, DEBRISAREA, MAXSIZE, OPENING)
    label = skilabel(clear_border(label, buffer_size=2))
    return label
Exemple #5
0
def adaptivethreshwithglobal_neckcut(img,
                                     holder,
                                     ADAPTIVEBLOCK=21,
                                     DEBRISAREA=50,
                                     MAXSIZE=1000,
                                     OPENING=2,
                                     FILTERSIZE=1,
                                     THRESHRELATIVE=1,
                                     SHRINK=0,
                                     REGWSHED=10,
                                     THRES_ANGLE=181,
                                     EDGELEN=5):
    img = gaussian_filter(img, FILTERSIZE)
    global_thresh = skifilter.threshold_otsu(img)
    bw = skifilter.threshold_adaptive(img, ADAPTIVEBLOCK, 'gaussian')
    bw = bw * img > global_thresh * THRESHRELATIVE
    bw = sizefilterandopen(bw, DEBRISAREA, MAXSIZE, OPENING)
    if SHRINK > 0:
        bw = binary_erosion(bw, np.ones((SHRINK, SHRINK)))
    label = devide_and_label_objects(bw, REGWSHED)

    cl_label = clear_border(label)
    outlines = labels2outlines(cl_label)
    rps = regionprops(outlines)
    good_coords = []
    for cell in rps:
        score, coords = calc_neck_score_thres(cell.coords,
                                              edgelen=EDGELEN,
                                              thres=THRES_ANGLE)

        if len(score) > 1:
            r0, c0 = coords[0, :]
            # Find candidates
            for cand in coords[1:, :]:
                cut_label = cut_neck(cl_label == cell.label, r0, c0, cand[0],
                                     cand[1])
                cand_label = skilabel(cut_label)
                cand_rps = regionprops(cand_label)
                cand_rps = [i for i in cand_rps if i.area > DEBRISAREA]
                if len(cand_rps) > 1:
                    good_coords.append([r0, c0, cand[0], cand[1]])
                    break
        # Reflect cut in the label
        for gc in good_coords:
            cut_neck(label, *gc)
    return label
def global_otsu(img,
                holder,
                FILTERSIZE=1,
                DEBRISAREA=50,
                MAXSIZE=1000,
                OPENING=2,
                SHRINK=0,
                REGWSHED=10):
    img = gaussian_filter(img, FILTERSIZE)
    global_thresh = skifilter.threshold_otsu(img)
    bw = img > global_thresh
    bw = sizefilterandopen(bw, DEBRISAREA, MAXSIZE, OPENING)
    if SHRINK > 0:
        bw = binary_erosion(bw, np.ones((SHRINK, SHRINK)))
    label = devide_and_label_objects(bw, REGWSHED)
    label = sizefilter_for_label(label, DEBRISAREA, MAXSIZE, OPENING)
    label = skilabel(clear_border(label, buffer_size=2))
    return label
def adaptivethresh2blocks(img,
                          holder,
                          ADAPTIVEBLOCK=21,
                          DEBRISAREA=50,
                          MAXSIZE=1000,
                          OPENING=2,
                          FILTERSIZE=1,
                          SHRINK=0,
                          REGWSHED=10):
    img = gaussian_filter(img, FILTERSIZE)
    bw = skifilter.threshold_adaptive(img, ADAPTIVEBLOCK, 'gaussian')
    bw2 = skifilter.threshold_adaptive(img, img.shape[0] / 4, 'gaussian')
    bw = bw * bw2
    bw = sizefilterandopen(bw, DEBRISAREA, MAXSIZE, OPENING)
    if SHRINK > 0:
        bw = binary_erosion(bw, np.ones((SHRINK, SHRINK)))
    label = devide_and_label_objects(bw, REGWSHED)
    label = sizefilter_for_label(label, DEBRISAREA, MAXSIZE, OPENING)
    label = skilabel(clear_border(label, buffer_size=2))
    return label
def adaptivethreshwithglobal(img,
                             holder,
                             ADAPTIVEBLOCK=21,
                             DEBRISAREA=50,
                             MAXSIZE=1000,
                             OPENING=2,
                             FILTERSIZE=1,
                             THRESHRELATIVE=1,
                             SHRINK=0,
                             REGWSHED=10):
    img = gaussian_filter(img, FILTERSIZE)
    global_thresh = skifilter.threshold_otsu(img)
    bw = skifilter.threshold_adaptive(img, ADAPTIVEBLOCK, 'gaussian')
    bw = bw * img > global_thresh * THRESHRELATIVE
    bw = sizefilterandopen(bw, DEBRISAREA, MAXSIZE, OPENING)
    if SHRINK > 0:
        bw = binary_erosion(bw, np.ones((SHRINK, SHRINK)))
    label = devide_and_label_objects(bw, REGWSHED)
    label = sizefilter_for_label(label, DEBRISAREA, MAXSIZE, OPENING)
    label = skilabel(clear_border(label, buffer_size=2))
    return label