web-dev-qa-db-fra.com

Extraction des fonctionnalités HoG à l'aide d'OpenCV

J'essaie d'extraire des fonctionnalités à l'aide de l'API HoG d'OpenCV, mais je n'arrive pas à trouver l'API qui me permet de le faire.

Ce que j'essaie de faire est d'extraire des fonctionnalités à l'aide de HoG de tous mes ensembles de données (un nombre défini d'images positives et négatives), puis de former mon propre SVM.

J'ai jeté un œil dans HoG.cpp sous OpenCV, et cela n'a pas aidé. Tous les codes sont enfouis dans des complexités et la nécessité de prendre en charge différents matériels (par exemple IPP d'Intel)

Ma question est:

  1. Existe-t-il une API d'OpenCV que je peux utiliser pour extraire toutes ces fonctionnalités/descripteurs à introduire dans un SVM? S'il y a comment puis-je l'utiliser pour former mon propre SVM?
  2. Si ce n'est pas le cas, existe-t-il des bibliothèques existantes qui pourraient accomplir la même chose?

Jusqu'à présent, je porte en fait une bibliothèque existante (http://hogprocessing.altervista.org/) de Processing (Java) vers C++, mais c'est toujours très lent, la détection prenant environ 16 secondes au moins

Quelqu'un d'autre a-t-il réussi à extraire les fonctionnalités de HoG, comment avez-vous procédé? Et avez-vous des codes open source que je pourrais utiliser?

Merci d'avance

opencvcomputer-visionfeature-detectionobject-recognitionfeature-extraction
38
sub_o

Vous pouvez utiliser la classe hog en opencv comme suit

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

Cette fonction calcule les caractéristiques du porc pour vous

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

Les fonctionnalités HOG calculées pour grayImg sont stockées dans le vecteur ders pour en faire une matrice, qui peut être utilisée plus tard pour la formation.

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

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

Vos fonctionnalités HOG sont désormais stockées dans la matrice Hogfeat.

Vous pouvez également définir la taille de la fenêtre, la taille des cellules et la taille des blocs en utilisant l'objet hog comme suit:

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;

J'espère que c'est utile :)

50
G453

Voici également la version 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);
3
user3398689

J'ai également écrit le programme de 2 fonctionnalités de porc en comparant avec l'aide de l'article ci-dessus. Et j'applique cette méthode pour vérifier si la région du ROI change ou non. Veuillez vous référer à la page ici. code source et introduction simple

3
Jeonghyun Kim

OpenCV 3 apporte quelques modifications à la façon dont les algorithmes GPU (c.-à-d. CUDA) peuvent être utilisés par l'utilisateur, voir Guide de transition - CUDA .

Pour mettre à jour la réponse de user3398689 vers OpenCV 3, voici un code coupé:

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

Vous pouvez ensuite utiliser les descripteurs de la variable 'dst' comme vous le souhaitez, par exemple, comme suggéré par G453.

1
Claudio