How to identify whether or not the area of an object is within another area desired by the user, drawn by mouse

The code

#include <opencv2\core.hpp>
#include <opencv2\highgui.hpp>
#include <opencv2\imgproc.hpp>

#include <vector>
#include <iostream>

using namespace std;
using namespace cv;

Size sz = Size(800, 600);
Mat image = Mat::zeros(sz, CV_8UC3);
Rect roi;
vector<Point> polygon;
bool buttonDown = false;

typedef enum
{
    CAPTURING_POLYGON,
    CAPTURING_ROI
} Capturing;
Capturing cap;

void roiCapture(int event, int x, int y, int flags, void *userdata)
{
    if(event == EVENT_LBUTTONDOWN)
    {
        roi = Rect(x, y, 0, 0);
        buttonDown = true;
    }
    else if(event == EVENT_LBUTTONUP)
    {
        buttonDown = false;
        roi = Rect(Point(roi.x, roi.y), Point(x, y));
    }
    else if(buttonDown)
        roi = Rect(Point(roi.x, roi.y), Point(x, y));       
}

void polygonCapture(int event, int x, int y, int flags, void *userdata)
{
    if(event == EVENT_LBUTTONUP)
        polygon.push_back(Point(x, y));
    else if(event == EVENT_RBUTTONDOWN)
        polygon.clear();
}

float calcOverlapping(const Rect &roi, const vector<Point> &polygon, const Size &sz, Mat &resp)
{
    // Desenha o polígono preenchido com branco em uma imagem binária toda em preto
    Mat imgPol = Mat::zeros(sz, CV_8UC1);
    vector<vector<Point>> points;
    points.push_back(polygon);
    int npts = polygon.size();
    fillPoly(imgPol, points, Scalar(255));

    // Desenha o retângulo preenchido com branco em uma imagem binária toda em preto
    Mat imgRoi = Mat::zeros(sz, CV_8UC1);
    rectangle(imgRoi, roi, Scalar(255, 255, 255), CV_FILLED);

    // Faz um "E" lógico das imagens. Isso causa uma interseção das áreas, pois apenas os pixels
    // que forem branco NAS DUAS imagens irão permanecer em branco na imagem de resposta.
    bitwise_and(imgPol, imgRoi, resp);

    // Conta os pixels que são diferentes de preto (0) na imagem resultante
    int intersec = countNonZero(resp);

    // Conta os pixels que são diferentes de preto (0) na imagem da ROI (porque a área dela é
    // usada como base (isto é, que se saber qual é a porcentagem da ROI que está dentro do 
    // polígono)
    int base = countNonZero(imgRoi);

    // A resposta é um percentual (entre 0 e 1), indicando quanto da ROI está na interseção.
    // Se a ROI estiver inteira dentro do polígono, a interseção vai ser total e esse valor vai
    // dar 1. Se estiver totalmente fora, a interseção vai ser nula e esse valor vai dar 0.
    return float(intersec) / float(base);
}

int main()
{
    // ===========================================
    // Captura das áreas para teste.
    // Essa parte você já faz (ou sabe fazer).
    // ===========================================
    namedWindow("Captura", WINDOW_AUTOSIZE);

    int fontFace = FONT_HERSHEY_SIMPLEX;
    double fontScale = 0.5;
    int thickness = 1;

    // Começa capturando a área do polígono
    cap = CAPTURING_POLYGON;
    setMouseCallback("Captura", polygonCapture, NULL);
    bool ok = true;
    while(ok)
    {
        // Pinta tudo de preto
        image = Scalar(0, 0, 0);

        // Desenha o texto de ajuda
        string text;
        if(cap == CAPTURING_ROI)
            text = "Desenhe o ROI com o mouse. Pressione [C] para continuar.";
        else
            text = "Adicione pontos ao POLIGONO com o mouse (botao direito limpa). Pressione [C] para continuar.";
        putText(image, text, Point(0, 15), fontFace, fontScale, Scalar(255, 255, 255), thickness);

        // Desenha o polígono, se ele tiver dados
        if(polygon.size() == 1)
            circle(image, polygon[0], 1, Scalar(255, 0, 255));
        else if(polygon.size() > 1)
        {
            vector<vector<Point>> points;
            points.push_back(polygon);
            int npts = polygon.size();
            fillPoly(image, points, Scalar(255, 0, 255));
        }

        // Desenha a ROI, se ela tiver dados
        if(roi.width != 0 || roi.height != 0)
            rectangle(image, roi, Scalar(0, 255, 255));

        imshow("Captura", image);
        int k = waitKey(10);
        switch(k)
        {
            case 27: // ESC
            case 'q':
            case 'Q':
                destroyAllWindows();
                return 0;

            case 'c':
            case 'C':
                if(cap == CAPTURING_POLYGON)
                {
                    cap = CAPTURING_ROI;
                    // Troca pra captura da ROI
                    setMouseCallback("Captura", roiCapture, NULL);
                }
                else
                    ok = false;
                break;
        }
    }

    // ===========================================
    // Cálculo do percentual de interseção.
    // Essa parte é a novidade.
    // ===========================================

    Mat resp;
    float val = calcOverlapping(roi, polygon, sz, resp);

    cout << "Valor de intereseção calculado: " << val << endl;

    imshow("Debug", resp);
    waitKey(0);

    return 0;
}

The really important function is calcOverlapping , which does the "magic". :)

Result Examples

In the following examples, the left image indicates the ROI (in yellow) and the polygon (in magenta), and the image on the right indicates only the intersection area in the resulting binary image of the logical E between the two binary images constructed from the figures in the left image.

Valordeinterseçãocalculado:0.748836

Valordeinterseçãocalculado:0.012016

Edition:RealUseExample

Youhavecreated#

Well,ifyouwanttheCascadedetectortofindonlypeoplewithintheregionboundedbytheredpolygon,justusewhatIexplainedaboveandmakethelogicaloperationtohaveonlythepixelsintheregionpolygonintoaROIthatcontinuestoberectangular(the"final" image in the example below). Then apply Cascade on this new image . Example (in Python this time, because I did it in a hurry - but it's the same thing in C ++):

import numpy as np
import cv2

image = cv2.imread('teste.png', cv2.IMREAD_COLOR)

# Define a Região de Interesse (ROI)
left = 15
top = 118
width = 615
height = 365
roi = image[top:height, left:width]

# Define o polígono delimitador
points = np.array([[(0, 184), (165, 40), (402, 0), (598, 20), (482, 56), (342, 245)]])
mask = np.zeros(roi.shape, roi.dtype)
cv2.fillPoly(mask, points, (255, 255, 255)) # Preenche com branco (note que a cor é RGB - i.e. 3 bandas, já que a imagem não é binária!)

final = cv2.bitwise_and(roi, mask)

cv2.imshow('Imagem Original', image)
cv2.imshow('ROI', roi)
cv2.imshow('Mascara', mask)
cv2.imshow('Final', final)

cv2.waitKey(0)

Result: