python - 航空写真で白い雪の背景にある黒い湖を検出する方法は?

Question

航空写真のサンプルは次のとおりです: ![凍っていない湖の航空写真][1]

凍結していない黒い湖のパラメータを画像から自動的に検出して抽出するにはどうすればよいですか? 主にPythonを使用しています。

編集：以下の私の答えを見てください。私は解決策を見つけたと思います。

Answer 1

私はそれを次のものを使って持っています：

###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()

これが、ボックスが重なっている最終的な画像です。

作る

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

の中へ

bboxes = remove_overlaps(slice_to_bbox(data_slices))

重複を取り除くには：

Answer 2

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

必要に応じて、いつでもパラメーターを操作できます。通常、かなり堅牢にしたい場合は、画像サイズに対する比率を使用します。Features クラスには、いくつかのブロブなどにバウンディング ボックスを描画するためのオプションも多数あります。

Answer 3

これは画像のセグメンテーションの問題であり、一般にさまざまな方法で対処できます。ここでの最も簡単な方法は、領域を拡大することです。

• 黒と白を分離するために選択したしきい値よりもグレー値が低いすべてのピクセルを見つけます。これらのピクセルは「シード」です。
• グレー値が特定のしきい値を下回るピクセルにのみフラッドするという成長条件を使用して、それらからフラッドアウトします (おそらく以前と同じですが、異なる可能性があります)。領域をこれ以上拡張できなくなったら終了します。フラッディング プロセス中に、互いに到達可能なシードを同じ領域に結合します。このプロセスにより、多数の接続された領域が生成されます。フラッディング プロセス中にこれらの領域のサイズを追跡できます。
• 特定のサイズよりも小さいリージョンを削除します (または、最大の湖だけに関心がある場合は、最大のリージョンを選択します)。
• 湖の一部であるピクセルから必要なパラメーターを計算します。たとえば、湖の平均グレー値は、湖内のピクセルのグレー値の平均などになります。パラメーターごとに異なる手法が必要になります。

Answer 4

私が知っていることから、明るさがしきい値を下回る領域の配列を作成できます ([0,1] 配列)。再帰的な削除など、形状の数/サイズなどをカウントする方法がいくつかあります。