#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "allheaders.h"
Input: sy (rows == height) sx (columns == width) Return: doubly indexed array (i.e., an array of sy row pointers, each of which points to an array of sx floats)
Notes: (1) The array[sy][sx] is indexed in standard "matrix notation", with the row index first.
Input: kels (source kernel) Return: keld (copy of kels), or null on error
Input: height, width Return: kernel, or null on error
Notes: (1) kernelCreate() initializes all values to 0. (2) After this call, (cy,cx) and nonzero data values must be assigned.
L_KERNEL* kernelCreateFromFile | ( | const char * | filename | ) |
Input: filename Return: kernel, or null on error
Notes: (1) The file contains, in the following order:
Input: pix cy, cx (origin of kernel) Return: kernel, or null on error
Notes: (1) The origin must be positive and within the dimensions of the pix.
L_KERNEL* kernelCreateFromString | ( | l_int32 | h, | |
l_int32 | w, | |||
l_int32 | cy, | |||
l_int32 | cx, | |||
const char * | kdata | |||
) |
Input: height, width cy, cx (origin) kdata Return: kernel of the given size, or null on error
Notes: (1) The data is an array of chars, in row-major order, giving space separated integers in the range [-255 ... 255]. (2) The only other formatting limitation is that you must leave space between the last number in each row and the double-quote. If possible, it's also nice to have each line in the string represent a line in the kernel; e.g., static const char *kdata = " 20 50 20 " " 70 140 70 " " 20 50 20 ";
void kernelDestroy | ( | L_KERNEL ** | pkel | ) |
Input: &kel (<to be="" nulled>="">) Return: void
Input: kernel size (of grid interiors; odd; minimum size of 17 is enforced) gthick (grid thickness; minimum size of 2 is enforced) Return: pix (display of kernel), or null on error
Notes: (1) This gives a visual representation of a kernel. (2) The origin is outlined in red.
Input: kel row col &val Return: 0 if OK; 1 on error
Input: kernel &min (<optional return>=""> minimum value) &max (<optional return>=""> maximum value) Return: 0 if OK, 1 on error
l_int32 kernelGetParameters | ( | L_KERNEL * | kel, | |
l_int32 * | psy, | |||
l_int32 * | psx, | |||
l_int32 * | pcy, | |||
l_int32 * | pcx | |||
) |
Input: kernel &sy, &sx, &cy, &cx (<optional return>="">; each can be null) Return: 0 if OK, 1 on error
Input: kernel &sum (<return> sum of all kernel values) Return: 0 if OK, 1 on error
Input: kels (source kel, to be inverted) Return: keld (spatially inverted, about the origin), or null on error
Notes: (1) For convolution, the kernel is spatially inverted before a "correlation" operation is done between the kernel and the image.
Input: kels (source kel, to be normalized) normsum (desired sum of elements in keld) Return: keld (normalized version of kels), or null on error or if sum of elements is very close to 0)
Notes: (1) If the sum of kernel elements is close to 0, do not try to calculate the normalized kernel. Instead, return a copy of the input kernel, with an error message.
L_KERNEL* kernelRead | ( | const char * | fname | ) |
Input: filename Return: kernel, or null on error
L_KERNEL* kernelReadStream | ( | FILE * | fp | ) |
Input: stream Return: kernel, or null on error
Input: kernel row col val Return: 0 if OK; 1 on error
Input: kernel cy, cx Return: 0 if OK; 1 on error
Input: fname (output file) kernel Return: 0 if OK, 1 on error
Input: stream kel Return: 0 if OK, 1 on error
Input: halfheight, halfwidth (sx = 2 * halfwidth + 1, etc) stdev (standard deviation) ratio (of stdev for wide filter to stdev for narrow one) Return: kernel, or null on error
Notes: (1) The DoG (difference of gaussians) is a wavelet mother function with null total sum. By subtracting two blurred versions of the image, it acts as a bandpass filter for frequencies passed by the narrow gaussian but stopped by the wide one.See: http://en.wikipedia.org/wiki/Difference_of_Gaussians (2) The kernel size (sx, sy) = (2 * halfwidth + 1, 2 * halfheight + 1). (3) The kernel center (cx, cy) = (halfwidth, halfheight). (4) The halfwidth and halfheight are typically equal, and are typically several times larger than the standard deviation. (5) The ratio is the ratio of standard deviations of the wide to narrow gaussian. It must be >= 1.0; 1.0 is a no-op. (6) Because the kernel is a null sum, it must be invoked without normalization in pixConvolve().
L_KERNEL* makeGaussianKernel | ( | l_int32 | halfheight, | |
l_int32 | halfwidth, | |||
l_float32 | stdev, | |||
l_float32 | max | |||
) |
Input: halfheight, halfwidth (sx = 2 * halfwidth + 1, etc) stdev (standard deviation) max (value at (cx,cy)) Return: kernel, or null on error
Notes: (1) The kernel size (sx, sy) = (2 * halfwidth + 1, 2 * halfheight + 1). (2) The kernel center (cx, cy) = (halfwidth, halfheight). (3) The halfwidth and halfheight are typically equal, and are typically several times larger than the standard deviation. (4) If pixConvolve() is invoked with normalization (the sum of kernel elements = 1.0), use 1.0 for max (or any number that's not too small or too large).
l_int32 makeGaussianKernelSep | ( | l_int32 | halfheight, | |
l_int32 | halfwidth, | |||
l_float32 | stdev, | |||
l_float32 | max, | |||
L_KERNEL ** | pkelx, | |||
L_KERNEL ** | pkely | |||
) |
Input: halfheight, halfwidth (sx = 2 * halfwidth + 1, etc) stdev (standard deviation) max (value at (cx,cy)) &kelx (<return> x part of kernel) &kely (<return> y part of kernel) Return: 0 if OK, 1 on error
Notes: (1) See makeGaussianKernel() for description of input parameters. (2) These kernels are constructed so that the result of both normalized and un-normalized convolution will be the same as when convolving with pixConvolve() using the full kernel. (3) The trick for the un-normalized convolution is to have the product of the two kernel elemets at (cx,cy) be equal to max, not max**2. That's why the max for kely is 1.0. If instead we use sqrt(max) for both, the results are slightly less accurate, when compared to using the full kernel in makeGaussianKernel().
NUMA* parseStringForNumbers | ( | const char * | str, | |
const char * | seps | |||
) |
Input: string (containing numbers; not changed) seps (string of characters that can be used between ints) Return: numa (of numbers found), or null on error
Note: (1) The numbers can be ints or floats.