SECURITY DOCUMENT INCLUDING PSEUDO-RANDOM IMAGE AND METHOD OF MAKING THE SAME

Abstract: A security document is provided comprising: a security image area on the face of the document and a printed security image within the security image area. At least a portion of the security image area is divided into a plurality of image element cells, such that the image element cells define an array of image element cells across the security image area. Each of the image element cells is divided into a plurality of pixels, such that each image element cell defines a cell pixel array. At least a portion of the security image area is divided into a plurality of complementary image element cells, such that the complementary image element cells define an array of complementary image element cells across the security image area. Each of the complementary image element cells is divided into a plurality of pixels, such that each complementary image element cell defines a cell pixel array. The printed security image comprises image elements and complementary image elements. The image elements are positioned uniformly with respect to the array of image element cells and substantially randomly with respect to the pixels within each of the image element cells. The complementary image elements are positioned uniformly with respect to the array of complementary image element cells and substantially randomly with respect to the pixels within each of the complementary image element cells.

Description: SECURITY DOCUMENT INCLUDING PSEUDO-RANDOM IMAGE AND METHOD OF MAKING THE SAME The present invention relates to security documents including a security image composed of individual security image elements and complementary security image elements. When an attempt is made to duplicate a document on which the security image is present, at least some of the security image elements change their appearance on the intended duplicate document, or are altered with respect to some other physical characteristic on the intended duplicate document. The change in appearance, or the altered physical characteristic, of the elements provides an indication that an attempt has been made to duplicate the document. For example, the security image elements and the complementary security image elements may be designed such that, upon the attempted duplication or reproduction, e.g., by photocopying, either the security image elements or the complementary security image elements are altered while the others remain substantially the same. The elements are arranged such that the attempted duplication results in the formation of a readily apparent warning image on the face of the document. Specifically, when an attempt is made to copy the document, the word "VOID" may appear on the duplicate document. Further, the security image elements and the complementary security image elements are arranged such that the presence of the security image and the security image elements is not readily apparent on the original. Examples of security documents of this type are illustrated in U.S. Patent Nos. 4,579,370, 5,149,140, 5,197,765, 5,340,159. The above-described prior art provides a means by which a person charged with the responsibility of reviewing security documents can identify documents that are unauthorized copies of the original security document. Unfortunately, a security document designer utilizing conventional darkroom screening techniques or conventional digital technology to produce security documents including security image elements and complementary security image elements has relatively limited control over the security image. Specifically, there is little the designer can do to influence the regular and repetitive shape, size, placement, angular orientation, and spacing of the image elements utilizing the conventional production methods. The ability to control these factors allows a designer to enhance the performance of security documents. Accordingly, there is a need for a security document and a method of preparing a security document wherein the image elements of the security image are positioned to minimize the appearance of regular structure, while the basic functionality of the security document is preserved. This need is met by the present invention wherein image elements are positioned uniformly with respect to an array of image element cells and substantially randomly with respect to the pixels within each of the image element cells, and wherein complementary image elements are positioned uniformly with respect to an array of complementary image element cells and substantially randomly with respect to the pixels within each of the complementary image element cells. The above reference to one type of conventional security document is not intended to limit the scope or application of the present invention to a specific type of security document. Rather, for the purposes of defining and describing the present invention, it should be understood that security image elements and complementary security image elements according to the present invention are any printed elements that function to provide an indication that an attempt has been made to duplicate or reproduce an original security document. The attempted duplication or reproduction could be through conventional or state of the art photocopying methods (analog, digital, color, black-and-white, etc.), printing methods (ink jet, laser, etc.), publishing methods, etc. In accordance with one embodiment of the present invention, a method of preparing a security document is provided comprising the steps of: (i) designating a security image area on the face of a document; (ii) dividing the security image area into a plurality of image element cells, such that the image element cells define an array of image element cells across the security image area; (iii) dividing each of the image element cells into a plurality of pixels, such that each image element cell defines a cell pixel array; (iv) establishing a set of active image element cells, wherein the set of active image element cells defines a security image; (v) positioning a pixel cluster within each of the active image element cells such that at least a portion of the pixel cluster is positioned within the active image element cell, wherein the position of the pixel cluster within each of the active image element cells is designated on a substantially random basis, and wherein each of the pixel clusters defines a predetermined image element; (vi) establishing a complementary security image within the security image area, wherein the complementary security image is formed by a set of predetermined complementary image elements; and (vii) printing a security document including printed areas corresponding to the predetermined image elements and the complementary image elements. The step of positioning the pixel cluster may further comprise the steps of: determining a separation distance between the pixel cluster and each adjacent pixel cluster; comparing the separation distance to a predetermined minimum separation value; and repositioning either the pixel cluster, the adjacent pixel clusters, or both, on a substantially random basis if the separation distance is less than the predetermined minimum separation value. The step of repositioning may comprise repositioning the pixel cluster on a substantially random basis if the separation distance is less than the predetermined minimum separation value. The dimensions of the pixels may correspond to the resolution of an imager utilized in the printing step. For example, the resolution of the imager may be approximately 5080 dpi and each of the plurality of pixels may be approximately a 1/5080" square. The active image element cells may define a warning term. The predetermined image element may be selected from a group consisting of a dot, a square, a line, a circle, a star, a character, a word, a logo, and any other geometrical shape, or clusters of geometrical shapes, suitable for the construction of a security image. The complementary security image portion preferably occupies a portion of the security image area not occupied by the security image. Alternatively, the security image and the complementary security image may occupy common portions of the security image area. The complementary security image may surround the security image. Alternatively, the complementary security image and the security image area may combine to bound the security image. The complementary security image may be established by: (i) dividing the security image area into a plurality of complementary image element cells, such that the complementary image element cells define an array of complementary image element cells across the security image area; (ii) dividing each of the complementary image element cells into a plurality of pixels, such that each complementary image element cell defines a complementary cell pixel array; (iii) establishing a set of active complementary image element cells, wherein the set of active complementary image element cells defines the complementary security image; and (iv) positioning a complementary pixel cluster within each of the active complementary image element cells such that at least a portion of the complementary pixel cluster is positioned within the active complementary image element cell, . wherein the position of the complementary pixel cluster within each of the active complementary image element cells is designated on a substantially random basis, and wherein each of the complementary pixel clusters defines a predetermined complementary image element. The step of positioning the complementary pixel cluster may further comprise the steps of: (i) determining a separation distance between the complementary pixel cluster and each adjacent complementary pixel cluster; (ii) comparing the separation distance to a predetermined complementary pixel minimum separation value; and (iii) repositioning either the complementary pixel cluster, one of the adjacent complementary pixel clusters, or both, on a substantially random basis if the separation distance is less than the predetermined minimum separation value. The complementary image element may be any geometrical shape or clusters of geometrical shapes suitable for the construction of a security image. In accordance with another embodiment of the present invention, a primary image element pixel may be designated within each of the active image element cells and its position within each of the active image element cells may be designated on a substantially random basis. Respective pixel clusters may then be constructed as a function of the respective positions of the primary image element pixels, wherein each of the pixel clusters defines a predetermined image element. In accordance with yet another embodiment of the present invention, a security document is provided comprising a security image area on the face of the document, a printed security image within the security image area, and a printed complementary security image within the security image area. The security image area is divided into a plurality of image element cells such that the image element cells define an array of image element cells across the security image area. Each of the image element cells is divided into a plurality of pixels such that each image element cell defines a cell pixel array. The printed security image comprises printed pixel clusters within respective ones of a set of active image element cells such that at least a portion of each printed pixel cluster is positioned within respective active image element cells. Each of the printed pixel clusters defines a predetermined image element. The set of active image element cells defines the security image. The printed pixel clusters are positioned within each of the active image element cells on a substantially random basis. Similarly, the printed complementary security image comprises a set of predetermined complementary image elements. Adjacent pixel clusters are preferably positioned such that they are separated by at least a predetermined minimum separation value. The image element cells preferably have equal dimensions and each of the pixels preferably have equal dimensions. The dimensions of the pixels preferably correspond to the resolution of an imager utilized to produce the security document. The security image area may also be divided into a plurality of complementary image element cells, such that the complementary image element cells define an array of complementary image element cells across the security image area. Each of the complementary image element cells may be divided into a plurality of pixels, such that each complementary image element cell defines a cell pixel array. The printed complementary security image may comprise printed complementary pixel clusters within respective ones of a set of active complementary image element cells such that at least a portion of each printed complementary pixel cluster is positioned within respective active complementary image element cells. Each of the printed complementary pixel clusters preferably defines a predetermined complementary image element and the set of active complementary image element cells preferably defines the complementary security image. The printed complementary pixel clusters are positioned within each of the complementary active image element cells on a substantially random basis. Adjacent complementary pixel clusters are positioned such that they are separated by at least a predetermined minimum separation value. According to yet another embodiment of the present invention, a security document is provided comprising: a security image area on the face of the document and a printed security image within the security image area. At least a portion of the security image area is divided into a plurality of image element cells, such that the image element cells define an array of image element cells across the security image area. Each of the image element cells is divided into a plurality of pixels, such that each image element cell defines a cell pixel array. At least a portion of the security image area is divided into a plurality of complementary image element cells, such that the complementary image element cells define an array of complementary image element cells across the security image area. Each of the complementary image element cells is divided into a plurality of pixels, such that each complementary image element cell defines a cell pixel array. The printed security image comprises image elements and complementary image elements. The image elements are positioned uniformly with respect to the array of image element cells and substantially randomly with respect to the pixels within each of the image element cells. The complementary image elements are positioned uniformly with respect to the array of complementary image element cells and substantially randomly with respect to the pixels within each of the complementary image element cells. According to yet another embodiment of the present invention, a security document processing system is provided comprising a document issuing station, at least one document receiving station, and a security document according to the present invention. Accordingly, it is an object of the present invention to ensure a nominally uniformly defined tone over the security image area of a security document while providing irregular placement of the image elements of the security image to minimize the appearance of regular structure. It is a further object of the present invention to give a security document designer unprecedented means to control image element shape, size, placement, angular orientation, distance to nearest neighbor, and the white space surrounding any individual image element. Other objects of the present invention will be apparent in light of the description of the invention embodied herein. The following detailed description of the preferred embodiments of the present invention can be best understood when read in conjunction with the following drawings, where like structure is indicated with like reference numerals and in which: Fig. 1 is a schematic illustration of a security document according to the present invention; Fig. 2 is a schematic illustration of a security image area according to the present invention; Fig. 3 is a schematic illustration of an image element cell according to the present invention; Fig. 4 is an illustration of a plurality of image element cells according to the present invention; Fig. 5 is a schematic illustration of a complementary image element cell according to the present invention; Fig. 6 is an illustration of a plurality of complementary image element cells according to the present invention; and Fig. 7 is a flow chart illustrating a method of preparing a security document according to the present invention. For the purposes of describing and defining the present invention, it should be understood that a security document is a document including a feature or characteristic designed or arranged to prevent successful unauthorized duplication of the document, typically by providing an indication of such on the document itself. The indication of an attempted duplication may be such that it is apparent to the naked eye or such that it is apparent through the use of an optical scanner, special viewing optics, special detection hardware, etc. The security document of the present invention, and its method of preparation, are illustrated in detail herein with reference to Figs. 1-7, where like structure is indicated with like reference numerals. A security document 10 according to the present invention is prepared by designating a security image area 12 on the face 11 of the document 10, see Fig. 7, step 100. Fig. 1 illustrates the typical positioning of the security image area 12 on the face of the security document 10. It is contemplated by the present invention, however, that the security image area 12 can be arranged to occupy the entire face 11 of the document 10 or merely a specific portion of the face 11 of the document 10. Preferably, the security image area 12 occupies at least the portions of the face 11 dedicated to security data 13, e.g., payor, payee, amount, authorized signature, etc. One example of the content of the security image area 12, according to the present invention is illustrated schematically in Fig. 2 and includes a printed security image 14, represented schematically by the solid lines forming the single "VOID" warning term in Fig. 2, and a printed complementary security image 16, represented schematically by the diagonal lines in Fig. 2. Typically, the complementary security image 16 occupies the portion of the security image area 12 not occupied by the security image 14. However, it is contemplated by the present invention that the security image 14 and the complementary security image 16 may overlap or occupy common portions of the security image area 12. As will be appreciated by those practicing the present invention, the hidden message technology of the present invention requires the utilization of security images and complementary security images that look very much alike to the ordinary observer. Any one of a number of readily available page assembly and drawing programs may be utilized to design the documents of the present invention, e.g., FreeHand 7.0.2, available from Macromedia, Inc., San Francisco, California. It is noted that the present invention is not limited to the single "VOID" arrangement illustrated in Fig. 2 and that the specific content of the security image may vary within the scope of the present invention. For example, U.S. Patent Nos. 4,341 ,404, 4,420,175, 4,579,370, 5,149,140, 5,197,765, 5,340,159, illustrate other possible security image arrangements that may be incorporated into the present invention. The security image area 12 is divided into a plurality of equally dimensioned image element cells 20 such that the image element cells 20 define an array of image element cells across the security image area 12, see Fig. 7, step 102, and Figs. 2, 3 and 4. Fig. 3 is an illustration of a single image element cell 20 and Fig. 4 is an illustration of a plurality, i.e., nine, image element cells 20. Each of these image element cells 20 is divided into a plurality of equally dimensioned pixels 22 such that each image element cell 20 defines a cell pixel array, see Fig. 3 and Fig. 7, step 104. To define the security image, a set of active image element cells 24, a portion of which is illustrated in Fig. 4, is established from the array of image element cells distributed across the security image area 12, see Fig. 7, step 106. For example, where the security image is the single "VOID" of Fig. 2, the set of active image element cells 24 is established such that they form the individual letters of the "VOID" image. A pixel cluster 26 is positioned within each of the active image element cells 24 such that at least a portion of the pixel cluster 26 is positioned within the boundaries of respective image element cells within the set of active image element cells 24, see Fig. 7, step 108. Each of the pixel clusters 26 defines a predetermined image element, e.g., a dot, a square, a line, a circle, a star, a character, a word, a logo, and any other geometrical shape, or clusters of geometrical shapes, suitable for the construction of a security image. The position of the pixel cluster 26 within the respective image element cells 20 of the set of active image element cells 24 is designated on a substantially random basis. Specifically, the position of the pixel cluster 26 is initially designated on a substantially random basis but, according to one aspect of the present invention, may be repositioned if its original location violates any predetermined cluster positioning rule. For example, the separation distance between a pixel cluster and each adjacent pixel cluster may be determined and compared to a predetermined minimum separation value, see Fig. 7, step 110. If the separation distance is less than the predetermined minimum separation value, the pixel cluster is repositioned on a substantially random basis, see Fig. 7, step 112. Alternatively, it is contemplated by the present invention that one of the adjacent pixel clusters could be repositioned on a substantially random basis to increase the separation distance. According to one embodiment of the present invention, the minimum separation value is selected such that the centroids of the adjacent pixel clusters are separated from each other by at least about 25 to 50 pixels, where each of the plurality of pixels comprises a square having 1/5080" (0.005mm) sides. Preferably, the center of each pixel cluster 26 is within the boundary of the active image element cell 24 and the pixel cluster 26 is permitted to extend outside the cell 24. The printed complementary security image 16, represented schematically by the diagonal lines in Fig. 2, is formed by a set of predetermined complementary image elements defined by complementary pixel clusters 36, see Figs. 5 and 6. Each of the complementary pixel clusters 36 defines a predetermined complementary image element selected, for example, from a group consisting of a dot, a square, a line, a circle, a star, a character, a word, a logo, and any other geometrical shape, or clusters of geometrical shapes, suitable for the construction of a security image. The printed complementary security image 16 is established in substantially the same manner as the printed security image 14. Specifically, the security image area 12 is divided into a plurality of equally dimensioned complementary image element cells 30 such that the complementary image element cells 30 define an array of complementary image element cells across the security image area 12, see Fig. 7, steps 114, 116. Each of the complementary image element cells 30 is divided into a plurality of equally dimensioned complementary pixels 32 such that each complementary image element cell 30 defines a complementary cell pixel array, see Fig. 7, step 118. A set of active complementary image element cells 34 is established to define the complementary security image 16 of Fig. 2, see Fig. 7, step 120. One complementary pixel cluster 36 is positioned within each of the active complementary image element cells 34 such that at least a portion of the complementary pixel cluster 36 is positioned within the respective active complementary image element cell 34, see Fig. 7, step 122. The position of the complementary pixel cluster 36 within each of the active complementary image element cells is designated on a substantially random basis, as described above with respect to the substantially random positioning of the pixel cluster 26. Specifically, the position of the complementary pixel cluster 26 is initially designated on a substantially random basis but, according to one aspect of the present invention, may be repositioned if its original location violates any predetermined cluster positioning rule. For example, the separation distance between a complementary pixel cluster and each adjacent complementary pixel cluster may be determined and compared to a predetermined minimum separation value, see Fig. 7, step 124. If the separation distance is less than the predetermined minimum separation value, the complementary pixel cluster 36 is repositioned on a substantially random basis and printed, see Fig. 7, steps 126 and 128. Referring now to Fig. 4 and Fig. 6, the relative dimensions of the image element cells 20 and the complementary image element cells 30 are illustrated. Specifically, Figs. 4 and 6 each illustrate the number of element cells 20, 30 occupying a 99x99 pixel portion of the security image area 12. In Fig. 4, a total of 9 image element cells 20 occupy the 99x99 pixel area. In Fig. 6, 49 whole and an additional 15 partial complementary image element cells 30 occupy the 99x99 pixel area. The individual pixels 22 of the image element cells 20 have the same dimensions as the individual pixels 32 of the complementary image element cells 30. Preferably, the dimensions of the individual pixels correspond to the resolution of an imager utilized to print the security document 10. For example, where the resolution of the imager is approximately 5080 dpi, each of the plurality of pixels comprises a square having approximately 1/5080" (0.005mm) sides. As is illustrated by Figs. 4 and 6, the image elements, i.e., the respective pixel clusters 26, are positioned uniformly with respect to the array of image element cells 20 as a whole and substantially randomly with respect to the pixels 22 within each of the image element cells 20. Specifically, the position of each image element 26 is random in the sense that it need not occupy a precise set of pixels 22 within the corresponding active image element cell 24, and is uniform, or non-random, in the sense that its position is anchored to its corresponding active image element cell 24. Similarly, the complementary image elements, i.e., the respective complementary pixel clusters 26, are positioned uniformly with respect to the array of complementary image element cells 30 as a whole and substantially randomly with respect to the pixels 32 within each of the complementary image element cells 30. Specifically, the position of each complementary image element 36 is random in the sense that it need not occupy a precise set of pixels 32 within the corresponding active complementary image element cell 34, and is uniform, or non-random, in the sense that its position is anchored to its corresponding active complementary image element cell 34. Thus, the security document of the present invention is said to embody a pseudo-random security image. It is contemplated that, as an alternative to positioning an entire pixel cluster 26 within an active image element cell 24 and determining the separation distance between adjacent pixel clusters 26, a primary image element pixel 28 may be designated within each active image element cell 24. Subsequently, the separation distance between primary image element pixels 28 of adjacent cells may be compared to the minimum separation value and, if necessary, the position of the primary image element pixel 28 may be redesignated. The respective pixel clusters 26 may then be constructed as a function of the respective positions of the primary image element pixels 28. The pixel clusters 26 and the complementary pixel clusters of the present invention are preferably constructed and positioned utilizing a computer program applied in an appropriate manner to produce data files, e.g., TIFF files, preferably at the native resolutions of the imagers of choice, e.g., 3048 dpi and 5080 dpi. The program allows designation of the number of image elements, i.e., pixel clusters, required to give a chosen tonal value. Preferably, the placement of the image elements is controlled or varied to avoid the appearance of regularity without allowing the uneven distributions sometimes associated with randomness. The resulting image element positions give uniform tone without the geometric regularity of conventional halftones. It is contemplated by the present invention that the image elements described herein may be positioned to provide graded or varying tones across the security image area and may be positioned manually, without the aid of an automated cluster positioning program. Preferably, all elements from the three standard security image layers, i.e., security image, complementary security image, and camouflage image, are combined into a single image defined at the native resolution of the imager and converted into a high resolution bitmap file. The image may be converted to TIFF format and used as a stock illustration for creation of numerous individual job files. In this manner, the high resolution images may be stored on an imager system and called for inclusion into various jobs at the final printing or output step. TIFF is a widely accepted file format for storing and interchanging raster images and has been incorporated into the American National Standards Institute Tag Image File Format for Image Technology (TIFF/IT) standard (ANSI IT 8.8). Most commercially available and widely accepted graphics software packages support TIFF files via "import" (input) and/or "export" (output) functions. The TIFF format provides definition for both color and monochrome images in conventional use. It is contemplated by the present invention, that any one of a variety of techniques may be utilized to combine the three standard security image layers. One such procedure is illustrated in the following source code: / * TESTLIB5.C - MAIN ROUTINE */ #include <conio.h> #include <ctype.h> #include <math.h> #include <memory.h> #indude <stdio.h> #indude <stdlib.h> #include <string.h> #include "imagelib.h" #indude "cext.h" #indude "vm.h" char image_path[] = "C:\\SCREENS\\IMAGES\\"; char log_path[] = "C.WSCREENSWLOGFILESW"; char pattern_library[] = "CiWSCREENSWPATTERNSWPATTERN.LIB"; struct box_t { float d_pcent; float a_pcent; long cells_across; long cells_down; float cell_width; float Cθlljieight; int x_modulo; int y_modulo; } Box[20]; IMGBLK *load_pattern(char *, char *); void remove_lf(char *); int setup(int, long, long, long, long, long, long); void main(int argc, char **argv) { VMPBLK *page = NULL; IMGBLK *blk = NULL; IMGBLK *msk = NULL; FILE *dfp = NULL; FILE * tiff_fp = NULL; char *cptr, *sptr, *eptr; char path[128], drive[65], dir[65], fname[65], ext[65]; char program_name[65]; char inbuf[80]; char filename[65]; char log_file[65]; char pattern_name[65], mask_name[65]; long pattern_dots, dots_needed, patterns_needed; long dots_set, total_dots_set; long vm_addr; long page_width, page_height; long pattern_width, pattem_height; long mask_width, mask_height; long h_sep, v_sep; long cells_across, cells_down; float cell_width, cell_height; long page_dots; float base_x, base_y; long cell_x, cell_y, x, y; int range, x_modulo, y_modulo, modulo, num; int trys, done, abort_flag, err, i, c; int prev_pcent, pcent; int box, num_boxes; float d_pcent, a_pcent; unsigned char mask; unsigned char far *ptr; /* Get program name string */ sptr = eptr = argv[0]; while(*eptr != 0) { if((*eptr == ϊ) || (*eptr == 'W')) { eptr++; sptr = eptr; } else { eptr++; } strcpy(program_name, sptr); strupr(program_name); printf("Program name: %s\n", program_name); / * Get name of TIFF file and open corresponding LOG file */ printf("\nEnter TIFF file name: "); gets(inbuf); strupr(inbuf); _splitpath(inbuf, drive, dir, fname, ext); if((strlen(drive)==0) && (strlen(dir)==0)) sprintf(filename, "%s%s.TIF", image_path, fname); else sprintf(filename, "%s%s%s.TIF", drive, dir, fname); sprintf(log_file, "%s%s.LOG", log_path, fname); printf("Enter LOG file name [%s]: ", log ile); gets(inbuf); if(strlen(inbuf) > 0) { strupr(inbuf); _splitpath(inbuf, drive, dir, fname, ext); sprintf(log_file, "%s%s%s.LOG", drive, dir, fname); } dtp = fopen(log_file, "wt"); if(dfp == NULL) { printf("Error trying to create LOG file %s\n", log_fιle); exit(1 ); } setbuf(dfp, NULL); fprintf(dfp, "Program name: %s\n\n", program_name); fprintf(dfp, "TIFF file: %s\n", filename); printf("Enter device DPI [%d]: ", X_dpi); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%d", &X_dpi); Y_dpi = X_dpi; fprintf(dfp, "Resolution: %dw x %dh\n", X_dpi, Y_dpi); page_width = (long)X_dpi; /* 1 inch */ page_height = (long)Y_dpi; / * 1 inch */ printf("\nEnter block width, height (in dots) [%ld, %ld] ", page_width, page_height); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%ld, %ld", &page_width, &page_height); page_width = ((page_width+7L)/8L) * 8L; page_dots = page_height * page_width; fprintf(dfp, "Block size: %ldw x %ldh\n", page_width, page_height); if((page = alloc_page((page_width/8), page_height)) == NULL) { printf("\nError allocating page\n"); goto PRG_EXIT; } num_boxes = 0; do { printf("How many blocks to generate [%d] ", num_boxes); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%d", &num_boxes); } while((num_boxes < 1) || (num_boxes > 20)); fprintf(dfp, "Num blocks: %d\n", num_boxes); printf("\nEnter pattern library file name (%s): ", patternjibrary); gets(inbuf); if(strlen(inbuf) > 0) strcpy(patternjibrary, inbuf); strupr(inbuf); printf("\nEnter pattem name: "); gets(inbuf); strupr(inbuf); strcpy(pattem_name, inbuf); if((blk = load_pattern(pattemJibrary, pattem_name)) == NULL) printf("\nError loading pattern %s from library %s\n", pattern_name, patternjibrary); goto PRG_EXIT; } / * verify pattern width and height in dots * / pattern_width = blk->lines; / * assume 1 :1 * / printffPattern width in dots [%ld] ", pattern_width); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%ld", &pattem_width); pattern_height = blk->lines; printffPattern height in dots [%ld] ", pattern_height); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%ld", &pattern_height); fprintf(dfp, "Pattern: %s\nPattern size: %ldw x %ldh\n\n", pattern_name, pattern_width, pattern_height); strcpy(mask_name, pattern_name); msk = blk; printf("\n Enter mask file name: "); gets(inbuf); if(strlen(inbuf) == 0) { strcpy(mask_name, pattern_name); msk = blk; } else { sscanf(inbuf, "%s", mask_name); strupr(mask_name); if((msk = readjmgblk(mask_name)) == NULL) { printf("\nError reading mask file %s\n", mask_name); goto PRG_EXIT; } } #endif / * how many dots set in this pattern? */ pattern_dots = 0; ptr = blk->ptr; for(y = 0 ; y < blk->lines ; y++) { for(x = 0 ; x < blk->wbytes ; x++) { for(i = 0, mask = 1 ; i < 8 ; i++, mask * = 2) if(*ptr & mask) pattem_dots++; ptr++; } } /* verify mask width and height in dots */ mask_width = msk->lines; /* assume 1 :1 * / maskjieight = msk->lines; #if 0 if(msk != blk) { printf("Mask width in dots [%d] ", mask_width); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%d", &mask_width); printf("Mask height in dots [%d] ", maskjieight); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%d", &mask_height); } #endif /* verify separation requirements */ h_sep = (mask_width-pattern_width)/2; v_sep = (mask_height-pattern_height)/2; if(msk != blk) { printf("\nHorizontal [%ld] ", h_sep); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%ld", &h_sep); printff'Vertical separation [%ld] ", v_sep); gets(inbuf); if(strlen(inbuf) > 0) sscanf(inbuf, "%ld", &v_sep); } setup(num_boxes, pattern_width, pattern_height, pattern_dots, page_width, page_height, page_dots); tiff p = fopen(filename, "wb"); if(tiff p == NULL) { printf("\nError create TIFF file (%s)\n", filename); goto PRG_EXIT; } for(box=0 ; box<num_boxes ; box++) { d_pcent = Box[box].d_pcent; cells_across = Box[box].cells_across; cells_down = Box[box].cells_down; cell_width = Box[box].cell_width; celljieight = Box[box].cell_height; x_modulo = Box[box].x_modulo; y_modulo = Box[box]N_modulo; a_pcent = Box[box].a_pcent; clear_page(page); dots_needed = (long)((d_pcent*(float)page_dots)/(float)100); dots set = 0; total_dots_set = 0; abort lag = 0; if(d_pcent == 0) goto SKIPJV1APPING; modulo = x_modulo * y_modulo; range = (RAND_MAX/modulo) * modulo; printf("\n\n Working on box %d of %d (press ESC to abort)... \n", (box+1 ), num_boxes); prev_pcent = -1 ; pcent = 0; for(cell_y = 0; cell_y < cells_down ; cell_y++) { if(abort lag) break; base_y = (float)cell_y*cell_height; for(cell_x = 0 ; cell_x < cells_across ; cell_x++) { if(abort lag) break; base_x = (float)cell_x*cell_width; if(pcent != prev_pcent) { a_pcent = (float)total_dots_set/(float)page_dots*(float)100; printf("\r%3d percent complete (%5.1f coverage)", pcent, a_pcent); prev_pcent = pcent; } pcent = (int)((float)dots_set (float)dots_needed * (float)100); done = 0; trys = 0; while(ldone) { while((num = rand()) >= range); num = num % modulo; x = (long)(num % x_modulo); y = (long)(num / x_modulo); x += (long)(base_x + 0.5); y += (long)(base_y + 0.5); if(overlap(page, x-h_sep, y-v_sep, msk) == 0) { mapjmage(page, x, y, blk); dots_set += pattem_dots; total_dots_set += pattern_dots; done = 1 ; } trys++; if(kbhit() || (trys > 50)) { getch(); phntf("\nCurrently at cell_y = %d, cell_x = %d", cell_y, cell_x); printf("\n[C]ontinue [A]bort [Override? "); printf("\n"); c = getchO; c = toupper(c); if(c == TV) abort lag = 1 ; if(c == O') done = 1; if(trys > 50) trys = 0; } if(abortJlag) break; } } /* end cell_x loop */ } /* end cell_y loop */ SKIPJV1APPING: if(abort_flag == 0) pcent = 100; a_pcent = (float)total_dots_set/(float)page_dots*(float)100; printf("\r%3d percent complete (%5.1f coverage)", pcent, a_pcent); if(box == 0) { fprintf(dfp, "Box Request Cells Cell Modulo Actual \n"); fprintf(dfp, "Num Percent Across Down Width Height X Y Percent\n"); } fprintf(dfp, "%3d %6.2f ", (box+1 ), Box[box].d_pcent); if(Box[box].d_pcent > 0) { fprintf(dfp, "%6ld%6ld %6.2f %6.2f %5d%5d %6.2f , Box[box].cells_across, Box[box].cells_down, Box[box].cell_width, Box[box].cell_height, Box[box].x_modulo, Box[box].y_modulo, a_pcent); } fprintf(dfp, "\n"); if(abort_flag != 0) goto PRG_EXIT; if(box == 0) { err = write_header(page, tiff _fp, num_boxes); if(err != 0) { printf("\nError writing TIFF header (err = %d)\n", err); goto PRG_EXIT; } } err = addJmage_block(page, tiff p); if(err != 0) { printf("\n Error add image block (err = %d)\n", err); goto PRG_EXIT; } } PRG_EXIT: if((msk != NULL) && (msk != blk)) freejmgblk(msk); if(blk != NULL) freejmgblk(blk); if(page != NULL) free_page(page); if(dfp != NULL) fclose(dfp); if(tiff_fp != NULL) fclose(tiff p); } IMGBLK *load_pattern(char *filename, char *pattern) { static unsigned char pmask[] = { 0x80, 0x40, 0x20, 0x10, 0x08,0x04, 0x02, 0x01 }; FILE *fp; IMGBLK *blk; unsigned char far *ptr; unsigned char *lptr; int mask; char name[64], linebuf[128]; int height, width, wbytes; int found; int h, w, b; / * Open specified library file */ if((fp = fopen(filename, "rt")) == NULL) { printf("Error opening library file (%s)\n", filename); return((IMGBLK *)0); } / * Search for requested pattern */ found = 0; while(fgets(linebuf, 128, fp) != NULL) { removejf(linebuf); if(strcmpi(pattern, linebuf) == 0) { found = 1 ; break; } } if(lfound) { printff'Pattem %s not found\n", pattern); fclose(fp); return((IMGBLK *)0); } / * Read pattern dimensions */ if(fgets(linebuf, 128, fp) == NULL) { printf("Error reading dimensions\n"); fclose(fp); return((IMGBLK *)0); } removejf(linebuf); if(sscanf(linebuf, "%d %d", &height, &width) != 2) { printf("Error scanning dimensions\n"); fclose(fp); return((IMGBLK * )0); } / * Allocate image block */ wbytes = (width+7)/8; if((blk = allocJmgblk((long)wbytes, " (long)height)) == NULL) { printf("Error allocating image block\n"); fclose(fp); retum((IMGBLK * )0); } / * Read pattern */ ptr = blk->ptr; for(h = 1 ; h <= height ; h++) { if(fgets(linebuf, 128, fp) == NULL) { printf("Error reading row %d of %d\n", h, height); freejmgblk(blk); fclose(fp); return((IMGBLK *)0); } removejf(linebuf); Iptr = linebuf; for(w = 0 ; w < wbytes ; w++) { *ptr = 0; for(b = 0 ; b < 8 ; b++) { if(*lptr == 0) continue; if(!isspace(*lptr)) *ptr |= pmask[b]; lptr++; } ptr++; } } fdose(fp); return(blk); } void removeJf(char *str) size len; len = strlen(str); if ((len > 0) && (str[len-1] == '\n')) str[len-1] = 0; } int setup(int num_boxes, long pattern_width, long pattem_height, long pattem_dots, long page_width, long pagejieight, long page_dots) { char buffer[128]; float d_pcent, a_pcent; float celljieight, cell_width; float temp, lo_pcent, hi_pcent; long dots_needed, patterns_needed; long cells_across, cells_down; int x_modulo, y_modulo; int box; while(1 ) { system("cls"); printf("Box Request Cells Cell Modulo Actual \n"); printf("Num Percent Across Down Width Height X Y Percent\n"); for(box=0 ; box<num_boxes ; box++) { printf("%3d %6.2f ", (box+1 ), Box[box].d_pcent); if(Box[box].d_pcent > 0) { temp = (float)min(Box[box].cells_across, Box[box].cells_down); lo_pcent = ((temp*temp*(float)pattern_dots)/(float)page_dots)*100.0; temp = (float)max(Box[boxJ.cells_across, Box[box].cells_down); hi_pcent = ((temp * temp*(float)pattern_dots)/(float)page_dots)*100.0; printf("%6ld%6ld %6.2f %6.2f %5d%5d %6.2f %6.2f,%6.2f', Box[box].cells_across, Box[box].cells_down, Box[box].cell_width, Box[box].cell_height, Box[box].x_modulo, Box[box]N_modulo, Box[box].a_pcent, lo_pcent, hi_pcent); } printf("\n"); } box = -1 ; printf("\n\nEnter box number to modify (0 to quit): "); gets(buffer); ,if(strlen(buffer) == 0) continue; sscanf(buffer, "%d", &box); if(box == 0) break; if((box < 1) || (box > num_boxes)) continue; box = box-1 ; d_pcent = Box[box].d_pcent; printf ("Enter desired percent [%5.1f]: ", d_pcent); gets(buffer); if(strlen(buffer) > 0) sscanf(buffer, "%f * , &d_pcent); dots_needed = (long)((d_pcent*(float)page_dots)/(float)100); if(dots_needed < pattern_dots) { Box[box].d_pcent = 0; continue; } pattern s_needed = (long)(((float)dots_needed/(float)pattern_dots)+0.5); cells_across = (long)(sqrt((double)patterns_needed) + 0.5); printf("Cells across [%dj: ", cells_across); gets(buffer); if(strlen(buffer) > 0) sscanf(buffer, "%d", &cells_across); cells_down = (long)(((float)patterns_needed/(float)cells_across)+0.5); printf("Cells down [%d]: ", cells_down); gets(buffer); if(strlen(buffer) > 0) sscanf(buffer, "%d", &cells_down); cell_width = (float)page_width/(float)cells_across; printf("Cell width [%f]: ", cell_width); gets(buffer); if(strlen(buffer) > 0) sscanf(buffer, "%f ', &cell_width); cell_height = (float)page_height/(float)cells_down; printf("Cell height [%f]: ", cell_height); gets(buffer); if(strlen(buffer) > 0) sscanf(buffer, "%f , &cell_height); x_modulo = (int)(cell_width - (float)pattem_width + 0.5); if(x_modulo == 0) x_modulo = 1 ; printf("X_modulo [%d]: ", x_modulo); gets(buffer); if(strlen(buffer) > 0) sscanf(buffer, "%d", &x_modulo); if(x_modulo == 0) x_modulo = 1 ; y_modulo = (int)(cell_height - (float)pattem_height + 0.5); if(y_modulo == 0) y_modulo = 1; printf("Y_modulo [%d]: ", y_modulo); gets(buffer); if(strlen(buffer) > 0) sscanf(buffer, "%d", &y_modulo); if(y_modulo == 0) y_modulo = 1; a_pcent = (float)(cells_across*cells_down*pattern_dots)/(float)page_dots; a_pcent = a_pcent * 100.0; Box[box].d_pcent = d_pcent; Box[box].cells_across = cells_across; Box[box].cells_down = cells_down; Box[box].cell_width = cell_width; Box[box].cell_height = cell_height; Box[box].x_modulo = x_modulo; Box[box]N_modulo = y_modulo; Box[box].a_pcent = a_pcent; } return(O); IMAGEPGS.C - LIBRARY OF ROUTINES. #include <malloc.h> #include <memory.h> #include <stdio.h> #include <string.h> #include <time.h> #include "imagelib.h" #include "vm.h" #define MAP_OFF_TOP 0x01 #define MAP_OFF_BOTTOM 0x02 #define MAP_OFF_LEFT 0x04 #define MAP_OFF_RIGHT 0x08 #define XDOTS_PERJNCH 3048 /* default resolution */ #define YDOTS_PERJNCH 3048 Definitions needed for TIFF formatting #define TYPE_BYTE 1 #define TYPE_ASCII 2 #define TYPE_SHORT 3 #define TYPE_LONG 4 #define TYPE_RATIONAL 5 #define NewSubfileType 254 #define ImageWidth 256 #define ImageLength 257 #define BitsPerSample 258 #define Compression 259 #define Photolnterp 262 #defιne StripOffsets 273 #define SamplesPerPixel 277 #define RowsPerStrip 278 #define StripByteCounts 279 #define XResolution 282 #define YResolution 283 #define ResolutionUnit 296 #define Software 305 #define DateTime 306 #defιne UNCOMPRESSED 1 #define PACK_BITS 32773U #defιne MAX_STRIP_SIZE 8*1024 typedef struct { char format[2]; int type; long ifd_offset; } TIFFJFH; typedef struct { int tag; int type; long count; long offset; } TIFFJFDE; typedef struct { int entries; TIFFJFDE *entry; } TIFFJFD; static int Page_Allocated = 0; static unsigned char img_mask[] = { 0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f }; int X_dpi = XDOTS_PERJNCH; int Y_dpi = YDOTS_PERJNCH; int write iff Jine(char far *p, unsigned n, FILE *fp, unsigned compression, unsigned * bytes_written); VMPBLK *alloc_page(long bytes_perjine, long lines) { VMPBLK *page; long size; / * Allow only one page to be allocated at any given time. */ if(Page_Allocated) return((VMPBLK *)0); if((page = (VMPBLK *)malloc(sizeof(VMPBLK))) == NULL) return((VMPBLK *)0); size = bytes_perjine * lines; if(vm_alloc((unsigned long)size) != 0) { free((void *)page); return((VMPBLK *)0); } Page_Allocated = 1 ; page->wbytes = bytes_perjine; page->lines = lines; page->size = size; return(page); } void free_page(VMPBLK *page) { vmJreeO; free((void *)page); Page_Allocated = 0; IMGBLK *alloc_imgblk(long bytes_perjine, long lines) { IMGBLK * blk; size size; if((blk = (IMGBLK * )malloc(sizeof(IMGBLK))) == NULL) return((IMGBLK *)0); size = (size )(bytes_perjine * lines); if((blk->ptr = (char far *)malloc(size)) == NULL) { freejmgblk(blk); retum((IMGBLK *)0); } blk->wbytes = bytes_perjine; blk->lines = lines; retum(blk); } void freeJmgblk(IMGBLK * blk) { free((void *)blk->ptr); free((void *)blk); } / * mapjmage - maps image block into memory with wrapping at borders */ int mapJmage(VMPBLK * page, long vm_x, long vm_y, IMGBLK *img) { long scan_adr, next_scan_adr, vrri_adr; long line, i; int byte_shift, map_result; unsigned char far * vm_ptr, *img_ptr; unsigned char prev_vm_byte, vm_byte, img_byte; if(!Page_Allocated) return(-1 ); /* wrap starting x/y coordinates if needed */ while(vm_x < 0) vm_x += (page->wbytes*8); while(vm_x >= (page->wbytes*8)) vm_x -= (page->wbytes*8); while(vm_y < 0) vm_y += (page->lines); while(vm_y >= page->lines) vm_y -= page->lines; byte_shift = (int)vm_x % 8; scan_adr = page->wbytes * vm_y; next_scan_adr = scan_adr + page->wbytes; map_result = 0; for(line = 0 ; line < img->lines ; iine++) { img_ptr = img->ptr + (line*img->wbytes); prev_vm_byte = 0; vm_adr = scan_adr + (vm_x/8); for(i = 0 ; i <img->wbytes ; i++) { img_byte = *img_ptr; vm_byte = (unsigned char) (((int)img_byte » byte_shift) | (int)prev_vm_byte); prev_vm_byte = (unsigned char) (((int)((img_byte ' & img_mask[byte_shift])) < « (8-byte_shift))); vm_ptr = vm_map(vm_adr); * vm_ptr = *vm_ptr | vm_byte; vm_adr++; if(vm_adr >= next_scan_adr) vm_adr -= page- >wbytes; img_ptr++; } if(prev_vm_byte != 0) { vm_ptr = vm_map(vm_adr); *vm_ptr = *vm_ptr | prev_vm_byte; } scan_adr = next_scan_adr; if(scan_adr >= page->size) scan_adr -= page->size; next_scan_adr = scan_adr + page->wbytes; } return(O); } int overlap(VMPBLK *page, long vm_x, long vm_y, IMGBLK *img) / * Tests for image overlap. Returns 0 if no pixels overlap, 1 if they do */ { long scan_adr, next_scan_adr, vm_adr; long line, i; int byte_shift; unsigned char far *vm_ptr, *img_ptr; unsigned char prev_vm_byte, vm_byte, img_byte; if(!Page_Allocated) return(-1); /* wrap starting x/y coordinates if needed */ while(vm_x < 0) vm_x += (page->wbytes*8); while(vm_x >= (page->wbytes * 8)) vm_x -= (page->wbytes*8); while(vm_y < 0) vm_y += (page->lines); while(vm_y >= page->lines) vm_y -= page->lines; byte_shift = (int)(vm_x % 8); scan_adr = page->wbytes * vm_y; next_scan_adr = scan_adr + page->wbytes; for(line = 0 ; line < img->lines ; line++) { img_ptr = img->ptr + (line*img->wbytes); prev_vm_byte = 0; vm_adr = scan_adr + (vm_x/8); for(i = 0 ; i <img->wbytes ; i++) { img_byte = *img_ptr; vm_byte = (unsigned char) (((int)img_byte » byte_shift) | (int)prev_vm_byte); prev_vm_byte = (unsigned char) (((int)((img_byte & img_mask[byte_shift])) « (8-byte_shift))); vm_ptr = vm_map(vm_adr); if(*vm_ptr & vm_byte) / * bits overlap? * / return(1); vm_adr++; if(vm_adr >= next_scan_adr) vm_adr -= page->wbytes; img_ptr++; } vm_ptr = vm_map(vm_adr); if(*vm_ptr & prev_vm_byte) return(1); scan_adr = next_scan_adr; if(scan_adr >= page->size) scan_adr -= page->size; next_scan_adr = scan_adr + page->wbytes; } retum(O); int clear_page(VMPBLK *page) { long vm_adr, num_vm_pgs, bytesjeft; long j, i; char far *buff; if(!Page_Allocated) return(-1); /* Clear image */ vm_adr = 0; num_vm_pgs = (page->size/VM_PAGE_SIZE); for(j=0 ; j<num_vm_pgs ; j++) { buff = vm_map(vm_adr); for(i=0 ; i<VM_PAGE_SIZE ; i++) * (buff + i) = 0x00; vm_adr += VM_PAGE_SIZE; } bytesjeft = page->size - (num_vm_pgs * VM_PAGE_SIZE); if(bytesjeft > 0) { buff = vm_map(vm_adr); for(i=0 ; i<bytesjeft ; i++) *(buff + i) = 0x00; } return(O); int write_header(VMPBLK *page, FILE * tfp, int totalJmage_blocks) { static TIFFJFDE ifde[] = { { NewSubfileType, TYPE_LONG, OL, OL }, { ImageWidth, TYPE_LONG, OL, OL }, { ImageLength, TYPEJ.ONG, OL, OL }, { BitsPerSample, TYPE_SHORT, OL, OL }, { Compression, TYPE_SHORT, OL, OL }, { Photolnterp, TYPE_SHORT, OL, OL }, { StripOffsets, TYPE_LONG, OL, OL }, { SamplesPerPixel, TYPE_SHORT, OL, OL }, { RowsPerStrip, TYPEJ DNG, OL, OL }, { StripByteCounts, TYPEJ.ONG, OL, OL }, { XResolution, TYPE_RATIONAL, OL, OL }, { YResolution, TYPE_RATIONAL, OL, OL }, { ResolutionUnit, TYPE SHORT, OL, OL }, ' { Software, TYPE_ASCII, OL, OL }, { DateTime, TYPE_ASCII, OL, OL } }; TIFFJFH ifh; TIFFJFD ifd; char software[80]; char date_str[9], time_str[9], datetime[32]; time tnow; long hdpi, vdpi, block_width, block_wbytes, blockjines; long totaljmagejines, totalJmage_size; long count, offset, tempjong; long addr_strip_offsets, addr_strip_byte_counts; long addr_xresolution, addr_yresolution; long addr_software, addr_datetime, addrjmage_data; size len; int errors; int i, j; /* Get current date and time */ time(&tnow); _strdate(date_str); _strtime(time_str); sprintf(software, "Standard Register, Copyright 1994-%.2s", &date_str[6]); /* Page parameters */ hdpi = X_dpi; vdpi = Y_dpi; block_width = (long)page->wbytes * 8L; block_wbytes = page->wbytes; blockjines = page->lines; / * Image parameters */ totaljmagejines = blockjines * totalJmage_blocks; totalJmage_size = totaljmagejines * block_wbytes; /* Fill in header and directory information */ / * ...header... */ ifh.format[0] = ifh.format[1] = 0x49; / * "II" * / if h. type = 42; ifh.ifd_offset = 8L; / * ...number of directory entries... * / ifd. entries = sizeof(ifde)/sizeof(TIFF_IFDE); ifd. entry = ifde; /* ...compute offset addresses for various entry fields... * / addr_strip_offsets = 8 + 2 + (ifd.entries*sizeof(TIFFJFDE)) + 4; addr_strip_byte_counts = addr_strip_offsets + 4; addr_xresolution = addr_strip_byte_counts + 4; addr_yresolution = addr_xresolution + 8; addr_software = addr_yresolution + 8; addr_datetime = addr_software + strlen(software) + 1 ; addrjmage_data = addr_datetime + 20; /* ...complete directory entries... */ errors = 0; for( i=0 ; i<ifd. entries ; i++ ) { switch(ifd.entry[i].tag) { case NewSubfileType: count = 1 L; offset = 0L; break; case ImageWidth: count = 1L; offset = block_width; break; case ImageLength: count = 1 L; offset = totaljmagejines; break; case BitsPerSample: count = 1 L; offset = 1L; break; case Compression: count = 1 L; offset = (long)UNCOMPRESSED; break; case Photolnterp: count = 1 L; offset = OL; break; case StripOffsets: count = 1 ; offset = addrjmage_data; break; case SamplesPerPixel: count = 1 L; offset = 1 L; break; case RowsPerStrip: count = 1 L; offset = totaljmagejines; break; case StripByteCounts: count = 1 ; offset = totaljmagejines * block_wbytes; break; case XResolution: count = 1 L; offset = addr_xresolution; break; case YResolution: count = 1 L; offset = addr_yresolution; break; case ResolutionUnit: count = 1 L; offset = 2L; break; case Software: count = (long)(strlen(software) + 1 ); offset = addr_software; break; case DateTime: / * ...form current date and time string... * / sprintf(datetime, "19%.2s:%.2s:%.2s %s", &date_str[6], &date_str[0], &date_str[3], time_str); count = 20L; offset = addr_datetime; break; default: printf("Unknown tag encountered (%d)\n", ifd.entry[i].tag); count = ifd.entry[i]. count; offset = ifd. entry [i]. offset; errors++; break; } ifd. entry[i]. count = count; ifd. entny[i]. offset = offset; } printf("\nlMAGE FILE HEADER\n"); printf("\tFormat : %c%c\n", ifh.format[0], ifh.format[1]); printf("\tType : %d\n", ifh.type); printf("\tlFD offset: %ld\n", if .ifd_offset); printf("\nlMAGE FILE DIRECTORYΛn"); printf("\tEntries: %d\n", ifd.entries); for(i=0 ; i<ifd. entries ; i++) { printf("\t%d %d %ld %ld\n", ifd. entry [j]. tag, ifd.entiNϊij.type, ifd. entryji]. count, ifd. entry[i]. offset); } / * Check for errors */ if (errors) return (-1 ); / * Write the file header */ len = fwrite((void *)&ifh, 1 , sizeof(TIFFJFH), tfp); if(len != sizeof(TIFFJFH)) { printf("Error writing file header\n"); return(-2); } /* Write the number of entries in the file directory */ len = fwrite((void *)&ifd. entries, 1 , sizeof(int), tfp); if (len != sizeof(int)) { printf("Error writing number of entries in file directory\n"); return(-3); } /* Write the directory entries */ for(i = 0 ; i < ifd. entries ; i++) { len = fwrite((void *)&ifd.entry[i], 1 , sizeof(TIFFJFDE), tfp); if(len != sizeof(TIFFJFDE)) { printf("Error writing directory entry %d\n", i); retum(-4); } } / * Write a (long) zero to terminate the directory */ tempjong = OL; fwrite((void * )&tempJong, 1 , 4, tfp); len = fwrite((void * )&addrjmage_data, 4, 1 , tfp); if(len != 1 ) { printf("Error writing address of image data\n"); return (-5); } len = fwrite((void * )&totalJmage_size, 4, 1 , tfp); if(len != 1 ) { printf("Error writing image data size\n"); retum(-6); } /*...x and y resolutions followed by a 1L...*/ tempjong = 1 L; hdpi = X_dpi; vdpi = Y_dpi; fwrite((void *)&hdpi, 1 , 4, tfp); fwrite((void *)&tempJong, 1 , 4, tfp); fwrite((void *)&vdpi, 1 , 4, tfp); fwrite((void *)&tempJong, 1 , 4, tfp); /*... software string...*/ len = fwrite((void *)software, 1 , (strlen(software)+1 ), tfp); if(len != (strlen(software)+1 )) { printf("Error writing software information\n"); return (-7); } /*...datetime string...*/ len = fwrite((void *)datetime, 1 , 20, tfp); if(len != 20) { printf("Error writing date and time\n"); retum(-δ); } return(O); } int addJmage_block(VMPBLK * page, FILE * tfp) { char far *vm_ptr; long vm_adr, num_vm_pgs, bytesjeft; int i, j; / * Go to the end of the image file to append */ if(fseek(tfp, OL, SEEK_END) != 0) { printffError seeking to EOF\n"); return(-1); } / * Dump image block one image page at a time */ vm_adr = 0; num_vm_pgs = (page->size VM_PAGE_SIZE); for(j=0 ; j<(int)num_vm_pgs ; j++) { vm_ptr = vm_map(vm_adr); if(fwrite(vm_ptr, sizeof(char), VM_PAGE_SIZE, tfp) != VM_PAGE_SIZE) { printf("Error writing page %d\n", j); return(-2); } vm_adr += VM_PAGE_SIZE; } bytesjeft = page->size - (num_vm_pgs * VM_PAGE_SIZE); if(bytesjeft > 0) { vm_ptr = vm_map(vm_adr); if(fwrite(vm_ptr, sizeof(char) (size )bytesjeft, tfp) != (size )bytesjeft) { printf("Error writing last page segment\n"); return(-3); } } return(O); } int write iffjine(char far * p, unsigned n, FILE *fp, unsigned compression, unsigned * bytes_written) { char buf[128]; unsigned bdex, i, j, t; unsigned len; int c; /* If not PackBits compression, don't compress */ if (compression != PACK_BITS) { len = fwrite(p, 1 , n, fp); *bytes_written = len; if(len == n) return(O); else return(-1); /* error * / } bdex = j = t = 0; *bytes_written = 0; do { i = 0; while((p[t+i]==p[t+i+1]) && i<127 && ((t+i)<(n-1 ))) ++i; if( (i > 0) || (bdex >= 128) ) { / * check for a previous string * / if(bdex) { c = (bdex-1)&0x7F; if(putc(c, fp) != c) return(-2); ( * bytes_written)++; j+=1; len = fwrite(buf, 1, bdex, fp); ( * bytes_written) += len; if(len != bdex) return(-3); j += bdex; bdex = 0; } if(i) { / * ...and then write the run */ c = (~i+1)&0xFF; if(fputc(c, fp) != c) return(-4); ( * bytes_written)++; c = (int)p[t+i] & OxFF; if(fputc(c, fp) != c) return(-5); (*bytes_written)++; t+=(i+1); } } else buf[bdex++] = p[t++]; } while(t < n); / * check for any pending strings */ if(bdex) { c = (bdex-1)&0x7F; if(fputc(c, fp) != c) return(-6); (*bytes_written)++; j+=i; len = fwrite(buf, 1 , bdex, fp); (*bytes_written) += len; if(len != bdex) return(-7); j += bdex; bdex = 0; } / * make even word boundry by adding nop */ if(j & 1 ) { c = 0x80; if(fputc(c, fp) != c) return(-8); ( * bytes_written)++; } return(O); /**************************************************************** * * * File: cext.c * * * * Description: * * Manage allocation and access of extended memory. * * * Modified 5-21-93 by Al Fledderman * The High Memory Area (HMA) is the first 64K of extended * memory. The HMA can be accessed (indirectly) from * real mode without switching to protected mode. The * * HMA area is included in the size returned by the BIOS * * call which returns extended memory size. Subtract out * * this 64K from reported size AND use 64K above 1 MB as * the beginning of extended memory (0x110000). * * * **************************************************************** / #include <dos.h> #include <memory.h> #define NOCLSFUNC 1 /* Don't include msc_cls() */ #include "compat.h" #include "cext.h" / * GDT structure for INT 15H */ struct _gdte { unsigned int limit; unsigned int adrbot; unsigned char adrtop; char arb; int zero; }; static struct _gdte gdt[6]; #ifdef POWERC static void far *old15; #else static void(far interrupt *old15)(); #endif static int installed=0; / * amount of memory/amount allocated */ static unsigned e_size,e_alloc; /* definitions for POWERC and Turbo C * / #if defined(_POWERC)||defined(_TURBOC_) / * This is a kludge to emulate Microsoft's _chainjntr() The strategy is to change the return address to the code in chain[]. And then return. The code in chain[] sets up the stack and simulates an interrupt to the old handler * / unsigned chain[14]= { 0x559c I 0xe589,0xb850,0,0x4687,0x87fe,0x46,0xb850,0,0x4687, 0x5d00,0xeafa,0,0 }; void far * eptr; #define _chainjntr(ptr) { cptr=(void far *) chain; \ _chain[12]=FP_OFF(ptr); \ _chain[13]=FP_SEG(ptr);\ chain[3]=Rip;\ chain[8]=Rcs; Rcs=FP_SEG( cptr);\ Rip=FP_OFF(_cptr);\ return; } #endif / * private routine to capture requests for extended memory size */ static void interrupt FAR trap15(INTREGS) { if ((Rax&0xFF00)!=0x8800) _chainJntr(old15); Rax=e_size; return; } ***************************************************************** * Get extended memory size (in K) from BIOS * ***************************************************************** / unsigned int ext_size() { union REGS r; r.h.ah=0x88; int86(0x15,&r,&r); if(r.x.ax > 64) return(r.x.ax - 64); else return(O); /***************************************************************** * Allocate memory in 1 K blocks, returns start address of block * or (LPTR) -1 if unable to allocate memory * ***************************************************************** / LPTR ext_alloc(unsigned size) { LPTR result; if (installed) retum(ext_realloc(size+e_alloc)); e_alloc=size; e_size=ext_size(); if (e_size<size) return((LPTR)-1 L); e_size-=size; old15=getvect(0x15); setvect(0x15,trap15); installed=1 ; return((LPTR)0x110000 + (LPTR)e_size*(LPTR)1024); } /***************************************************************** * Attempt to change the size of an allocated block (size in K). * Returns start address or (LPTR) -1 if unsuccessful * *****************************************************************/ LPTR ext_realloc(unsigned size) { if (! installed) return(ext_alloc(size)); if (size>e_alloc+e_size) return((LPTR)-1L); if (size<e_alloc) { e_size+=e_alloc-size; e_alloc=size; } else if (size>e_alloc) { if (getvect(0x15)!=trap15) retum((LPTR)-1L); e_size-=size-e_alloc; e_alloc=size; } return((LPTR)0x110000 + (LPTR)e_size * (LPTR)1024); } /***************************************************************** * Free the extended block. Always call before exiting. * * If exitflag is set, the INT 15 trap will be reset. If another * * program has captured INT 15, ext ree will return a -1. If * * you call with exitflag == 0, and another program has captured * INT 15, the vector is not reset and extjree returns a 1. * * Otherwise, extjree returns 0 and releases INT 15 * ***************************************************************** / int ext ree(int exitflag) { int rc=0; if (Installed) return(rc); if (getvect(0x15)==trap15||exitflag) { if (getvect(0x15)!=trap15) rc=-1; installed=0; setvect(0x15,old15); } else { e_size+=e_alloc; e_alloc=0; rc=1 ; } retum(rc); } ***************************************************************** * Move a block of memory using BIOS calls. Works up to 16 Mbyte ***************************************************************** / int extmemcpy(LPTR dst.LPTR src, unsigned wc) { union REGS r; struct SREGS s; void far *gdtptr; gdtptr=(void far *) gdt; / * clear GDT */ memset(gdt,0,sizeof(gdt)); / * Set up GDT */ gdt[3].limit=gdt[2].limit=wc*2-1; gdt[2].adrbot=(unsJgned int)(src&0xffff); gdt[2].adrtop=(unsigned char)((src&0xff0000L)»16); gdt[3].adrbot=(unsigned int)(dst&0xffff); gdt[3].adrtop=(unsigned char)((dst&0xff0000L)»16); gdt[2].arb=gdt[3].arb=0x93; s.es=FP_SEG(gdtptr); r.h.ah=0x87; r.x.cx=wc; r.x.si=FP_OFF(gdtptr); int86x(0x15,&r,&r,&s); retum(r.h.ah); } **************************************************************** * * * File: vm ext.c * * * * r D>e___<sr»c<-»r-;iprN+t;io«n_-i -: * * Manages virtual memory for DUP.C using extended memory. * Requires CEXT.C * * **************************************************************** #include <dos.h> #include "cext.h" #define PAGESIZE 16384 static int vmpage=-1 ; static LPTR vmstart=0L; static char vmbuffer[PAGESIZE]; int vm_commit(void); / * Allocate VM swap space * / int vm_alloc(unsigned long size) { / * free any already allocated */ if (vmstart) ext ree(1); / * compute number of 1 K pages req'd */ if (size%PAGESIZE) size=(size/PAGESIZE+1)*PAGESIZE; size/=1024; if ((unsigned long)ext_size()<size) return(1); / * allocate from CEXT * / vmstart=ext_alloc((unsigned) size); if (Ivmstart) return(1 ); /* should never happen * / return(O); } / * Free VM */ void vm JreeQ { ext ree(1 ); } / * Map a VM address */ char far * vm_map(unsigned long offset) { int page; char far * rval=(char far *)0; char far * mixbug=(char far *) vmbuffer; / * compute page */ page=(int)(offset PAGESIZE); / * if page isn't the current page .... */ if (page!=vmpage) { / * commit current page */ if (vm_commit()) return(rval); vmpage=page; /* copy new page in * / if (extmemcpy(segJoJinear(mixbug)Nmstart+(unsigned long) vmpage * PAGESIZE,PAGESIZE/2)) return(rval); } / * compute offset in page buffer */ FP_SEG(rval)=FP_SEG(mixbug); FP_OFF(rval)=offset-(unsigned long)page * PAGESIZE+FP_OFF(mixbug); return(rval); } / * commit VM page to extended memory */ int vm_commit(void) { void far *mixbug=(void far * ) vmbuffer; / * don't do inital page */ if (vmpage==-1 ) return(O); / * copy it out */ if (extmemcpy(vmstart+(unsigned long) vmpage*PAGESIZE, seg JoJinear(mixbug),PAGESIZE/2)) return(1 ); retum(O); } The image generation procedure of the present invention enables definition of precise patterns in terms of specific pixels of the high resolution imager and use of these patterns to create high resolution files. The resulting output image is completely "dot addressable" at the resolution of the imaging engine. For the purpose of describing the procedure of the present invention, it is noted that the "image element" is a two-dimensional pattern of control bits that can be defined in shapes that utilize the potential of the high resolution imager. Each control bit has one of two states, "set" or "clear," and will control one spot of the laser imaging device when operating at the native resolution of the imager. The image element has no inherent resolution. Thus the number of the laser spots controlled by each control bit depends upon the resolution and image size defined in the image file and the native resolution of the imager. For maximum image control and fidelity of the reproduction to the original, the file resolution should match that of the targeted imagesetter. Image file generation is controlled by the following parameters: (i) image resolution, (ii) image size, (iii) image element shape, (iv) percent of area covered, and (v) the adjacency rule. The resolution of the image is often described in dots per inch (dpi). On laser film recorders these precisely placed marks may also be described as laser spots per inch. For maximum image control, the mark frequency should correspond to the highest resolution of the imaging device in dots or laser spots per inch. It is usual to have the same mark frequency in both dimensions of the two dimensional image. The image size is specified as the number of dots across the image (width) and the number of dots down the image (height). The usual image dimensions in linear values can be determined by dividing the image dimensions in dots by the resolution in dots per conventional linear measure (inches, centimeters, etc.). The image element shape is the elemental cluster of laser spots that is repeated and positioned to fill a specified area. This cluster may be round, square, solid, open, perhaps with irregular boundaries, etc. It will remain consistent over an arbitrarily defined area that may be very large or very small depending on the design intent for the image. The percent of area covered is defined as the total number of imaged (on) dots divided by the total number of dots in the image area x 100. This approach allows the mixing of different image elements in the same area and computing the percent of area covered by all the image elements of a specific type or the percent of area covered by all elements of all types. The closeness of placement of adjacent image elements is controlled by specifying the minimum number of dots that must separate nearest neighbor elements. This prevents clustering of many image elements together to produce larger image elements and assures a nearly uniform tone for the image area. Each control bit in the image element determines whether the corresponding dot on the imager should be on or off. As a result there are only two states - either set or clear. The total number of imaged dots needed is determined by multiplying the decimal percent of area covered that is desired by the total number of dots in the image area. The image element patterns are examined to determine the number of "set" bits in each image element. The total number of image element cells are determined by dividing the total number of laser spot addresses in the area of interest by the number of "on" bits per image element. The length and width of the image area is computed in terms of image element cells as described above. For example, suppose the total image size is 6.0 inches wide(15cm) by 3 inches (7.5cm) high, the imager resolution is 5080 spots per inch, the target coverage by the particular pattern for the security image layer is 10%, and the image element cells include 33x33 or 1089 total pixels (see Fig. 4): 6.0 x 5080 x 3.0 x 5080 = 464,515,200 laser spot addresses 464,515,200 x .10 = 46,451 ,520 laser spots "on" to give 10% of the total laser spot addresses an "on" value. Our image element has 109 "set" spots per each image element (10% of 1089). 46,451 ,520 / 109 = 426,160 total image element cells Since the length of the document is twice the width, we compute the number of cells along the length and width as follows: c = the number of cells along the width and 2c = the number of cells along the length. 2c x 1c = 2c 2 = 426,160 cells "on" total c = 462 and 2c = 924 If we were using standard uniformly positioned, single size image elements, we would likely say that this array of cells is about a 154 line screen: 462 cells / 3 inches = 154 cells/inch 924 cells / 6 inches = 154 cells/inch. The resulting cells contain about 1089 addresses within the boundaries of the cell created in response to the required percent of area covered: 5080 / 154 = 32.987 or about 33 33 2 = 1089 laser spots per cell. Note that the cell size changes with the specified percent of area covered to permit different average placement of the given image element. In cases where rounding produces fractional cell sizes measured in laser spots, the procedure tracks the discrepancies and introduces a whole bit as needed to round the cells to integral values. This insures filling the total image area. Cell size, image element size, and percent of area covered, which strongly influences cell size, can all converge on values that severely limit image element placement or force element overlap or collision. Preferably, the program according to the present invention is designed to generate warnings for these unacceptable conditions. It is contemplated by the present invention that the total image area, i.e., the security image area 12 of Figs. 1 and 2, may occupy only a portion of a face of a security document and that the image area may be reproduced or "tiled" to occupy substantially the entire face of the security document. Such a "tiling" method would decrease the amount of computer memory required to create, modify, and otherwise process the pseudo-random image of the present invention and would likely decrease the time required to design a security document containing a pseudo-random image of the present invention. It is contemplated by the present invention that additional images of different cell sizes including additional image elements may be defined. These arrays can be set to cover the same image area. Preferably, rules are established that take into account the previously placed image elements and their "set" bits as well as the new ones to be placed, and permit the mixing of image elements of different sizes and shapes in the same area of interest. In principle, such a procedure can be repeated an arbitrary number of times to introduce numerous arrays of different size and shape image elements into the same image area. As will be appreciated by those practicing the present invention, the multiple array procedure works best with relatively light coverage resulting from fairly large spaces between image elements. Having described the invention in detail and by reference to preferred embodiments thereof, it will be apparent that modifications and variations are possible without departing from the scope of the invention defined in the appended claims.

Claims: CLAIMS 1. A method of preparing a security document comprising the steps of: designating a security image area on the face of a document; dividing said security image area into a plurality of image element cells, such that said image element cells define an array of image element cells across said security image area; dividing each of said image element cells into a plurality of pixels, such that each image element cell defines a cell pixel array; establishing a set of active image element cells, wherein said set of active image element cells defines a security image; positioning a pixel cluster within each of said active image element cells such that at least a portion of said pixel cluster is positioned within said active image element cell, wherein the position of said pixel cluster within each of said active image element cells is designated on a substantially random basis, and wherein each of said pixel clusters defines a predetermined image element; establishing a complementary security image within said security image area, wherein said complementary security image is formed by a set of predetermined complementary image elements; and printing a security document including printed areas corresponding to said predetermined image elements and said complementary image elements. 2. A method of preparing a security document as claimed in claim 1 wherein said step of positioning said pixel cluster further comprises the steps of: determining a separation distance between said pixel cluster and each adjacent pixel cluster; comparing said separation distance to a predetermined minimum separation value; and repositioning at least one of said pixel cluster and said adjacent pixel clusters on a substantially random basis where said separation distance is less than said predetermined minimum separation value. 3. A method of preparing a security document as claimed in claim 2 wherein said step of repositioning comprises repositioning said pixel cluster on a substantially random basis. 4. A method of preparing a security document as claimed in claim 2 wherein said step of repositioning comprises repositioning one of said adjacent pixel clusters on a substantially random basis. 5. A method of preparing a security document as claimed in claim 1 wherein said image element cells have equal dimensions. 6. A method of preparing a security document as claimed in claim 1 wherein each of said pixels have equal dimensions. 7. A method of preparing a security document as claimed in claim 1 wherein the dimensions of said pixels correspond to the resolution of an imager utilized in said printing step. 8. A method of preparing a security document as claimed in claim 1 wherein the resolution of said imager is at least approximately 5080 dpi and wherein each of said plurality of pixels has an area less than or equal to approximately a 1/5080" (0.005mm)square. 9. A method of preparing a security document as claimed in claim 1 wherein said active image element cells define a warning term. 10. A method of preparing a security document as claimed in claim 1 wherein said predetermined image element is selected from a group consisting of a dot, a square, a line, a circle, a star, a character, a word, a logo, and any other geometrical shape, or clusters of geometrical shapes, suitable for the construction of a security image. 11. A method of preparing a security document as claimed in claim 1 wherein said complementary security image portion occupies a portion of said security image area not occupied by said security image. 12. A method of preparing a security document as claimed in claim 1 wherein said security image and said complementary security image occupy common portions of said security image area. 13. A method of preparing a security document as claimed in claim 1 wherein said complementary security image surrounds said security image. 14. A method of preparing a security document as claimed in claim 1 wherein said complementary security image and said security image area bound said security image. 15. A method of preparing a security document as claimed in claim 1 wherein said complementary security image is established by: dividing said security image area into a plurality of complementary image element cells, such that said complementary image element cells define an array of complementary image element cells across said security image area; dividing each of said complementary image element cells into a plurality of pixels, such that each complementary image element cell defines a complementary cell pixel array; establishing a set of active complementary image element cells, wherein said set of active complementary image element cells defines said complementary security image; and positioning a complementary pixel cluster within each of said active complementary image element cells such that at least a portion of said complementary pixel cluster is positioned within said active complementary image element cell, wherein the position of said complementary pixel cluster within each of said active complementary image element cells is designated on a substantially random basis, and wherein each of said complementary pixel clusters defines a predetermined complementary image element. 16. A method of preparing a security document as claimed in claim 15 wherein said step of positioning said complementary pixel cluster further comprises the steps of: determining a separation distance between said complementary pixel cluster and each adjacent complementary pixel cluster; comparing said separation distance to a predetermined complementary pixel minimum separation value; and repositioning at least one of said complementary pixel cluster and said adjacent complementary pixel clusters on a substantially random basis where said separation distance is less than said predetermined minimum separation value. 17. A method of preparing a security document as claimed in claim 15 wherein said complementary image element is selected from a group consisting of a dot, a square, a line, a circle, a star, a character, a word, a logo, and any other geometrical shape, or clusters of geometrical shapes, suitable for the construction of a security image. 18. A method of preparing a security document as claimed in claim 15 wherein said image element cells have different dimensions than said complementary image element cells. 19. A method of preparing a security document as claimed in claim 15 wherein said image element cells have different dimensions than said complementary image element cells and wherein said pixels of said image element cells have the same dimensions as said pixels of said complementary image element cells. 20. A method of preparing a security document comprising the steps of: designating a security image area on the face of a document; dividing said security image area into a plurality of image element cells, such that said image element cells define an array of image element cells across said security image area; dividing each of said image element cells into a plurality of pixels, such that each image element cell defines a cell pixel array; establishing a set of active image element cells, wherein said set of active image element cells defines a security image; designating a primary image element pixel within each of said active image element cells, wherein the position of said primary image element pixel within each of said active image element cells is designated on a substantially random basis; constructing respective pixel clusters as a function of the respective positions of said primary image element pixels, wherein each of said pixel clusters defines a predetermined image element; establishing a complementary security image within said security image area, wherein said complementary security image is formed by a set of predetermined complementary image elements; and printing a security document including printed areas corresponding to said predetermined image elements and said complementary image elements. 21. A method of preparing a security document as claimed in claim 20 wherein said step of designating said primary image element pixel within each of said active image element cells further comprises the steps of: determining a separation distance between said primary image element pixel and each adjacent primary image element pixel; comparing said separation distance to a predetermined minimum separation value; and redesignating at least one of said primary image element pixel and said adjacent primary image element pixels within said active image element cell on a substantially random basis where said separation distance is less than said predetermined minimum separation value. 22. A method of preparing a security document as claimed in claim 21 wherein said primary image element pixel is redesignated within said active image element cell on a substantially random basis where said separation distance is less than said predetermined minimum separation value. 23. A method of preparing a security document as claimed in claim 20 wherein said primary image element pixel is included within said pixel cluster. 24. A method of preparing a security document as claimed in claim 20 wherein said complementary security image is established by: dividing said security image area into a plurality of complementary image element cells, such that said complementary image element cells define an array of complementary image element cells across said security image area; dividing each of said complementary image element cells into a plurality of pixels, such that each complementary image element cell defines a complementary cell pixel array; establishing a set of active complementary image element cells, wherein said set of active complementary image element cells defines said complementary security image; designating a primary complementary image element pixel within each of said active complementary image element cells, wherein the position of said primary complementary image element pixel within each of said active complementary image element cells is designated on a substantially random basis; and constructing respective complementary pixel clusters as a function of the respective positions of said primary complementary image element pixels, wherein each of said complementary pixel clusters defines said predetermined complementary image element. 25. A method of preparing a security document as claimed in claim 24 wherein said step of designating said primary complementary image element pixel within each of said active complementary image element cells further comprises the steps of: determining a separation distance between said primary complementary image element pixel and an adjacent primary complementary image element pixel; comparing said separation distance to a predetermined minimum separation value; and redesignating at least one of said primary complementary image element pixel and said adjacent primary complementary image element pixels within said active complementary image element cell on a substantially random basis where said separation distance is less than said predetermined minimum separation value. 26. A security document comprising: a security image area on the face of said document, wherein said security image area is divided into a plurality of image element cells, such that said image element cells define an array of image element cells across said security image area, and wherein each of said image element cells is divided into a plurality of pixels, such that each image element cell defines a cell pixel array; a printed security image within said security image area, wherein said printed security image comprises printed pixel clusters within respective ones of a set of active image element cells such that at least a portion of each printed pixel cluster is positioned within respective active image element cells, wherein each of said printed pixel clusters defines a predetermined image element, wherein said set of active image element cells defines said security image, and wherein said printed pixel clusters are positioned within each of said active image element cells on a substantially random basis; and a printed complementary security image within said security image area, wherein said printed complementary security image comprises a set of predetermined complementary image elements. 27. A security document as claimed in claim 26 wherein adjacent pixel clusters are positioned such that they are separated by at least a predetermined minimum separation value. 28. A security document as claimed in claim 26 wherein adjacent pixel clusters are positioned such that their respective centroids are separated by at least a predetermined minimum separation value. 29. A security document as claimed in claim 26 wherein said image element cells have equal dimensions. 30. A security document as claimed in claim 26 wherein each of said pixels have equal dimensions. 31. A security document as claimed in claim 26 wherein the dimensions of said pixels correspond to the resolution of an imager utilized to produce said security document. 32. A security document as claimed in claim 26 wherein the resolution of said imager is approximately 5080 dpi and wherein each of said plurality of pixels is approximately a 1/5080" square. 33. A security document as claimed in claim 26 wherein said active image element cells define a warning term. 34. A security document as claimed in claim 26 wherein said predetermined image element is selected from a group consisting of a dot, a square, a line, a circle, a star, a character, a word, a logo, and any other geometrical shape, or clusters of geometrical shapes, suitable for the construction of a security image. 35. A security document as claimed in claim 26 wherein said complementary security image portion occupies a portion of said security image area not occupied by said security image. 36. A security document as claimed in claim 26 wherein said security image and said complementary security image occupy common portions of said security image area. 37. A security document as claimed in claim 26 wherein said complementary security image surrounds said security image. 38. A security document as claimed in claim 26 wherein said complementary security image and said security image area bound said security image. 39. A security document as claimed in claim 26 wherein said security image area is divided into a plurality of complementary image element cells, such that said complementary image element cells define an array of complementary image element cells across said security image area, each of said complementary image element cells is divided into a plurality of pixels, such that each complementary image element cell defines a cell pixel array, said printed complementary security image comprises printed complementary pixel clusters within respective ones of a set of active complementary image element cells such that at least a portion of each printed complementary pixel cluster is positioned within respective active complementary image element cells, each of said printed complementary pixel clusters defines a predetermined complementary image element, said set of active complementary image element cells defines said complementary security image, and wherein said printed complementary pixel clusters are positioned within each of said complementary active image element cells on a substantially random basis. 40. A security document as claimed in claim 39 wherein adjacent complementary pixel clusters are positioned such that they are separated by at least a predetermined minimum separation value. 41. A security document as claimed in claim 39 wherein adjacent complementary pixel clusters are positioned such that their respective centroids are separated by at least a predetermined minimum separation value. 42. A security document as claimed in claim 39 wherein said complementary image element is selected from a group consisting of a dot, a square, a line, a circle, a star, a character, a word, a logo, and any other geometrical shape, or clusters of geometrical shapes, suitable for the construction of a security image. 43. A security document comprising: a security image area on the face of the document, wherein at least a portion of said security image area is divided into a plurality of image element cells, such that said image element cells define an array of image element cells across said security image area, each of said image element cells is divided into a plurality of pixels, such that each image element cell defines a cell pixel array, at least a portion of said security image area is divided into a plurality of complementary image element cells, such that said complementary image element cells define an array of complementary image element cells across said security image area, and wherein each of said complementary image element cells is divided into a plurality of pixels, such that each complementary image element cell defines a cell pixel array; and a printed security image within said security image area, wherein said printed security image comprises image elements and complementary image elements, said image elements are positioned uniformly with respect to said array of image element cells and substantially randomly with respect to said pixels within each of said image element cells, and said complementary image elements are positioned uniformly with respect to said array of complementary image element cells and substantially randomly with respect to said pixels within each of said complementary image element cells. 44. A security document as claimed in claim 43 wherein said image elements are positioned such that they are separated by at least a predetermined minimum separation value. 45. A security document as claimed in claim 43 wherein said image elements are positioned such that their respective centroids are separated by at least a predetermined minimum separation value. 46. A security document as claimed in claim 43 wherein said complementary image elements are positioned such that they are separated by at least a predetermined minimum separation value. 47. A security document as claimed in claim 43 wherein said complementary image elements are positioned such that their respective Centroids are separated by at least a predetermined minimum separation value. 48. A security document processing system comprising a document issuing station, at least one document receiving station, and a security document comprising: a security image area on the face of the document, wherein at least a portion of said security image area is divided into a plurality of image element cells, such that said image element cells define an array of image element cells across said security image area, each of said image element cells is divided into a plurality of pixels, such that each image element cell defines a cell pixel array, at least a portion of said security image area is divided into a plurality of complementary image element cells, such that said complementary image element cells define an array of complementary image element cells across said security image area, and wherein each of said complementary image element cells is divided into a plurality of pixels, such that each complementary image element cell defines a cell pixel array; and a printed security image within said security image area, wherein said printed security image comprises image elements and complementary image elements, said image elements are positioned uniformly with respect to said array of image element cells and substantially randomly with respect to said pixels within each of said image element cells, and said complementary image elements are positioned uniformly with respect to said array of complementary image element cells and substantially randomly with respect to said pixels within each of said complementary image element cells.

Inventors: FLEDDERMAN ALBERT J, MOWRY WILLIAM H JR, FLEDDERMAN, ALBERT, J., MOWRY, WILLIAM, H., JR.
Applicants: STANDARD REGISTER CO, THE STANDARD REGISTER COMPANY
Application year: 1999
Main classification: B41M3
IPC codes: B41J21, B41M3, H04N1