Як виявити ялинку? [зачинено]

Які методи обробки зображень можна використовувати для реалізації програми, яка визначає ялинки, відображені на наступних зображеннях?

Я шукаю рішення, які будуть працювати над усіма цими зображеннями. Тому підходи, які потребують підготовки каскадних класифікаторів Haar або відповідності шаблонів , не дуже цікаві.

Я шукаю те, що можна написати будь-якою мовою програмування, якщо воно використовує лише технології Open Source . Розв’язання має бути протестовано із зображеннями, якими ділиться в цьому питанні. Є 6 вхідних зображень, і відповідь повинна відображати результати обробки кожного з них. Нарешті, для кожного вихідного зображення повинні бути намальовані червоні лінії для оточення виявленого дерева.

Як би ви вирішили програмно виявити дерева на цих зображеннях?

У мене є підхід, який я вважаю цікавим і трохи відрізняється від решти. Основна відмінність мого підходу порівняно з деякими іншими полягає в тому, як виконується етап сегментації зображення - я використовував DBSCAN алгоритм кластеризації від Scikit-learn Python; він оптимізований для пошуку дещо аморфних форм, які не обов'язково мають єдиний чіткий центроїд.

На найвищому рівні мій підхід досить простий і його можна розділити приблизно на 3 кроки. Спочатку я застосовую поріг (або власне, логічне "або" двох окремих і виразних порогів). Як і в багатьох інших відповідях, я припускав, що ялинка буде одним із яскравих об’єктів на сцені, тому перший поріг - це просто простий монохромний тест яскравості; будь-які пікселі зі значеннями вище 220 за шкалою 0-255 (де чорний - 0, а білий - 255), зберігаються у бінарне чорно-біле зображення. Другий поріг намагається шукати червоні та жовті вогні, які особливо помітні на деревах у верхньому лівому та нижньому правому куті від шести зображень та добре виділяються на синьо-зеленому тлі, який є поширеним у більшості фотографій. Я перетворюю зображення rgb в простір hsv, і вимагати, щоб відтінок був менше 0,2 за шкалою 0,0-1,0 (що відповідає границі між жовтим та зеленим) або більше 0,95 (відповідає межі між фіолетовим та червоним), і додатково мені потрібні яскраві насичені кольори: і насиченість, і значення повинні бути вище 0,7. Результати двох порогових процедур є логічно "або" -ed разом, і отримана матриця чорно-білих бінарних зображень показана нижче:

Ви чітко бачите, що кожне зображення має один великий кластер пікселів, що приблизно відповідає розташуванню кожного дерева, плюс кілька зображень також мають деякі інші невеликі кластери, що відповідають або вогням у вікнах деяких будівель, або фон сцени на горизонті. Наступним кроком є ​​те, щоб комп'ютер визнав, що це окремі кластери, і правильно позначити кожен піксель за допомогою ідентифікаційного номера членського кластера.

Для цього завдання я вибрав DBSCAN . Тут досить хороше візуальне порівняння того, як DBSCAN поводиться, як правило, стосовно інших алгоритмів кластеризації, доступних тут . Як я вже говорив раніше, це добре справляється з аморфними формами. Вихід DBSCAN з кожним кластером, побудованим в іншому кольорі, показаний тут:

Потрібно пам’ятати кілька речей, дивлячись на цей результат. По-перше, DBSCAN вимагає від користувача встановити параметр "близькості", щоб регулювати його поведінку, який ефективно контролює, наскільки має бути відокремлена пара точок, щоб алгоритм оголосив новий окремий кластер, а не агломерацію тестової точки на вже існуючий кластер. Я встановив це значення в 0,04 рази більше за діагональ кожного зображення. Оскільки зображення відрізняються за розміром від приблизно VGA до приблизно HD 1080, такий тип визначення масштабу є критичним.

Ще один момент, який варто зауважити, полягає в тому, що алгоритм DBSCAN під час його реалізації в scikit-learn має обмеження пам'яті, які є досить складними для деяких великих зображень у цьому зразку. Тому для декількох більших зображень мені довелося "зменшити" (тобто зберегти лише кожен 3-й або 4-й піксель і скинути інші) кожен кластер, щоб залишитися в межах цієї межі. В результаті цього процесу відсікання на деяких великих зображеннях залишилися окремі розріджені пікселі. Тому лише для відображення кольорові пікселі на вищезазначених зображеннях були ефективно «розширені» лише трохи, щоб вони краще виділялися. Це суто косметична операція заради розповіді; хоча в моєму кодексі є коментарі, в яких згадується про цю дилатацію,

Після того, як кластери будуть ідентифіковані та помічені, третій і останній крок стає простим: я просто беру найбільший кластер у кожному зображенні (у цьому випадку я вибрав для вимірювання "розмір" за загальною кількістю пікселів-членів, хоча можна було б настільки ж просто замість цього використовується якийсь тип метрики, яка вимірює фізичну міру) і обчислити опуклий корпус для цього кластера. Опуклий корпус потім стає межею дерева. Шість опуклих корпусів, обчислених цим методом, показані нижче червоним кольором:

Вихідний код написаний для Python 2.7.6, і це залежить від numpy , scipy , matplotlib та scikit-learn . Я розділив його на дві частини. Перша частина відповідає за фактичну обробку зображення:

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

а друга частина - це сценарій рівня користувача, який викликає перший файл і генерує всі наведені вище сюжети:

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

РЕДАКТУВАЛЬНА ПРИМІТКА. Я редагував цю публікацію, щоб (i) обробляти кожне зображення дерева окремо, як цього вимагають вимоги;

Нижче представлений підхід, який враховує яскравість та форму об'єкта. Іншими словами, він шукає об’єкти, що мають форму трикутника та зі значною яскравістю. Він був реалізований в Java, використовуючи рамки обробки зображень Marvin .

Перший крок - кольорове обмеження. Завдання тут - зосередити аналіз на об'єктах зі значною яскравістю.

вихідні зображення:

вихідний код:

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

На другому кроці найяскравіші точки зображення розширюються з метою формування фігур. Результатом цього процесу є ймовірна форма предметів зі значною яскравістю. Застосовуючи сегментацію заливного заливу, виявляються від’єднані форми.

вихідні зображення:

вихідний код:

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

Як показано на вихідному зображенні, було виявлено кілька фігур. У цій проблемі на зображеннях є лише кілька яскравих точок. Однак такий підхід був застосований для вирішення більш складних сценаріїв.

На наступному етапі кожна форма аналізується. Простий алгоритм виявляє фігури з малюнком, схожим на трикутник. Алгоритм аналізує об’єктну форму за рядком. Якщо центр маси кожної лінії фігури майже однаковий (заданий поріг), а маса збільшується в міру збільшення y, об'єкт має форму трикутника. Маса лінії фігури - це кількість пікселів у тому рядку, який належить фігурі. Уявіть, що ви нарізаєте об'єкт по горизонталі та аналізуєте кожен горизонтальний сегмент. Якщо вони централізовані один до одного і довжина збільшується від першого сегмента до останнього за лінійним малюнком, напевно, у вас є об'єкт, що нагадує трикутник.

вихідний код:

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

Нарешті, положення кожної форми, подібне до трикутника та зі значною яскравістю, в даному випадку ялинку, виділяється на оригінальному зображенні, як показано нижче.

кінцеві вихідні зображення:

остаточний вихідний код:

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

Перевагою такого підходу є той факт, що він, ймовірно, працюватиме із зображеннями, що містять інші світяться об'єкти, оскільки він аналізує форму об'єкта.

Щасливого Різдва!

РЕДАКЦІЯ ПРИМІТКА 2

Йде дискусія про схожість вихідних зображень цього рішення та деяких інших. Насправді вони дуже схожі. Але такий підхід не просто сегментує об’єкти. Він також аналізує фігури об'єкта в певному сенсі. Він може обробляти кілька світних предметів в одній сцені. Насправді ялинку не потрібно бути найяскравішою. Я просто перекладаю це, щоб збагатити дискусію. У зразках є упередженість, що просто шукаючи найяскравіший об’єкт, ви знайдете дерева. Але чи справді ми хочемо зупинити дискусію на цьому етапі? У цей момент, наскільки комп'ютер насправді розпізнає предмет, що нагадує ялинку? Спробуємо закрити цю прогалину.

Нижче представлений результат лише для з'ясування цього моменту:

вхідне зображення

вихід

Ось моє просте і німе рішення. Він заснований на припущенні, що дерево буде найяскравішою і великою річчю на малюнку.

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

Перший крок - виявити найяскравіші пікселі на малюнку, але ми повинні зробити відмінність між самим деревом та снігом, який відбиває його світло. Тут ми намагаємось виключити сніг, застосувавши дійсно простий фільтр кольорових кодів:

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

Вибачте, але на даний момент у мене поганий зв’язок, тому неможливо завантажувати фотографії. Я спробую це зробити пізніше.

Щасливого Різдва.

Редагувати:

Ось кілька знімків підсумкового результату:

Я написав код у Matlab R2007a. Я використовував k-засоби, щоб грубо витягти ялинку. Я покажу проміжний результат лише одним зображенням, а кінцеві результати - всіма шістьма.

По-перше, я намалював простір RGB на простір лабораторії, що може посилити контраст червоного кольору в його b-каналі:

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

Окрім функції у кольоровому просторі, я також використовував функцію текстури, яка більше стосується сусідства, а не кожного пікселя. Тут я лінійно поєднав інтенсивність з трьох вихідних каналів (R, G, B). Причина, чому я відформатував цей спосіб, полягає в тому, що на ялинках на зображенні всі червоні вогні на них, а іноді і зелене / іноді синє освітлення.

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

Я застосував локальну бінарну схему 3X3 I0, використав центральний піксель як поріг і отримав контраст, обчисливши різницю між середнім значенням інтенсивності пікселя над порогом і середнім значенням під ним.

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

Оскільки у мене всього 4 функції, я вибрав би K = 5 у своєму методі кластеризації. Код k-засобів показаний нижче (це з курсу машинного навчання доктора Ендрю Нг. Я пройшов курс раніше, і сам написав код у своєму завданні з програмування).

[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

Оскільки програма працює на моєму комп’ютері дуже повільно, я просто запустив 3 ітерації. Зазвичай критеріями зупинки є (i) час ітерації принаймні 10, або (ii) більше не змінюється на центроїдах. На мій тест, збільшення ітерації може диференціювати тло (небо та дерево, небо та будівля, ...) точніше, але не показало кардинальних змін у видобутку ялинки. Також зауважте, що k-засоби не застраховані від випадкової ініціалізації центроїдів, тому рекомендується запускати програму кілька разів для порівняння.

Після k-засобів I0була обрана мічена область з максимальною інтенсивністю . І граничне трасування було використано для вилучення кордонів. Мені остання ялинка є найскладнішою для видобутку, оскільки контраст на цій картині недостатньо високий, оскільки вони є в першій п'ятірці. Інша проблема мого методу полягає в тому, що я використовував bwboundariesфункцію в Matlab для відстеження меж, але іноді також включаються внутрішні межі, як ви можете спостерігати в результатах 3-го, 5-го, 6-го. Темна сторона в ялинках не тільки не змогла бути згрупована підсвіченою стороною, але й призводить до такої кількості крихітних внутрішніх меж ( imfillне дуже покращується). У всьому моєму алгоритмі ще багато місця для вдосконалення.

Деякі публікації вказують, що середній зсув може бути більш надійним, ніж k-засоби, і багато алгоритмів на основі графіків також дуже конкурентоспроможні за складної сегментації меж. Я написав алгоритм середнього зсуву сам, здається, краще витягувати регіони без достатнього світла. Але середній зсув дещо сегментований, і потрібна певна стратегія об'єднання. Він працював навіть набагато повільніше, ніж k-означає, на моєму комп’ютері, я боюся, що мені доведеться його відмовити. Я з нетерпінням чекаю, що інші представлять тут чудові результати за допомогою цих сучасних алгоритмів, згаданих вище.

Але я завжди вважаю, що вибір функції є ключовим компонентом сегментації зображення. При правильному підборі функції, який може максимально збільшити межу між об'єктом і фоном, безліч алгоритмів сегментації обов'язково спрацює. Різні алгоритми можуть покращити результат від 1 до 10, але вибір функції може покращити його від 0 до 1.

Щасливого Різдва !

Це моя остання публікація з використанням традиційних підходів до обробки зображень ...

Тут я якось поєдную свої дві інші пропозиції, домагаючись ще кращих результатів . Власне кажучи, я не бачу, як ці результати можуть бути кращими (особливо, коли ви дивитесь на масковані зображення, які створює метод).

В основі підходу лежить поєднання трьох ключових припущень :

1. Зображення повинні мати великі коливання в областях дерева
2. Зображення повинні мати більш високу інтенсивність у регіонах дерева
3. Фонові регіони повинні мати низьку інтенсивність і бути переважно блакитними

Маючи на увазі ці припущення, метод працює наступним чином:

1. Перетворення зображень у HSV
2. Відфільтруйте V канал за допомогою фільтра LoG
3. Застосовуйте жорстке порогове значення на відфільтрованому LoG зображенні, щоб отримати маску "Активність"
4. Застосуйте жорсткий поріг до V каналу, щоб отримати маску інтенсивності B
5. Застосовуйте порогове значення H-каналу для зйомки областей низької інтенсивності синього кольору у маску С
6. Поєднайте маски за допомогою AND, щоб отримати остаточну маску
7. Розширіть маску, щоб збільшити регіони та з'єднати дисперсні пікселі
8. Усуньте невеликі регіони і отримайте остаточну маску, яка в кінцевому підсумку буде представляти лише дерево

Ось код у MATLAB (знову ж таки, скрипт завантажує всі зображення jpg у поточну папку, і, знову ж таки, це далеко не оптимізований фрагмент коду):

% 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

Результати

Результати з високою роздільною здатністю ще доступні тут!
Ще більше експериментів з додатковими зображеннями можна знайти тут.

Мої кроки вирішення:

1. Отримати R-канал (від RGB) - всі операції, які ми робимо на цьому каналі:

2. Створіть цікавий регіон (ROI)

   • Поріг каналу R з мінімальним значенням 149 (верхнє право зображення)

   • Розширити область результатів (зображення зліва вліво)

3. Виявити егези в обчислених роях. Дерево має багато країв (зображення в середньому правому куті)

   • Розширити результат

   • Ерозія з більшим радіусом (зображення внизу ліворуч)

4. Виберіть найбільший (за площею) об’єкт - це область результатів

5. ConvexHull (дерево - опуклий багатокутник) (зображення праворуч внизу)

6. Обв'язувальний ящик (зображення праворуч внизу - скринька грина)

Крок за кроком:

Перший результат - найпростіший, але не в програмному забезпеченні з відкритим кодом - "Адаптивна Vision Studio + Бібліотека адаптивних бачень": Це не з відкритим кодом, але дуже швидко прототипується:

Весь алгоритм виявлення ялинки (11 блоків):

Наступний крок. Ми хочемо рішення з відкритим кодом. Змініть AVL-фільтри на OpenCV-фільтри: Тут я зробив невеликі зміни, наприклад, для виявлення країв використовується фільтр cvCanny, щоб поважати Рой, я помножив зображення регіону на зображення ребер, щоб вибрати найбільший елемент, який я використав findContours + contourArea, але ідея така ж.

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

Зараз я не можу показувати зображення з проміжними кроками, оскільки я можу розмістити лише 2 посилання.

Гаразд, ми використовуємо фільтри openSource, але це ще не весь відкритий код. Останній крок - порт до коду c ++. Я використовував OpenCV у версії 2.4.4

Результатом остаточного коду c ++ є:

Код c ++ також досить короткий:

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