Python skimage.morphology 模块，medial_axis() 实例源码

def to_sdf(self):
        """ Converts the 2D image to a 2D signed distance field.

        Returns
        -------
        :obj:`numpy.ndarray`
            2D float array of the signed distance field
        """
        # compute medial axis transform
        skel, sdf_in = morph.medial_axis(self.data, return_distance=True)
        useless_skel, sdf_out = morph.medial_axis(
            np.iinfo(np.uint8).max - self.data, return_distance=True)

        # convert to true sdf
        sdf = sdf_out - sdf_in
        return sdf

def execute_Skeleton(proxy,obj):

    from skimage.morphology import medial_axis

    threshold=0.1*obj.threshold

    try: 
        img2=obj.sourceObject.Proxy.img
        img=img2.copy()
    except: 
        sayexc()
        img=cv2.imread(__dir__+'/icons/freek.png')

    data = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # Compute the medial axis (skeleton) and the distance transform
    skel, distance = medial_axis(data, return_distance=True)

    # Distance to the background for pixels of the skeleton
    dist_on_skel = distance * skel

    # entferne ganz duenne linien
    dist_on_skelw =(dist_on_skel >= threshold)* distance

    say("size of the image ...")
    say(dist_on_skelw.shape)
#   skel = np.array(dist_on_skelw,np.uint8) 
    skel = np.array(dist_on_skelw *255/np.max(dist_on_skelw),np.uint8) 
    obj.Proxy.img=cv2.cvtColor(skel*100, cv2.COLOR_GRAY2BGR)
    obj.Proxy.dist_on_skel=dist_on_skelw

def place_routers_on_skeleton(d, cmethod):
    wireless = np.where(d["graph"] == Cell.Wireless, 1, 0)
    # perform skeletonization
    skeleton = skeletonize(wireless)
    med_axis = medial_axis(wireless)

    skel = skeleton
    # skel = med_axis
    # get all skeleton positions
    pos = []
    for i in range(skel.shape[0]):
        for j in range(skel.shape[1]):
            if skel[i][j]:
                pos.append((i, j))

    budget = d['budget']
    shuffle(pos)

    max_num_routers = min([int(d['budget'] / d['price_router']), len(pos)])
    print("Num of routers constrained by:")
    print(" budget:   %d" % int(int(d['budget'] / d['price_router'])))
    print(" skeleton: %d" % len(pos))

    for i in tqdm(range(max_num_routers), desc="Placing Routers"):
        new_router = pos[i]
        a, b = new_router

        # check if remaining budget is enough
        d["graph"][a][b] = Cell.Router
        d, ret, cost = _add_cabel(d, new_router, budget)
        budget -= cost

        if not ret:
            break

    return d

def place_routers_on_skeleton_iterative(d, cmethod):
    budget = d['budget']
    R = d['radius']
    max_num_routers = int(d['budget'] / d['price_router'])
    coverage = np.where(d["graph"] == Cell.Wireless, 1, 0).astype(np.bool)

    pbar = tqdm(range(max_num_routers), desc="Placing Routers")
    while budget > 0:
        # perform skeletonization
        # skeleton = skeletonize(coverage)
        skeleton = medial_axis(coverage)
        # get all skeleton positions
        pos = np.argwhere(skeleton > 0).tolist()
        # escape if no positions left
        if not len(pos):
            break
        # get a random position
        shuffle(pos)
        a, b = pos[0]
        # place router
        d["graph"][a][b] = Cell.Router
        d, ret, cost = _add_cabel(d, (a, b), budget)
        if not ret:
            print("No budget available!")
            break
        budget -= cost
        # refresh wireless map by removing new coverage
        m = wireless_access(a, b, R, d['graph']).astype(np.bool)
        coverage[(a - R):(a + R + 1), (b - R):(b + R + 1)] &= ~m
        pbar.update()
    pbar.close()

    return d

def medial_axis(data, idx, branch = True):
    h, w = data.shape
    data = data.ravel()
    for id in idx:

        if data[id]==0:continue
        i2=id-w;i8=id+w;i1=i2-1;i3=i2+1;
        i4=id-1;i6=id+1;i7=i8-1;i9=i8+1;

        c = (data[i1]>0)<<0|(data[i2]>0)<<1\
            |(data[i3]>0)<<2|(data[i4]>0)<<3\
            |(data[i6]>0)<<4|(data[i7]>0)<<5\
            |(data[i8]>0)<<6|(data[i9]>0)<<7
        if (lut[c//8]>> c%8) &1:data[id]=0
    return 0;

def mid_axis(img):
    dis = ndimg.distance_transform_edt(img)
    idx = np.argsort(dis.flat).astype(np.int32)
    medial_axis(dis, idx, lut)
    return dis

def execute_FatColor(proxy,obj):

    import matplotlib.pyplot as plt

    from skimage.morphology import medial_axis

    try: 
        img2=obj.sourceObject.Proxy.img
        img=img2.copy()
    except: 
        sayexc()
        img=cv2.imread(__dir__+'/icons/freek.png')

    lower = np.array([255,255,255])
    upper = np.array([255,255,255])

    mask = cv2.inRange(img, lower, upper)
    res = cv2.bitwise_and(img,img, mask= mask)

    ks=3
    kernel = np.ones((ks,ks),np.uint8)

    kernelPLUS=np.array([[0, 1, 0],
           [1, 1, 1],
           [0, 1, 0]], dtype=np.uint8)

    kernelCROSS=np.array([[1, 0,1],
           [0, 1, 0],
           [1, 0, 1]], dtype=np.uint8)

    dilation = cv2.dilate(res,kernel,iterations = 1)
    erode1 = cv2.erode(res,kernelPLUS,iterations = 1)
    erode2 = cv2.erode(res,kernelCROSS,iterations = 1)
    erode = cv2.erode(res,kernel,iterations = 1)
    res=dilation
    res=erode1 + erode2 

    dilation = cv2.dilate(res,kernel,iterations = 1)
    res=dilation

#   plt.imshow(res, cmap=plt.cm.PRGn, interpolation='nearest')
#   plt.show()

    obj.Proxy.img=res



#---------------------------------

def skeletonize_image(image, method=None, dilation=None, binarization=None,
                      invert=False):
    """Extract a 1 pixel wide representation of image by morphologically
    thinning the white contiguous blobs (connected components).
    If image is not black and white, a binarization process is applied
    according to binarization, which can be 'sauvola', 'isodata', 'otsu',
    'li' (default, ref: binarize()).

    A process of dilation can also be applied by specifying the number
    of pixels in dilate prior to extracting the skeleton.

    The method for skeletonization can be 'medial', '3d', 'regular', or a
    'combined' version of the three. Defaults to 'regular'.
    A 'thin' operator is also available. For reference,
    see http://scikit-image.org/docs/dev/auto_examples/edges/plot_skeleton.html
    """
    # if image is all one single color, return it
    if len(np.unique(image)) == 1:
        return image
    # scikit-image needs only 0's and 1's
    mono_image = binarize_image(image, method=binarization) / 255
    if invert:
        mono_image = invert_image(mono_image)
    if dilation:
        dilation = (2 * dilation) + 1
        dilation_kernel = np.ones((dilation, dilation), np.uint8)
        mono_image = cv2.morphologyEx(mono_image, cv2.MORPH_DILATE,
                                      dilation_kernel)
    with warnings.catch_warnings(record=True):
        warnings.filterwarnings('ignore', category=UserWarning)
        if method == '3d':
            skeleton = morphology.skeletonize_3d(mono_image)
        elif method == 'medial':
            skeleton = morphology.medial_axis(mono_image,
                                              return_distance=False)
        elif method == 'thin':
            skeleton = morphology.thin(mono_image)
        elif method == 'combined':
            skeleton = (morphology.skeletonize_3d(mono_image)
                        | morphology.medial_axis(mono_image,
                                                 return_distance=False)
                        | morphology.skeletonize(mono_image))
        else:
            skeleton = morphology.skeletonize(mono_image)
    return convert(skeleton)