Public Member Functions | Static Public Member Functions | Private Member Functions | Static Private Member Functions
brip_vil_float_ops Class Reference

#include <brip_vil_float_ops.h>

List of all members.

Public Member Functions

 ~brip_vil_float_ops ()

Static Public Member Functions

static vil_image_view< float > convolve (vil_image_view< float > const &input, vbl_array_2d< float > const &kernel)
 convolves with the specified kernel.
static unsigned gaussian_radius (const double sigma, const double fuzz=0.02)
 helper to determine processing border required by Gaussian smoothing.
static vil_image_view< float > gaussian (vil_image_view< float > const &input, float sigma, float fill=0.0f)
 convolves with a Gaussian kernel.
static void non_maximum_suppression (vil_image_view< float > const &input, int n, float thresh, vcl_vector< float > &x_pos, vcl_vector< float > &y_pos, vcl_vector< float > &value)
 non-maximum suppression on a NxN neighborhood, with sub-pixel location.
static vil_image_view< float > half_resolution (vil_image_view< float > const &input, float filter_coef=0.359375f)
 downsamples the input using the Bert-Adelson algorithm.
static vil_image_view< float > double_resolution (vil_image_view< float > const &input, float filter_coef=0.6f)
 interpolates the input using the Bert-Adelson algorithm.
static vil_image_view< float > difference (vil_image_view< float > const &image_1, vil_image_view< float > const &image_2)
 subtracts image_1 from image_2.
static vil_image_view< float > threshold (vil_image_view< float > const &image, const float thresh, const float level=255.0)
 sets values greater than thresh to specified level and the rest to zero.
static vil_image_view< float > abs_clip_to_level (vil_image_view< float > const &image, const float thresh, const float level=0.0)
 sets absolute values greater than thresh to specified level.
static vil_image_view< float > average_NxN (vil_image_view< float > const &img, int N)
static void gradient_3x3 (vil_image_view< float > const &input, vil_image_view< float > &grad_x, vil_image_view< float > &grad_y)
 The gradient using a 3x3 kernel.
static void gradient_mag_3x3 (vil_image_view< float > const &input, vil_image_view< float > &mag)
static void hessian_3x3 (vil_image_view< float > const &input, vil_image_view< float > &Ixx, vil_image_view< float > &Ixy, vil_image_view< float > &Iyy)
 Compute the Hessian of the input, use a 3x3 mask.
static vil_image_view< float > beaudet (vil_image_view< float > const &Ixx, vil_image_view< float > const &Ixy, vil_image_view< float > const &Iyy, bool determinant=true)
static void extrema_kernel_mask (float lambda0, float lambda1, float theta, vbl_array_2d< float > &kernel, vbl_array_2d< bool > &mask, float cutoff_percentage=0.01f)
static vil_image_view< float > std_dev_operator (vil_image_view< float > const &sd_image, vbl_array_2d< float > const &kernel)
 Compute the standard deviation of an operator response, given the image intensity standard deviation at each pixel.
static vil_image_view< float > std_dev_operator_method2 (vil_image_view< float > const &sd_image, vbl_array_2d< float > const &kernel)
 Compute the standard deviation of an operator response, given the image intensity standard deviation at each pixel.
static float extrema_revert_angle (float angle)
 a helper function for the extrema method, revert angle to the range [-90, 90].
static vil_image_view< float > extrema (vil_image_view< float > const &input, float lambda0, float lambda1, float theta, bool bright=true, bool output_response_mask=true, bool unclipped_response=false)
 Find ansiotropic intensity extrema. Theta is in degrees.
static vil_image_view< float > extrema_rotational (vil_image_view< float > const &input, float lambda0, float lambda1, float theta_interval, bool bright=true)
 Find ansiotropic intensity extrema at a range of orientations and return the maximal response at the best orientation.
static void max_inscribed_rect (float lambda0, float lambda1, float theta, float &u_rect, float &v_rect)
 compute the inscribed rectangle in an ellipse with largest (1+h)(1+w). Needed for fast non-maximal suppression. Theta is in degrees.
static vil_image_view< float > fast_extrema (vil_image_view< float > const &input, float lambda0, float lambda1, float theta, bool bright=true, bool output_response_mask=true, bool unclipped_response=false, float cutoff_percentage=0.01f)
 Find intensity extrema using kernel decomposition.
static void grad_matrix_NxN (vil_image_view< float > const &input, unsigned n, vil_image_view< float > &IxIx, vil_image_view< float > &IxIy, vil_image_view< float > &IyIy)
 IxIx.transpose gradient matrix elements for a NxN region(N = 2n+1).
static vil_image_view< float > trace_grad_matrix_NxN (vil_image_view< float > const &input, unsigned n)
 Tr(IxIx.transpose) for a NxN region, N = 2n+1).
static vil_image_view< float > harris (vil_image_view< float > const &IxIx, vil_image_view< float > const &IxIy, vil_image_view< float > const &IyIy, double scale=0.04)
 Computes the Harris corner measure.
static vil_image_view< float > sqrt_grad_singular_values (vil_image_view< float > &input, int n)
 computes the conditioning of the 2n+1 x 2n+1 gradient neigborhood.
static vil_image_view< float > max_scale_trace (vil_image_view< float > input, float min_scale, float max_scale, float scale_inc)
static vil_image_view< float > max_scale_trace_value (vil_image_view< float > input, float min_scale, float max_scale, float scale_inc)
 exactly same as max_scale_trace, only return the image with actual trace values at max scales instead of the image with max scale values.
static void Lucas_KanadeMotion (vil_image_view< float > &current_frame, vil_image_view< float > &previous_frame, int n, double thresh, vil_image_view< float > &vx, vil_image_view< float > &vy)
 computes Lucas-Kanade optical flow on a 2n+1 neighborhood.
static void lucas_kanade_motion_on_view (vil_image_view< float > const &curr_frame, vil_image_view< float > const &prev_frame, const double thresh, float &vx, float &vy)
 computes velocity of a region(view) using Lucas Kanade.
static void velocity_by_correlation (vil_image_view< float > const &curr_image, vil_image_view< float > const &prev_region, const unsigned start_i, const unsigned end_i, const unsigned start_j, const unsigned end_j, const unsigned zero_i, const unsigned zero_j, float &vx, float &vy)
 computes velocity of a region(view) using correlation.
static int Horn_SchunckMotion (vil_image_view< float > const &current_frame, vil_image_view< float > const &previous_frame, vil_image_view< float > &vx, vil_image_view< float > &vy, const float alpha_coef=10000.0f, const int no_of_iterations=5)
 computes optical flow using Horn & Schunck's method.
static void fill_x_border (vil_image_view< float > &image, unsigned w, float value)
 fills a border of width w on left and right of image with value.
static void fill_y_border (vil_image_view< float > &image, unsigned h, float value)
 fills a border of width h on top and bottom of image with value.
static vil_image_view
< unsigned char > 		convert_to_byte (vil_image_view< float > const &image)
 converts a float image to a byte value range.
static vil_image_view
< unsigned char > 		convert_to_byte (vil_image_view< float > const &image, float min_val, float max_val)
 converts a float image to a byte value range within a specified range.
static vil_image_view
< unsigned char > 		convert_to_byte (vil_image_view< unsigned short > const &image, unsigned short min_val, unsigned short max_val)
 converts an unsigned short image to a byte value range within a specified range.
static vil_image_view
< unsigned char > 		convert_to_byte (vil_image_resource_sptr const &image)
 converts a generic image to a byte image. Use this instead of convert_to_grey.
static vil_image_view
< unsigned short > 		convert_to_short (vil_image_view< float > const &image, float min_val, float max_val)
 converts a float image to an unsigned short image within a range.
static vil_image_view
< unsigned short > 		convert_to_short (vil_image_view< float > const &image)
 converts a float image to an unsigned short image.
static vil_image_view
< unsigned short > 		convert_to_short (vil_image_resource_sptr const &image)
 converts a generic image to an unsigned short image.
static vil_image_view< float > convert_to_float (vil_image_resource const &image)
 converts a vil_image_resource to a float image.
static vil_image_view< float > convert_to_float (vil_image_resource_sptr const &image)
 converts a vil_image_resource to a float image (preferred interface).
static vil_image_view< float > convert_to_float (vil_image_view< unsigned char > const &image)
static vil_image_view< float > convert_to_float (vil_image_view< unsigned short > const &image)
static vil_image_view< bool > convert_to_bool (vil_image_view< unsigned char > const &image)
 converts a byte image to a bool image.
static vil_image_view< float > convert_to_float (vil_image_view< vil_rgb< vxl_byte > > const &image)
 converts an RGB image to a float image.
static void convert_to_IHS (vil_image_view< vil_rgb< vxl_byte > > const &image, vil_image_view< float > &I, vil_image_view< float > &H, vil_image_view< float > &S)
 convert a color image to float IHS images.
static void convert_to_IHS (vil_image_view< unsigned char > const &image, vil_image_view< float > &I, vil_image_view< float > &H, vil_image_view< float > &S)
static void display_IHS_as_RGB (vil_image_view< float > const &I, vil_image_view< float > const &H, vil_image_view< float > const &S, vil_image_view< vil_rgb< vxl_byte > > &image)
 display IHS images as RGB (not conversion from IHS to RGB).
static vil_image_view< vil_rgb
< vxl_byte > > 		combine_color_planes (vil_image_view< unsigned char > const &R, vil_image_view< unsigned char > const &G, vil_image_view< unsigned char > const &B)
 Create a color image from multiple view channels.
static vil_image_view< vil_rgb
< vxl_byte > > 		combine_color_planes (vil_image_resource_sptr const &R, vil_image_resource_sptr const &G, vil_image_resource_sptr const &B)
 Create a unsigned char color image from multiple resource channels.
static vil_image_view
< unsigned char > 		convert_to_grey (vil_image_resource const &img)
 converts a generic image to greyscale (RGB<unsigned char>).
static vbl_array_2d< float > load_kernel (vcl_string const &file)
 loads a 2n+1 x 2n+1 convolution kernel (see .cxx for file format).
static void basis_images (vcl_vector< vil_image_view< float > > const &input_images, vcl_vector< vil_image_view< float > > &basis)
 compute basis images for a set of input images.
static bool fourier_transform (vil_image_view< float > const &input, vil_image_view< float > &mag, vil_image_view< float > &phase)
 compute the Fourier transform using the vnl FFT algorithm.
static bool inverse_fourier_transform (vil_image_view< float > const &mag, vil_image_view< float > const &phase, vil_image_view< float > &output)
 compute the inverse Fourier transform using the vnl FFT algorithm.
static void resize (vil_image_view< float > const &input, unsigned width, unsigned height, vil_image_view< float > &output)
 resize to specified dimensions, fill with zeros if output is larger.
static bool resize_to_power_of_two (vil_image_view< float > const &input, vil_image_view< float > &output)
 resize to closest power of two larger dimensions than the input.
static bool spatial_frequency_filter (vil_image_view< float > const &input, float dir_fx, float dir_fy, float f0, float radius, bool output_fourier_mag, vil_image_view< float > &output)
 filter the input image with a Gaussian blocking filter.
static double bilinear_interpolation (vil_image_view< float > const &input, double x, double y)
 2x2 bilinear interpolation of image at specified location.
static bool homography (vil_image_view< float > const &input, vgl_h_matrix_2d< double >const &H, vil_image_view< float > &output, bool output_size_fixed=false, float output_fill_value=0.0f)
 map the input to the output by a homography.
static vil_image_view< float > rotate (vil_image_view< float > const &input, double theta_deg)
 rotate the input image counter-clockwise about the image origin.
static bool chip (vil_image_view< float > const &input, vsol_box_2d_sptr const &roi, vil_image_view< float > &chip)
 extract a region of interest. If roi does not overlap input, return false.
static bool chip (vil_image_resource_sptr const &image, brip_roi_sptr const &roi, vil_image_resource_sptr &chip)
 convert image resource to a chip of equivalent pixel type.
static float average_in_box (vil_image_view< float > const &v, vgl_box_2d< double > const &box)
 compute the average of the image intensity within the specified region.
static vcl_vector< float > scan_region (vil_image_resource_sptr img, vgl_polygon< double > poly, float &min, float &max)
 scan a polygon and return the pixel values as well as max min.
static float cross_correlate (vil_image_view< float > const &image1, vil_image_view< float > const &image2, float x, float y, int radius=5, float intensity_thresh=25.0f)
 cross-correlate two images at a given sub-pixel location.
static bool cross_correlate (vil_image_view< float > const &image1, vil_image_view< float > const &image2, vil_image_view< float > &out, int radius=5, float intensity_thresh=25.0f)
 cross_correlate two images using running sums.
static void ihs_to_rgb (vil_rgb< vxl_byte > &rgb, const float i, const float h, const float s)
 convert a single i,h,s pixel to rgb.
static void rgb_to_ihs (vil_rgb< vxl_byte > const &rgb, float &i, float &h, float &s)
 convert a single rgb pixel to ihs.
static float entropy_i (const unsigned i, const unsigned j, const unsigned i_radius, const unsigned j_radius, vil_image_view< float > const &intensity, const float range=255.0, const unsigned bins=16)
 Compute the intensity entropy of a region about the specified pixel.
static float entropy_g (const unsigned i, const unsigned j, const unsigned i_radius, const unsigned j_radius, vil_image_view< float > const &gradx, vil_image_view< float > const &grady, const float range=360.0, const unsigned bins=8)
 Compute the gradient entropy of a region about the specified pixel.
static float entropy_hs (const unsigned i, const unsigned j, const unsigned i_radius, const unsigned j_radius, vil_image_view< float > const &hue, vil_image_view< float > const &sat, const float range=360.0, const unsigned bins=8)
 Compute the hue and saturation entropy of a region about the specified pixel.
static vil_image_view< float > entropy (const unsigned i_radius, const unsigned j_radius, const unsigned step, vil_image_resource_sptr const &img, const float sigma=1.0f, const bool intensity=true, const bool gradient=true, const bool ihs=false)
 Compute the entropy of the specified region about each pixel.
static float minfo_i (const unsigned i0, const unsigned j0, const unsigned i1, const unsigned j1, const unsigned i_radius, const unsigned j_radius, vil_image_view< float > const &intensity0, vil_image_view< float > const &intensity1, const float range=255.0, const unsigned bins=16)
static float minfo_g (const unsigned i0, const unsigned j0, const unsigned i1, const unsigned j1, const unsigned i_radius, const unsigned j_radius, vil_image_view< float > const &gradx0, vil_image_view< float > const &grady0, vil_image_view< float > const &gradx1, vil_image_view< float > const &grady1, const float range=360.0, const unsigned bins=8)
 Compute the gradient minfo of a region about the specified pixel.
static float minfo_hs (const unsigned i0, const unsigned j0, const unsigned i1, const unsigned j1, const unsigned i_radius, const unsigned j_radius, vil_image_view< float > const &hue0, vil_image_view< float > const &sat0, vil_image_view< float > const &hue1, vil_image_view< float > const &sat1, const float range=360.0, const unsigned bins=8)
 Compute the hue and saturation minfo of a region about the specified pixel.
static bool minfo (const unsigned i_radius, const unsigned j_radius, const unsigned step, vil_image_resource_sptr const &img0, vil_image_resource_sptr const &img1, vil_image_view< float > &MI0, vil_image_view< float > &MI1, const float sigma=1.0f, const bool intensity=true, const bool gradient=true, const bool ihs=false)
 compute the minfo of the specified region about each pixel.
static vil_image_resource_sptr sum (vil_image_resource_sptr const &img0, vil_image_resource_sptr const &img1)
 Add two images from a general resource (forces types to be the same).
static vil_image_resource_sptr difference (vil_image_resource_sptr const &img0, vil_image_resource_sptr const &img1)
 subtract two generic images, return img0-img1 (forces types to the same).
static vil_image_resource_sptr negate (vil_image_resource_sptr const &imgr)
 negate an image returning the same pixel type (only greyscale).
static vil_image_view
< unsigned char > 		color_order (vil_image_view< float > const &color_image, float eq_tol)
 Color order operator, output an index based on RGB intensity order.

Private Member Functions

 brip_vil_float_ops ()
 Default constructor is private.

Static Private Member Functions

static bool local_maximum (vbl_array_2d< float > const &nighborhood, int n, float &value)
 find if the center pixel of a neighborhood is the maximum value.
static void interpolate_center (vbl_array_2d< float > const &neighborhood, float &dx, float &dy)
 find the sub-pixel offset to the maximum using a 3x3 quad interpolation.
static void half_resolution_1d (const float *input, unsigned n, float k0, float k1, float k2, float *output)
 sub-sample a 1-d array using the Bert-Adelson algorithm.
static void double_resolution_1d (const float *input, const unsigned n_input, const float k0, const float k1, const float k2, float *output)
 interpolate a 1-d array using the Bert-Adelson algorithm.
static bool fft_1d (int dir, int m, double *x, double *y)
 One dimensional fft.
static bool fft_2d (vnl_matrix< vcl_complex< double > > &c, int nx, int ny, int dir)
 Two dimensonal fft.
static void ftt_fourier_2d_reorder (vnl_matrix< vcl_complex< double > > const &F1, vnl_matrix< vcl_complex< double > > &F2)
 Transform the fft coefficients from/to fft/frequency order(self inverse).
static float gaussian_blocking_filter (float dir_fx, float dir_fy, float f0, float radius, float fx, float fy)
 Blocking filter function.
static float elu (float phi, float lamda0, float lambda1, float theta)
 u-coordinate of an ellipse defined by lambda0, lambda1 and theta, vs. phi.
static float elv (float phi, float lamda0, float lambda1, float theta)
 v-coordinate of an ellipse defined by lambda0, lambda1 and theta, vs. phi.

Detailed Description

Definition at line 34 of file brip_vil_float_ops.h.

Constructor & Destructor Documentation

brip_vil_float_ops::~brip_vil_float_ops ( ) [inline]

Definition at line 37 of file brip_vil_float_ops.h.

brip_vil_float_ops::brip_vil_float_ops ( ) [inline, private]

Default constructor is private.

Definition at line 559 of file brip_vil_float_ops.h.

Member Function Documentation

vil_image_view< float > brip_vil_float_ops::abs_clip_to_level ( vil_image_view< float > const &  image,
const float  thresh,
const float  level = 0.0 
) [static]

sets absolute values greater than thresh to specified level.

Definition at line 582 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::average_in_box ( vil_image_view< float > const &  v,
vgl_box_2d< double > const &  box 
) [static]

compute the average of the image intensity within the specified region.

Definition at line 3428 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::average_NxN ( vil_image_view< float > const &  img,
int  N 
) [static]

Definition at line 599 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::basis_images ( vcl_vector< vil_image_view< float > > const &  input_images,
vcl_vector< vil_image_view< float > > &  basis 
) [static]

compute basis images for a set of input images.

Definition at line 2062 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::beaudet ( vil_image_view< float > const &  Ixx,
vil_image_view< float > const &  Ixy,
vil_image_view< float > const &  Iyy,
bool  determinant = true 
) [static]

Definition at line 710 of file brip_vil_float_ops.cxx.

double brip_vil_float_ops::bilinear_interpolation ( vil_image_view< float > const &  input,
double  x,
double  y 
) [static]

2x2 bilinear interpolation of image at specified location.

Bi-linear interpolation on the neigborhood below.

        xr
     yr 0  x
        x  x

Definition at line 2507 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::chip ( vil_image_view< float > const &  input,
vsol_box_2d_sptr const &  roi,
vil_image_view< float > &  chip 
) [static]

extract a region of interest. If roi does not overlap input, return false.

< changed < to <= to include the boundary points too

Definition at line 2703 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::chip ( vil_image_resource_sptr const &  image,
brip_roi_sptr const &  roi,
vil_image_resource_sptr &  chip 
) [static]

convert image resource to a chip of equivalent pixel type.

convert image resource to cropped view according to a roi.

Definition at line 2732 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned char > brip_vil_float_ops::color_order ( vil_image_view< float > const &  color_image,
float  eq_tol 
) [static]

Color order operator, output an index based on RGB intensity order.

Definition at line 3603 of file brip_vil_float_ops.cxx.

vil_image_view< vil_rgb< vxl_byte > > brip_vil_float_ops::combine_color_planes ( vil_image_view< unsigned char > const &  R,
vil_image_view< unsigned char > const &  G,
vil_image_view< unsigned char > const &  B 
) [static]

Create a color image from multiple view channels.

All views have to have the same array dimensions

Definition at line 1843 of file brip_vil_float_ops.cxx.

vil_image_view< vil_rgb< vxl_byte > > brip_vil_float_ops::combine_color_planes ( vil_image_resource_sptr const &  R,
vil_image_resource_sptr const &  G,
vil_image_resource_sptr const &  B 
) [static]

Create a unsigned char color image from multiple resource channels.

Images do not have to be the same size arraysp

Definition at line 1860 of file brip_vil_float_ops.cxx.

vil_image_view< bool > brip_vil_float_ops::convert_to_bool ( vil_image_view< unsigned char > const &  image) [static]

converts a byte image to a bool image.

Definition at line 1633 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned char > brip_vil_float_ops::convert_to_byte ( vil_image_view< float > const &  image) [static]

converts a float image to a byte value range.

Definition at line 1402 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned char > brip_vil_float_ops::convert_to_byte ( vil_image_view< float > const &  image,
float  min_val,
float  max_val 
) [static]

converts a float image to a byte value range within a specified range.

Convert the range between min_val and max_val to 255.

Definition at line 1433 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned char > brip_vil_float_ops::convert_to_byte ( vil_image_view< unsigned short > const &  image,
unsigned short  min_val,
unsigned short  max_val 
) [static]

converts an unsigned short image to a byte value range within a specified range.

Definition at line 1458 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned char > brip_vil_float_ops::convert_to_byte ( vil_image_resource_sptr const &  image) [static]

converts a generic image to a byte image. Use this instead of convert_to_grey.

Definition at line 1484 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::convert_to_float ( vil_image_resource const &  image) [static]

converts a vil_image_resource to a float image.

Definition at line 1900 of file brip_vil_float_ops.cxx.

static vil_image_view<float> brip_vil_float_ops::convert_to_float ( vil_image_resource_sptr const &  image) [inline, static]

converts a vil_image_resource to a float image (preferred interface).

Definition at line 266 of file brip_vil_float_ops.h.

vil_image_view< float > brip_vil_float_ops::convert_to_float ( vil_image_view< unsigned char > const &  image) [static]

Definition at line 1609 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::convert_to_float ( vil_image_view< unsigned short > const &  image) [static]

Definition at line 1621 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::convert_to_float ( vil_image_view< vil_rgb< vxl_byte > > const &  image) [static]

converts an RGB image to a float image.

Definition at line 1648 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned char > brip_vil_float_ops::convert_to_grey ( vil_image_resource const &  img) [static]

converts a generic image to greyscale (RGB<unsigned char>).

Convert any image to an unsigned_char image.

Definition at line 1934 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::convert_to_IHS ( vil_image_view< vil_rgb< vxl_byte > > const &  image,
vil_image_view< float > &  I,
vil_image_view< float > &  H,
vil_image_view< float > &  S 
) [static]

convert a color image to float IHS images.

Definition at line 1737 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::convert_to_IHS ( vil_image_view< unsigned char > const &  image,
vil_image_view< float > &  I,
vil_image_view< float > &  H,
vil_image_view< float > &  S 
) [static]

Definition at line 1758 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned short > brip_vil_float_ops::convert_to_short ( vil_image_view< float > const &  image,
float  min_val,
float  max_val 
) [static]

converts a float image to an unsigned short image within a range.

Definition at line 1490 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned short > brip_vil_float_ops::convert_to_short ( vil_image_view< float > const &  image) [static]

converts a float image to an unsigned short image.

range determined automatically

Definition at line 1518 of file brip_vil_float_ops.cxx.

vil_image_view< unsigned short > brip_vil_float_ops::convert_to_short ( vil_image_resource_sptr const &  image) [static]

converts a generic image to an unsigned short image.

Definition at line 1536 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::convolve ( vil_image_view< float > const &  input,
vbl_array_2d< float > const &  kernel 
) [static]

convolves with the specified kernel.

Convolve with a kernel.

It's assumed that the kernel is square with odd dimensions

Definition at line 70 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::cross_correlate ( vil_image_view< float > const &  image1,
vil_image_view< float > const &  image2,
float  x,
float  y,
int  radius = 5,
float  intensity_thresh = 25.0f 
) [static]

cross-correlate two images at a given sub-pixel location.

perform normalized cross-correlation at a sub-pixel location.

Thus all the pixel values are interpolated.

Definition at line 2792 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::cross_correlate ( vil_image_view< float > const &  image1,
vil_image_view< float > const &  image2,
vil_image_view< float > &  out,
int  radius = 5,
float  intensity_thresh = 25.0f 
) [static]

cross_correlate two images using running sums.

Definition at line 2961 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::difference ( vil_image_view< float > const &  image_1,
vil_image_view< float > const &  image_2 
) [static]

subtracts image_1 from image_2.

Subtract image_1 from image_2.

Will not operate unless the two input images are the same dimensions

Definition at line 513 of file brip_vil_float_ops.cxx.

vil_image_resource_sptr brip_vil_float_ops::difference ( vil_image_resource_sptr const &  img0,
vil_image_resource_sptr const &  img1 
) [static]

subtract two generic images, return img0-img1 (forces types to the same).

Definition at line 3072 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::display_IHS_as_RGB ( vil_image_view< float > const &  I,
vil_image_view< float > const &  H,
vil_image_view< float > const &  S,
vil_image_view< vil_rgb< vxl_byte > > &  image 
) [static]

display IHS images as RGB (not conversion from IHS to RGB).

map so that intensity is proportional to saturation and hue is color.

Definition at line 1810 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::double_resolution ( vil_image_view< float > const &  input,
float  filter_coef = 0.6f 
) [static]

interpolates the input using the Bert-Adelson algorithm.

Definition at line 222 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::double_resolution_1d ( const float *  input,
const unsigned  n_input,
const float  k0,
const float  k1,
const float  k2,
float *  output 
) [static, private]

interpolate a 1-d array using the Bert-Adelson algorithm.

Definition at line 199 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::elu ( float  phi,
float  lamda0,
float  lambda1,
float  theta 
) [static, private]

u-coordinate of an ellipse defined by lambda0, lambda1 and theta, vs. phi.

theta and phi are in radians.

Definition at line 4068 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::elv ( float  phi,
float  lamda0,
float  lambda1,
float  theta 
) [static, private]

v-coordinate of an ellipse defined by lambda0, lambda1 and theta, vs. phi.

theta and phi are in radians.

Definition at line 4078 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::entropy ( const unsigned  i_radius,
const unsigned  j_radius,
const unsigned  step,
vil_image_resource_sptr const &  img,
const float  sigma = 1.0f,
const bool  intensity = true,
const bool  gradient = true,
const bool  ihs = false 
) [static]

Compute the entropy of the specified region about each pixel.

Definition at line 3171 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::entropy_g ( const unsigned  i,
const unsigned  j,
const unsigned  i_radius,
const unsigned  j_radius,
vil_image_view< float > const &  gradx,
vil_image_view< float > const &  grady,
const float  range = 360.0,
const unsigned  bins = 8 
) [static]

Compute the gradient entropy of a region about the specified pixel.

Compute the entropy of the gradient direction of a region.

No bounds check

Note no bounds checking!

Definition at line 3129 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::entropy_hs ( const unsigned  i,
const unsigned  j,
const unsigned  i_radius,
const unsigned  j_radius,
vil_image_view< float > const &  hue,
vil_image_view< float > const &  sat,
const float  range = 360.0,
const unsigned  bins = 8 
) [static]

Compute the hue and saturation entropy of a region about the specified pixel.

No bounds check

Note no bounds checking!

Definition at line 3152 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::entropy_i ( const unsigned  i,
const unsigned  j,
const unsigned  i_radius,
const unsigned  j_radius,
vil_image_view< float > const &  intensity,
const float  range = 255.0,
const unsigned  bins = 16 
) [static]

Compute the intensity entropy of a region about the specified pixel.

Compute the entropy of the intensity of a region.

No bounds check

Note no bounds checking!

Definition at line 3110 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::extrema ( vil_image_view< float > const &  input,
float  lambda0,
float  lambda1,
float  theta,
bool  bright = true,
bool  output_response_mask = true,
bool  unclipped_response = false 
) [static]

Find ansiotropic intensity extrema. Theta is in degrees.

Definition at line 3802 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::extrema_kernel_mask ( float  lambda0,
float  lambda1,
float  theta,
vbl_array_2d< float > &  kernel,
vbl_array_2d< bool > &  mask,
float  cutoff_percentage = 0.01f 
) [static]

Definition at line 3676 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::extrema_revert_angle ( float  angle) [static]

a helper function for the extrema method, revert angle to the range [-90, 90].

Definition at line 3659 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::extrema_rotational ( vil_image_view< float > const &  input,
float  lambda0,
float  lambda1,
float  theta_interval,
bool  bright = true 
) [static]

Find ansiotropic intensity extrema at a range of orientations and return the maximal response at the best orientation.

Find anisotropic intensity extrema at a range of orientations and return the maximal response at the best orientation. Theta interval is in degrees.

Theta interval is in degrees If lambda0 == lambda1 then reduces to the normal extrema operator

if lambda0 == lambda1 then reduces to the normal extrema operator

the kernel generator does not treat the x and y axis symmetrically, the method works correctly only when lambda0 > lambda1. theoretically one can always call this method by switching the lambdas but the caller of the method should make this switch if needed hence the assertion

elliptical operator has 180 degree rotational symmetry, so only the angles in the range [0,180] matter.

compute the response.

now we have pixel-wise best angle, run the non-max suppression around each non-zero pixel using the angles mask.

get the mask for this angle.

now prepare the output accordingly.

Definition at line 3922 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::fast_extrema ( vil_image_view< float > const &  input,
float  lambda0,
float  lambda1,
float  theta,
bool  bright = true,
bool  output_response_mask = true,
bool  unclipped_response = false,
float  cutoff_percentage = 0.01f 
) [static]

Find intensity extrema using kernel decomposition.

Theta is in degrees. Image rotation is applied then separated u, v kernels produce the response.

Definition at line 4224 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::fft_1d ( int  dir,
int  m,
double *  x,
double *  y 
) [static, private]

One dimensional fft.

1d fourier transform.

This computes an in-place complex-to-complex FFT x and y are the real and imaginary arrays of 2^m points. dir = 1 gives forward transform dir = -1 gives reverse transform

Formula: forward 

                  N-1
                  ---
              1   \          - j k 2 pi n / N
      X(n) = ---   >   x(k) e                    = forward transform
              N   /                                n=0..N-1
                  ---
                  k=0

Formula: reverse 

                  N-1
                  ---
                  \          j k 2 pi n / N
      X(n) =       >   x(k) e                    = forward transform
                  /                                n=0..N-1
                  ---
                  k=0

Definition at line 2154 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::fft_2d ( vnl_matrix< vcl_complex< double > > &  c,
int  nx,
int  ny,
int  dir 
) [static, private]

Two dimensonal fft.

Perform a 2D FFT inplace given a complex 2D array.

The direction dir, 1 for forward, -1 for reverse The size of the array (nx,ny) Return false if there are memory problems or the dimensions are not powers of 2

Definition at line 2231 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::fill_x_border ( vil_image_view< float > &  image,
unsigned  w,
float  value 
) [static]

fills a border of width w on left and right of image with value.

Definition at line 1365 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::fill_y_border ( vil_image_view< float > &  image,
unsigned  h,
float  value 
) [static]

fills a border of width h on top and bottom of image with value.

Definition at line 1383 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::fourier_transform ( vil_image_view< float > const &  input,
vil_image_view< float > &  mag,
vil_image_view< float > &  phase 
) [static]

compute the Fourier transform using the vnl FFT algorithm.

Compute the fourier transform.

If the image dimensions are not a power of 2 then the operation fails.

Definition at line 2308 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::ftt_fourier_2d_reorder ( vnl_matrix< vcl_complex< double > > const &  F1,
vnl_matrix< vcl_complex< double > > &  F2 
) [static, private]

Transform the fft coefficients from/to fft/frequency order(self inverse).

reorder the transform values to sequential frequencies as in conventional Fourier transforms.

The transformation is its self-inverse.

Definition at line 2282 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::gaussian ( vil_image_view< float > const &  input,
float  sigma,
float  fill = 0.0f 
) [static]

convolves with a Gaussian kernel.

Definition at line 316 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::gaussian_blocking_filter ( float  dir_fx,
float  dir_fy,
float  f0,
float  radius,
float  fx,
float  fy 
) [static, private]

Blocking filter function.

block a periodic signal by suppressing two Gaussian lobes in the frequency domain.

The lobes are on the line defined by dir_fx and dir_fy through the dc origin, assumed (0, 0). The center frequency, f0, is the distance along the line to the center of each blocking lobe (+- f0). radius is the standard deviation of each lobe. Later we can define a "filter" class.

Definition at line 2430 of file brip_vil_float_ops.cxx.

unsigned brip_vil_float_ops::gaussian_radius ( const double  sigma,
const double  fuzz = 0.02 
) [static]

helper to determine processing border required by Gaussian smoothing.

Definition at line 285 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::grad_matrix_NxN ( vil_image_view< float > const &  input,
unsigned  n,
vil_image_view< float > &  IxIx,
vil_image_view< float > &  IxIy,
vil_image_view< float > &  IyIy 
) [static]

IxIx.transpose gradient matrix elements for a NxN region(N = 2n+1).

$Ix Ix^t$ gradient matrix elements.

That is, 

                          _                           _
                         | (dI/dx)^2    (dI/dx)(dI/dy) |
                         |                             |
    A = Sum(neighborhood)|                             |
                         |(dI/dx)(dI/dy)   (dI/dx)^2   |
                         |_                           _|

over a 2n+1 x 2n+1 neigborhood

Definition at line 754 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::gradient_3x3 ( vil_image_view< float > const &  input,
vil_image_view< float > &  grad_x,
vil_image_view< float > &  grad_y 
) [static]

The gradient using a 3x3 kernel.

Compute the gradient of the input, use a 3x3 mask.

           1  |-1  0  1|         1  |-1 -1 -1|
     Ix = --- |-1  0  1|   Iy = --- | 0  0  0|
           6  |-1  0  1|         6  | 1  1  1|

Larger masks are computed by pre-convolving with a Gaussian

Definition at line 620 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::gradient_mag_3x3 ( vil_image_view< float > const &  input,
vil_image_view< float > &  mag 
) [static]

Definition at line 646 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::half_resolution ( vil_image_view< float > const &  input,
float  filter_coef = 0.359375f 
) [static]

downsamples the input using the Bert-Adelson algorithm.

Downsamples the image by 2 using the Burt-Adelson reduction algorithm.

Convolution with a 5-point kernel [(0.5-ka)/2, 0.25, ka, 0.25, (0.5-ka)/2] ka = 0.6 maximum decorrelation, wavelet for image compression. ka = 0.5 linear interpolation, ka = 0.4 Gaussian filter ka = 0.359375 min aliasing, wider than Gaussian The image sizes are related by: output_dimension = (input_dimension +1)/2.

Definition at line 136 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::half_resolution_1d ( const float *  input,
unsigned  n,
float  k0,
float  k1,
float  k2,
float *  output 
) [static, private]

sub-sample a 1-d array using the Bert-Adelson algorithm.

Downsamples the 1-d array by 2 using the Burt-Adelson reduction algorithm.

Definition at line 106 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::harris ( vil_image_view< float > const &  IxIx,
vil_image_view< float > const &  IxIy,
vil_image_view< float > const &  IyIy,
double  scale = 0.04 
) [static]

Computes the Harris corner measure.

Definition at line 812 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::hessian_3x3 ( vil_image_view< float > const &  input,
vil_image_view< float > &  Ixx,
vil_image_view< float > &  Ixy,
vil_image_view< float > &  Iyy 
) [static]

Compute the Hessian of the input, use a 3x3 mask. 

            1 | 1  -2  1|          1 |  1  1  1|         1  | 1  0 -1|
     Ixx = ---| 1  -2  1|   Iyy = ---| -2 -2 -2|  Ixy = --- | 0  0  0|
            3 | 1  -2  1|          3 |  1  1  1|         4  |-1  0  1|

Larger masks are computed by pre-convolving with a Gaussian

Definition at line 673 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::homography ( vil_image_view< float > const &  input,
vgl_h_matrix_2d< double >const &  H,
vil_image_view< float > &  output,
bool  output_size_fixed = false,
float  output_fill_value = 0.0f 
) [static]

map the input to the output by a homography.

Transform the input to the output by a homography.

Note:
if the output size is fixed then only the corresponding input image space is transformed.

If the output size is fixed then only the corresponding region of input image space is transformed.

Definition at line 2529 of file brip_vil_float_ops.cxx.

int brip_vil_float_ops::Horn_SchunckMotion ( vil_image_view< float > const &  current_frame,
vil_image_view< float > const &  previous_frame,
vil_image_view< float > &  vx,
vil_image_view< float > &  vy,
const float  alpha_coef = 10000.0f,
const int  no_of_iterations = 5 
) [static]

computes optical flow using Horn & Schunck's method.

Definition at line 1223 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::ihs_to_rgb ( vil_rgb< vxl_byte > &  rgb,
const float  i,
const float  h,
const float  s 
) [static]

convert a single i,h,s pixel to rgb.

Definition at line 1699 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::interpolate_center ( vbl_array_2d< float > const &  neighborhood,
float &  dx,
float &  dy 
) [static, private]

find the sub-pixel offset to the maximum using a 3x3 quad interpolation.

Definition at line 406 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::inverse_fourier_transform ( vil_image_view< float > const &  mag,
vil_image_view< float > const &  phase,
vil_image_view< float > &  output 
) [static]

compute the inverse Fourier transform using the vnl FFT algorithm.

Definition at line 2353 of file brip_vil_float_ops.cxx.

vbl_array_2d< float > brip_vil_float_ops::load_kernel ( vcl_string const &  file) [static]

loads a 2n+1 x 2n+1 convolution kernel (see .cxx for file format).

Read a convolution kernel from file.

Assumes a square kernel with odd dimensions, i.e., w,h = 2n+1 format: 

       n
       scale
       k00  k01  ... k02n
             ...
       k2n0 k2n1 ... k2n2n

Definition at line 2019 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::local_maximum ( vbl_array_2d< float > const &  nighborhood,
int  n,
float &  value 
) [static, private]

find if the center pixel of a neighborhood is the maximum value.

Determine if the center of a (2n+1)x(2n+1) neighborhood is a local maximum.

Definition at line 385 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::lucas_kanade_motion_on_view ( vil_image_view< float > const &  curr_frame,
vil_image_view< float > const &  prev_frame,
const double  thresh,
float &  vx,
float &  vy 
) [static]

computes velocity of a region(view) using Lucas Kanade.

computes Lucas-Kanade optical flow on the complete input views.

Definition at line 1110 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::Lucas_KanadeMotion ( vil_image_view< float > &  current_frame,
vil_image_view< float > &  previous_frame,
int  n,
double  thresh,
vil_image_view< float > &  vx,
vil_image_view< float > &  vy 
) [static]

computes Lucas-Kanade optical flow on a 2n+1 neighborhood.

Definition at line 1052 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::max_inscribed_rect ( float  lambda0,
float  lambda1,
float  theta,
float &  u_rect,
float &  v_rect 
) [static]

compute the inscribed rectangle in an ellipse with largest (1+h)(1+w). Needed for fast non-maximal suppression. Theta is in degrees.

theta and phi are in radians.

Definition at line 4089 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::max_scale_trace ( vil_image_view< float >  input,
float  min_scale,
float  max_scale,
float  scale_inc 
) [static]

Definition at line 881 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::max_scale_trace_value ( vil_image_view< float >  input,
float  min_scale,
float  max_scale,
float  scale_inc 
) [static]

exactly same as max_scale_trace, only return the image with actual trace values at max scales instead of the image with max scale values.

Definition at line 912 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::minfo ( const unsigned  i_radius,
const unsigned  j_radius,
const unsigned  step,
vil_image_resource_sptr const &  img0,
vil_image_resource_sptr const &  img1,
vil_image_view< float > &  MI0,
vil_image_view< float > &  MI1,
const float  sigma = 1.0f,
const bool  intensity = true,
const bool  gradient = true,
const bool  ihs = false 
) [static]

compute the minfo of the specified region about each pixel.

Definition at line 3331 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::minfo_g ( const unsigned  i0,
const unsigned  j0,
const unsigned  i1,
const unsigned  j1,
const unsigned  i_radius,
const unsigned  j_radius,
vil_image_view< float > const &  gradx0,
vil_image_view< float > const &  grady0,
vil_image_view< float > const &  gradx1,
vil_image_view< float > const &  grady1,
const float  range = 360.0,
const unsigned  bins = 8 
) [static]

Compute the gradient minfo of a region about the specified pixel.

No bounds check

Definition at line 3258 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::minfo_hs ( const unsigned  i0,
const unsigned  j0,
const unsigned  i1,
const unsigned  j1,
const unsigned  i_radius,
const unsigned  j_radius,
vil_image_view< float > const &  hue0,
vil_image_view< float > const &  sat0,
vil_image_view< float > const &  hue1,
vil_image_view< float > const &  sat1,
const float  range = 360.0,
const unsigned  bins = 8 
) [static]

Compute the hue and saturation minfo of a region about the specified pixel.

No bounds check

Definition at line 3297 of file brip_vil_float_ops.cxx.

float brip_vil_float_ops::minfo_i ( const unsigned  i0,
const unsigned  j0,
const unsigned  i1,
const unsigned  j1,
const unsigned  i_radius,
const unsigned  j_radius,
vil_image_view< float > const &  intensity0,
vil_image_view< float > const &  intensity1,
const float  range = 255.0,
const unsigned  bins = 16 
) [static]

Definition at line 3226 of file brip_vil_float_ops.cxx.

vil_image_resource_sptr brip_vil_float_ops::negate ( vil_image_resource_sptr const &  imgr) [static]

negate an image returning the same pixel type (only greyscale).

Definition at line 533 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::non_maximum_suppression ( vil_image_view< float > const &  input,
int  n,
float  thresh,
vcl_vector< float > &  x_pos,
vcl_vector< float > &  y_pos,
vcl_vector< float > &  value 
) [static]

non-maximum suppression on a NxN neighborhood, with sub-pixel location.

Definition at line 470 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::resize ( vil_image_view< float > const &  input,
unsigned  width,
unsigned  height,
vil_image_view< float > &  output 
) [static]

resize to specified dimensions, fill with zeros if output is larger.

Definition at line 2379 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::resize_to_power_of_two ( vil_image_view< float > const &  input,
vil_image_view< float > &  output 
) [static]

resize to closest power of two larger dimensions than the input.

resize the input to the closest power of two image dimensions.

Definition at line 2395 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::rgb_to_ihs ( vil_rgb< vxl_byte > const &  rgb,
float &  i,
float &  h,
float &  s 
) [static]

convert a single rgb pixel to ihs.

< (Hue is undefined)

< (between yellow and magenta)

< (between cyan and yellow)

< (between magenta and cyan)

< (convert Hue to degrees)

< (Hue must be positive)

< (Hue must be less than 360)

Definition at line 1662 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::rotate ( vil_image_view< float > const &  input,
double  theta_deg 
) [static]

rotate the input image counter-clockwise about the image origin.

Demonstrates the use of image homography

Definition at line 2677 of file brip_vil_float_ops.cxx.

vcl_vector< float > brip_vil_float_ops::scan_region ( vil_image_resource_sptr  img,
vgl_polygon< double >  poly,
float &  min,
float &  max 
) [static]

scan a polygon and return the pixel values as well as max min.

Definition at line 3489 of file brip_vil_float_ops.cxx.

bool brip_vil_float_ops::spatial_frequency_filter ( vil_image_view< float > const &  input,
float  dir_fx,
float  dir_fy,
float  f0,
float  radius,
bool  output_fourier_mag,
vil_image_view< float > &  output 
) [static]

filter the input image with a Gaussian blocking filter.

Definition at line 2459 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::sqrt_grad_singular_values ( vil_image_view< float > &  input,
int  n 
) [static]

computes the conditioning of the 2n+1 x 2n+1 gradient neigborhood.

Definition at line 846 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::std_dev_operator ( vil_image_view< float > const &  sd_image,
vbl_array_2d< float > const &  kernel 
) [static]

Compute the standard deviation of an operator response, given the image intensity standard deviation at each pixel.

Definition at line 3739 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::std_dev_operator_method2 ( vil_image_view< float > const &  sd_image,
vbl_array_2d< float > const &  kernel 
) [static]

Compute the standard deviation of an operator response, given the image intensity standard deviation at each pixel.

Uses a modified formula to compute std_dev

Definition at line 3775 of file brip_vil_float_ops.cxx.

vil_image_resource_sptr brip_vil_float_ops::sum ( vil_image_resource_sptr const &  img0,
vil_image_resource_sptr const &  img1 
) [static]

Add two images from a general resource (forces types to be the same).

Definition at line 3034 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::threshold ( vil_image_view< float > const &  image,
const float  thresh,
const float  level = 255.0 
) [static]

sets values greater than thresh to specified level and the rest to zero.

Definition at line 564 of file brip_vil_float_ops.cxx.

vil_image_view< float > brip_vil_float_ops::trace_grad_matrix_NxN ( vil_image_view< float > const &  input,
unsigned  n 
) [static]

Tr(IxIx.transpose) for a NxN region, N = 2n+1).

Definition at line 797 of file brip_vil_float_ops.cxx.

void brip_vil_float_ops::velocity_by_correlation ( vil_image_view< float > const &  curr_image,
vil_image_view< float > const &  prev_region,
const unsigned  start_i,
const unsigned  end_i,
const unsigned  start_j,
const unsigned  end_j,
const unsigned  zero_i,
const unsigned  zero_j,
float &  vx,
float &  vy 
) [static]

computes velocity of a region(view) using correlation.

Definition at line 1163 of file brip_vil_float_ops.cxx.

The documentation for this class was generated from the following files:
Generated on Tue Nov 22 2011 09:36:03 for contrib/brl/bseg/brip by   doxygen 1.7.5.1