Extraction des caractéristiques des porcs à 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, c'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 coup d'oeil dans le cochon.cpp sous OpenCV, et ça n'a pas aidé. Tous les codes sont enfouis dans des complexités et la nécessité de répondre aux différents hardwares (IPP D'Intel par exemple)

mon la question est:

  1. y a-t-il une API D'OpenCV que je puisse utiliser pour extraire toutes les fonctionnalités / descripteurs à introduire dans un SVM ? S'il y a un moyen de l'utiliser pour former ma propre SVM ?
  2. s'il n'y en a pas, y a-t-il des bibliothèques existantes qui pourraient accomplir la même chose ?

pour l'instant, je porte une bibliothèque existante (http://hogprocessing.altervista.org/) du traitement (Java) au C++, mais c'est encore très lent, avec la détection prend au moins 16 secondes!--1-->

quelqu'un d'autre A réussi à extraire de Porc caractéristiques, comment les avez-vous entoure ? Et avez-vous des codes open source que je pourrais utiliser ?

Merci d'avance

37
demandé sur sub_o 2012-07-24 11:33:09

4 réponses

vous pouvez utiliser la classe hog dans opencv comme suit

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

cette fonction calcule les traits de cochon pour vous

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

Le PORC caractéristiques calculées pour grayImg sont stockés dans ders vecteur pour en faire une matrice, qui peut être utilisé 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);

maintenant, vos caractéristiques de HOG sont stockées dans hogfeat matrix.

vous pouvez également définir la taille de la fenêtre, la taille de la cellule et la taille du bloc 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 :)

48
répondu G453 2017-12-07 12:34:01

j'ai aussi écrit le programme de 2 Hog feature comparant avec l'aide de l'article ci-dessus. Et j'applique cette méthode pour vérifier si la région du retour sur investissement change ou non. Veuillez vous référer à la page ici. code source et introduction simple

3
répondu Jeonghyun Kim 2015-02-27 04:39:14

voici aussi 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
répondu 2015-06-26 20:25:58

OpenCV 3 fournit quelques modifications à la façon dont les algorithmes GPU (i.e. CUDA) peuvent être utilisés par l'utilisateur, voir le Guide de Transition-CUDA.

pour mettre à jour la réponse de user3398689 à OpenCV 3, Voici un code snippé: 

#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 alors utiliser les descripteurs de la variable 'dst' comme vous préférez, par exemple, comme suggéré par G453.

1
répondu Claudio 2017-02-22 22:40:23