feature - object recognition opencv

Extracción de características de HoG usando OpenCV

Question

Estoy tratando de extraer características usando la API HoG de OpenCV, sin embargo, parece que no puedo encontrar la API que me permita hacer eso.

Lo que trato de hacer es extraer las características usando HoG de todo mi conjunto de datos (un número determinado de imágenes positivas y negativas), luego entrenar mi propio SVM.

Eché un vistazo a HoG.cpp bajo OpenCV, y no sirvió de nada. Todos los códigos están ocultos dentro de las complejidades y la necesidad de atender diferentes hardwares (por ejemplo, el IPP de Intel)

Mi pregunta es:

1. ¿Hay alguna API de OpenCV que pueda usar para extraer todas esas características / descriptores que se incluirán en una SVM? Si hay cómo puedo usarlo para entrenar mi propia SVM?
2. Si no existe, ¿hay alguna biblioteca existente, que podría lograr lo mismo?

Hasta ahora, en realidad estoy portando una biblioteca existente (http://hogprocessing.altervista.org/) de Processing (Java) a C ++, pero aún es muy lenta, con una detección que tarda por lo menos 16 segundos

¿Alguien más ha logrado extraer las características de HoG, cómo lo ha solucionado? ¿Y tienes algún código fuente abierto que pueda usar?

Gracias por adelantado

Answer 1

Aquí también está la versión de la GPU.

cv::Mat temp;
gpu::GpuMat gpu_img, descriptors;

cv::gpu::HOGDescriptor gpu_hog(win_size, Size(16, 16), Size(8, 8), Size(8, 8), 9,
                               cv::gpu::HOGDescriptor::DEFAULT_WIN_SIGMA, 0.2, gamma_corr,
                               cv::gpu::HOGDescriptor::DEFAULT_NLEVELS);
gpu_img.upload(img);
gpu_hog.getDescriptors(gpu_img, win_stride, descriptors, cv::gpu::HOGDescriptor::DESCR_FORMAT_ROW_BY_ROW);
            descriptors.download(temp);

Answer 2

OpenCV 3 proporciona algunos cambios en la forma en que los algoritmos de la GPU (es decir, CUDA) pueden ser utilizados por el usuario; consulte la Guía de transición - CUDA .

Para actualizar la respuesta del usuario3398689 a OpenCV 3, aquí hay un código recortado:

#include <opencv2/core/cuda.hpp>
#include <opencv2/cudaimgproc.hpp>

[...]

/* Suppose you load an image in a cv::Mat variable called ''src'' */

int img_width  = 320;
int img_height = 240;
int block_size = 16;
int bin_number = 9;

cv::Ptr<cv::cuda::HOG> cuda_hog = cuda::HOG::create(Size(img_width, img_height),
                                                    Size(block_size, block_size),
                                                    Size(block_size/2, block_size/2),
                                                    Size(block_size/2, block_size/2),
                                                    bin_number);

/* The following commands are optional: default values applies */
cuda_hog->setDescriptorFormat(cuda::HOG::DESCR_FORMAT_COL_BY_COL);
cuda_hog->setGammaCorrection(true);
cuda_hog->setWinStride(Size(img_width_, img_height_));

cv::cuda::GpuMat image;
cv::cuda::GpuMat descriptor;

image.upload(src);

/* May not apply to you */
/* CUDA HOG works with intensity (1 channel) or BGRA (4 channels) images */
/* The next function call convert a standard BGR image to BGRA using the GPU */
cv::cuda::GpuMat image_alpha;
cuda::cvtColor(image, image_alpha, COLOR_BGR2BGRA, 4);

cuda_hog->compute(image_alpha, descriptor);

cv::Mat dst;
image_alpha.download(dst);

Luego puede usar los descriptores en la variable ''dst'' como prefiera, por ejemplo, como lo sugiere G453.

Answer 3

Puedes usar la clase hog en opencv de la siguiente manera

HOGDescriptor hog;
vector<float> ders;
vector<Point> locs;

Esta función calcula las características del cerdo para usted

hog.compute(grayImg, ders, Size(32, 32), Size(0, 0), locs);

Las características de HOG calculadas para grayImg se almacenan en ders vector para convertirlo en una matriz, que luego se puede utilizar para el entrenamiento.

Mat Hogfeat(ders.size(), 1, CV_32FC1);

for(int i=0;i<ders.size();i++)
    Hogfeat.at<float>(i,0)=ders.at(i);

Ahora sus características HOG se almacenan en la matriz Hogfeat.

También puede establecer el tamaño de la ventana, el tamaño de la celda y el tamaño del bloque utilizando el objeto hog siguiente manera:

hog.blockSize = 16;
hog.cellSize = 4;
hog.blockStride = 8;

// This is for comparing the HOG features of two images without using any SVM 
// (It is not an efficient way but useful when you want to compare only few or two images)
// Simple distance
// Consider you have two HOG feature vectors for two images Hogfeat1 and Hogfeat2 and those are same size.

double distance = 0;
for(int i = 0; i < Hogfeat.rows; i++)
    distance += abs(Hogfeat.at<float>(i, 0) - Hogfeat.at<float>(i, 0));

if (distance < Threshold)
    cout<<"Two images are of same class"<<endl;
else
    cout<<"Two images are of different class"<<endl;

Espero que sea útil :)

Answer 4

También escribí el programa de 2 características de cerdos comparando con la ayuda del artículo anterior. Y aplico este método para verificar el cambio de región de ROI o no. Por favor, consulte la página aquí. código fuente e introducción simple