Question

以下是航拍图像示例：！[一些未冻结的湖泊的空中图像] [1]

如何从图像中自动检测和提取黑色未冻湖的参数？我主要使用Python。

编辑：请参阅下面的答案;我想我找到了解决方案。

Answer 1

这是一个图像分割问题，通常有很多不同的方法可以解决它。这里最简单的方法似乎是区域增长：

查找灰度值低于您选择的某个阈值的每个像素，将黑色与白色分开 - 这些像素是您的“种子”。
使用您只会泛滥成灰色值也低于某个阈值（可能与之前相同但可能不同）的像素的生长条件从它们中溢出。当您无法进一步扩展您所拥有的区域时终止。在洪水过程中，将彼此可到达的种子组合到同一区域。该过程将产生许多连接区域。您可以在洪水过程中跟踪这些区域的大小。
删除任何低于特定大小的区域（或者，如果您只对最大的湖泊感兴趣，请选择您拥有的最大区域）。
从属于湖泊的像素计算您想要的参数。例如，湖泊的平均灰度值将是湖泊中像素的灰度值的平均值等。不同的参数将需要不同的技术。

Answer 2

我使用以下内容得到它：

###Credits:
###http://stackoverflow.com/questions/9525313/rectangular-bounding-box-around-blobs-in-a-monochrome-image-using-python
###http://stackoverflow.com/questions/4087919/how-can-i-improve-my-paw-detection

import numpy as np
import scipy.ndimage as ndimage
import scipy.spatial as spatial
import scipy.misc as misc
import matplotlib.pyplot as plt
import matplotlib.patches as patches

class BBox(object):
    def __init__(self, x1, y1, x2, y2):
        '''
        (x1, y1) is the upper left corner,
        (x2, y2) is the lower right corner,
        with (0, 0) being in the upper left corner.
        '''
        if x1 > x2: x1, x2 = x2, x1
        if y1 > y2: y1, y2 = y2, y1
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2
    def taxicab_diagonal(self):
        '''
        Return the taxicab distance from (x1,y1) to (x2,y2)
        '''
        return self.x2 - self.x1 + self.y2 - self.y1
    def overlaps(self, other):
        '''
        Return True iff self and other overlap.
        '''
        return not ((self.x1 > other.x2)
                    or (self.x2 < other.x1)
                    or (self.y1 > other.y2)
                    or (self.y2 < other.y1))
    def __eq__(self, other):
        return (self.x1 == other.x1
                and self.y1 == other.y1
                and self.x2 == other.x2
                and self.y2 == other.y2)

def find_paws(data, smooth_radius = 5, threshold = 0.0001):
    # http://stackoverflow.com/questions/4087919/how-can-i-improve-my-paw-detection
    """Detects and isolates contiguous regions in the input array"""
    # Blur the input data a bit so the paws have a continous footprint 
    data = ndimage.uniform_filter(data, smooth_radius)
    # Threshold the blurred data (this needs to be a bit > 0 due to the blur)
    thresh = data > threshold
    # Fill any interior holes in the paws to get cleaner regions...
    filled = ndimage.morphology.binary_fill_holes(thresh)
    # Label each contiguous paw
    coded_paws, num_paws = ndimage.label(filled)
    # Isolate the extent of each paw
    # find_objects returns a list of 2-tuples: (slice(...), slice(...))
    # which represents a rectangular box around the object
    data_slices = ndimage.find_objects(coded_paws)
    return data_slices

def slice_to_bbox(slices):
    for s in slices:
        dy, dx = s[:2]
        yield BBox(dx.start, dy.start, dx.stop+1, dy.stop+1)

def remove_overlaps(bboxes):
    '''
    Return a set of BBoxes which contain the given BBoxes.
    When two BBoxes overlap, replace both with the minimal BBox that contains both.
    '''
    # list upper left and lower right corners of the Bboxes
    corners = []

    # list upper left corners of the Bboxes
    ulcorners = []

    # dict mapping corners to Bboxes.
    bbox_map = {}

    for bbox in bboxes:
        ul = (bbox.x1, bbox.y1)
        lr = (bbox.x2, bbox.y2)
        bbox_map[ul] = bbox
        bbox_map[lr] = bbox
        ulcorners.append(ul)
        corners.append(ul)
        corners.append(lr)        

    # Use a KDTree so we can find corners that are nearby efficiently.
    tree = spatial.KDTree(corners)
    new_corners = []
    for corner in ulcorners:
        bbox = bbox_map[corner]
        # Find all points which are within a taxicab distance of corner
        indices = tree.query_ball_point(
            corner, bbox_map[corner].taxicab_diagonal(), p = 1)
        for near_corner in tree.data[indices]:
            near_bbox = bbox_map[tuple(near_corner)]
            if bbox != near_bbox and bbox.overlaps(near_bbox):
                # Expand both bboxes.
                # Since we mutate the bbox, all references to this bbox in
                # bbox_map are updated simultaneously.
                bbox.x1 = near_bbox.x1 = min(bbox.x1, near_bbox.x1)
                bbox.y1 = near_bbox.y1 = min(bbox.y1, near_bbox.y1) 
                bbox.x2 = near_bbox.x2 = max(bbox.x2, near_bbox.x2)
                bbox.y2 = near_bbox.y2 = max(bbox.y2, near_bbox.y2) 
    return set(bbox_map.values())

if __name__ == '__main__':
    fig = plt.figure()
    ax = fig.add_subplot(111)

    data = misc.imread('sampleKiteLakeImage.jpg')
    im = ax.imshow(data)    
    data_slices = find_paws(255-data, smooth_radius = 2, threshold = 200)

    bboxes = slice_to_bbox(data_slices) #remove_overlaps(slice_to_bbox(data_slices))
    for bbox in bboxes:
        xwidth = bbox.x2 - bbox.x1
        ywidth = bbox.y2 - bbox.y1
        p = patches.Rectangle((bbox.x1, bbox.y1), xwidth, ywidth,
                              fc = 'none', ec = 'red')
        ax.add_patch(p)

    plt.show()

这是带有重叠框的最终图像。 boxes outlining lakes with no overlap

请

bboxes = slice_to_bbox(data_slices) #remove_overlaps(slice_to_bbox(data_slices))

到

bboxes = remove_overlaps(slice_to_bbox(data_slices))

摆脱重叠： boxes outlining lakes with overlap

Answer 3

以下是在SimpleCV中快速完成此操作的方法：

from SimpleCV import *

lakeimg = Image('http://i.stack.imgur.com/ku8F8.jpg') #load this image from web, or could be locally if you wanted.
invimg = lakeimg.invert() #we invert because blobs looks for white blobs, not black
lakes = invimg.findBlobs() # you can always change parameters to find different sized blobs
if lakes: lakes.draw() #if it finds blobs then draw around them
invimg.show() #display the image

如果您希望始终可以使用参数，通常我们会根据图像大小使用比率，如果您希望它相当健壮。要素类中还有一些选项可用于在几个blob等上绘制边界框。

Answer 4

据我所知，您可以创建亮度低于阈值（[0,1]数组）的区域数组。有一些方法可以计算形状的数量/大小等，例如递归删除。

如何在空中图像中检测白雪皑皑的背景上的黑色湖泊？

4 个答案: