Package cv

Convert a POINTER(CvMat) into numpy.array

Input:

mat: a POINTER(CvMat)

Output:

mat2: a numpy.array

Convert a POINTER(IplImage) into numpy.array

Input:

img: a POINTER(IplImage)

Output:

img2: a numpy.array

Convert an image of type uint8 into an image integral of type double.

Input:

img: a 2D numpy.array of type uint8 iimg: a 2D numpy.array of type double of the same size to hold the data

Output:

data filled into img2, where iimg[x,y] = int( img[x,y], i = 0..x, j = 0..y )

Convert an image of type uint8 into an image integral of type uint32.

Input:

img: a 2D numpy.array of type uint8 iimg: a 2D numpy.array of type uint32 of the same size to hold the data

Output:

data filled into img2, where iimg[x,y] = int( img[x,y], i = 0..x, j = 0..y )

Similar to stats.statslist(), but integrate each image of type uint8 first, then vectorize, then do the stats.

Input:

input_data: a array 2D images of type uint8 (numpy.array)

Output:

w, mean, cov: total weight, mean vector and covariance matrix

Convert an image of type uint8 into an image integral of type int32.

Input:

img: a 2D numpy.array of type uint8 iimg: a 2D numpy.array of type int32 of the same size to hold the data

Output:

data filled into img2, where iimg[x,y] = int( img[x,y], i = 0..x, j = 0..y )

Given a J-class ClassificationDataset of image patches. The patches are either in 'uint8' raw form (vi = False), or in 'double' vectorintegrated form (vi = True)

Input:

classification_dataset: a ClassificationDataset vi: input data are vectorintegrated?

Output:

stats2: a Stats2 holding the obtained statistics

Given a list of image patches, integrate then vectorize them all.

Input:

input_data: a numpy.array of shape (N,d,d) type uint8

Output:

output_data: the vectorized-integrated version, a numpy.array of shape (N,d*d) type float64

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'

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

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

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

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

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

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

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

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

datapath

Value:

'M:\\utils\\Python25\\lib\\site-packages\\pycv\\cs\\cv\\data'