Abstract:
An apparatus and method for automatically merging multiple image portions to produce a single image. Image portions are produced, such as by a hand-held scanner, with overlapping areas. The overlapping area of a first image portion is examined to determine a distinguishing feature. The overlapping area of the second image portion is then searched to locate the corresponding feature. The differences in alignment of the two features, such as rotation, expansion or compression, are then determined. One of the image portions is then rotated, compressed or expanded in the amount necessary to align the two images. The two images are then merged by eliminating the overlapping portion of one of the images.

Description:
This is a Continuation of application Ser. No. 07/805,448 filed Dec. 10, 1991, now abandoned. 
    
    
     COPYRIGHT NOTICE 
     A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure as it appears in the Patent and Trademark Office, patent file or records, but otherwise reserves all copyrights whatsoever. 
     BACKGROUND OF THE INVENTION 
     The present invention relates generally to the field of computer graphics and, more particularly, to methods and apparatus for merging graphic images. 
     Computers have become a powerful tool for the rapid and economic creation of pictures, and are particularly well suited for drafting and publishing tasks. For drafting, computer-aided design or &#34;CAD&#34; has found wide application. Instead of pen and paper, the CAD user employs a computer with a pointing device (typically a mouse, light pen, digitizer tablet, or the like) to create an electronic description of a drawing in the computer&#39;s memory. 
     For publishing, desktop publishing or &#34;DTP&#34; has become the standard. In DTP, both text and graphic images are manipulated on a computer screen, much as they are in CAD. In either system, when the user is satisfied with the drawing, he or she obtains a &#34;hard copy&#34; by sending the stored image to an output device, such as a laser printer or plotter. 
     In working with graphic images, it is often desirable to &#34;acquire&#34; images and represent them in a computer. For example, a DTP user may wish to import a photograph into a newsletter. Before an image is available to the user, however, it must be converted to a format which the computer may interpret. 
     Thus, the process of entering images into a computer requires that an electronic description be generated. There are two basic approaches to describing images: vector objects and bitmaps. Vector objects are mathematical descriptions of an image. For example, a line may be described by its starting and ending points. A circle may be described by its center and radius. Of particular interest to the present invention, however, are bitmap images. 
     In bitmaps, an image is described as a two dimensional array of bits or pixels (picture elements). By arranging combinations of black and white pixels (0 and 1 bits), a monochromatic image may be reproduced. This technique is commonly employed to reproduce images for newspapers and magazines. Bitmaps are almost always rectangular, and if the image itself is not rectangular, then the image must be rendered with a &#34;mask&#34; bitmap that defines the shape of the image. 
     While the bulk of a bitmap comprises the bits themselves, header information is also necessary to define how the bits are interpreted. This includes the height and width of the bitmap (expressed in number of pixels) and color information. In a monochromatic bitmap, one bit in the bitmap corresponds to one pixel on the display. A color bitmap requires multiple bits per pixel. In this case, the header information describes how the multiple bits correspond to particular colors. There are multiple file formats for storing bitmaps. Examples include ZSoft&#39;s PC Paintbrush (PCX), CompuServe&#39;s Graphics Interchange Format (GIF), and Microsoft&#39;s Tagged-Image File Format (TIFF). 
     Because bitmaps are used to store real-world images, they usually enter a computer through a scanner or a video frame grabber. A scanner converts a photographic image into a bitmapped data file; similarly, a frame grabber converts a video signal (from a video camera or VCR) to a bitmapped data file. Bitmaps can also be created by hand using computer &#34;paint&#34; programs, such as Microsoft&#39;s Windows™ Paintbrush program. Once converted into a bitmap, an image may be transferred to other computers in the same manner as other binary files (e.g., via magnetic media or modem). 
     Scanners, which are probably by far the most popular means for importing images, employ a light source and photodetectors to &#34;read&#34; or &#34;scan&#34; images into a computer. Two basic types are available: flatbed and handheld. The general construction and operation of each will now be briefly described. 
     Flatbed scanners look and operate very much like an ordinary photocopier. First, the user places an image to be scanned upon the flatbed (flat glass). Next, the scanner is activated, e.g., by pressing a button. The image is then scanned by a light source. Instead of generating a photocopy, however, the scanner focuses the image onto photodetectors which produce binary data representative of the image. Upon completion of the scan, the data are stored on a computer disk as a binary file, typically in one of the aforementioned bitmap file formats. The data file is now available to the user for use in application software, such as desktop publishing packages, paint programs, and the like. 
     In &#34;handheld&#34; scanners, on the other hand, substantially all of the scanning system is housed within a single handheld unit. Instead of placing an image to be scanned on a glass surface, as one would do with a photocopier or flatbed scanner, the image is laid face up on a flat surface, typically a desktop. The scanner, which includes a roller or wheels, is dragged across the surface of the image. The image is then recorded in a manner similar to that for flatbed systems. 
     While scanners allow for the easy importation of a variety of images, they have a significant limitation. Scanners, particularly handheld models, have a limited scanning area or &#34;window&#34; for accommodated materials to be scanned. If the image to be scanned is larger than the viewing window of the scanner, then the image cannot be captured in a single operation. In this instance, the desired image must be scanned as a series of multiple strips, i.e., portions which are small enough to fit within the viewport of the scanner. After scanning all the strips, the image may be reconstructed within the computer by manually &#34;stitching&#34; the strips back together (as described hereinbelow). 
     Before a user may stitch strips back together, other problems must be overcome. In particular, the hand scanner&#39;s reliance upon the human hand as a means for moving the unit across a source image creates artifacts. For example, strips obtained from the same image will typically have different lengths. Moreover, the geometric orientation between strips often differ in horizontal alignment (X translation), vertical alignment (Y translation), rotation, and the like. In addition, one or more strips may undergo varying rates of uniform compression and/or expansion, depending on how fast or slow the user has moved the scanner across the image. To faithfully reproduce the source image, therefore, these artifacts must be eliminated or minimized. 
     Even if the difficulty of artifacts is overcome, the process of stitching strips together to form the original image is cumbersome. For example, a common technique for stitching strips together requires the user to &#34;eyeball&#34; (i.e., judge with one&#39;s eyes) the alignment between the bitmap strips. The technique is far from perfect, however, as this requires an elaborate trial and error technique to obtain an acceptable image. In addition, the current process does not correct for the difference in documents or images because of &#34;stretching&#34; (transformation) due to a fast scanning speed. Moreover, the user must often manually correct for vertical skewing (rotation) of each image strip. Routinely, the user obtains a bitmap where the intersections of the strips (i.e., the stitched areas) appear rough and misaligned. 
     Another technique requires the use of registration marks, i.e., marks that are added to the source image that allow the software to find the marks and merge the image. The marks are generally added to an image by scanning the image with a transparency having the marks overlaid on the image. The software then finds the marks and attempts to merge the images based upon the location of the marks. Another technique employs a plastic grid to aid the user in scanning images in strips in a more consistent manner. However, none of these techniques are transparent to the user, nor are they fully automated. Moreover, these techniques rely heavily on the dexterity of the individual user in aligning images or adding registration marks to the image that the software can find and use to merge the images. The results are almost always less than satisfactory. 
     Thus, it is desirable to provide a system and methods which automatically align bitmap images with minimum user effort. Moreover, the methods employed should achieve precise alignment between two or more images--precision that cannot be achieved by manual positioning techniques alone. The present invention fulfills this and other needs. 
     SUMMARY OF THE INVENTION 
     Computers have found wide application for the creation and editing of drawings or graphic images. A particularly easy technique for creating images is to scan a drawing into a computer using one of the commercially available scanners. Because scanning devices, particularly handheld scanners, have a limited viewport or viewing window for obtaining images, prior art systems had required the computer user to expend significant effort and time manually piecing or stitching scanned images together for those images which do not fit within the viewport. 
     According to the present invention, a method for automatically merging images on a computer system includes acquiring first and second image strips; locating at least one feature in the first image strip; locating this feature in the second image strip; and merging the two image strips into a single image, based on the matched features. Additional strips may be acquired and merged as desired. For better results, a plurality of features are matched between the image strips. 
     A system for automerging images, constructed in accordance with the principles of the present invention, includes a computer having a memory and a processor; a scanner for acquiring an image as a series of image strips; means for locating at least one feature in the first image strip; means for locating this feature in the second image strip; and means for merging the two image strips into a single image by aligning the two features. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIGS. 1A-C illustrate the process of acquiring and merging bitmaps using manual techniques. 
     FIGS. 1D-F illustrate artifacts which are common in merged bitmaps. 
     FIG. 2 is a block diagram of a computer system in which the present invention may be embodied. 
     FIGS. 3A-B illustrate a window interface or work surface of the present invention for manipulating images. 
     FIG. 3C illustrates a scan mode panel of the present invention. 
     FIG. 4 is a flow chart of the Automerge method of the present invention. 
     FIGS. 5A-B are a flow chart of the M --  MergeFind method of the present invention. 
     FIGS. 5C-D illustrate the process of sampling pixel blocks from a select region. 
     FIG. 6A is a flow chart of the Autocorrelate method of the present invention. 
     FIG. 6B illustrates the movement of pixels during the Autocorrelate method. 
     FIG. 7 is a flow chart of the M --  MergeMatch method of the present invention. 
     FIGS. 8A-B are a flow chart of the Coarse/Fine Correlation of the present invention. 
     FIGS. 9A-B are a flow chart of the Rank --  Features method of the present invention. 
     FIGS. 9C-E illustrate the pairing of features and matches within each image strip. 
     FIGS. 9F-G illustrate the calculation of stretching between image strips. 
     FIGS. 9H-I illustrate the calculation of multiple regions of compression and/or expansion between image strips. 
     FIG. 10A is a flow chart of the Calculate Dimensions method of the present invention. 
     FIGS. 10B-C illustrate the calculation of rectangles and matrix operations for merging. 
     FIG. 11 is a flow chart of the M --  MergeImage method of the present invention. 
    
    
     DESCRIPTION OF THE PREFERRED EMBODIMENT 
     Introduction 
     Referring now to FIGS. 1A-F, a conventional technique for merging a plurality of image strips will be described. If the image strips are not already digitized as a bitmap, then the strips must first be acquired. As shown in FIG. 1A, for example, a source bitmap image 5 may be acquired by scanning with a handheld scanner 105. Since image 5 is wider than the maximum width W of scanner 105, however, it cannot be acquired in a single pass. In particular, an area C, which beyond the viewing window of the scanner 105, will be cropped. Thus, the image must be scanned as two separate strips. Typically, the first strip will occupy the entire width W of scanner 105; the second strip will include the area cropped C as well as a small overlap region O. 
     As shown in FIG. 1B, two image strips 10, 20 are obtained (in separate operations) from the single image 5. Image strip 10 has a width of W (the maximum width of the scanning window), with the portion of the image 10 which lies outside of this effective area being cropped. Thus, the user must obtain an additional strip, such as the strip 20, which includes the portion of the source image which was cropped C as well as an overlapping region O. For simplification, image strips 10, 20 are shown without skewing, compression, and/or expansion artifacts, which typically will be present in images obtained with a hand scanner. 
     With particular reference to FIGS. 1C-F, the merging of image strips 10, 20 will be described. As shown in FIG. 1C, one image strip (e.g., strip 20) is moved towards the other. Typically, the user first selects a stitching (or similar) mode. Next, a special cursor, such as cursor 22, is displayed to assist the user in the operation. In response to user-generated signals, one image strip (e.g., strip 20) is moved or &#34;dragged&#34; in a direction 15 towards the other image strip (e.g., strip 10); the signals may be supplied by a pointing device (e.g., a mouse) moving the cursor 22 in a desired direction. In this manner, signals from the pointing device are used to move or translate the image strip 20 towards the image strip 10. 
     Referring now to FIG. 1D, the completed image 30 is shown. Image 30 is a single image, such as a bitmap, which results from the merging of strips 10, 20 (at intersection I). While the image is a fair reproduction of the original, it is misaligned at the intersection I of the two image strips. As shown in FIGS. 1E-F, the misalignment within the image can best be seen from enlarged sections 31, 35 (taken from FIG. 1D). In section 31, for example, the intersection I of the strips is misaligned at point 32. Additional alignment artifacts are shown in section 35 where misalignment occurs at points 36, 37, 38. 
     For purposes of illustration, the foregoing example has been confined to simple translational artifacts--in this case, horizontal (X) translation of one strip relative to another. In addition to translation artifacts, however, the strips used to reconstruct a single image will often have undergone a complex combination of other transformations, including skewing, compression, and/or expansion artifacts. Hence, merging images by conventional techniques routinely yields unsatisfactory results. 
     Preferred Embodiments 
     1. Acquisition of images 
     The invention may be embodied on a computer system such as the system 100 of FIG. 2, which comprises a central processor 101, a main memory 102, an I/O controller 103, a screen or display 104, a scanner 105, a mass storage device 106, a keyboard 107, a pointing device 108, and an output device 109. The various components of the system 100 communicate through a system bus 110 or similar architecture. 
     In operation, the user enters commands through keyboard 107 and/or pointing device 108, which may be a mouse, a track ball, a digitizing tablet, or the like. The computer displays text, graphic images, and other data through screen 104, such as a cathode ray tube. A hard copy of the image may be obtained from output device 109, which is typically a printer or a plotter. In a preferred embodiment, an appropriately programmed IBM PC-compatible personal computer (available from International Business Machines, Corp. of Armonk, N.Y.) is used running under MS-DOS and Microsoft Windowsυ (both available from Microsoft, Corp. of Redmond, Wash.). 
     In this interactive computer system, the user acquires graphic images from a variety of sources. Common sources includes input devices (e.g., scanner), software (e.g., paint programs), disk files (e.g., TIFF, PCX, and GIF formats), and the like. In typical operation, images are acquired with the scanner 105, which may be either a flatbed or handheld scanner. Scanners suitable for use as the scanner 105 are available from a variety of vendors; in a preferred embodiment, scanner 105 is a ScanMan™ 256, available from Logitech Corp. of Fremont, Calif. Once entered into the computer 100, an image is stored as a bitmapped graphic and, thus, may be represented in the computer&#39;s memory 102. 
     Referring now to FIG. 3A, the system 100 provides a window or workspace 120 for display on screen 104. Window 120 is a rectangular, graphical user interface, running in Microsoft Windows™, for viewing and manipulating graphic images. Window 120 contains a plurality of menus 140, 150, 160, each having submenus and software tools for use on graphic images. Of particular interest to the present invention is an Acquire tool 151, which is available from menu 150. Window 120 also includes a client area 130 for displaying images, such as the bitmapped graphic image 131. 
     Referring to FIG. 3B, the operation of window 120 for acquiring a graphic image will now be illustrated. The user initiates the image acquisition, for example, by selecting the Acquire option 151 from the menu 150 of FIG. 3A. In response, the system 100 displays a scanning window 220. Window 220 includes interface components or resources, such as a scanning preview window 230, a ruler bar 250, a scan mode panel 240, radio buttons 260, dialogue buttons 280, and a status line 270. 
     Next, the user selects a &#34;scan mode&#34; from panel 240 which indicates the type (i.e., single or multiple strips) and orientation (i.e., portrait or landscape) of the image to be scanned. As shown in detail in FIG. 3C, panel 240 includes a plurality of icons arranged into two rows: single-strip scan 241 and multiple-strip scan 245. From single-strip scan 241, the user may select from a variety of single-strip modes, including 1) single-strip portrait 242 (top-to-bottom), 2) single-strip landscape 243 (left-to-right), and 3) single-strip landscape 244 (right-to-left). Similarly, from multiple-strip scan 245, the user may select from 1) multiple-strip portrait 246 (top-to-bottom), 2) multiple-strip landscape 247 (left-to-right), and 3) multiple-strip landscape 248 (right-to-left). 
     A particular advantage of the user interface provided by the scan mode panel 240 is efficiency of user input. Specifically, a variety of different images (e.g., single or multiple, portrait or landscape, and the like) may be acquired as a single operation. For example, to acquire an image as two vertical strips the user need only select multiple-strip portrait 246, scan the first strip, select stop (not shown), scan the second strip, and select Done (from buttons 280). 
     Other scanning parameters may also be set at this point. The viewing width W of the scanner may be shortened, for example, by selecting positions on the ruler bar 250. Additional scanning parameters (e.g., grey scale or line art) may be entered by activating the &#34;Options&#34; button of buttons 280. If no parameters are specified by the user, however, system 100 will assume default values (e.g., single scan of line art). 
     Next, the user actually scans the source image by activating the scanner 105, typically by pressing a button or switch device located on the scanner. Upon activation, the scanner 105 is ready to capture or acquire the source image; thus at this point, the user drags the scanner 105 across the source image in a smooth and continuous motion. Immediate user feedback is provided by preview window 230 which displays the acquired image in real-time. 
     On completion of the scan, the user selects &#34;Done&#34; from the buttons 280, typically by pressing the &#34;D&#34; key or selecting the button with the pointing device. At this point, the acquired image is stored in memory 102. If the user is not satisfied with the acquired image shown in window 230, the user may select &#34;Rescan&#34; from the buttons 280 and repeat the scanning process. Otherwise, the image will typically be saved to non-volatile storage 106 as a bitmap (e.g., TIFF) file. After two or more image strips have been acquired, the source image may be reconstructed by automerging techniques of the present invention. 
     2. Automerge: Automatic merging of images 
     The following description will focus on the automerging of two bitmap image strips obtained by a handheld scanning device. However, the present invention is not limited to such image formats or devices. Instead, a plurality of image strips having any one of a number of image formats (including both bitmap and vector formats) may be automatically merged in accordance with the present invention. Additionally, the image strips may be entered into the system 100 in a variety of formats (e.g., vector formats) and by a variety of means (e.g., file transfers, paint programs, and the like). 
     a. General operation 
     The automerging of images in accordance with the present invention will now be described. In an exemplary embodiment, system 100 operates under the control of an Automerge routine to combine two or more image strips together to recreate the source image. The routine, which is typically loaded into memory 102 from storage 106, instructs or directs processor 101 in the automatic merging of the image strips. 
     In a preferred embodiment, the Automerge routine is implemented in a message-passing environment (e.g., Microsoft Windows™); thus, the routine is invoked in response to events received from an event handler. The dispatching of messages in an event-based system such as Microsoft Windowsυ, is known in the arts; see, e.g., Petzold, C., Programming Windows, second edition, Microsoft Press, 1990, the disclosure of which is hereby incorporated by reference. Upon invocation, the Automerge routine will invoke or call (directly or indirectly) additional routines, including M --  MergeFind, Autocorrelate, M --  MergeMatch, Coarse/Fine Correlation, Rank --  Features, Calculate Dimensions, and M --  MergeImage routines. 
     Referring now to FIG. 4, the general operation of the Automerge routine 400 is illustrated by a flow chart. In step 401, the image strips (usually two at a time) are obtained. Typically, the image strips are obtained as bitmaps by hand scanning a source image (as previously described). 
     In step 402, system 100 is initialized for merging images. In particular, data structures are initialized in memory 102 for processing the images. For purposes of illustration, each image may be defined by the following record (struct), written in the C programming language: 
     
         ______________________________________    Typedef struct {        short Width, Height;        IMAGECLASS Class;        FPGETLINE Getline;        short Handle;    } IMAGEINFO;______________________________________ 
    
     where Width and Height specify the dimensions of the image; Class, an enumerated variable of type IMAGECLASS, specifies whether the image is bilevel, grayscale, or color; GetLine is a pointer to a function which returns (via a pointer to a buffer) the pixel data for a single line in the image; and Handle serves as a handle or index of the image. 
     In step 403, a &#34;feature extraction&#34; is performed for the first strip by the M --  MergeFind routine (described hereinbelow in FIG. 5), which extracts two or more distinct features of interest from an area of the first strip which overlaps with the second strip (e.g., overlap O from FIG. 1). The method finds distinct areas or &#34;features,&#34; i.e. those areas which have the most amount (highest score) of &#34;uncorrelation&#34; in a given or surrounding neighborhood. To improve automerging, groups of features are sought in different areas of the first strip. Ideally, the features should be unique within the search area of the strip. The technique may be customized for a particular class of images (e.g., gray scale or bilevel line art). For example, the actual number of features, the area and number in the strip for the features to be searched, and the size of a feature are all parameters that can be customized to the image type. 
     In step 403, features found in the extraction step (i.e., from the overlapping area of the first strip) are located or detected in the second strip by the M --  MergeMatch routine (described hereinbelow in FIG. 7). For detection, the routine employs a sequential similarity detection algorithm (SSDA)--an optimized variant of normalized correlation or pattern matching--which is known in the art. For each group of features found in the first strip, M --  MergeMatch seeks a matching group in the second strip. Each feature/match pair is given a score describing how well it matches, how unique the match is, and how far apart a match has occurred (between first set and second set of pairs). The pairs with the best scores will be used in step 404 to perform the actual merging of image strips. 
     In step 404, the geometry of the second strip is normalized to the geometry of the first strip. Specifically, using the best features extracted from the first strip and the corresponding best matches in the second strip, the second strip is transformed into the geometry of the first strip. Exemplary transformations of the second strip include rotation, compression or expansion, shearing, and the like. 
     Finally, in step 405, the two image strips are merged together by the M --  MergeImage routine. The basic process includes mapping the second strip (now normalized) into the first strip. The actual mapping is accomplished by matrix transformations (set forth in further detail hereinbelow). At the conclusion of step 405, the merged image is displayed in client area 130 (of FIG. 3A). 
     b. Specific operation 
     Referring now to FIGS. 5-11, the individual components of the Automerge method will now be described in further detail. In FIGS. 5A-B, the M --  MergeFind method or routine 500 is represented by a flow chart. The routine is invoked with an image strip, a list of regions, and a number of features to find in each region N. The method returns a list of features (as Feature --  List). 
     The individual steps of the method are as follows. In step 501, a loop is established to examine each region in the list for features. As shown in FIGS. 5C-D, a region R is an area, typically a rectangle, defined within the overlap area. If an additional region to be examined exists at step 501, then at step 503 a threshold, a sorting list, and a feature list are initialized. The threshold is a minimum score for a feature. If an area under examination has a score below the threshold, the area will not be retained for further examination. While the threshold is initially set to a preselected value, the threshold will typically be adjusted upward, during runtime, to be no less than the score of features already found. The sorting list is a local data structure, typically implemented as a linked list. As features are located, they are stored, according to rank, in the sorting list. In a preferred embodiment, the sorting list has a finite limit of, for example, four members. Thus, features having a low score are automatically excluded. After examining a given region, the sorting list will contain the best (i.e., highest scoring) features located. By appending the sorting list to the feature list, the best features within each region are identified. Once all regions have been examined (no at step 501), then the method concludes by returning the feature-list at step 502. Otherwise, the method continues on to step 504. 
     At step 504, the search for features in a region begins by setting the block coordinates to the top left position of the region. In step 505, a block of data is retrieved from the first strip based on the width and height of the feature (Feature --  Width and Feature --  Height). This determines the bounds of a region, which will typically define a square sample block S (of FIGS. 5C-D). In a preferred embodiment, the sample block S is a 16×16 array of pixels. However, any convenient array size may be employed. In addition, the region may be divided into smaller rectangular regions (the size of a feature) to determine if it is a good feature (i.e., a good match). 
     In step 506, the Autocorrelate routine (described in further detail hereinbelow) is invoked to determine a score or Autocorrelate index for a given sample block. The method determines the &#34;uniqueness&#34; of the feature in a sample block by a series of image move and difference operations. If in step 507, the Autocorrelate index is greater than the threshold, the method stores the block position and index in the sorting list at step 510. If the sorting list is full at step 511, then the method removes the block with a smaller index at step 512 and resets the threshold to the minimum index in the list at step 513. After step 513, the method continues on to step 508 to move the block coordinates to the right; the method also proceeds directly to step 508 when the autocorrelate index is less than the threshold (i.e., no at step 507). At step 508, the method moves the block coordinates to the right, i.e., gets the next sample block. 
     In step 509, if the right limit (i.e., the right edge) of the region has been reached, then the block coordinates for the image strip are moved downward at step 514. Otherwise (no at step 509), the method loops to step 505 and continues as before. At step 515, the image is tested to determine whether the bottom limit (i.e., bottom edge) of the region has been reached. If the bottom limit of the region has not been reached (no at step 515), then the method loops back to step 505 and continues. However, if the edge has been reached (yes at step 515), then at step 516 the sorting list is appended to the feature list and the method loops back to step 501 to begin examination of the next region. 
     Referring now to FIGS. 6A-B, the Autocorrelate method, which is called in step 506 above, is illustrated. In the Autocorrelate method 600, a sample block of the image is examined to determine if it is a feature. This is determined by taking correlations of a sample block with a version of the block which has been moved. Each individual correlation must be larger than the current correlation threshold. 
     The individual steps of the method 600 will now be described in turn. In step 601, the current image block under examination is copied to a temporary data structure, such as a temporary array. In step 602, the data in the block array is shifted or moved downward, as illustrated by block 651 of FIG. 6B. In step 603, an index or score of correlation is determined from the absolute value of the subtraction of the shifted version from the original. The operation may be summarized by the following equation: ##EQU1## where x and y represent the horizontal and vertical coordinates, respectively, for a given point in the block. 
     In step 604, if the index is not less than the threshold, then in step 605 the data in the array is shifted to the right, as shown by block 652 of FIG. 6B. However, if the index is less than the threshold (yes at step 604), then the method concludes. After step 605, the index is calculated in step 606 by again determining the difference between the shifted version of an image block from the original block: ##EQU2## 
     In step 607, again the index is tested to determine whether it is less than the threshold; if it is not, then in step 608 the data and the array is shifted upward, as shown by block 653 of FIG. 6B. Otherwise (yes at step 607), the method concludes. After step 608, the index is again calculated in step 609 as follows: ##EQU3## In step 610, the block is again shifted upward (block 654 of FIG. 6B) and the index calculated. In essence, step 610 repeats steps 607-609. Additional correlation operations (e.g., block 655), may be performed, as desired. In step 611, the index is returned. 
     Referring now to FIG. 7, the M --  MergeMatch method or routine 700 is illustrated. In this method, for each feature found in the right strip, a corresponding feature is sought in the left strip. A list of matches in the second strip is then returned. Each step will now be described in further detail. 
     In step 701, a loop is established to examine all features in the Feature --  List (i.e., the features returned from the first strip). If an additional feature exists, then in step 702 an estimate is made as to the position of a match in the second strip (based on the position of the feature in the first strip). In step 703, the size and position of the region to search is calculated based on the estimated position of the match. 
     In step 704, a bitmap of the feature of interest (from the first strip) is obtained. In step 705, the feature is filtered (e.g., by a low-pass filter) to smooth out its features. In step 706, a coarse correlation is made by invoking the Coarse Correlation method (set forth hereinbelow), which returns the best matches of the region using a subsample version of the feature under examination. Unlike a Fine Correlation method (described hereinbelow), the Coarse Correlation method only examines a select number of pixels (e.g., every other pixel). 
     In step 707, another loop is established to examine all coarse matches found (by the previous step). If another coarse match exists at step 707, then in step 708 a small region is defined around the match, and in step 709 the true position of the match is determined by calling the Fine Correlation method. 
     After fine correlation, the method loops back to step 707 for additional coarse matches. However, if another coarse match does not exist at step 707, then the method continues to step 710 where the best match (and associated features) is stored in a Match --  List. The method then loops back to step 701 to process another feature. If an additional feature does not exist at step 701, however, then the method continues on to 711 where the features are ranked by the Rank --  Features method (described hereinbelow). In step 712, the dimensions of the M --  MergeImage are calculated and the method then concludes. 
     Referring now to FIGS. 8A-B, the Coarse/Fine correlation method 800 is illustrated by a flow chart. In the method 800, for a given feature and a given region of the second strip, a list of N best matches is returned, with the correlation performed at either coarse or fine resolution. As such, the operation of the method is very similar to that of the Auto-Correlation method. Instead of correlating an image block with a version of itself, however, method 800 seeks to correlate a feature from the first strip with an image block in the second strip. The steps of the method will now be described in detail. 
     In step 801, threshold and Sorting List data structures (previously described) are locally initialized. At step 802, the block coordinates for the strip are set to the top left position of the region. At step 803, the size of the second strip is determined. In step 804, if a coarse correlation is desired, then in step 805 a subsample block and feature bitmap are obtained. Otherwise (no at step 804), step 805 is skipped. At step 806, index is calculated from the equation: ##EQU4## 
     At step 807, if the index is less than threshold, then in step 808 the block is moved to the right. Otherwise (no at step 807), the procedure jumps to step 813 (shown in FIG. 8B). 
     In step 813, the block position and index are stored in the Sorting --  List. In step 814, if the list is full, then the method continues on to steps 815 and 816. If the list is not full however, then the procedure continues on to step 808. In step 815 the block with the biggest index is removed from the list. In step 816 the threshold is calculated from the maximum indices in the list. After step 816, the method jumps back to step 808. 
     In step 808, the block is moved to the right. At step 809, the block is tested to determine whether it is at the right limit of the region. If it is, then the block is moved to the right at step 810; otherwise (no), the method returns back to step 802. At step 811, if the right limit of the region has been reached, then the method returns the sorting list at step 812 and then concludes. If the right limit has not been reached (no at step 811), then the method loops back to step 802. 
     Referring now to FIGS. 9A-B, the Rank --  Features method 900 is illustrated. In general, for a given list of features and a list of corresponding matches, the method returns the best pair of feature/match combination. 
     The steps of the method will now be described in further detail. In step 901, the features are grouped in pairs. As shown in FIGS. 9C-E, for example, possible pairs for the left strip include L1/L2, L1/L3, L2/L3, and so forth. In step 902, a loop is established for all pairs. If an additional pair exists in 902, then in step 903 the distance between members of the pair is determined. For example, for feature pair L1/L2 and match pair R1/R2, the distance may be determined: 
     
         % F.sub.Dist =|L1-L2|                    (5) 
    
     
         % M.sub.Dist =|R1-R2| 
    
     In step 904, if either distance is less than a preselected minimum, then the method loops back to step 902. Otherwise, the method continues on to step 905 to determine theta--the angle between a line joining feature pairs and a line joining match pairs. In step 906, if theta is greater than a preselected maximum angle (i.e., the maximally allowed angle), then the method loops back to step 902 to examine another pair. If not, however, the method continues on to step 907 to get the stretch (i.e., compression and/or expansion transformation of one strip relative to another), which is determined from feature and corresponding match pairs as follows: ##EQU5## 
     Referring to FIGS. 9D-E, the operation of determining stretch between strips is graphically shown. In FIG. 9F-G, the right strip is expanded or stretched relative to the left strip. The exact amount of stretch may be determined by the ratio of F DIST  to M DIST . The amount of stretching between images may not be constant, however. Therefore, as shown in FIGS. 9H-I, compression and/or expansion is measured at several locations of the image strips. From this information, areas may be selectively corrected for stretching. 
     In step 908, if stretch is greater than the maximum stretch, then the method loops back to step 902. Otherwise, the method continues on to step 909 to store the pair information in a Pair --  List. After step 909, the method loops back to step 902 to process additional pairs. 
     After all pairs have been processed (i.e., no at step 902), the method continues on to step 910 to calculate the mean and standard deviation of theta and stretch in the Pair --  List. In step 911, stretch values in the Pair --  List are normalized according to the obtained standard deviation of theta. In step 912, a loop is established to examine all pairs of the Pair --  List. If an additional pair remains at step 912, then the method continues on to step 913 to determine the distance between a pair and population mean in (theta, stretch) plane. 
     In step 914, if distance is greater than the computed standard deviation, then the method loops back to step 912 to examine another pair in the Pair --  List. Otherwise (no at step 914), the pair is removed from the Pair --  List at step 915, after which the method loops back to step 912. 
     If no more pairs remain to be examined in step 912, the method jumps to step 916 to rank the pairs in the Pair --  List. This ranking is based on the closeness of a pair to the center of the population and correlation index. In step 917, the two features and matches which comprise the best Pair --  List are returned, and the method concludes. 
     Referring now to FIGS. 10A-C, the Calculate Dimensions method 1000, which is invoked in step 712, is illustrated. For two features, their associated matches, and the bounding rectangles of two image strips (first strip and second strip), the method calculates the dimensions of the merged image. The method assumes that Automerge corrects only for rotation, stretching, and translation transformations. Those skilled in the art will appreciate that other transformations may be accommodated within the scope of the present invention. The steps of the method 1000 will now be described. 
     In step 1001, the coordinates of two points in strip one, which, together with the two features form a rectangle of arbitrary width (Rect1 of FIG. 10B) are calculated. In step 1002, a corresponding rectangle (Rect2 of FIG. 10B) is calculated for strip 2. In step 1003, for the two rectangles (Rect1 and Rect2) a projective affine transformation matrix is determined. 
     In step 1004, a third rectangle (Rect3 of FIG. 10C) is calculated from an outline of strip 2. In step 1005, a fourth rectangle (Rect4 of FIG. 10C) is calculated from a bounding rectangle of Rect3. In step 1006 the biggest rectangle, derived from Rect4 and the bounding rectangle of strip 1, is returned. 
     Referring now to FIG. 11, the M --  MergeImage method 1100 is illustrated. For two image strips (strip 1 and strip 2), two features in strip 1, and two matches in strip 2, the method combines strip 1 and strip 2 into a resulting image (Result). 
     The individual steps of the method will now be described. In step 1101, a first rectangle (Rect1) is calculated for strip 1 (as described hereinabove). In step 102, a second rectangle (Rect2) is calculated for strip 2. In step 1103, from the two rectangles (Rect1 and Rect2) a projective affine transformation matrix (shown in FIG. 10B) is calculated. In step 1104, a third rectangle (Rect3) is calculated from an outline of strip 2 in Result. In step 1105, X and Y offsets of strip 1 (in Result) are calculated. In step 1106, the first strip is copied into Result. In step 1107, a projective affine transformation matrix is calculated from the two rectangles (Rect1 and Rect2). 
     In step 1108, a loop is established to examine each pixel of Result. If an additional pixel exists at step 1108, then in step 1109 the position of the pixel in the second strip is calculated (based on brightness). In step 1110, the Brightness (X, Y) is replaced with bi-linear interpolation, a known technique, after which the method loops back to step 1108 for another pixel of Result. If there are no more pixels (no at step 1108 no), then the method concludes. At the conclusion of the method, the two image strips have been merged. 
     Attached hereto as Appendix A are source code listings, implemented in the C programming language, providing a description of the invention suitable for use in a general purpose digital computer system, such as a plurality of IBM PC-compatible personal computers. Those skilled in the art will appreciate that the present invention may be implemented in other programming languages and/or other platforms. 
     While the invention is described in some detail with specific reference to a single preferred embodiment and certain alternatives, there is no intent to limit the invention to that particular embodiment or those specific alternatives. While specific examples have been shown using monochromatic bitmapped graphic images, for example, it will be apparent to those skilled in the art to apply the teachings of the present invention to other formats, including color bitmapped images, vector images, and the like. Therefore, the true scope of the invention is defined not by the foregoing description but by the following claims. ##SPC1##