Bir Noel Ağacı nasıl tespit edilir? [kapalı]

Aşağıdaki görüntülerde görüntülenen Noel ağaçlarını tespit eden bir uygulamayı uygulamak için hangi görüntü işleme teknikleri kullanılabilir?

Tüm bu görüntüler üzerinde çalışacak çözümler arıyorum. Bu nedenle, haar kaskad sınıflandırıcıları veya şablon eşleştirme eğitimi gerektiren yaklaşımlar çok ilginç değildir.

Yalnızca Açık Kaynak teknolojilerini kullandığı sürece herhangi bir programlama dilinde yazılabilecek bir şey arıyorum . Çözüm, bu soruda paylaşılan görüntülerle test edilmelidir. Orada 6 giriş görüntüleri cevap bunların her işlem sonuçlarını göstermesi gerekir. Son olarak, her biri için çıkış görüntüsü olmalıdır kırmızı çizgiler tespit ağaç surround çizin.

Bu görüntülerdeki ağaçları programlı olarak nasıl tespit edersiniz?

İlginç ve diğerlerinden biraz farklı olduğunu düşündüğüm bir yaklaşımım var. Yaklaşımımdaki temel fark, diğerlerinden bazılarıyla karşılaştırıldığında, görüntü segmentasyon adımının nasıl gerçekleştirildiğidir - Python'un scikit-learn'undan DBSCAN kümeleme algoritmasını kullandım ; mutlaka tek bir net sentroidi bulunmayabilecek şekilsiz şekiller bulmak için optimize edilmiştir.

En üst seviyede yaklaşımım oldukça basittir ve yaklaşık 3 adıma ayrılabilir. Önce bir eşik (ya da aslında iki ayrı ve farklı eşiğin mantıksal "veya") uyguluyorum. Diğer cevapların çoğunda olduğu gibi, Noel ağacının sahnedeki daha parlak nesnelerden biri olacağını varsaydım, bu yüzden ilk eşik sadece basit bir tek renkli parlaklık testi; 0-255 ölçeğinde (siyahın 0 ve beyazın 255 olduğu) 220'nin üzerinde değerleri olan tüm pikseller, ikili siyah beyaz bir görüntüye kaydedilir. İkinci eşik, altı görüntünün sol üst ve sağ alt tarafındaki ağaçlarda özellikle belirgin olan kırmızı ve sarı ışıkları aramaya çalışır ve fotoğrafların çoğunda yaygın olan mavi-yeşil arka plana karşı iyi bir şekilde öne çıkar. RGB görüntüsünü hsv alanına çeviriyorum, ve renk tonunun 0.0-1.0 ölçeğinde (kabaca sarı ve yeşil arasındaki sınıra karşılık gelen) 0.2'den az veya 0.95'den (mor ve kırmızı arasındaki sınıra karşılık gelen) olmasını ve ayrıca parlak, doygun renklere gereksinim duymasını gerektirir: doygunluk ve değerin her ikisi de 0.7'nin üzerinde olmalıdır. İki eşik prosedürünün sonuçları mantıksal olarak "veya" - bir araya getirilir ve elde edilen siyah beyaz ikili görüntülerin matrisi aşağıda gösterilmiştir:

Her görüntünün, kabaca her ağacın konumuna karşılık gelen büyük bir piksel kümesine sahip olduğunu açıkça görebilirsiniz, ayrıca bazı görüntülerin bazılarında, bazı binaların pencerelerindeki ışıklara veya bir arka plan sahne ufukta. Bir sonraki adım, bilgisayarın bunların ayrı kümeler olduğunu tanımasını sağlamak ve her pikseli bir küme üyelik kimlik numarasıyla doğru bir şekilde etiketlemektir.

Bu görev için DBSCAN'ı seçtim . Burada bulunan diğer kümeleme algoritmalarına göre DBSCAN'ın tipik olarak nasıl davrandığına dair oldukça iyi bir görsel karşılaştırma var . Daha önce söylediğim gibi, amorf şekillerle iyi sonuç verir. DBSCAN çıktısı, her kümenin farklı bir renkte çizilmesiyle burada gösterilir:

Bu sonuca bakarken dikkat etmeniz gereken birkaç nokta var. Birincisi, DBSCAN'ın, davranışın düzenlenmesi için algoritmanın bir test noktasını toplamak yerine yeni bir ayrı küme bildirmesi için bir çift noktanın ne kadar ayrılması gerektiğini etkili bir şekilde kontrol eden bir "yakınlık" parametresi ayarlamasını gerektirmesidir. önceden var olan bir küme. Bu değeri, her görüntünün diyagonalinde 0,04 kat olarak ayarladım. Görüntülerin boyutu kabaca VGA'dan yaklaşık HD 1080'e kadar değiştiğinden, bu tür ölçeğe bağlı tanım kritiktir.

Dikkat çeken bir başka nokta, scikit-learn uygulamasında uygulandığı gibi DBSCAN algoritmasının, bu örnekteki daha büyük görüntülerin bazıları için oldukça zor olan bellek sınırlarına sahip olmasıdır. Bu nedenle, daha büyük görüntülerin bir kısmı için, bu sınırın içinde kalmak için aslında her kümeyi "yok etmek" (yani, yalnızca her 3. veya 4. pikselde tutmak ve diğerlerini bırakmak) gerekiyordu. Bu ayıklama işleminin bir sonucu olarak, kalan tek tek seyrek piksellerin bazı büyük görüntülerde görülmesi zordur. Bu nedenle, yalnızca görüntüleme amacıyla, yukarıdaki görüntülerdeki renk kodlu pikseller etkili bir şekilde "genişletilmiştir", böylece daha iyi görünürler. Bu sadece anlatı uğruna kozmetik bir operasyon; kodumda bu genişlemeden bahseden yorumlar olsa da,

Kümeler tanımlandıktan ve etiketlendikten sonra, üçüncü ve son adım kolaydır: Her görüntüdeki en büyük kümeyi basitçe alıyorum (bu durumda, toplam üye pikseli sayısı açısından "boyutu" ölçmeyi seçtim, ancak biri bunun yerine, fiziksel kapsamı ölçen bir tür metriği kolayca kullanabilir) ve bu küme için dışbükey gövdeyi hesaplar. Dışbükey gövde daha sonra ağaç sınırı haline gelir. Bu yöntemle hesaplanan altı dışbükey gövde aşağıda kırmızı renkle gösterilmiştir:

Kaynak kodu Python 2.7.6 için yazılmıştır ve bağlı numpy , SciPy , matplotlib ve scikit-öğrenirler . İki parçaya ayırdım. İlk bölüm gerçek görüntü işlemeden sorumludur:

from PIL import Image
import numpy as np
import scipy as sp
import matplotlib.colors as colors
from sklearn.cluster import DBSCAN
from math import ceil, sqrt

"""
Inputs:

    rgbimg:         [M,N,3] numpy array containing (uint, 0-255) color image

    hueleftthr:     Scalar constant to select maximum allowed hue in the
                    yellow-green region

    huerightthr:    Scalar constant to select minimum allowed hue in the
                    blue-purple region

    satthr:         Scalar constant to select minimum allowed saturation

    valthr:         Scalar constant to select minimum allowed value

    monothr:        Scalar constant to select minimum allowed monochrome
                    brightness

    maxpoints:      Scalar constant maximum number of pixels to forward to
                    the DBSCAN clustering algorithm

    proxthresh:     Proximity threshold to use for DBSCAN, as a fraction of
                    the diagonal size of the image

Outputs:

    borderseg:      [K,2,2] Nested list containing K pairs of x- and y- pixel
                    values for drawing the tree border

    X:              [P,2] List of pixels that passed the threshold step

    labels:         [Q,2] List of cluster labels for points in Xslice (see
                    below)

    Xslice:         [Q,2] Reduced list of pixels to be passed to DBSCAN

"""

def findtree(rgbimg, hueleftthr=0.2, huerightthr=0.95, satthr=0.7, 
             valthr=0.7, monothr=220, maxpoints=5000, proxthresh=0.04):

    # Convert rgb image to monochrome for
    gryimg = np.asarray(Image.fromarray(rgbimg).convert('L'))
    # Convert rgb image (uint, 0-255) to hsv (float, 0.0-1.0)
    hsvimg = colors.rgb_to_hsv(rgbimg.astype(float)/255)

    # Initialize binary thresholded image
    binimg = np.zeros((rgbimg.shape[0], rgbimg.shape[1]))
    # Find pixels with hue<0.2 or hue>0.95 (red or yellow) and saturation/value
    # both greater than 0.7 (saturated and bright)--tends to coincide with
    # ornamental lights on trees in some of the images
    boolidx = np.logical_and(
                np.logical_and(
                  np.logical_or((hsvimg[:,:,0] < hueleftthr),
                                (hsvimg[:,:,0] > huerightthr)),
                                (hsvimg[:,:,1] > satthr)),
                                (hsvimg[:,:,2] > valthr))
    # Find pixels that meet hsv criterion
    binimg[np.where(boolidx)] = 255
    # Add pixels that meet grayscale brightness criterion
    binimg[np.where(gryimg > monothr)] = 255

    # Prepare thresholded points for DBSCAN clustering algorithm
    X = np.transpose(np.where(binimg == 255))
    Xslice = X
    nsample = len(Xslice)
    if nsample > maxpoints:
        # Make sure number of points does not exceed DBSCAN maximum capacity
        Xslice = X[range(0,nsample,int(ceil(float(nsample)/maxpoints)))]

    # Translate DBSCAN proximity threshold to units of pixels and run DBSCAN
    pixproxthr = proxthresh * sqrt(binimg.shape[0]**2 + binimg.shape[1]**2)
    db = DBSCAN(eps=pixproxthr, min_samples=10).fit(Xslice)
    labels = db.labels_.astype(int)

    # Find the largest cluster (i.e., with most points) and obtain convex hull   
    unique_labels = set(labels)
    maxclustpt = 0
    for k in unique_labels:
        class_members = [index[0] for index in np.argwhere(labels == k)]
        if len(class_members) > maxclustpt:
            points = Xslice[class_members]
            hull = sp.spatial.ConvexHull(points)
            maxclustpt = len(class_members)
            borderseg = [[points[simplex,0], points[simplex,1]] for simplex
                          in hull.simplices]

    return borderseg, X, labels, Xslice

ve ikinci bölüm, ilk dosyayı çağıran ve yukarıdaki tüm grafikleri oluşturan kullanıcı düzeyinde bir betiktir:

#!/usr/bin/env python

from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from findtree import findtree

# Image files to process
fname = ['nmzwj.png', 'aVZhC.png', '2K9EF.png',
         'YowlH.png', '2y4o5.png', 'FWhSP.png']

# Initialize figures
fgsz = (16,7)        
figthresh = plt.figure(figsize=fgsz, facecolor='w')
figclust  = plt.figure(figsize=fgsz, facecolor='w')
figcltwo  = plt.figure(figsize=fgsz, facecolor='w')
figborder = plt.figure(figsize=fgsz, facecolor='w')
figthresh.canvas.set_window_title('Thresholded HSV and Monochrome Brightness')
figclust.canvas.set_window_title('DBSCAN Clusters (Raw Pixel Output)')
figcltwo.canvas.set_window_title('DBSCAN Clusters (Slightly Dilated for Display)')
figborder.canvas.set_window_title('Trees with Borders')

for ii, name in zip(range(len(fname)), fname):
    # Open the file and convert to rgb image
    rgbimg = np.asarray(Image.open(name))

    # Get the tree borders as well as a bunch of other intermediate values
    # that will be used to illustrate how the algorithm works
    borderseg, X, labels, Xslice = findtree(rgbimg)

    # Display thresholded images
    axthresh = figthresh.add_subplot(2,3,ii+1)
    axthresh.set_xticks([])
    axthresh.set_yticks([])
    binimg = np.zeros((rgbimg.shape[0], rgbimg.shape[1]))
    for v, h in X:
        binimg[v,h] = 255
    axthresh.imshow(binimg, interpolation='nearest', cmap='Greys')

    # Display color-coded clusters
    axclust = figclust.add_subplot(2,3,ii+1) # Raw version
    axclust.set_xticks([])
    axclust.set_yticks([])
    axcltwo = figcltwo.add_subplot(2,3,ii+1) # Dilated slightly for display only
    axcltwo.set_xticks([])
    axcltwo.set_yticks([])
    axcltwo.imshow(binimg, interpolation='nearest', cmap='Greys')
    clustimg = np.ones(rgbimg.shape)    
    unique_labels = set(labels)
    # Generate a unique color for each cluster 
    plcol = cm.rainbow_r(np.linspace(0, 1, len(unique_labels)))
    for lbl, pix in zip(labels, Xslice):
        for col, unqlbl in zip(plcol, unique_labels):
            if lbl == unqlbl:
                # Cluster label of -1 indicates no cluster membership;
                # override default color with black
                if lbl == -1:
                    col = [0.0, 0.0, 0.0, 1.0]
                # Raw version
                for ij in range(3):
                    clustimg[pix[0],pix[1],ij] = col[ij]
                # Dilated just for display
                axcltwo.plot(pix[1], pix[0], 'o', markerfacecolor=col, 
                    markersize=1, markeredgecolor=col)
    axclust.imshow(clustimg)
    axcltwo.set_xlim(0, binimg.shape[1]-1)
    axcltwo.set_ylim(binimg.shape[0], -1)

    # Plot original images with read borders around the trees
    axborder = figborder.add_subplot(2,3,ii+1)
    axborder.set_axis_off()
    axborder.imshow(rgbimg, interpolation='nearest')
    for vseg, hseg in borderseg:
        axborder.plot(hseg, vseg, 'r-', lw=3)
    axborder.set_xlim(0, binimg.shape[1]-1)
    axborder.set_ylim(binimg.shape[0], -1)

plt.show()

DÜZENLEME NOT: Bu yayını, (i) her ağaç görüntüsünü gereksinimlerden istendiği gibi ayrı ayrı işlemek için düzenledim, (ii) sonucun kalitesini artırmak için hem nesne parlaklığını hem de şeklini göz önünde bulundurun.

Aşağıda nesnenin parlaklığını ve şeklini dikkate alan bir yaklaşım sunulmaktadır. Başka bir deyişle, üçgen benzeri bir şekle ve önemli bir parlaklığa sahip nesneleri arar. Java'da Marvin görüntü işleme çerçevesi kullanılarak uygulandı .

İlk adım renk eşiğidir. Buradaki amaç, analizi önemli ölçüde parlaklığa sahip nesnelere odaklamaktır.

çıktı görüntüler:

kaynak kodu:

public class ChristmasTree {

private MarvinImagePlugin fill = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.fill.boundaryFill");
private MarvinImagePlugin threshold = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.color.thresholding");
private MarvinImagePlugin invert = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.color.invert");
private MarvinImagePlugin dilation = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.morphological.dilation");

public ChristmasTree(){
    MarvinImage tree;

    // Iterate each image
    for(int i=1; i<=6; i++){
        tree = MarvinImageIO.loadImage("./res/trees/tree"+i+".png");

        // 1. Threshold
        threshold.setAttribute("threshold", 200);
        threshold.process(tree.clone(), tree);
    }
}
public static void main(String[] args) {
    new ChristmasTree();
}
}

İkinci adımda, şekiller oluşturmak için görüntüdeki en parlak noktalar genişletilir. Bu işlemin sonucu, önemli parlaklığa sahip nesnelerin olası şeklidir. Taşkın dolgu segmentasyonu uygulandığında, bağlantısı kesilen şekiller algılanır.

çıktı görüntüler:

kaynak kodu:

public class ChristmasTree {

private MarvinImagePlugin fill = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.fill.boundaryFill");
private MarvinImagePlugin threshold = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.color.thresholding");
private MarvinImagePlugin invert = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.color.invert");
private MarvinImagePlugin dilation = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.morphological.dilation");

public ChristmasTree(){
    MarvinImage tree;

    // Iterate each image
    for(int i=1; i<=6; i++){
        tree = MarvinImageIO.loadImage("./res/trees/tree"+i+".png");

        // 1. Threshold
        threshold.setAttribute("threshold", 200);
        threshold.process(tree.clone(), tree);

        // 2. Dilate
        invert.process(tree.clone(), tree);
        tree = MarvinColorModelConverter.rgbToBinary(tree, 127);
        MarvinImageIO.saveImage(tree, "./res/trees/new/tree_"+i+"threshold.png");
        dilation.setAttribute("matrix", MarvinMath.getTrueMatrix(50, 50));
        dilation.process(tree.clone(), tree);
        MarvinImageIO.saveImage(tree, "./res/trees/new/tree_"+1+"_dilation.png");
        tree = MarvinColorModelConverter.binaryToRgb(tree);

        // 3. Segment shapes
        MarvinImage trees2 = tree.clone();
        fill(tree, trees2);
        MarvinImageIO.saveImage(trees2, "./res/trees/new/tree_"+i+"_fill.png");
}

private void fill(MarvinImage imageIn, MarvinImage imageOut){
    boolean found;
    int color= 0xFFFF0000;

    while(true){
        found=false;

        Outerloop:
        for(int y=0; y<imageIn.getHeight(); y++){
            for(int x=0; x<imageIn.getWidth(); x++){
                if(imageOut.getIntComponent0(x, y) == 0){
                    fill.setAttribute("x", x);
                    fill.setAttribute("y", y);
                    fill.setAttribute("color", color);
                    fill.setAttribute("threshold", 120);
                    fill.process(imageIn, imageOut);
                    color = newColor(color);

                    found = true;
                    break Outerloop;
                }
            }
        }

        if(!found){
            break;
        }
    }

}

private int newColor(int color){
    int red = (color & 0x00FF0000) >> 16;
    int green = (color & 0x0000FF00) >> 8;
    int blue = (color & 0x000000FF);

    if(red <= green && red <= blue){
        red+=5;
    }
    else if(green <= red && green <= blue){
        green+=5;
    }
    else{
        blue+=5;
    }

    return 0xFF000000 + (red << 16) + (green << 8) + blue;
}

public static void main(String[] args) {
    new ChristmasTree();
}
}

Çıktı görüntüsünde gösterildiği gibi, birden çok şekil tespit edildi. Bu problemde, görüntülerde sadece birkaç parlak nokta var. Ancak, bu yaklaşım daha karmaşık senaryolarla başa çıkmak için uygulanmıştır.

Bir sonraki adımda her şekil analiz edilir. Basit bir algoritma, üçgene benzer bir desene sahip şekilleri algılar. Algoritma, nesne şeklini satır satır analiz eder. Her şekil çizgisinin kütlesinin merkezi hemen hemen aynı ise (bir eşik verilir) ve y arttıkça kütle artarsa, nesnenin üçgen benzeri bir şekli vardır. Şekil çizgisinin kütlesi, o çizgideki şekle ait piksel sayısıdır. Nesneyi yatay olarak dilimlediğinizi ve her bir yatay segmenti analiz ettiğinizi düşünün. Birbirlerine merkezileşirlerse ve uzunluk ilk segmentten lineer bir desende sonuncuya yükselirse, muhtemelen bir üçgene benzeyen bir nesneniz vardır.

kaynak kodu:

private int[] detectTrees(MarvinImage image){
    HashSet<Integer> analysed = new HashSet<Integer>();
    boolean found;
    while(true){
        found = false;
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                int color = image.getIntColor(x, y);

                if(!analysed.contains(color)){
                    if(isTree(image, color)){
                        return getObjectRect(image, color);
                    }

                    analysed.add(color);
                    found=true;
                }
            }
        }

        if(!found){
            break;
        }
    }
    return null;
}

private boolean isTree(MarvinImage image, int color){

    int mass[][] = new int[image.getHeight()][2];
    int yStart=-1;
    int xStart=-1;
    for(int y=0; y<image.getHeight(); y++){
        int mc = 0;
        int xs=-1;
        int xe=-1;
        for(int x=0; x<image.getWidth(); x++){
            if(image.getIntColor(x, y) == color){
                mc++;

                if(yStart == -1){
                    yStart=y;
                    xStart=x;
                }

                if(xs == -1){
                    xs = x;
                }
                if(x > xe){
                    xe = x;
                }
            }
        }
        mass[y][0] = xs;
        mass[y][3] = xe;
        mass[y][4] = mc;    
    }

    int validLines=0;
    for(int y=0; y<image.getHeight(); y++){
        if
        ( 
            mass[y][5] > 0 &&
            Math.abs(((mass[y][0]+mass[y][6])/2)-xStart) <= 50 &&
            mass[y][7] >= (mass[yStart][8] + (y-yStart)*0.3) &&
            mass[y][9] <= (mass[yStart][10] + (y-yStart)*1.5)
        )
        {
            validLines++;
        }
    }

    if(validLines > 100){
        return true;
    }
    return false;
}

Son olarak, her şeklin bir üçgene benzer ve önemli bir parlaklığa sahip konumu, bu durumda bir Noel ağacı, aşağıda gösterildiği gibi orijinal görüntüde vurgulanır.

son çıkış görüntüleri:

nihai kaynak kodu:

public class ChristmasTree {

private MarvinImagePlugin fill = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.fill.boundaryFill");
private MarvinImagePlugin threshold = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.color.thresholding");
private MarvinImagePlugin invert = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.color.invert");
private MarvinImagePlugin dilation = MarvinPluginLoader.loadImagePlugin("org.marvinproject.image.morphological.dilation");

public ChristmasTree(){
    MarvinImage tree;

    // Iterate each image
    for(int i=1; i<=6; i++){
        tree = MarvinImageIO.loadImage("./res/trees/tree"+i+".png");

        // 1. Threshold
        threshold.setAttribute("threshold", 200);
        threshold.process(tree.clone(), tree);

        // 2. Dilate
        invert.process(tree.clone(), tree);
        tree = MarvinColorModelConverter.rgbToBinary(tree, 127);
        MarvinImageIO.saveImage(tree, "./res/trees/new/tree_"+i+"threshold.png");
        dilation.setAttribute("matrix", MarvinMath.getTrueMatrix(50, 50));
        dilation.process(tree.clone(), tree);
        MarvinImageIO.saveImage(tree, "./res/trees/new/tree_"+1+"_dilation.png");
        tree = MarvinColorModelConverter.binaryToRgb(tree);

        // 3. Segment shapes
        MarvinImage trees2 = tree.clone();
        fill(tree, trees2);
        MarvinImageIO.saveImage(trees2, "./res/trees/new/tree_"+i+"_fill.png");

        // 4. Detect tree-like shapes
        int[] rect = detectTrees(trees2);

        // 5. Draw the result
        MarvinImage original = MarvinImageIO.loadImage("./res/trees/tree"+i+".png");
        drawBoundary(trees2, original, rect);
        MarvinImageIO.saveImage(original, "./res/trees/new/tree_"+i+"_out_2.jpg");
    }
}

private void drawBoundary(MarvinImage shape, MarvinImage original, int[] rect){
    int yLines[] = new int[6];
    yLines[0] = rect[1];
    yLines[1] = rect[1]+(int)((rect[3]/5));
    yLines[2] = rect[1]+((rect[3]/5)*2);
    yLines[3] = rect[1]+((rect[3]/5)*3);
    yLines[4] = rect[1]+(int)((rect[3]/5)*4);
    yLines[5] = rect[1]+rect[3];

    List<Point> points = new ArrayList<Point>();
    for(int i=0; i<yLines.length; i++){
        boolean in=false;
        Point startPoint=null;
        Point endPoint=null;
        for(int x=rect[0]; x<rect[0]+rect[2]; x++){

            if(shape.getIntColor(x, yLines[i]) != 0xFFFFFFFF){
                if(!in){
                    if(startPoint == null){
                        startPoint = new Point(x, yLines[i]);
                    }
                }
                in = true;
            }
            else{
                if(in){
                    endPoint = new Point(x, yLines[i]);
                }
                in = false;
            }
        }

        if(endPoint == null){
            endPoint = new Point((rect[0]+rect[2])-1, yLines[i]);
        }

        points.add(startPoint);
        points.add(endPoint);
    }

    drawLine(points.get(0).x, points.get(0).y, points.get(1).x, points.get(1).y, 15, original);
    drawLine(points.get(1).x, points.get(1).y, points.get(3).x, points.get(3).y, 15, original);
    drawLine(points.get(3).x, points.get(3).y, points.get(5).x, points.get(5).y, 15, original);
    drawLine(points.get(5).x, points.get(5).y, points.get(7).x, points.get(7).y, 15, original);
    drawLine(points.get(7).x, points.get(7).y, points.get(9).x, points.get(9).y, 15, original);
    drawLine(points.get(9).x, points.get(9).y, points.get(11).x, points.get(11).y, 15, original);
    drawLine(points.get(11).x, points.get(11).y, points.get(10).x, points.get(10).y, 15, original);
    drawLine(points.get(10).x, points.get(10).y, points.get(8).x, points.get(8).y, 15, original);
    drawLine(points.get(8).x, points.get(8).y, points.get(6).x, points.get(6).y, 15, original);
    drawLine(points.get(6).x, points.get(6).y, points.get(4).x, points.get(4).y, 15, original);
    drawLine(points.get(4).x, points.get(4).y, points.get(2).x, points.get(2).y, 15, original);
    drawLine(points.get(2).x, points.get(2).y, points.get(0).x, points.get(0).y, 15, original);
}

private void drawLine(int x1, int y1, int x2, int y2, int length, MarvinImage image){
    int lx1, lx2, ly1, ly2;
    for(int i=0; i<length; i++){
        lx1 = (x1+i >= image.getWidth() ? (image.getWidth()-1)-i: x1);
        lx2 = (x2+i >= image.getWidth() ? (image.getWidth()-1)-i: x2);
        ly1 = (y1+i >= image.getHeight() ? (image.getHeight()-1)-i: y1);
        ly2 = (y2+i >= image.getHeight() ? (image.getHeight()-1)-i: y2);

        image.drawLine(lx1+i, ly1, lx2+i, ly2, Color.red);
        image.drawLine(lx1, ly1+i, lx2, ly2+i, Color.red);
    }
}

private void fillRect(MarvinImage image, int[] rect, int length){
    for(int i=0; i<length; i++){
        image.drawRect(rect[0]+i, rect[1]+i, rect[2]-(i*2), rect[3]-(i*2), Color.red);
    }
}

private void fill(MarvinImage imageIn, MarvinImage imageOut){
    boolean found;
    int color= 0xFFFF0000;

    while(true){
        found=false;

        Outerloop:
        for(int y=0; y<imageIn.getHeight(); y++){
            for(int x=0; x<imageIn.getWidth(); x++){
                if(imageOut.getIntComponent0(x, y) == 0){
                    fill.setAttribute("x", x);
                    fill.setAttribute("y", y);
                    fill.setAttribute("color", color);
                    fill.setAttribute("threshold", 120);
                    fill.process(imageIn, imageOut);
                    color = newColor(color);

                    found = true;
                    break Outerloop;
                }
            }
        }

        if(!found){
            break;
        }
    }

}

private int[] detectTrees(MarvinImage image){
    HashSet<Integer> analysed = new HashSet<Integer>();
    boolean found;
    while(true){
        found = false;
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                int color = image.getIntColor(x, y);

                if(!analysed.contains(color)){
                    if(isTree(image, color)){
                        return getObjectRect(image, color);
                    }

                    analysed.add(color);
                    found=true;
                }
            }
        }

        if(!found){
            break;
        }
    }
    return null;
}

private boolean isTree(MarvinImage image, int color){

    int mass[][] = new int[image.getHeight()][11];
    int yStart=-1;
    int xStart=-1;
    for(int y=0; y<image.getHeight(); y++){
        int mc = 0;
        int xs=-1;
        int xe=-1;
        for(int x=0; x<image.getWidth(); x++){
            if(image.getIntColor(x, y) == color){
                mc++;

                if(yStart == -1){
                    yStart=y;
                    xStart=x;
                }

                if(xs == -1){
                    xs = x;
                }
                if(x > xe){
                    xe = x;
                }
            }
        }
        mass[y][0] = xs;
        mass[y][12] = xe;
        mass[y][13] = mc;   
    }

    int validLines=0;
    for(int y=0; y<image.getHeight(); y++){
        if
        ( 
            mass[y][14] > 0 &&
            Math.abs(((mass[y][0]+mass[y][15])/2)-xStart) <= 50 &&
            mass[y][16] >= (mass[yStart][17] + (y-yStart)*0.3) &&
            mass[y][18] <= (mass[yStart][19] + (y-yStart)*1.5)
        )
        {
            validLines++;
        }
    }

    if(validLines > 100){
        return true;
    }
    return false;
}

private int[] getObjectRect(MarvinImage image, int color){
    int x1=-1;
    int x2=-1;
    int y1=-1;
    int y2=-1;

    for(int y=0; y<image.getHeight(); y++){
        for(int x=0; x<image.getWidth(); x++){
            if(image.getIntColor(x, y) == color){

                if(x1 == -1 || x < x1){
                    x1 = x;
                }
                if(x2 == -1 || x > x2){
                    x2 = x;
                }
                if(y1 == -1 || y < y1){
                    y1 = y;
                }
                if(y2 == -1 || y > y2){
                    y2 = y;
                }
            }
        }
    }

    return new int[]{x1, y1, (x2-x1), (y2-y1)};
}

private int newColor(int color){
    int red = (color & 0x00FF0000) >> 16;
    int green = (color & 0x0000FF00) >> 8;
    int blue = (color & 0x000000FF);

    if(red <= green && red <= blue){
        red+=5;
    }
    else if(green <= red && green <= blue){
        green+=30;
    }
    else{
        blue+=30;
    }

    return 0xFF000000 + (red << 16) + (green << 8) + blue;
}

public static void main(String[] args) {
    new ChristmasTree();
}
}

Bu yaklaşımın avantajı, nesne şeklini analiz ettiği için muhtemelen diğer aydınlık nesneleri içeren görüntülerle çalışmasıdır.

Mutlu Noeller!

NOT 2'yi DÜZENLE

Bu çözümün ve diğer bazılarının çıktı görüntülerinin benzerliği hakkında bir tartışma var. Aslında çok benzerler. Ancak bu yaklaşım sadece nesneleri parçalamakla kalmaz. Nesne şekillerini bir anlamda analiz eder. Aynı sahnede birden fazla parlak nesneyi işleyebilir. Aslında, Noel ağacının en parlak olması gerekmez. Sadece tartışmayı zenginleştirmek için onu terk ediyorum. Örneklerde sadece en parlak nesneyi arayan bir önyargı var, ağaçları bulacaksınız. Ancak, bu noktada tartışmayı gerçekten durdurmak istiyor muyuz? Bu noktada, bilgisayar bir Noel ağacına benzeyen bir nesneyi gerçekten ne kadar tanıyor? Bu boşluğu kapatmaya çalışalım.

Aşağıda bu noktayı açıklamak için bir sonuç sunulmuştur:

girdi resmi

çıktı

İşte benim basit ve aptal çözümüm. Ağacın resimdeki en parlak ve büyük şey olacağı varsayımına dayanmaktadır.

//g++ -Wall -pedantic -ansi -O2 -pipe -s -o christmas_tree christmas_tree.cpp `pkg-config --cflags --libs opencv`
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc,char *argv[])
{
    Mat original,tmp,tmp1;
    vector <vector<Point> > contours;
    Moments m;
    Rect boundrect;
    Point2f center;
    double radius, max_area=0,tmp_area=0;
    unsigned int j, k;
    int i;

    for(i = 1; i < argc; ++i)
    {
        original = imread(argv[i]);
        if(original.empty())
        {
            cerr << "Error"<<endl;
            return -1;
        }

        GaussianBlur(original, tmp, Size(3, 3), 0, 0, BORDER_DEFAULT);
        erode(tmp, tmp, Mat(), Point(-1, -1), 10);
        cvtColor(tmp, tmp, CV_BGR2HSV);
        inRange(tmp, Scalar(0, 0, 0), Scalar(180, 255, 200), tmp);

        dilate(original, tmp1, Mat(), Point(-1, -1), 15);
        cvtColor(tmp1, tmp1, CV_BGR2HLS);
        inRange(tmp1, Scalar(0, 185, 0), Scalar(180, 255, 255), tmp1);
        dilate(tmp1, tmp1, Mat(), Point(-1, -1), 10);

        bitwise_and(tmp, tmp1, tmp1);

        findContours(tmp1, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
        max_area = 0;
        j = 0;
        for(k = 0; k < contours.size(); k++)
        {
            tmp_area = contourArea(contours[k]);
            if(tmp_area > max_area)
            {
                max_area = tmp_area;
                j = k;
            }
        }
        tmp1 = Mat::zeros(original.size(),CV_8U);
        approxPolyDP(contours[j], contours[j], 30, true);
        drawContours(tmp1, contours, j, Scalar(255,255,255), CV_FILLED);

        m = moments(contours[j]);
        boundrect = boundingRect(contours[j]);
        center = Point2f(m.m10/m.m00, m.m01/m.m00);
        radius = (center.y - (boundrect.tl().y))/4.0*3.0;
        Rect heightrect(center.x-original.cols/5, boundrect.tl().y, original.cols/5*2, boundrect.size().height);

        tmp = Mat::zeros(original.size(), CV_8U);
        rectangle(tmp, heightrect, Scalar(255, 255, 255), -1);
        circle(tmp, center, radius, Scalar(255, 255, 255), -1);

        bitwise_and(tmp, tmp1, tmp1);

        findContours(tmp1, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
        max_area = 0;
        j = 0;
        for(k = 0; k < contours.size(); k++)
        {
            tmp_area = contourArea(contours[k]);
            if(tmp_area > max_area)
            {
                max_area = tmp_area;
                j = k;
            }
        }

        approxPolyDP(contours[j], contours[j], 30, true);
        convexHull(contours[j], contours[j]);

        drawContours(original, contours, j, Scalar(0, 0, 255), 3);

        namedWindow(argv[i], CV_WINDOW_NORMAL|CV_WINDOW_KEEPRATIO|CV_GUI_EXPANDED);
        imshow(argv[i], original);

        waitKey(0);
        destroyWindow(argv[i]);
    }

    return 0;
}

İlk adım resimdeki en parlak pikselleri tespit etmektir, ancak ağacın kendisi ile ışığını yansıtan kar arasında bir ayrım yapmak zorundayız. Burada renk kodları üzerinde gerçekten basit bir filtre uygulayan karı hariç tutmaya çalışıyoruz:

GaussianBlur(original, tmp, Size(3, 3), 0, 0, BORDER_DEFAULT);
erode(tmp, tmp, Mat(), Point(-1, -1), 10);
cvtColor(tmp, tmp, CV_BGR2HSV);
inRange(tmp, Scalar(0, 0, 0), Scalar(180, 255, 200), tmp);

Sonra her "parlak" pikseli buluruz:

dilate(original, tmp1, Mat(), Point(-1, -1), 15);
cvtColor(tmp1, tmp1, CV_BGR2HLS);
inRange(tmp1, Scalar(0, 185, 0), Scalar(180, 255, 255), tmp1);
dilate(tmp1, tmp1, Mat(), Point(-1, -1), 10);

Sonunda iki sonuca katılıyoruz:

bitwise_and(tmp, tmp1, tmp1);

Şimdi en büyük parlak nesneyi arıyoruz:

findContours(tmp1, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
max_area = 0;
j = 0;
for(k = 0; k < contours.size(); k++)
{
    tmp_area = contourArea(contours[k]);
    if(tmp_area > max_area)
    {
        max_area = tmp_area;
        j = k;
    }
}
tmp1 = Mat::zeros(original.size(),CV_8U);
approxPolyDP(contours[j], contours[j], 30, true);
drawContours(tmp1, contours, j, Scalar(255,255,255), CV_FILLED);

Şimdi neredeyse yaptık, ama kar nedeniyle hala bazı kusurlar var. Onları kesmek için, istenmeyen parçaları silmek için bir ağacın şekline yaklaşık olarak yaklaşmak üzere bir daire ve bir dikdörtgen kullanarak bir maske oluşturacağız:

m = moments(contours[j]);
boundrect = boundingRect(contours[j]);
center = Point2f(m.m10/m.m00, m.m01/m.m00);
radius = (center.y - (boundrect.tl().y))/4.0*3.0;
Rect heightrect(center.x-original.cols/5, boundrect.tl().y, original.cols/5*2, boundrect.size().height);

tmp = Mat::zeros(original.size(), CV_8U);
rectangle(tmp, heightrect, Scalar(255, 255, 255), -1);
circle(tmp, center, radius, Scalar(255, 255, 255), -1);

bitwise_and(tmp, tmp1, tmp1);

Son adım, ağacımızın konturunu bulmak ve orijinal resme çizmektir.

findContours(tmp1, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
max_area = 0;
j = 0;
for(k = 0; k < contours.size(); k++)
{
    tmp_area = contourArea(contours[k]);
    if(tmp_area > max_area)
    {
        max_area = tmp_area;
        j = k;
    }
}

approxPolyDP(contours[j], contours[j], 30, true);
convexHull(contours[j], contours[j]);

drawContours(original, contours, j, Scalar(0, 0, 255), 3);

Üzgünüm ama şu anda kötü bir bağlantım var, bu yüzden resim yüklemem mümkün değil. Daha sonra yapmaya çalışacağım.

Mutlu Noeller.

DÜZENLE:

İşte son çıktının bazı resimleri:

Kodu Matlab R2007a'da yazdım. Noel ağacını kabaca çıkarmak için k-araçları kullandım. Ara sonucumu yalnızca bir resim ve altı sonucun tümü ile göstereceğim.

İlk olarak, RGB alanını Lab kanalına eşledim, b kanalındaki kırmızı kontrastını artırabilir:

colorTransform = makecform('srgb2lab');
I = applycform(I, colorTransform);
L = double(I(:,:,1));
a = double(I(:,:,2));
b = double(I(:,:,3));

Renk uzayındaki özelliğin yanı sıra, her pikselden ziyade mahalle ile ilgili doku özelliğini de kullandım. Burada 3 orijinal kanaldan (R, G, B) yoğunluğu doğrusal olarak birleştirdim. Bu şekilde biçimlendirmemizin nedeni, resimdeki yılbaşı ağaçlarının üzerinde kırmızı ışıklar ve bazen de yeşil / bazen mavi aydınlatma olması.

R=double(Irgb(:,:,1));
G=double(Irgb(:,:,2));
B=double(Irgb(:,:,3));
I0 = (3*R + max(G,B)-min(G,B))/2;

Üzerine 3X3 yerel ikili desen uyguladım I0, eşik olarak orta pikseli kullandım ve eşiğin üzerindeki ortalama piksel yoğunluğu değeri ile altındaki ortalama değer arasındaki farkı hesaplayarak kontrastı elde ettim.

I0_copy = zeros(size(I0));
for i = 2 : size(I0,1) - 1
    for j = 2 : size(I0,2) - 1
        tmp = I0(i-1:i+1,j-1:j+1) >= I0(i,j);
        I0_copy(i,j) = mean(mean(tmp.*I0(i-1:i+1,j-1:j+1))) - ...
            mean(mean(~tmp.*I0(i-1:i+1,j-1:j+1))); % Contrast
    end
end

Toplamda 4 özelliğim olduğundan, kümeleme yöntemimde K = 5'i seçerdim. K-araçlarının kodu aşağıda gösterilmiştir (Dr. Andrew Ng'in makine öğrenimi kursundan alınmıştır. Daha önce dersi aldım ve kodu programlama görevine kendim yazdım).

[centroids, idx] = runkMeans(X, initial_centroids, max_iters);
mask=reshape(idx,img_size(1),img_size(2));

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function [centroids, idx] = runkMeans(X, initial_centroids, ...
                                  max_iters, plot_progress)
   [m n] = size(X);
   K = size(initial_centroids, 1);
   centroids = initial_centroids;
   previous_centroids = centroids;
   idx = zeros(m, 1);

   for i=1:max_iters    
      % For each example in X, assign it to the closest centroid
      idx = findClosestCentroids(X, centroids);

      % Given the memberships, compute new centroids
      centroids = computeCentroids(X, idx, K);

   end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function idx = findClosestCentroids(X, centroids)
   K = size(centroids, 1);
   idx = zeros(size(X,1), 1);
   for xi = 1:size(X,1)
      x = X(xi, :);
      % Find closest centroid for x.
      best = Inf;
      for mui = 1:K
        mu = centroids(mui, :);
        d = dot(x - mu, x - mu);
        if d < best
           best = d;
           idx(xi) = mui;
        end
      end
   end 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function centroids = computeCentroids(X, idx, K)
   [m n] = size(X);
   centroids = zeros(K, n);
   for mui = 1:K
      centroids(mui, :) = sum(X(idx == mui, :)) / sum(idx == mui);
   end

Program bilgisayarımda çok yavaş çalıştığı için 3 yineleme çalıştırdım. Normalde durdurma kriterleri (i) en az 10 tekrarlama süresi veya (ii) artık sentroidlerde değişiklik olmamasıdır. Testime göre, yinelemenin artırılması arka planı (gökyüzü ve ağaç, gökyüzü ve bina, ...) daha doğru bir şekilde farklılaştırabilir, ancak Noel ağacının çıkarılmasında önemli bir değişiklik göstermedi. Ayrıca, k-araçlarının rastgele centroid başlatmaya bağışık olmadığını unutmayın, bu nedenle bir karşılaştırma yapmak için programı birkaç kez çalıştırmak önerilir.

K-vasıtasından sonra, maksimum yoğunluğu olan etiketli bölge I0seçildi. Sınırları çıkarmak için sınır izleme kullanılmıştır. Bana göre, son Noel ağacı çıkarılması en zor olanı çünkü bu resimdeki kontrast ilk beşte olduğu gibi yeterince yüksek değil. Metodumdaki bir başka konu da bwboundaries, sınırı izlemek için Matlab'da işlevi kullandığım , ancak bazen iç sınırların da 3., 5., 6. sonuçlarda gözlemleyebileceğiniz gibi dahil edilmesidir. Noel ağaçlarındaki karanlık taraf sadece aydınlatılmış tarafla kümelenmekle kalmadı, aynı zamanda çok sayıda küçük iç sınırın izlenmesine de yol açıyor ( imfillçok fazla iyileşmiyor). Tüm algoritma hala çok geliştirme alanı var.

Bazı yayınlar ortalama kaydırmanın k-araçlarından daha sağlam olabileceğini ve birçok grafik kesimi tabanlı algoritmanın karmaşık sınır segmentasyonunda çok rekabetçi olduğunu göstermektedir. Ortalama bir algoritma yazdım, bölgelerin yeterince ışık olmadan daha iyi çıkarıldığı görülüyor. Ancak ortalama değişim biraz fazla bölümlere ayrılmıştır ve birleştirme stratejisine ihtiyaç vardır. Bilgisayarımda k-araçlarından bile daha yavaş koştu, korkarım ki vazgeçmeliyim. Yukarıda bahsedilen modern algoritmalarla diğerlerinin burada mükemmel sonuçlar vereceğini merakla bekliyorum.

Yine de her zaman özellik seçiminin görüntü segmentasyonunda anahtar bileşen olduğuna inanıyorum. Nesne ve arka plan arasındaki kenar boşluğunu en üst düzeye çıkarabilen uygun bir özellik seçimi ile, birçok segmentasyon algoritması kesinlikle işe yarayacaktır. Farklı algoritmalar sonucu 1'den 10'a yükseltebilir, ancak özellik seçimi 0'dan 1'e yükseltebilir.

Mutlu Noeller !

Bu, geleneksel görüntü işleme yaklaşımlarını kullanan son görevim ...

Burada bir şekilde diğer iki teklifimi birleştirerek daha da iyi sonuçlar elde ediyorum . Aslında bu sonuçların nasıl daha iyi olabileceğini göremiyorum (özellikle yöntemin ürettiği maskeli görüntülere baktığınızda).

Yaklaşımın merkezinde üç temel varsayımın kombinasyonu vardır :

1. Görüntüler ağaç bölgelerinde yüksek dalgalanmalara sahip olmalıdır
2. Görüntüler ağaç bölgelerinde daha yüksek yoğunluğa sahip olmalıdır
3. Arka plan bölgelerinin yoğunluğu düşük olmalı ve çoğunlukla mavi renkte olmalıdır

Bu varsayımlar göz önünde bulundurulduğunda, yöntem aşağıdaki gibi çalışır:

1. Görüntüleri HSV'ye dönüştürme
2. V kanalını bir LoG filtresiyle filtreleme
3. 'Etkinlik' maskesi A'yı elde etmek için LoG filtreli görüntüye sabit eşikleme uygulayın
4. Yoğunluk maskesi B'yi elde etmek için V kanalına sert eşik uygulayın
5. Arka plan maskesine C düşük yoğunluklu blue-ish bölgelerini yakalamak için H kanal eşiği uygulayın
6. Son maskeyi almak için AND ile maskeleri birleştirin
7. Bölgeleri büyütmek ve dağınık pikselleri bağlamak için maskeyi genişletin
8. Küçük bölgeleri ortadan kaldırın ve sonunda sadece ağacı temsil edecek son maskeyi alın

İşte MATLAB'daki kod (yine, komut dosyası geçerli klasördeki tüm jpg görüntülerini yükler ve yine bu optimize edilmiş bir kod parçası olmaktan çok uzaktır):

% clear everything
clear;
pack;
close all;
close all hidden;
drawnow;
clc;

% initialization
ims=dir('./*.jpg');
imgs={};
images={}; 
blur_images={}; 
log_image={}; 
dilated_image={};
int_image={};
back_image={};
bin_image={};
measurements={};
box={};
num=length(ims);
thres_div = 3;

for i=1:num, 
    % load original image
    imgs{end+1}=imread(ims(i).name);

    % convert to HSV colorspace
    images{end+1}=rgb2hsv(imgs{i});

    % apply laplacian filtering and heuristic hard thresholding
    val_thres = (max(max(images{i}(:,:,3)))/thres_div);
    log_image{end+1} = imfilter( images{i}(:,:,3),fspecial('log')) > val_thres;

    % get the most bright regions of the image
    int_thres = 0.26*max(max( images{i}(:,:,3)));
    int_image{end+1} = images{i}(:,:,3) > int_thres;

    % get the most probable background regions of the image
    back_image{end+1} = images{i}(:,:,1)>(150/360) & images{i}(:,:,1)<(320/360) & images{i}(:,:,3)<0.5;

    % compute the final binary image by combining 
    % high 'activity' with high intensity
    bin_image{end+1} = logical( log_image{i}) & logical( int_image{i}) & ~logical( back_image{i});

    % apply morphological dilation to connect distonnected components
    strel_size = round(0.01*max(size(imgs{i})));        % structuring element for morphological dilation
    dilated_image{end+1} = imdilate( bin_image{i}, strel('disk',strel_size));

    % do some measurements to eliminate small objects
    measurements{i} = regionprops( logical( dilated_image{i}),'Area','BoundingBox');

    % iterative enlargement of the structuring element for better connectivity
    while length(measurements{i})>14 && strel_size<(min(size(imgs{i}(:,:,1)))/2),
        strel_size = round( 1.5 * strel_size);
        dilated_image{i} = imdilate( bin_image{i}, strel('disk',strel_size));
        measurements{i} = regionprops( logical( dilated_image{i}),'Area','BoundingBox');
    end

    for m=1:length(measurements{i})
        if measurements{i}(m).Area < 0.05*numel( dilated_image{i})
            dilated_image{i}( round(measurements{i}(m).BoundingBox(2):measurements{i}(m).BoundingBox(4)+measurements{i}(m).BoundingBox(2)),...
                round(measurements{i}(m).BoundingBox(1):measurements{i}(m).BoundingBox(3)+measurements{i}(m).BoundingBox(1))) = 0;
        end
    end
    % make sure the dilated image is the same size with the original
    dilated_image{i} = dilated_image{i}(1:size(imgs{i},1),1:size(imgs{i},2));
    % compute the bounding box
    [y,x] = find( dilated_image{i});
    if isempty( y)
        box{end+1}=[];
    else
        box{end+1} = [ min(x) min(y) max(x)-min(x)+1 max(y)-min(y)+1];
    end
end 

%%% additional code to display things
for i=1:num,
    figure;
    subplot(121);
    colormap gray;
    imshow( imgs{i});
    if ~isempty(box{i})
        hold on;
        rr = rectangle( 'position', box{i});
        set( rr, 'EdgeColor', 'r');
        hold off;
    end
    subplot(122);
    imshow( imgs{i}.*uint8(repmat(dilated_image{i},[1 1 3])));
end

Sonuçlar

Yüksek çözünürlüklü sonuçlar hala burada!
Ek görüntülerle daha fazla deney burada bulunabilir.

Çözüm adımım:

1. R kanalını al (RGB'den) - bu kanalda yaptığımız tüm işlemler:

2. İlgi Çekici Bölge Oluştur (YG)

   • Minimum 149 değeri olan eşik R kanalı (sağ üst görüntü)

   • Sonuç bölgesini genişlet (sol ortadaki resim)

3. Hesaplanan yatırım getirisindeki yaşları tespit edin. Ağacın birçok kenarı var (sağ ortadaki resim)

   • Dilate sonucu

   • Daha büyük yarıçaplı erozyon (sol alt resim)

4. En büyük (alana göre) nesneyi seçin - sonuç bölgesi

5. ConvexHull (ağaç dışbükey çokgendir) (sağ alt resim)

6. Sınırlayıcı kutu (sağ alt resim - grren kutusu)

Adım adım:

İlk sonuç - en basit ama açık kaynaklı yazılım değil - "Adaptive Vision Studio + Adaptive Vision Library": Bu açık kaynak kodlu değil, prototip oluşturmak için çok hızlı:

Noel ağacını tespit etmek için tüm algoritma (11 blok):

Sonraki adım. Açık kaynaklı bir çözüm istiyoruz. AVL filtrelerini OpenCV filtrelerine değiştir: Burada küçük değişiklikler yaptım, örneğin Edge Detection, cvCanny filtresini kullanıyordu, roi'ye göre, bölge görüntüsünü kenar görüntüsüyle çarptığımda, en büyük öğeyi bulduğum findContours + contourArea öğesini seçti, ancak fikir aynı.

https://www.youtube.com/watch?v=sfjB3MigLH0&index=1&list=UUpSRrkMHNHiLDXgylwhWNQQ

Şimdi ara adımları olan görüntüleri gösteremiyorum çünkü sadece 2 bağlantı koyabiliyorum.

Tamam şimdi openSource filtrelerini kullanıyoruz ama hala açık kaynak değil. Son adım - c ++ koduna bağlantı noktası. 2.4.4 sürümünde OpenCV kullandım

Son c ++ kodunun sonucu:

c ++ kodu da oldukça kısadır:

#include "opencv2/highgui/highgui.hpp"
#include "opencv2/opencv.hpp"
#include <algorithm>
using namespace cv;

int main()
{

    string images[6] = {"..\\1.png","..\\2.png","..\\3.png","..\\4.png","..\\5.png","..\\6.png"};

    for(int i = 0; i < 6; ++i)
    {
        Mat img, thresholded, tdilated, tmp, tmp1;
        vector<Mat> channels(3);

        img = imread(images[i]);
        split(img, channels);
        threshold( channels[2], thresholded, 149, 255, THRESH_BINARY);                      //prepare ROI - threshold
        dilate( thresholded, tdilated,  getStructuringElement( MORPH_RECT, Size(22,22) ) ); //prepare ROI - dilate
        Canny( channels[2], tmp, 75, 125, 3, true );    //Canny edge detection
        multiply( tmp, tdilated, tmp1 );    // set ROI

        dilate( tmp1, tmp, getStructuringElement( MORPH_RECT, Size(20,16) ) ); // dilate
        erode( tmp, tmp1, getStructuringElement( MORPH_RECT, Size(36,36) ) ); // erode

        vector<vector<Point> > contours, contours1(1);
        vector<Point> convex;
        vector<Vec4i> hierarchy;
        findContours( tmp1, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );

        //get element of maximum area
        //int bestID = std::max_element( contours.begin(), contours.end(), 
        //  []( const vector<Point>& A, const vector<Point>& B ) { return contourArea(A) < contourArea(B); } ) - contours.begin();

            int bestID = 0;
        int bestArea = contourArea( contours[0] );
        for( int i = 1; i < contours.size(); ++i )
        {
            int area = contourArea( contours[i] );
            if( area > bestArea )
            {
                bestArea  = area;
                bestID = i;
            }
        }

        convexHull( contours[bestID], contours1[0] ); 
        drawContours( img, contours1, 0, Scalar( 100, 100, 255 ), img.rows / 100, 8, hierarchy, 0, Point() );

        imshow("image", img );
        waitKey(0);
    }


    return 0;
}