Image Processing and Analysis. Image Graphics and Printing. Image Morphology and Transforms. Subpixel Accuracy Measurements. Blob Analysis and Particle Tracking, Image Correlation. Image Load, Save, and Print. For use with XCLIB, SVOBJ, or 4MOBJ. C/C++ Library for 16 & 32 Bit DOS Programs. DLL for 16 & 32 bit Windows Applications.

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

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¹⁶ 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 2²³ 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), (2)

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.

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.

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.

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

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.

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

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

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

For use with XCLIB: Any PIXCI® D, D24, D32, D3X, A, or CL1 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 series(3) for use with the Model 12.

For use with SVOBJ: Any SILICON VIDEO® MUX™ imaging board.

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++ V10.0/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/2K/XP 32 bit DLLs, for any compiler or Windows application.

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.

Licensing permits royalty free inclusion of library routines into programs using the 4MEG VIDEO™, the SILICON VIDEO® MUX™, or the PIXCI® D, D24, D32, D3X, A, and CL1 imaging boards.

SOFTWARE INCLUDES:

As required by chosen environment: Object code libraries (.LIB), and/or Dynamic Link Library (.DLL).

C prototype files (.H).

Printed manual(s).