Bagaimana cara mendeteksi Pohon Natal? [Tutup]

Teknik pemrosesan gambar apa yang dapat digunakan untuk mengimplementasikan aplikasi yang mendeteksi pohon Natal yang ditampilkan dalam gambar berikut?

Saya mencari solusi yang akan bekerja pada semua gambar ini. Oleh karena itu, pendekatan yang membutuhkan pelatihan pengklasifikasi haar cascade atau pencocokan templat tidak terlalu menarik.

Saya mencari sesuatu yang dapat ditulis dalam bahasa pemrograman apa pun , asalkan hanya menggunakan teknologi Open Source . Solusinya harus diuji dengan gambar yang dibagikan pada pertanyaan ini. Ada 6 gambar input dan jawabannya harus menampilkan hasil pemrosesan masing-masing. Akhirnya, untuk setiap gambar keluaran harus ada garis merah menggambar untuk mengelilingi pohon yang terdeteksi.

Bagaimana cara Anda mendeteksi pohon secara terprogram dalam gambar-gambar ini?

Saya memiliki pendekatan yang menurut saya menarik dan sedikit berbeda dari yang lain. Perbedaan utama dalam pendekatan saya, dibandingkan dengan yang lain, adalah bagaimana langkah segmentasi gambar dilakukan - saya menggunakan algoritma pengelompokan DBSCAN dari scikit-learn Python; itu dioptimalkan untuk menemukan bentuk agak amorf yang mungkin belum tentu memiliki pusat massa tunggal yang jelas.

Di tingkat atas, pendekatan saya cukup sederhana dan dapat dipecah menjadi sekitar 3 langkah. Pertama saya menerapkan ambang batas (atau sebenarnya, logika "atau" dua ambang batas yang berbeda dan berbeda). Seperti banyak jawaban lain, saya berasumsi bahwa pohon Natal akan menjadi salah satu objek yang lebih terang di tempat kejadian, jadi ambang pertama hanyalah uji kecerahan monokrom sederhana; setiap piksel dengan nilai di atas 220 pada skala 0-255 (di mana hitam 0 dan putih 255) disimpan ke gambar biner hitam-putih. Ambang kedua mencoba mencari lampu merah dan kuning, yang terutama menonjol di pohon-pohon di kiri atas dan kanan bawah dari enam gambar, dan menonjol dengan latar belakang biru-hijau yang lazim di sebagian besar foto. Saya mengkonversi gambar rgb ke ruang hsv, dan mensyaratkan bahwa rona kurang dari 0,2 pada skala 0,0-1,0 (sesuai kira-kira dengan batas antara kuning dan hijau) atau lebih besar dari 0,95 (sesuai dengan batas antara ungu dan merah) dan juga saya membutuhkan warna-warna cerah, jenuh: saturasi dan nilai keduanya harus di atas 0,7. Hasil dari dua prosedur ambang secara logis "atau" -ed bersama, dan matriks yang dihasilkan dari gambar biner hitam-putih ditunjukkan di bawah ini:

Anda dapat dengan jelas melihat bahwa setiap gambar memiliki satu kelompok besar piksel yang secara kasar sesuai dengan lokasi setiap pohon, ditambah beberapa gambar juga memiliki beberapa kelompok kecil lainnya yang terkait dengan lampu di jendela beberapa bangunan, atau ke adegan latar belakang di cakrawala. Langkah selanjutnya adalah membuat komputer mengenali bahwa ini adalah cluster yang terpisah, dan beri label setiap piksel dengan benar dengan nomor ID keanggotaan cluster.

Untuk tugas ini saya memilih DBSCAN . Ada perbandingan visual yang cukup bagus tentang bagaimana biasanya perilaku DBSCAN, relatif terhadap algoritma pengelompokan lainnya, tersedia di sini . Seperti yang saya katakan sebelumnya, itu baik dengan bentuk amorf. Output dari DBSCAN, dengan masing-masing cluster diplot dalam warna yang berbeda, ditunjukkan di sini:

Ada beberapa hal yang perlu diperhatikan ketika melihat hasil ini. Pertama adalah bahwa DBSCAN mengharuskan pengguna untuk menetapkan parameter "proximity" untuk mengatur perilakunya, yang secara efektif mengontrol bagaimana dipisahkannya sepasang titik agar algoritma dapat mendeklarasikan cluster terpisah baru daripada menggumpalkan titik uji ke cluster yang sudah ada sebelumnya. Saya menetapkan nilai ini menjadi 0,04 kali ukuran sepanjang diagonal setiap gambar. Karena ukuran gambar bervariasi dari kira-kira VGA hingga HD 1080, definisi skala-relatif ini sangat penting.

Hal lain yang patut dicatat adalah bahwa algoritma DBSCAN seperti yang diterapkan dalam scikit-learn memiliki batas memori yang cukup menantang untuk beberapa gambar yang lebih besar dalam sampel ini. Oleh karena itu, untuk beberapa gambar yang lebih besar, saya benar-benar harus "memusnahkan" (yaitu, pertahankan hanya setiap piksel ke-3 atau ke-4 dan jatuhkan yang lain) setiap cluster agar tetap dalam batas ini. Sebagai hasil dari proses pemusnahan ini, piksel jarang individu yang tersisa sulit dilihat pada beberapa gambar yang lebih besar. Oleh karena itu, hanya untuk tujuan tampilan, piksel kode warna pada gambar di atas telah secara efektif "dilatasi" hanya sedikit sehingga lebih menonjol. Ini murni operasi kosmetik demi narasi; meskipun ada komentar yang menyebutkan pelebaran ini dalam kode saya,

Setelah cluster diidentifikasi dan diberi label, langkah ketiga dan terakhir mudah: Saya cukup mengambil cluster terbesar di setiap gambar (dalam hal ini, saya memilih untuk mengukur "ukuran" dalam hal jumlah total piksel anggota, meskipun orang bisa baru saja dengan mudah menggunakan beberapa jenis metrik yang mengukur tingkat fisik) dan menghitung convex hull untuk cluster tersebut. Lambung cembung kemudian menjadi batas pohon. Enam lambung cembung yang dihitung melalui metode ini ditunjukkan di bawah ini dalam warna merah:

Kode sumber ditulis untuk Python 2.7.6 dan itu tergantung pada numpy , scipy , matplotlib dan scikit-learn . Saya sudah membaginya menjadi dua bagian. Bagian pertama bertanggung jawab atas pemrosesan gambar yang sebenarnya:

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

dan bagian kedua adalah skrip tingkat pengguna yang memanggil file pertama dan menghasilkan semua plot di atas:

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

EDIT CATATAN: Saya mengedit posting ini untuk (i) memproses setiap gambar pohon secara terpisah, seperti yang diminta dalam persyaratan, (ii) untuk mempertimbangkan kecerahan dan bentuk objek untuk meningkatkan kualitas hasil.

Di bawah ini disajikan pendekatan yang mempertimbangkan kecerahan dan bentuk objek. Dengan kata lain, ia mencari objek dengan bentuk seperti segitiga dan dengan kecerahan yang signifikan. Itu diimplementasikan di Jawa, menggunakan kerangka kerja pemrosesan gambar Marvin .

Langkah pertama adalah ambang warna. Tujuannya di sini adalah untuk memfokuskan analisis pada objek dengan kecerahan yang signifikan.

gambar output:

Kode sumber:

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();
}
}

Pada langkah kedua, titik paling terang pada gambar dilebarkan untuk membentuk bentuk. Hasil dari proses ini adalah kemungkinan bentuk objek dengan kecerahan yang signifikan. Menerapkan segmentasi pengisian banjir, bentuk terputus terdeteksi.

gambar output:

Kode sumber:

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();
}
}

Seperti yang ditunjukkan pada gambar output, banyak bentuk terdeteksi. Dalam masalah ini, hanya ada beberapa titik terang dalam gambar. Namun, pendekatan ini diimplementasikan untuk menangani skenario yang lebih kompleks.

Pada langkah berikutnya setiap bentuk dianalisis. Algoritma sederhana mendeteksi bentuk dengan pola yang mirip dengan segitiga. Algoritma ini menganalisis objek bentuk garis demi garis. Jika pusat massa masing-masing garis bentuk hampir sama (diberi ambang batas) dan massa bertambah seiring y bertambah, objek memiliki bentuk seperti segitiga. Massa garis bentuk adalah jumlah piksel dalam garis yang termasuk dalam bentuk itu. Bayangkan Anda mengiris objek secara horizontal dan menganalisis setiap segmen horizontal. Jika mereka terpusat satu sama lain dan panjangnya bertambah dari segmen pertama ke yang terakhir dalam pola linier, Anda mungkin memiliki objek yang menyerupai segitiga.

Kode sumber:

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;
}

Akhirnya, posisi setiap bentuk mirip dengan segitiga dan dengan kecerahan yang signifikan, dalam hal ini pohon Natal, disorot dalam gambar aslinya, seperti yang ditunjukkan di bawah ini.

gambar hasil akhir:

kode sumber akhir:

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();
}
}

Keuntungan dari pendekatan ini adalah fakta bahwa ia mungkin akan bekerja dengan gambar yang mengandung objek bercahaya lain karena menganalisis bentuk objek.

Selamat Natal!

EDIT CATATAN 2

Ada diskusi tentang kesamaan gambar output dari solusi ini dan beberapa yang lain. Bahkan, mereka sangat mirip. Namun pendekatan ini tidak hanya mensegmentasi objek. Ini juga menganalisis bentuk objek dalam beberapa hal. Itu dapat menangani beberapa objek bercahaya dalam adegan yang sama. Faktanya, pohon Natal tidak perlu menjadi yang paling terang. Saya hanya membahasnya untuk memperkaya diskusi. Ada bias dalam sampel yang hanya mencari objek paling terang, Anda akan menemukan pohon. Tetapi, apakah kita benar-benar ingin menghentikan diskusi pada titik ini? Pada titik ini, seberapa jauh komputer benar-benar mengenali objek yang menyerupai pohon Natal? Mari kita coba untuk menutup celah ini.

Di bawah ini disajikan hasil hanya untuk menjelaskan hal ini:

masukan gambar

keluaran

Ini solusi sederhana dan bodoh saya. Ini didasarkan pada asumsi bahwa pohon itu akan menjadi hal yang paling terang dan besar dalam gambar.

//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;
}

Langkah pertama adalah mendeteksi piksel paling terang dalam gambar, tetapi kita harus melakukan pembedaan antara pohon itu sendiri dan salju yang memantulkan cahayanya. Di sini kami mencoba untuk mengecualikan salju yang menerapkan filter yang sangat sederhana pada kode warna:

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);

Lalu kami menemukan setiap piksel "cerah":

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);

Akhirnya kami bergabung dengan dua hasil:

bitwise_and(tmp, tmp1, tmp1);

Sekarang kita mencari objek terang terbesar:

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);

Sekarang kita hampir selesai, tetapi masih ada beberapa ketidaksempurnaan karena salju. Untuk memotongnya, kami akan membuat topeng menggunakan lingkaran dan persegi panjang untuk memperkirakan bentuk pohon untuk menghapus potongan yang tidak diinginkan:

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);

Langkah terakhir adalah menemukan kontur pohon kami dan menggambarnya di gambar aslinya.

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);

Maaf, tetapi saat ini saya memiliki koneksi yang buruk sehingga tidak mungkin bagi saya untuk mengunggah gambar. Saya akan coba melakukannya nanti.

Selamat Natal.

EDIT:

Berikut beberapa gambar hasil akhir:

Saya menulis kode di Matlab R2007a. Saya menggunakan k-means untuk mengekstrak pohon natal secara kasar. Saya akan menunjukkan hasil antara saya hanya dengan satu gambar, dan hasil akhir dengan semua enam.

Pertama, saya memetakan ruang RGB ke ruang Lab, yang dapat meningkatkan kontras merah di saluran b-nya:

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

Selain fitur dalam ruang warna, saya juga menggunakan fitur tekstur yang relevan dengan lingkungan daripada setiap piksel itu sendiri. Di sini saya secara linear menggabungkan intensitas dari 3 saluran asli (R, G, B). Alasan mengapa saya diformat dengan cara ini adalah karena pohon-pohon natal di gambar semua memiliki lampu merah pada mereka, dan kadang-kadang pencahayaan hijau / kadang-kadang biru juga.

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

Saya menerapkan pola biner lokal 3X3 pada I0, menggunakan piksel tengah sebagai ambang, dan memperoleh kontras dengan menghitung perbedaan antara nilai intensitas piksel rata-rata di atas ambang batas dan nilai rata-rata di bawahnya.

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

Karena saya memiliki total 4 fitur, saya akan memilih K = 5 dalam metode pengelompokan saya. Kode untuk k-means ditunjukkan di bawah ini (ini dari kursus pembelajaran mesin Dr. Andrew Ng. Saya mengambil kursus sebelumnya, dan saya menulis kode sendiri dalam tugas pemrogramannya).

[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

Karena program ini berjalan sangat lambat di komputer saya, saya hanya menjalankan 3 iterasi. Biasanya kriteria berhenti adalah (i) waktu iterasi setidaknya 10, atau (ii) tidak ada perubahan pada centroid lagi. Untuk pengujian saya, meningkatkan iterasi dapat membedakan latar belakang (langit dan pohon, langit dan bangunan, ...) lebih akurat, tetapi tidak menunjukkan perubahan drastis dalam ekstraksi pohon natal. Juga perhatikan k-means tidak kebal terhadap inisialisasi centroid acak, sehingga menjalankan program beberapa kali untuk membuat perbandingan direkomendasikan.

Setelah k-means, wilayah berlabel dengan intensitas maksimum I0dipilih. Dan penelusuran batas digunakan untuk mengekstraksi batas. Bagi saya, pohon natal terakhir adalah yang paling sulit untuk diekstraksi karena kontras dalam gambar itu tidak cukup tinggi seperti pada lima pohon pertama. Masalah lain dalam metode saya adalah bahwa saya menggunakan bwboundariesfungsi di Matlab untuk melacak batas, tetapi kadang-kadang batas-batas bagian dalam juga dimasukkan karena Anda dapat mengamati dalam hasil 3, 5, 6. Sisi gelap di dalam pohon natal tidak hanya gagal untuk dikelompokkan dengan sisi yang diterangi, tetapi mereka juga menyebabkan begitu banyak batasan batin kecil yang ditelusuri ( imfilltidak bertambah banyak). Secara keseluruhan, algoritma saya masih memiliki banyak ruang perbaikan.

Beberapa publikasi menunjukkan bahwa mean-shift mungkin lebih kuat daripada k-means, dan banyak algoritma berbasis grafik-cut juga sangat kompetitif pada segmentasi batas yang rumit. Saya menulis algoritma mean-shift sendiri, sepertinya lebih baik mengekstrak wilayah tanpa cukup cahaya. Tetapi pergeseran berarti sedikit lebih tersegmentasi, dan beberapa strategi penggabungan diperlukan. Itu berjalan jauh lebih lambat daripada k-berarti di komputer saya, saya takut saya harus menyerah. Saya berharap dapat melihat orang lain akan mengirimkan hasil yang sangat baik di sini dengan algoritma modern yang disebutkan di atas.

Namun saya selalu percaya pemilihan fitur adalah komponen kunci dalam segmentasi gambar. Dengan pemilihan fitur yang tepat yang dapat memaksimalkan margin antara objek dan latar belakang, banyak algoritma segmentasi pasti akan berfungsi. Algoritme yang berbeda dapat meningkatkan hasil dari 1 hingga 10, tetapi pemilihan fitur dapat meningkatkannya dari 0 hingga 1.

Selamat Natal !

Ini adalah posting terakhir saya menggunakan pendekatan pemrosesan gambar tradisional ...

Di sini saya entah bagaimana menggabungkan dua proposal saya yang lain, mencapai hasil yang lebih baik . Sebenarnya saya tidak bisa melihat bagaimana hasil ini bisa lebih baik (terutama ketika Anda melihat gambar bertopeng yang dihasilkan metode ini).

Inti dari pendekatan ini adalah kombinasi dari tiga asumsi utama :

1. Gambar harus memiliki fluktuasi tinggi di wilayah pohon
2. Gambar harus memiliki intensitas yang lebih tinggi di wilayah pohon
3. Daerah latar belakang harus memiliki intensitas rendah dan sebagian besar biru-ish

Dengan asumsi ini, metode ini berfungsi sebagai berikut:

1. Konversi gambar ke HSV
2. Saring saluran V dengan filter LoG
3. Terapkan ambang keras pada gambar yang difilter LoG untuk mendapatkan topeng 'aktivitas' A
4. Terapkan ambang keras ke saluran V untuk mendapatkan topeng intensitas B
5. Terapkan ambang saluran H untuk menangkap daerah blue-ish intensitas rendah ke dalam topeng latar belakang C
6. Gabungkan topeng menggunakan DAN untuk mendapatkan topeng terakhir
7. Lebarkan topeng untuk memperbesar wilayah dan menghubungkan piksel yang tersebar
8. Hilangkan daerah kecil dan dapatkan topeng terakhir yang pada akhirnya hanya akan mewakili pohon

Berikut adalah kode dalam MATLAB (sekali lagi, skrip memuat semua gambar jpg di folder saat ini dan, sekali lagi, ini masih jauh dari sepotong kode yang dioptimalkan):

% 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

Hasil

Hasil resolusi tinggi masih tersedia di sini!
Bahkan lebih banyak percobaan dengan gambar tambahan dapat ditemukan di sini.

Langkah solusi saya:

1. Dapatkan saluran R (dari RGB) - semua operasi yang kami lakukan di saluran ini:

2. Buat Wilayah Bunga (ROI)

   • Saluran R ambang batas dengan nilai min 149 (gambar kanan atas)

   • Melebarkan wilayah hasil (gambar kiri tengah)

3. Mendeteksi eges dalam roi yang dihitung. Pohon memiliki banyak sisi (gambar kanan tengah)

   • Dilatasi hasilnya

   • Melaju dengan radius lebih besar (gambar kiri bawah)

4. Pilih objek (berdasarkan wilayah) terbesar - ini adalah wilayah hasil

5. ConvexHull (pohon adalah cembung poligon) (gambar kanan bawah)

6. Bounding box (gambar kanan bawah - kotak grren)

Selangkah demi selangkah:

Hasil pertama - paling sederhana tetapi tidak dalam perangkat lunak sumber terbuka - "Adaptive Vision Studio + Adaptive Vision Library": Ini bukan open source tetapi sangat cepat untuk prototipe:

Seluruh algoritme untuk mendeteksi pohon natal (11 blok):

Langkah berikutnya. Kami menginginkan solusi open source. Ubah filter AVL menjadi filter OpenCV: Di sini saya melakukan sedikit perubahan misalnya Deteksi Tepi menggunakan filter cvCanny, untuk menghormati roi, saya melakukan penggandaan gambar wilayah dengan gambar tepi, untuk memilih elemen terbesar yang saya gunakan findContours + contourArea tetapi gagasannya sama.

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

Saya tidak dapat menampilkan gambar dengan langkah perantara sekarang karena saya hanya dapat menempatkan 2 tautan.

Ok sekarang kita menggunakan filter openSource tetapi itu belum sepenuhnya open source. Langkah terakhir - port ke kode c ++. Saya menggunakan OpenCV dalam versi 2.4.4

Hasil akhir kode c ++ adalah:

kode c ++ juga cukup pendek:

#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;
}