PXIPL™ LIBRARY
Imaging Processing and Analysis Library
PROCESSING POWER
The PXIPL Library empowers C/C++ and Windows programmers to process and analyze images in conjunction with:
- The PIXCI® imaging boards and XCLIB Library,
- The EPIX® SILICON VIDEO® cameras, their PIXCI® imaging board, and XCLIB Library,
- The 4MEG VIDEO™ imaging boards and 4MOBJ Library, or
- The SILICON VIDEO® imaging boards and SVOBJ Library.
The PXIPL Library is compatible with all of the hardware and software environments supported by the XCLIB, 4MOBJ, and SVOBJ libraries. PXIPL routines operate directly upon imaging board buffers, upon images in PC memory, or upon images stored on disk.
PXIPL provides a wide selection of imaging routines. The major categories include: processing, enhancements, graphic lines and shapes, text overlay, printing, morphology, filters and edge detectors, transforms, convolutions, sequence integration and averaging, image printing, image copy and resizing, single image and image pair normalizations, blob analysis, histograms and moments, image load and save, calibration, correlation, subpixel accuracy measurements, and particle tracking.
SOPHISTICATED SOLUTIONS
The PXIPL C/C++ Function Library allows embedding image processing and analysis into user-written applications. Under Windows, the PXIPL DLL provides services to existing Windows applications which support "hooks" into DLLs.
Under Windows, PXIPL also provides image display on the S/VGA with integrated (non-blinking) cross-hair cursor overlay and integrated palette modifications. PXIPL also provides "waterfall" display of repeatedly captured image lines on the S/VGA.
PXIPL assists user-written programs in applications such as image enhancement, archival, analysis, and measurement; event and motion study; document capture; particle analysis; visual inspection; machine vision and quality control. Join the scientists and engineers in medical, industrial, and research environments who rely upon EPIX® imaging solutions.
FEATURES
|
Resolution Flexibility - PXIPL functions can process images of almost any size, located either in image board memory, PC memory, or disk files. PXIPL functions will process any image captured by an EPIX® imaging board using either 4MOBJ, SVOBJ, or XCLIB software. Typical capture resolutions include 4x1, 32x32, 512x240, 752x480, 768x580, 1024x768, or 2048x2048. Monochrome pixels with a dynamic range from 1 bit (2 grey levels) to as large as 16 bits (2 16 grey levels) can be processed. Color pixels, in either RGB, YCrCb, or HSB color space, with a range of 1 to 16 bits per color component, are supported. Selected operations also support up to 32 bits per pixel. Image sequence operations, such as sequence average or sequence integration, support up to 223 images (8 bits per pixel). The PXIPL functions are not restricted to processing images which were captured by EPIX® imaging boards. Images from any source, residing in PC memory, can be any size and any number of colors, limited only by availability of PC memory, and the CPU word size.1 Virtual Memory - Should PC memory be insufficient, images may also reside in disk files. All images, whether in an imaging board buffer, in PC memory, or in a disk file, can be enhanced and analyzed by the same functions! Functional Flexibility - Typical PXIPL functions provide a broad spectrum of operations, allowing a single function to do the work of many functions. For example, a convolution function accepts parameters describing the image buffer, the area of interest within the buffer, the convolution size N, and the N×N kernel coefficients. This single function allows convolving with a 3×3, 9×9, 31×31, or 99×99 kernel size, limited only by available PC memory. |
Efficiency - PXIPL functions are coded in optimized C, with selected segments hand-coded in assembler. Many functions internally identify special cases, invoking code optimized for each special case. The N×N convolution, for example, examines the coefficients provided and selects custom routines depending upon the size of N, the multiplication and summation precision needed, and whether division is required. Proven Performance - The same functions provided with PXIPL also form the backbone of the ready-to-run XCAP, 4MIP, SVIP, and XCIP interactive image analysis programs, and have been proven through daily use in on-line, rigorous, imaging applications. Image Selection Flexibility - A typical enhancement function operates on any image buffer, on either the full image or selected area of interest, with the result saved to any buffer or area of interest of the same dimensions. Image pair operations allow independent selection of the two source image operands and of the image destination. PXIPL functions for nonrectangular regions use a common method of region specification, supporting rotated elliptical, rotated rectangular, N-sided polygon, boundary path, and scan list specifications. Functions can operate on any pixel color component of a color image; selected functions can also operate upon all color components. |
SAMPLE CODE
Operating upon imaging board buffers & images in PC memory.
struct pximage im1, im2, im3;
struct pxy xysize = {752, 480};
unsigned char buffer[752][480];
void *mallocbuf = NULL;
im1 = *pxd_defineImage(1,1, // access imaging
0,0,-1,-1,..,"Grey"); // board's buffer 1.
pximage_memory(&im, buffer, // access existing
&xysize, PXDATUCHAR, // image in PC malloc memory,
8, 1, // size 752x480, of chars,
PXHINTGREY, 0); // 8 bits per pixel,
// one color, monochrome
pximage_memmalloc(&im3, // create & access new image
&mallocbuf,&xysize, // in PC memory, 752x480,
PXDATUCHAR, 8, // of chars, 8 bits/pixel,
1, PXHINTGREY); // one color, monochrome
pxip8_pairsub(&im1, &im2, // Subtract pixels of
&im3, 0); // image 1 from image 2,
// put result in image 3.
Operating upon selected colors of selected color space.
struct pximage *ip1, *ip2, *ip3; unsigned long histogram[16], cnt; ip1 = pxd_defineImage(1,1, // access image board buffer 1, 188,120,564,360, // AOI of center 1/4 (assuming .., "BofRGB"); // 752x480), RGB color space, // access color #3, B of RGB. pxip8_histab2(NULL, ip1, // compute Blue AOI histogram histogram,16); // binned into 16 ranges. ip2 = pxd_defineImage(1,1, // access image board buffer 1, 0,0,-1,-1,.., // full image AOI, as HSB, "SofBSH"); // access color #2, S of HSB. pxip8_pixthresholdcnt(NULL, // count Saturation ip2, 42, 0,&cnt); // values >= 42 ip3 = pxd_defineImage(1,2, // access image board buffer 2, 0,0,-1,-1,.., // full image AOI, as HSB "SofBSH"); // access color #2, S of HSB pxip8_copy(NULL,&ip3,&ip2); // set saturation of buffer 1 // from buffer 2, leaving // hue & brightness unchanged
Performing 15x15 convolution on AOI.
int kernel[15][15], i, j; // Define 15x15 kernel as low pass
for (i = 15; i--; ) // filter with all coefficients 1.
for (j = 15; j--; )
kernel[i][j] = 1;
pxip8_NxNconvolve( // Do 15x15 convolution on 100x100
pxd_defineImage(1,1,0,0,100,100,..,"Grey"),
// AOI of buffer 1, result into
pxd_defineImage(1,2,0,0,100,100,..,"Grey"),
15, kernel, 0, 0, 0); // buffer 2.
Searching for blobs.
struct pxywindow bounds;
struct pxip8blob blob[100]; // results
struct pxy search = {-1, 0}; // init search coordinates
int n, i;
bounds.nw.x = 3; // min blob width
bounds.nw.y = 3; // min blob height
bounds.se.x = 100; // max blob width
bounds.se.y = 100; // max blob height
n = pxip8_bloblist(NULL, // search image buffer 5
pxd_defineImage(1,5,0,0,-1,-1,..,"Grey"),
&search, 'g'^'t', 123, 0, // for up to 10 blobs
&bounds,0,NULL,100,blob,NULL); // identified by pixel
// values >= 123
printf("Blobs found: %d\\n", n);
for (i = 0; i < n; i++) // report blobs
printf("Blob: %d, Center of Mass: (%g,%g), Area: %ld\\n",
i, blob[i].ucom.xd, blob[i].ucom.yd, blob[i].xyarea);
Saving image sequence to single TIFF file.
struct pxio8tiffparm tiffparm;
memset(&tiffparm, 0, sizeof tiffparm);
tiffparm.bits = 8; // set number of bits to be saved
tiffparm.description = "Test Run #4"; // and a short description.
for (int i = 0; i < 100; i++) // save sequence of 100 buffers
pxio8_tiffwrite(NULL,
pxd_defineImage(1,i+1,0,0,-1,-1,..,"Default"),
"RUN4.TIF", i, // from image buffer i & full AOI
NULL, &tiffparm, 0); // to file name & subimage number
Computing Center of Mass of AOI.
double mass, xcenter, ycenter;
pxip8_masscenter(NULL, // use AOI of buffer 3
pxd_defineImage(1,3,0,0,100,100,..,"Grey"),
&mass, &xcenter, &ycenter); // returned results
printf("Mass Center @ (%g,%g)\\n",
xcenter, ycenter); // report results
FUNCTIONS
PXIPL FUNCTIONS
SPECIFICATIONS
ENVIRONMENT:
Standard versions support:
- Microsoft C/C++ V7.0, V8.0 (Visual C/C++ V1/V2) 16 bit in M or L models. For DOS V3.0 or later, 8088 or better.
- Borland C/C++ V4.0, V5.0 16 bit in M or L models. For DOS V3.0 or later, 8088 or better.
- Watcom C/C++ V11.0 32 bit in F model. For Tenberry (Rational) DOS extender, 80386 or better.
- Windows 3.x 16 bit DLLs, for any compiler or Windows application. For Windows V3.x, Standard or Enhanced mode, 80286 or better.
- Windows 95, 98, ME 32 bit DLLs, for any compiler or Windows application.
- Windows NT, 2000, XP, Vista, 7, 8 32 bit DLLs, for any compiler or Windows application.
- Windows XP(x64), Vista(x64), 7(x64), 8(x64) 64 bit DLLs, for any compiler or Windows application.
- Linux V2.4.8 or later kernel on Intel 80x86.
- Linux V2.6 or later kernel on Intel x86-64.
Other versions available on request.
Memory requirements: Approximately 16 to 1024 Kbytes, dependent upon selection of library routines.
PXIPL is optionally provided with, and must be used with, the 4MOBJ, SVOBJ, XCLIB, version with which it is packaged. PXIPL routines require the presence of a supported imaging board.
IMAGING BOARD:
For use with XCLIB: Any PIXCI® A, CL1, CL2, CL3SD, D, D24, D32, D2X, D3X, E1, E1DB, E4, E4DB, EB1, EB1-PoCL, EC1, ECB1, ECB1-34,EL1, EL1DB, SI, , SI1, SI4, SV2, SV3, SV4, SV5, SV5A, or SV5B imaging board. Any PIXCI® imaging board with an EPIX® SILICON VIDEO® camera.
For use with 4MOBJ: Any 4MEG VIDEO™ Model 5, Model 10, or Model 12, imaging board. Also supports the IMAGE MEMORY EXPANSION and the COC40 series2 for use with the Model 12.
For use with SVOBJ: Any SILICON VIDEO® MUX™ imaging board.
LICENSING:
Licensing permits royalty free inclusion of library routines into programs using the 4MEG VIDEO™, the SILICON VIDEO® MUX™, or the or the PIXCI® imaging boards.
SOFTWARE INCLUDES:
As required by chosen environment: Object code libraries (.lib), Dynamic Link Library (.dll), and/or Object code archive (.a).
C prototype files (.h).
Printed manual(s).
PRICING
- In 16 bit programming environments: the product of the number pixels per line and color components per pixel may not exceed 32767, the number of lines may not exceed 32767. In 16 and 32 bit programming environments: the size of an image and image sequence may not exceed 232-1 bytes. In 64 programming environments: the size of an image may not exceed 2232-1 bytes, the size of an image sequence may not exceed 2264-1 bytes.
- PXIPL for the COC40 supports Native and Bound routines for the TMS320C40, as well as PC routines. A detailed description is provided in the PXIPL-COC40 brochure.