Module haar

Find all Haar-like features, applied on a M-by-N image patch.

Input:

M, N: number of rows and columns of an image patch

Output:

haars: a list of tuples (A,ind,ind2) output from _features_from_shape()

Take a set of Haar features and subsample it.

Input:
    haars: a set of Haar features, output of generate_Haars()
    ratio: the ratio to subsample, if 'haars' has N features,
        the output 'haars' will have roughly ratio*N features
Output:
    ohaars: a smaller set of Haar features

Take a 2-class ClassificationDataset, obtain the global statistics,
then project using different Haar directions.

Input:
    cd: a 2-class ClassificationDataset
    haars: the generated Haar feature set of J features
Output: output of _project_Haar_stats() actually
    B: a list of J*2-class Stats2e, each for each type of Haar features.
    invert: a list of numpy.arrays, each array tells whether which feature
        needs negating its projection direction

Project the input data into a line using haar direction specified by coefficients 'A' and indices 'ind'

Input:

input_data: a vectorintegrated 2D numpy.array A,ind: coefficients and indices of a Haar feature

Output:

x: a 1D numpy.array of projected values

Parameters:

• stats2, Stats2 - a vectorintegrated 2D numpy.array
• ind, array(shape=(n, ), dtype='int') - indices of the SR feature
• A, array(shape=(n, ), dtype='double') - coefficients of the SR feature

Returns:

stats2e: a 1D Stats2e representing the projected result

Given local statistics, train a THaarClassifier.
Select the 'best' Haar feature in the set.
The features are trained using one of three criteria:
    crit = 0: param1 is 'thelambda', then call gaussian.find_classification_threshold()
    crit = 1: param1 is 'minDR', then call gaussian.find_filtering_threshold()
    crit = 2: param1 is 'maxFAR', then call gaussian.find_filtering_threshold2()

Input: 
    Binvert: (B,invert), is output of get_local_stats() actually
        B: a list of J*2-class Stats2e, each for each type of Haar features.
        invert: a list of numpy.arrays, each array tells whether which feature
            needs negating its projection direction
    haars: the generated Haar feature set of J features
    crit, param1: as mentioned above
Output:
    lc: a THaarClassifier, with lc.err as the estimated 'error'

Take a 2-class ClassificationDataset, then train a THaarClassifier. Select the 'best' Haar feature in the set. This function actually calls get_local_stats(), followed by train_Haar_with_local_stats()

Input:

cd: a 2-class ClassificationDataset haars: the generated Haar feature set crit, param1: as mentioned above

Output:

lc: a THaarClassifier, with lc.err as the estimated 'error'

Take a ScoringCDataset, then train a THaarClassifier 'filter' using UAC.
Select the 'best' Haar feature in the set.

Input:
    scd: a ScoringCDataset -- must be vectorintegrated
    haars: the generated Haar feature set
    rmaxFRR, rmaxFAR: train 'filter' to reject if there is a classifier
        that can do FRR <= rmaxFRR and FAR <= rmaxFAR
Output:
    lc: a THaarClassifier, with:
        lc.sol: training (FRR,FAR)
    c: voting coefficient
    both lc and c will be None if there's no filter satisfied

Take a CDataset, then train a GeneralizedCascade of THaarClassifiers.

Input:
    scd: a 2-class ScoringCDataset -- must be vectorintegrated
        scd *is modified* after the training process
    cdgenerator: a CDGenerator that can generate negative points for scd
    haars: the generated Haar feature set
    thelambda: the goal for 'improver' is to minimize thelambda*FRR+FAR
    rmaxFRR, rmaxFAR: train 'filter' to reject if there is a classifier
        that can do FRR <= rmaxFRR and FAR <= rmaxFAR
Output:
    gc: a GeneralizedCascade

Train Sparse Rectangular features and select the best feature classifier.

Suppose we have 2 classes c: positive and negative.
Suppose the vector-integrated version of an image of size 'len'-by-'len'
is a random vector y.
Let 'stats' be the Stats2 statistics of the two classes.
Consider 'criterion' and 'param1' described in sdGTSolve().

Now consider the following features called Sparse Rectangular features:
   H = \sum_{k=1}^{nrects} a_k \pi(x_k,y_k,w_k,h_k)
This function trains and selects the 'best' Sparse Rectangular feature
classifier based on sdGTSolve()'s criterion.
The classifier is as follows:
    return sign( (H \convolve I) - threshold )

The underlying algorithm is Differential Evolution.
It runs for 'nseconds' seconds.

:Parameters:
    stats : Stats2
        Statistics of the 2 classes
    criterion : int
        from 0 to 3, used in conjunction with param1, see sdGTSolve()
    param1 : double
        see 'criterion'
    nrects : int
        number of rectangles of the sparse feature
    nseconds : double
        this algorithm uses Differential Evolution, so this tells at
        most how many seconds to run

:Returns:
    fc: THaarClassifier
        the best feature classifier obtained
        fc.err is the estimated 'error' obtained

    ngen : int
        number of generations used in DE
    ngenome : int
        number of genomes generated in DE
    nvgenome : int
        number of *valid* genomes generated in DE

A training function that takes in a WeightedCDataset and produces a weak BinaryClassifier.

This training function uses train_SRClassifier() to train but with 6 rectangles and 2 seconds. Also, the threshold of the weak classifier is refined after training. The objective is to minimize classification error with lambda = 1.0

Parameters:

• wcd (WeightedCDataset) - a weighted dataset of vector-integrated patches

Returns:

fc: THaarClassifier

the best feature classifier obtained with

fc.b being the best threshold after refined fc.err is the estimated 'error' corresponding to fc.b fc.b2 is the best threshold estimated by train_SRClassifier() fc.err2 is its corresponding 'estimated error' fc.stats2e is its corresponding 1D statistics