Compute channel feature pyramid given an input image. While chnsCompute() computes channel features at a single scale, chnsPyramid() calls chnsCompute() multiple times on different scale images to create a scale-space pyramid of channel features. In its simplest form, chnsPyramid() first creates an image pyramid, then calls chnsCompute() with the specified "pChns" on each scale of the image pyramid. The parameter "nPerOct" determines the number of scales per octave in the image pyramid (an octave is the set of scales up to half of the initial scale), a typical value is nPerOct=8 in which case each scale in the pyramid is 2^(-1/8)~=.917 times the size of the previous. The smallest scale of the pyramid is determined by "minDs", once either image dimension in the resized image falls below minDs, pyramid creation stops. The largest scale in the pyramid is determined by "nOctUp" which determines the number of octaves to compute above the original scale. While calling chnsCompute() on each image scale works, it is unnecessary. For a broad family of features, including gradient histograms and all channel types tested, the feature responses computed at a single scale can be used to approximate feature responses at nearby scales. The approximation is accurate at least within an entire scale octave. For details and to understand why this unexpected result holds, please see: P. Dollár, R. Appel, S. Belongie and P. Perona "Fast Feature Pyramids for Object Detection", PAMI 2014. The parameter "nApprox" determines how many intermediate scales are approximated using the techniques described in the above paper. Roughly speaking, channels at approximated scales are computed by taking the corresponding channel at the nearest true scale (computed w chnsCompute) and resampling and re-normalizing it appropriately. For example, if nPerOct=8 and nApprox=7, then the 7 intermediate scales are approximated and only power of two scales are actually computed (using chnsCompute). The parameter "lambdas" determines how the channels are normalized (see the above paper). lambdas for a given set of channels can be computed using chnsScaling.m, alternatively, if no lambdas are specified, the lambdas are automatically approximated using two true image scales. Typically approximating all scales within an octave (by setting nApprox=nPerOct-1 or nApprox=-1) works well, and results in large speed gains (~4x). See example below for a visualization of the pyramid computed with and without the approximation. While there is a slight difference in the channels, during detection the approximated channels have been shown to be essentially as effective as the original channels. While every effort is made to space the image scales evenly, this is not always possible. For example, given a 101x100 image, it is impossible to downsample it by exactly 1/2 along the first dimension, moreover, the exact scaling along the two dimensions will differ. Instead, the scales are tweaked slightly (e.g. for a 101x101 image the scale would go from 1/2 to something like 50/101), and the output contains the exact scaling factors used for both the heights and the widths ("scaleshw") and also the approximate scale for both dimensions ("scales"). If "shrink">1 the scales are further tweaked so that the resized image has dimensions that are exactly divisible by shrink (for details please see the code). If chnsPyramid() is called with no inputs, the output is the complete default parameters (pPyramid). Finally, we describe the remaining parameters: "pad" controls the amount the channels are padded after being created (useful for detecting objects near boundaries); "smooth" controls the amount of smoothing after the channels are created (and controls the integration scale of the channels); finally "concat" determines whether all channels at a single scale are concatenated in the output. An emphasis has been placed on speed, with the code undergoing heavy optimization. Computing the full set of (approximated) *multi-scale* channels on a 480x640 image runs over *30 fps* on a single core of a machine from 2011 (although runtime depends on input parameters). USAGE pPyramid = chnsPyramid() pyramid = chnsPyramid( I, pPyramid ) INPUTS I - [hxwx3] input image (uint8 or single/double in [0,1]) pPyramid - parameters (struct or name/value pairs) .pChns - parameters for creating channels (see chnsCompute.m) .nPerOct - [8] number of scales per octave .nOctUp - [0] number of upsampled octaves to compute .nApprox - [-1] number of approx. scales (if -1 nApprox=nPerOct-1) .lambdas - [] coefficients for power law scaling (see BMVC10) .pad - [0 0] amount to pad channels (along T/B and L/R) .minDs - [16 16] minimum image size for channel computation .smooth - [1] radius for channel smoothing (using convTri) .concat - [1] if true concatenate channels .complete - [] if true does not check/set default vals in pPyramid OUTPUTS pyramid - output struct .pPyramid - exact input parameters used (may change from input) .nTypes - number of channel types .nScales - number of scales computed .data - [nScales x nTypes] cell array of computed channels .info - [nTypes x 1] struct array (mirrored from chnsCompute) .lambdas - [nTypes x 1] scaling coefficients actually used .scales - [nScales x 1] relative scales (approximate) .scaleshw - [nScales x 2] exact scales for resampling h and w EXAMPLE I=imResample(imread('peppers.png'),[480 640]); pPyramid=chnsPyramid(); pPyramid.minDs=[128 128]; pPyramid.nApprox=0; tic, P1=chnsPyramid(I,pPyramid); toc pPyramid.nApprox=7; tic, P2=chnsPyramid(I,pPyramid); toc figure(1); montage2(P1.data{2}); figure(2); montage2(P2.data{2}); figure(3); montage2(abs(P1.data{2}-P2.data{2})); colorbar; See also chnsCompute, chnsScaling, convTri, imPad Piotr's Computer Vision Matlab Toolbox Version 3.25 Copyright 2014 Piotr Dollar & Ron Appel. [pdollar-at-gmail.com] Licensed under the Simplified BSD License [see external/bsd.txt]

Generated by