aneksteind's profile - activity

I am using code inspired by https://github.com/opencv/opencv/blob.... My code is barely any different, and yet cannot detect ANYTHING. Any help would be appreciated. When running the program, it says (as I have instructed it to if this happens) that the list of detections is empty...

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include "opencv2/imgcodecs.hpp"
#include <opencv2/highgui.hpp>
#include <opencv2/ml.hpp>
#include <opencv2/objdetect.hpp>
#include <string>
#include <iostream>
#include <fstream>
#include <vector>

#include <time.h>

using namespace cv;
using namespace cv::ml;
using namespace std;

void getSvmDetector(Ptr<SVM> & svm, vector < float > & detector);
void draw_locations(Mat & img, const vector < Rect > & locations, const Scalar & color);
void load_images(string dir, vector< Mat > & images, int numFiles);
void compute_hog(vector < Mat > & mats, vector < Mat > & gradient, Size & s);
void train_svm(const vector < Mat > & gradient_list, const vector < int > & labels);
void convert_to_ml(const vector< Mat > & train_samples, Mat & trainData);

int main(int, char**)
{
    int numPos = 6;
    int numNeg = 20;

    vector< Mat > pos_lst;
    vector< Mat > neg_lst;
    vector< Mat > gradient_list;
    vector < int > labels;

    string posDir = "C:/Users/danekstein/Desktop/rectangle/";
    string negDir = "C:/Users/danekstein/Desktop/nr/";

    // load and label positive images
    cout << "positive images loading..." << endl;
    load_images(posDir, pos_lst, numPos);
    labels.assign(pos_lst.size(), +1);

    // size with only positives
    const unsigned int old = (unsigned)labels.size();

    // load and label positive images
    cout << "negative images loading..." << endl;
    load_images(negDir, neg_lst, numNeg);   
    labels.insert(labels.end(), neg_lst.size(), -1);

    // check the labels were successfully added
    CV_Assert(old < labels.size());

    cout << "computing hog for positives" << endl;
    compute_hog(pos_lst, gradient_list, Size(256, 128));

    cout << "computing hog for negatives" << endl;
    compute_hog(neg_lst, gradient_list, Size(256, 128));


    train_svm(gradient_list, labels);

    Scalar border_color(0, 255, 0);
    Mat img, draw;
    Ptr<SVM> svm;
    HOGDescriptor hog = HOGDescriptor::HOGDescriptor();
    hog.winSize = Size(256, 128);


    // locations where a plane is detected
    vector< Rect > locations;

    // loading the trained svm
    svm = StatModel::load<SVM>("C:/Users/danekstein/Desktop/r.yml");

    // set the trained svm to the hog 
    vector< float > hog_detector;

    getSvmDetector(svm, hog_detector);

    // set the detector
    hog.setSVMDetector(hog_detector);

    Mat image = imread("C:/Users/danekstein/Desktop/rectangle/1.jpg");

    locations.clear();

    cout << "detecting features from sample" << endl;

    hog.detectMultiScale(image,locations);

    draw = image.clone();
    draw_locations(draw, locations, border_color);

    imshow("Image", draw);
    waitKey(0);
    destroyAllWindows();

}

void load_images(string dir, vector< Mat > & images, int numImages) {
    for (int i = 0; i < numImages; i++) {

        Mat im = imread(dir + to_string(i) + ".jpg");
        if (im.empty()) cout << "not good";

#ifdef _DEBUG

#endif
        images.push_back(im.clone());
    }
}

void compute_hog(vector < Mat > & mats, vector < Mat > & gradients, Size & size) {
    HOGDescriptor hog;
    hog.winSize = size;
    Mat gray;
    vector< Point > location;
    vector< float > descriptors;

    vector< Mat >::const_iterator img = mats.begin();
    vector< Mat >::const_iterator end = mats.end();
    for (; img != end; ++img) {
        cvtColor(*img, gray, COLOR_BGR2GRAY);
        hog.compute(gray, descriptors, Size(1,1), Size(0, 0), location);
        gradients.push_back(Mat(descriptors).clone());
    }
}

void getSvmDetector(Ptr<SVM> & svm, vector< float>  & detector) {
    // grab the support vectors... yay!
    Mat sv = svm->getSupportVectors();
    const int sv_total = sv.rows;

    // get the decision function
    Mat alpha, svidx;
    double rho = svm->getDecisionFunction ...

I have an XML file with the contents of a trained SVM using HOG features from 14000 images in total, 9000 negative samples, and 5000 positive. I trained my SVM using OpenCV's Java extensions, but had to use C++ in order to extract the support vectors from my XML file because Java's bindings don't support that. When I load my XML file into my C++ program and try to detect an airplane, I am not getting any found locations of features. To make it ridiculously simple, I trained the SVM on about 15 negative images and 5 positive ones, then tried detecting features on one of the images I trained it with, and still am not getting any rectangles drawn on my screen because there are no features getting detected. If anyone can help with this, I'd appreciate it. The code below is the Java code I used to train the SVM, and the C++ code I am using to detect features for a given input image.

Training...

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfFloat;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.highgui.Highgui;
import org.opencv.objdetect.HOGDescriptor;
import org.opencv.ml.CvSVM;
import org.opencv.ml.CvSVMParams;

public class Detector {

    public static void main(String[] args) {
        System.loadLibrary( Core.NATIVE_LIBRARY_NAME );


        // the locations of the training data
        File[] trainingSetA = new File ("C:/Users/danekstein/Desktop/positiveSample/").listFiles();
        File[] negative = new File ("C:/Users/danekstein/Desktop/negativeSample/").listFiles();


        List<File[]> trainingSets = new ArrayList<File[]>();

        trainingSets.add(trainingSetA);
        trainingSets.add(negative);

        // the amount of examples in each set
        int posACount = trainingSetA.length;
        int negCount = negative.length;

        // our labels are all initialized to being -1, Negative
        Mat aLabels = new Mat(posACount + negCount, 1, 5, new Scalar(-1));

        // we overwrite the positive portion of the matrix with 1, Positive
        aLabels.rowRange(0,posACount).setTo(new Scalar(1));

        //creating arrays for our feature vectors
        Mat[] featuresA = new Mat[posACount];
        Mat[] featuresN = new Mat[negCount];

        for(File[] set : trainingSets){

            int count = 0;

            for(File image : set){

                // read in the image as a matrix
                Mat img = Highgui.imread(image.getAbsolutePath(), 0);

                // create a new descriptor
                HOGDescriptor descriptor = new HOGDescriptor(new Size(256,128),new Size(128,64), new Size(1,1), new Size(8,8), 9);

                // initialize a vector in which the features will be placed
                MatOfFloat descriptors = new MatOfFloat();

                // compute the feature vector and store it in 'descriptors'
                descriptor.compute(img, descriptors);

                if(set.equals(trainingSetA)) featuresA[count] = descriptors.t();
                if(set.equals(negative)) featuresN[count] = descriptors.t();

                count++;
                System.out.println(count);
            }
        }

        System.out.println("Adding features to training matrix...");


        Mat trainingMatA = new Mat(posACount + negCount, featuresA[0].cols(), featuresA[0].type());

        for(int i=0;i<posACount;i++){
            featuresA[i].copyTo(trainingMatA.rowRange(i,i+1));
        }
        for(int i=0;i<negCount;i++){
            featuresN[i].copyTo(trainingMatA.rowRange(i+posACount,i+posACount+1 ...