webentwicklung-frage-antwort-db.com.de

Extrahieren von HoG-Features mit OpenCV

Ich versuche, Features mit der HoG-API von OpenCV zu extrahieren, finde jedoch anscheinend nicht die API, die mir dies ermöglicht.

Ich versuche, mithilfe von HoG Features aus meinem gesamten Datensatz (eine festgelegte Anzahl positiver und negativer Bilder) zu extrahieren und dann meine eigene SVM zu trainieren.

Ich habe unter OpenCV einen Blick in HoG.cpp geworfen, und es hat nicht geholfen. Alle Codes sind in Komplexität und die Notwendigkeit, für verschiedene Hardware (z. B. Intel IPP) gerecht zu werden, eingebettet.

Meine Frage ist:

  1. Gibt es eine API von OpenCV, mit der ich all diese Features/Deskriptoren extrahieren kann, die in eine SVM eingespeist werden sollen? Wenn ja, wie kann ich damit meine eigene SVM trainieren?
  2. Wenn nicht, gibt es da draußen Bibliotheken, die dasselbe leisten könnten?

Bisher portiere ich eine vorhandene Bibliothek (http://hogprocessing.altervista.org/) von Processing (Java) nach C++, aber es ist immer noch sehr langsam. Die Erkennung dauert mindestens 16 Sekunden

Hat noch jemand erfolgreich HoG-Funktionen extrahiert, wie sind Sie damit umgegangen? Und haben Sie Open-Source-Codes, die ich verwenden könnte?

Danke im Voraus

38
sub_o

Sie können die Klasse hog in opencv wie folgt verwenden

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

Diese Funktion berechnet die Schweinemerkmale für Sie

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

Die für grayImg berechneten HOG-Features werden in ders vector gespeichert, um daraus eine Matrix zu erstellen, die später für das Training verwendet werden kann.

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

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

Jetzt werden Ihre HOG-Features in der Hogfeat-Matrix gespeichert.

Sie können auch die Fenstergröße, die Zellengröße und die Blockgröße festlegen, indem Sie das Objekt hog wie folgt verwenden:

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 nützlich :)

50
G453

Hier ist auch die GPU-Version.

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

Ich habe auch das Programm von 2 hog feature geschrieben, das mit Hilfe des obigen Artikels verglichen wurde. Und ich wende diese Methode an, um zu überprüfen, ob sich der ROI-Bereich ändert oder nicht. Bitte beziehen Sie sich auf die Seite hier. Quellcode und einfache Einführung

3
Jeonghyun Kim

OpenCV 3 bietet einige Änderungen an der Art und Weise, wie GPU-Algorithmen (d. H. CUDA) vom Benutzer verwendet werden können, siehe Transition Guide - CUDA .

Um die Antwort von user3398689 auf OpenCV 3 zu aktualisieren, ist hier ein Code eingefügt:

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

Sie können dann die Deskriptoren in der Variablen 'dst' verwenden, wie Sie möchten, z. B. wie von G453 vorgeschlagen.

1
Claudio