HistogramsOfOrientedGradients Class

public class HistogramsOfOrientedGradients : BaseFeatureExtractor<FeatureDescriptor>

Public Class HistogramsOfOrientedGradients
	Inherits BaseFeatureExtractor(Of FeatureDescriptor)

// Let's load an example image, such as Lena,
// from a standard dataset of example images:
var images = new TestImages(path: localPath);
Bitmap lena = images["lena.bmp"];

// Create a new Histogram of Oriented Gradients with the default parameter values:
var hog = new HistogramsOfOrientedGradients(numberOfBins: 9, blockSize: 3, cellSize: 6);

// Use it to extract descriptors from the Lena image:
List<double[]> descriptors = hog.ProcessImage(lena);

// Now those descriptors can be used to represent the image itself, such
// as for example, in the Bag-of-Visual-Words approach for classification.

// Ensure results are reproducible
Accord.Math.Random.Generator.Seed = 0;

// The Bag-of-Visual-Words model converts images of arbitrary 
// size into fixed-length feature vectors. In this example, we
// will be setting the codebook size to 3. This means all feature
// vectors that will be generated will have the same length of 3.

// By default, the BoW object will use the sparse SURF as the 
// feature extractor and K-means as the clustering algorithm.
// In this example, we will use the Local Binary Pattern (LBP) 
// feature extractor and the Binary-Split clustering algorithm.
// However, this is just an example: the best features and the
// best clustering algorithm might need to be found through 
// experimentation. Please also try with KMeans first to obtain
// a baseline value.

// Create a new Bag-of-Visual-Words (BoW) model using LBP features
var bow = BagOfVisualWords.Create(new LocalBinaryPattern(), new BinarySplit(3));

// Since we are using generics, we can setup properties 
// of the binary split clustering algorithm directly:
bow.Clustering.ComputeCovariances = false;
bow.Clustering.ComputeProportions = false;
bow.Clustering.ComputeError = false;

// Get some training images
Bitmap[] images = GetImages();

// Compute the model
bow.Learn(images);

// After this point, we will be able to translate
// images into double[] feature vectors using
double[][] features = bow.Transform(images);

// Now, the features can be used to train any classification
// algorithm as if they were the images themselves. For example,
// let's assume the first three images belong to a class and
// the second three to another class. We can train an SVM using

int[] labels = { -1, -1, +1, +1, +1, +1 };

// Create the SMO algorithm to learn a Linear kernel SVM
var teacher = new SequentialMinimalOptimization<Gaussian>()
{
    Complexity = 100 // make a hard margin SVM
};

// Obtain a learned machine
var svm = teacher.Learn(features, labels);

// Use the machine to classify the features
bool[] output = svm.Decide(features);

// Compute the error between the expected and predicted labels
double error = new ZeroOneLoss(labels).Loss(output); // should be 0