Extrahieren von HoG-Funktionen mit OpenCV

Ich versuche zum extrahieren von features mithilfe von OpenCV ' s HoG-API, aber ich kann nicht scheinen zu finden, die API, die mir erlauben, das zu tun.

Was ich versuche zu tun, ist zu extrahieren Funktionen mit HoG aus allen meinen Daten (eine festgelegte Anzahl von positiv-und negativ-Bilder), dann Zug meine eigene SVM.

Ich spähte in HoG.cpp unter OpenCV, und es hat nicht geholfen. Alle codes sind begraben innerhalb Komplexität und der Notwendigkeit gerecht zu werden für verschiedene Bauteile (z.B. der Intel IPP)

Meine Frage ist:

  1. Gibt es eine API von OpenCV, die ich verwenden können, um zu extrahieren alle diese Funktionen /Deskriptoren zur Einspeisung in ein SVM ? Wenn es, wie kann ich es nutzen, um Zug meine eigene SVM ?
  2. Wenn es nicht ist, gibt es bereits Bibliotheken gibt, die könnten das gleiche erreichen ?

Bisher bin ich eigentlich portieren einer vorhandenen Bibliothek (http://hogprocessing.altervista.org/) von der Verarbeitung (Java) in C++, aber es ist immer noch sehr langsam, mit Erkennung der Einnahme um mindestens 16 Sekunden

Hat jemand anderes erfolgreich zu extrahieren HoG-features, wie hast du um Sie herum gehen ? Und haben Sie irgendwelche open-source-codes, die ich verwenden könnte ?

Vielen Dank im Voraus

InformationsquelleAutor der Frage sub_o | 2012-07-24

  1. 48

    Können Sie hog-Klasse in opencv wie folgt

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

    Diese Funktion berechnet die hog-features für Sie

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

    Den HOG-features berechnet, für grayImg gespeichert sind, in ders Vektor in eine matrix, die verwendet werden können, später für die Ausbildung.

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

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

    Nun Ihre HOG-Merkmale gespeichert in Hogfeat matrix.

    Können Sie auch die Fenstergröße, die Größe der Zelle und der Blockgröße mit dem Objekt hog wie folgt:

    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;

    Hoffe es ist hilfreich 🙂

    InformationsquelleAutor der Antwort G453

  2. 3

    Schrieb ich auch das Programm des 2 hog-feature-Vergleich mit Hilfe des obigen Artikels.
    Und ich Wende diese Methode zu überprüfen, ROI-region zu verändern oder nicht.
    Finden Sie auf der Seite hier.
    source-code und einfache Einführung

    InformationsquelleAutor der Antwort Jeonghyun Kim

  3. 3

    Hier ist die GPU-version als auch. 

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

    InformationsquelleAutor der Antwort

  4. 1

    OpenCV 3 enthält einige änderungen an der GPU-algorithmen (z.B. CUDA) kann vom Benutzer verwendet werden, finden Sie in der Transition Guide - CUDA.

    Aktualisieren die Antwort von user3398689 zu OpenCV 3, hier ist ein code snipped: 

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

    Können Sie dann mit den Deskriptoren in der 'dst' - variable, wie Sie bevorzugen, wie, z.B., wie vorgeschlagen, durch G453.

    InformationsquelleAutor der Antwort Claudio

Schreibe einen Kommentar