Abstract:
A graphic arts image is partitioned into two-dimensional pictorial entities known as &#34;blobs&#34; which are susceptible of identification by a number of parameters. An entire picture is scanned and the relative frequencies of particular blob parameters are used to develop modified variable-length Elias-Huffman codes representative of the parameterized picture information in compacted form. Efficient storage, retrieval and transmission of large sets of high fidelity picture data are thereby facilitated.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to apparatus and methods for the coding and storing of graphical information. More particularly, the present invention relates to apparatus and methods for generating and storing coded representations of high fidelity graphic art images suitable for the photocomposition of printed materials. 
     2. Description of the Prior Art 
     Recent years have witnessed greatly increased usage of automatic means for composing and printing page copy for use in directories, catalogs, magazines and other printed works. An important aspect of such photocomposition schemes is the coding and storage of machine-compatible signals representative of graphical source information. In particular, when pictorial information and/or high-resolution type fonts are to be used, it has been found necessary to identify by scanning with great particularity the individual graphical entities associated with the source material. To permit the further processing of these data it has usually been necessary to store them in memories having substantial capacity. Often these data are stored for long times, as when they are to be used in successive issues of a book, magazine or the like. Because typical published materials, especially photographic or other picture materials are so diverse, and because the information content of such materials is so great, the volume of data required to be stored is potentially very large. It is especially important therefore that these data be stored in as efficient a manner as possible. 
     A number of particular coding and storage schemes have been developed for efficiently storing and transmitting information. For example, the variable length codes described in Elias, &#34;Predictive Coding&#34;, IRE Transactions Information Theory, March 1955, have proved to be useful in many variations. The well-known Huffman codes described, for example, in Huffman, &#34;A Method for the Construction of Minimum Redundancy Codes,&#34; Proceedings I.R.E., September 1952, pp. 1098-1101, and Fano, Transmission of Information, The MIT Press, 1961, pp. 75-81, offer optimum efficiency under particular circumstances. The application of these techniques to graphical information has generally been limited to one-dimensional coding, i.e., coding of signals associated with a single scan line in the source copy. 
     U.S. Pat. No. 3,461,231 issued Aug. 12, 1969 to R. V. Quinlan describes a system for performing limited two-dimensional encoding. However, his techniques are limited to transmitting only an indication of the differences between data corresponding to two successive scan lines. A related technique is presented in Tyler, &#34;Two Hardcopy Terminals for PCM Communications of Meteorological Products,&#34; Conference Record, 1969 International Conference on Communications, June 9-11, 1969, pp. 11-21 through 11-28. Tyler encodes his data (meteorological information) in terms of differential lengths for run lengths on two successive scan lines. Huang, &#34;Run-Length Coding and its Extensions&#34;, in Huang and Tretiak (Eds.), Picture Bandwidth Compression, Gordan and Breach, New York 1972, pp. 231-264, discusses some extensions to the work of Tyler. 
     Other two-dimentional coding of picture information is described in D. N. Graham, &#34;Image Transmission by Two-Dimensional Contour Coding,&#34; Proceedings of the IEEE, Vol. 55, No. 3, March 1967, pp. 336-345. 
     The above-cited Quinlan and Tyler references indicate a need to determine not only what is encoded, i.e., which parameters are encoded, but also how, exactly, these parameters are to be encoded. The latter aspect of the problem is also treated in U.S. Pat. No. 3,643,019, issued Feb. 15, 1972 to J. P. Beltz. Particular reference is made by Beltz of the applicability of his techniques in commercial photocomposition systems such as the RCA VIDEOCOMP Series 70/800. Although Beltz applies a variable-length coding to segments defining a &#34;zone&#34;, each such zone is the area defined by a single scan line, i.e., he does not attempt to extend his results to two-dimensional coding. Likewise, though Graham and Huang speak of Huffman codes, their application is to very specific geometric entities. 
     SUMMARY OF THE INVENTION 
     In accordance with one embodiment of the present invention, a visible image, e.g., a photograph, typed copy, line drawing or any combination of these or like images, is scanned, sampled and converted into two-level quantized signals. Quantized signals representing like-valued geometrically related image areas known as &#34;blobs&#34; are identified and designated to be processed together. Thus signals representing each of the blobs in the image are analyzed and a number of important blob parameters are extracted in each case. A frequency analysis of values for the blob parameters is then performed. Based on the results of these analyses a code assignment is made to each of the blob parameter values based on its relative frequency of occurrence. Thus, for example, frequently occurring blob parameter values are assigned short code words while infrequently occurring blob parameter values are assigned long code words. A particular code used in one embodiment is a variation of the above-cited Huffman code. 
     A number of alternative blob characterizations and codes are presented in which certain approximations yield significant efficiencies with scant sacrifice of fidelity. 
     A preferred embodiment of the present invention utilizes a programmed general purpose digital computer. 
    
    
     BRIEF DESCRIPTION OF THE DRAWING 
     FIG. 1 shows a simple black-on-white image which serves as a vehicle for illustrating certain fundamental image processing functions. 
     FIG. 2 shows prior art image scanning, sampling and quantizing circuitry. 
     FIGS. 3A-3K show typical signals representative of the image of FIG. 1 and useful clock signals in timed relation with said typical signals. 
     FIG. 4 shows a typical blob. 
     FIG. 5 shows an overall block diagram, in accordance with one embodiment of the present invention, of a system for encoding and storing signals supplied by a circuit such as that shown in FIG. 2 which are representative of graphic art images including those shown in FIGS. 1 and 4. 
     FIG. 6 shows how commonly occurring graphic art images (type fonts) are conveniently segmented into blobs in accordance with one aspect of the present invention. 
     FIG. 7 is a flowchart identifying the sequence of operations performed in a preferred embodiment of the present invention. 
     FIG. 8 shows a useful approximate blob in accordance with another aspect of the present invention. 
    
    
     DETAILED DESCRIPTION 
     1. Background and Definitions 
     Before proceeding with the detailed description, it proves convenient to define certain terms and describe some conventions used with some regularity in the sequel. 
     It is well known that much information-bearing copy has only two levels of image intensity, e.g., black and white. In other cases one or more intermediate brightness levels, i.e., gray levels, are used. In still other cases, multiple colors and brightness levels are used. For present purposes, image copy will be assumed to possess only two brightness levels (conveniently black and white), although generalization to multiple intensities and different colors will be apparent to those skilled in the art. For example, FIG. 1 shows an image comprising the word TIME in black on a white background. When actual image intensity is not two-valued, a standard quantizing operation will be used to &#34;round-off&#34; signals representing such images. 
     Although high quality reproduction of images often requires substantial continuity of all connected parts of an image, i.e., no gaps in the reproduced image, it proves convenient in intermediate processing to use digital techniques, i.e., to treat such images as collections of discrete elements. Thus in the range of FIG. 1 there is superimposed on the image a grid of horizontal and vertical lines defining individual picture elements (pels). For ease of explanation the grid shown in FIG. 1 is considerably coarser than that required for high fidelity reproduction. In practice these pels are arbitrarily, but sequentially, assigned to particular image subject matter by causing the image to be scanned by an optical or other scanning means, thereby to generate a signal indicative of the brightness level occurring along a narrow scan line. A typical optical image scanning system is disclosed in U.S. Pat. No. 3,445,588 issued to J. F. Nicholson on May 20, 1969. Functionally equivalent scanning apparatus is disclosed in the abovecited Beltz patent in connection with the RCA VIDEOCOMP Series 70/800 photocomposition system. Many particular scanning devices may be used to generate signals representative of the image intensity along a scan line. 
     The actual definition of individual pels is accomplished in standard practice by sampling the output of the scanner. Thus, in general, the output of a scanner is a continuous signal not unlike that associated with standard television broadcast signals. These signals are then sampled in response to periodic clock signals generated by a source of standard design. FIG. 2 shows in block diagram form typical prior art circuitry for performing the scanning and sampling operation. An image 110 is scanned repetitively along horizontal lines by scanner 111. Sampling (sample and hold) circuit 101 then samples the continuous output from scanner 111 in response to timing signals from clock circuit 102. As noted above, in some cases the image will correspond to other than simple black-and-white intensities. In this case quantizer 112 is used to generate a quantized version of the signals generated by scanner 111 as sampled by sampling circuit 101. Because these operations are commonplace in the image processing and other arts, further details of the circuitry in FIG. 2 will not be disclosed explicity. 
     Returning again to the image of FIG. 1 as superimposed on the background grid horizontal and vertical lines, it is noted that a pattern of 22 horizontal strips or scan lines is used to define pels associated with the entire image (TIME) and a representative portion of the background. Each scan line in turn is conveniently divided into 59 picture elements as in the Quinlan U.S. Pat. No. 3,461,231 cited above. The simple case illustrated in FIG. 1 corresponds to the case where each image entity (letters in this case) exactly fills the area defined by an integral number of pels. No such limitation is fundamental to the present invention, however, as will be seen below. 
     FIGS. 3A-K show typical signals generated by the circuitry of FIG. 2 when used to operate on an image of the type shown in FIG. 1. FIG. 3J shows clock signals generated by clock circuit 102 in FIG. 2. These clock signals occur at the rate of one for each time interval equal to the time required for scanner 111 to scan along a given scan line for a distance equal to the length of one pel. When applied to sampler circuit 101 the signal shown in FIG. 3J causes a value equal to that appearing on the output of scanner 111 to be sampled and held for a duration equal to one clock interval. This value appears at the output of sampler circuit 101. Since the image shown in FIG. 1 is a simple black and white image, quantizer 12 shown in FIG. 2 does not alter (except, perhaps in absolute magnitude where appropriate) the signals generated by sample-and-hold circuit 101. Thus the output appearing on lead 103 in FIG. 2 for typical identified scan lines of the image shown in FIG. 1 appears in FIGS. 3A-I. FIG. 3K illustrates a scan-line clock signal conveniently provided by clock circuit 102; the repetition rate is equal to one pulse every 59 pel invervals. 
     As commonly used in television and other picture processing arts, a &#34;run&#34; is an occurrence of like-brightness level pels in consecutive pel positions along a scan line. Thus in FIG. 1, on scan line 3, a black run begins at the fourth pel and continues through the fifteenth pel, a run of 12 black pels. While horizontal scanning is assumed in the present disclosure, it is clear that similar runs can be defined for vertical scan lines. In further connection with the actual scanning, it will be assumed that each scan line proceeds from a left end to a right end. Particular pels along each scan line are identified by an abscissa coordinate integer beginning at the left with 1 and ending with N for an N-pel scan line. 
     A collection of geometrically related pels of like brightness level which satisfy certain connectivity constraints shall be designated a &#34;blob.&#34; Much of the following detailed description will proceed in terms of such blobs. In particular, a blob comprises one or more runs of pels of the same brightness level on successive lines satisfying the condition that 
     Run beginnings and endings, respectively, of two successive runs on successive scan lines are no more than J pels apart in the direction along the scan lines. 
     In typical operation a value of J=3 yields good results. The first (highest or leftmost for horizontal and vertical scan lines, respectively run in a blob is called a &#34;head;&#34; the last (lowest or rightmost for horizontal and vertical scan lines, respectively) run is analogously referred to as a &#34;tail.&#34; Runs on scan lines between head and tail scan lines are referred to as &#34;intermediate&#34; or &#34;spine&#34; runs. FIG. 4 shows a typical non-rectangular blob with the head and tail identified explicitly. Note that the left end of the top (head) run is positioned only two pels from the left end of the second run and that the respective right ends are not relatively displaced at all horizontally. Thus the J = 3 constraint has been observed for the first two (and by inspections all remaining) runs. 
     It should also be noted that a blob may consist of only a single run (a head) or of two runs (a head and a tail). 
     2. Overview of a Typical Embodiment 
     FIG. 5 shows a broad flow diagram of processing by a preferred encoding and storage system for graphic art images in accordance with the present invention. It should be noted as a preliminary matter however, that in typical operation, scanner 111 in FIG. 2 may scan over image 110 at a density of 200-2,000 scan lines per inch. This should be contrasted with the relatively sparse occurrence of scan lines illustratively shown in FIG. 1. The amount of information presented on the lead 103 (the output lead from quantizer 112 in FIG. 2) to be processed in accordance with FIG. 5 may therefore be considerable. The present invention is directed to improved means and methods for coding and storing this information. 
     FIG. 5 defines the processing of the input stream of data from the quantizer 112 in FIG. 2. It proves convenient to divide the overall processing of input information into four principal processing functions, as shown in FIG. 5. Each of these will now be described separately. 
     Block 501 in FIG. 5 indicates that the input stream from quantizer 112 (or sampler 101 if quantization proves unnecessary) is initially operated on to define the individual blobs in the input data. For reasons to become apparent shortly, blobs of both brightness levels are extracted. In the process of defining blobs, it is typical to scan a current and an immediately preceding scan line to determine connectivity. The definition processing involves the extraction of a relevant number of parameters to describe the individual blobs. After the parameters have been derived, the raw data need no longer be stored. Instead, only the parameters need be stored for subsequent processing. Thus, the &#34;current line&#34; data replaces the &#34;preceding line&#34; data, and a new &#34;current line&#34; is read. The blob definition and storage processing results in the storing of a list or stack of data entries for each run. In particular, there is stored for each run an indication of the abscissae of the left and right ends of the run, and pointers to other stack entries for connecting runs in a blob. 
     Block 502 in FIG. 5 corresponds to the function of collecting blob statistics, i.e., the number of occurrences of particular values for the blob parameters. It proves convenient, for example, to determine the frequency of occurrences of particular values for 
     1. the length of the heads; 
     2. the &#34;connection pattern&#34; of the left and right ends of a run to the left and right ends of the preceding run in a given blob, if any; and 
     3. the blob position. 
     The &#34;connection pattern&#34; for a particular run comprises either two separate codes, one each for the left and right ends of the run, or one code representative of the manner in which the run connects at both ends. The blob position is encoded as the distance from the blob to the previously encoded blob of the same brightness level. Specifically, it is the number of pels scanned in the line-by-line scan starting to the right of the right end of the head of the previous blob of the same brightness level and ending at the left end of the head of the current blob. The first blob of each brightness level is positioned relative to the beginning of the first scan line. 
     Based on the statistics derived in processing represented by the block 502 in FIG. 5, a determination (block 503) is made of which codes may be most efficiently used to encode the blob parameters. The derivation of the &#34;best&#34; codes is determined by identifying those codes requiring the minimum total number of bits upon final encoding of the blob parameters. As was noted above, blob parameters (and related statistics) are derived for blobs of each brightness level. Upon final encoding, of course, only blobs of one brightness level need be encoded and stored. However, having available statistics for blobs of both brightness levels permits the selection of that set of blobs (all of a single brightness level) requiring the fewest bits. 
     To illustrate the manner in which a selection between blobs of one brightness level or the other may be made, reference is made to FIG. 6. FIG. 6 illustrates the blob configuration for the letters A, B and C in a particular type font. Vertical scanning at the rate of 480 lines per inch has been used. The individual blobs are separately identified in FIG. 6. Note that the letter B achieves minimum coding when the negative image (the background in the sense of FIG. 1) is encoded rather than the actual image itself. 
     The final block in FIG. 5, 504, corresponds to the actual encoding of the parameters for each of the stored runs using the codes derived by the processing indicated by 503 in FIG. 5. A more efficient coding is achieved by encoding the parameters of all successive runs in a given blob before proceeding to those runs for the next succeeding blob. The blobs are encoded in the sequence in which their heads were encountered in the scanning process. The encoding of each blob consists of 
     1. a position code; 
     2. a code for the length of the head; 
     3. one or two connection codes for each body and tail run, if any; and 
     4. a blob end code. 
     It is noted that the end code must be distinct from any of the connection codes to properly demark successive blobs. 
     PREFERRED CODES 
     Although many advantages of the present invention accrue merely by reason of the identification and parameterization of graphic features, i.e., blobs, it proves convenient to consider further advantages flowing from the selection of particular codes for the various blob parameters. This section will discuss particular codes which may be utilized to yield high efficiency coding as compared with other well-known coding techniques. These codes are optimum or near optimum for important classes of graphic information. 
     It is useful to consider as an illustration some of the factors involved in choosing a code for the blob position parameter. It should be recalled that position is specified in accordance with the number of pels scanned along from a reference point to the start of the associated blob. The (relative) position parameter for indicating the location of a given blob relative to a previous blob of the same brightness level may be made by recording a 1 for each pel at the start of a blob and a 0 for each pel scanned starting at the right of the head run of a blob and continuing to the next blob head of the same brightness level. For example, if the character T in FIG. 1 is deemed to be divided into two blobs (one for the vertical member and one for the horizontal member) and the character I consists of a single blob, then the position parameter indications (beginning with the horizontal blob of the T) would be 10001 . . . . 
     The frequency count of particular values for the position parameter for various blobs then resolves to making a frequency count of the lengths of runs of Os intermediate each 1. For an image with N blobs there will, of course, be N runs of Os. It proves convenient to treat the frequency count, converted to percentages, as a probability distribution P attributed to some source S. Thus, the assignment of codes to parameter values is equivalent to the assignment of code words for an ordinary communication source whose messages occur in accordance with the probability distribution P. Assuming S to be memoryless, it is clear that the smallest attainable number of bits per message is the first order entropy H1 of P. See, for example, Fano, Transmission of Information, MIT Press 1961, Chapter 2. 
     A particularly efficient code to be used for encoding information from such a source S is the run length coding described in Elias, &#34;Predictive Coding,&#34; IRE Trans. on Information Theory, March 1955, pp. 16-33. In Elias method the run length (where the run is the run length of Os) is encoded using a variable length code word of symbols of base M + 1 in positional form. One of the M + 1 values separates code words. For many typical graphical images, a value of M = 3 proves particularly convenient. No codebooks are required for this code because it is constricted algebraically. 
     In other cases it proves convenient to use the well-known Huffman coding techniques in deriving code books for run lengths of the type described above in this section. Huffman codes are also described at some length in the above-cited Fano book. 
     While it has been assumed that a separate code book is to be generated for each image it should be clear that this need not be the case. Thus, for images of some complexity (involving relatively large code books), which images have a general similarity to each other, it is possible to utilize a single code book for an entire ensemble of images. The degree of similarity of successive images and the relative availability of facilities for calculating and storing code books will, of course, dictate the relative merits of using specially tailored code books or ensemble code books for successive images. 
     Where it is necessary to use codebooks specially tailored for each image, the amount of storage required for the codebooks often becomes critical, particularly for high resolution processing. In some cases we can use a well-known procedure to decrease the required storage by modifying the code structure so that the number of variable-length codes, and hence the number of codebook items, is less than the total number of parameter values. This is done by first sectioning a particular subset of the parameter values into a number of distinct ranges or groups, and assigning one variable-length codeword to each group, rather than to each member in the group. For a particular parameter value within such a group, the code consists of the variable-length codeword assigned to the group, followed by a fixed-length codeword, which distinguishes among the members of the group. 
     However, this latter procedure is economical only where the original distribution is sparse toward one end, which end accommodates the grouped parameter values. For, use of both a variable-length code and a fixed-length code for any given parameter value increases the storage required for the parameter value codewords. Only where such dual variable and fixed-length encodings occur rarely, does the saving in codebook storage offset the increase in the storage for the parameter value codewords. This approach is economical, for example, in the encoding of the head length parameter. It is not useful wherever the original distribution is relatively flat, as it often is for the position parameter. 
     It is possible, however to derive in accordance with another aspect of the present invention a new code hereinafter referred to as &#34;Huffman Modulo Coding.&#34; 
     Starting with an original frequency count, two other frequency counts are derived. Each item contributing to the original frequency count is divided by a base, B, obtaining a multiple of the base and a non-negative remainder less than the base. Frequency counts of the multiples, and of the remainders are then formed separately. The codebook size, K, of the original frequency count is equal to the largest contributing item. In effect, the multiple frequency count is the original frequency count partitioned into (K/B)+1 consecutive groups. The remainder frequency count is the original frequency count partitioned into B residue classes. 
     Next, the Huffman codes for the multiple and remainder distributions are derived separately. Each original source symbol is now encoded with two codes, one for the multiple, and one for the remainder. The total number of bits required by the original encoding, T1, and the total required by the derived encoding, T2 are then compared. Note that: 
     
         T1 = S1 + C1 
    
     
         t2 = s2 + s3 + c2 + c3 
    
     where, 
     S1 = bits to encode original source data 
     C1 = bits for codebook for original codes 
     S2 = bits to encode multiples 
     C2 = bits for codebook for multiple codes 
     S3 = bits to encode remainders 
     C3 = bits for codebook for remainder codes. 
     A judicious choice of B results in T2 less than T1. T2 consists of the two parts (S2+S3) and (C2+C3). These items vary with B, which ranges from 1 to K. First, inspecting (S2+S3), we note that when B is one, the multiple and original distributions are identical, resulting in S2=S1, and S3=0. The remainder distribution is treated as null, since it contains only one entry. When B equals K, the multiple distribution is treated as null, and the remainder and original distributions are identical, resulting in S2=0, and S3=S1. As B ranges from 1 to K, the multiple bits, S2, start at S1 and tend toward zero, whereas the remainder bits, S3, start at zero and tend toward S1. For simplified cases with very regular original distribution, it can be shown that the sum (S2+S3) is constant for all B. In actual examples this sum tends very slowly upwards as B increases. 
     Considering the multiple and remainder codebook bits, C2 and C3, it is noted first that to minimize the storage of any Huffman codebook where the code words are in monotonic order, the codes themselves do not have to be stored. Instead the number of significant bits of the codes are considered in the order they appear in the associated frequency count. The set of such lengths in frequency count order is then run-length encoded. These encoded run lengths comprise the codebook bits. Assume for the moment that the number of bits required to store a codebook is roughly proportional to the number of items in the codebook. The sum of the number of items in the multiple and remainder codebooks is f(B) = (K/B)+1+B. This function is minimum at B = √K. At this base the number of codebook items is f(√K) = 2√K + 1. Under the assumption that the number of bits required to store the codebooks is directly proportional to the size of the codebooks, the theoretical reduction in codebook bits of the Huffman Modulo code over the simple Huffman code is (2√K + 1) K, or, 2√K for large K. 
     In actuality, the number of codebook bits depends on the codebook size (but not linearly), the properties of the original distribution and the procedure to encode the codebook. In practice, an approximation to the base giving the minimum number of codebook bits is chosen using the formula 
     
         B = (-1 +√1 + 0.8(C1))/2. 
    
     codebook reductions experienced are in the neighborhood of .08. In many cases, compression of the codebooks in this manner yields a smaller number of total bits for Huffman coding than for the Elias coding. The Huffman Modulo coding method can, of course, be iterated on the derived multiple and remainder distributions to higher levels. 
     APPROXIMATION 
     Useful approximations to the above-described coding techniques may range from near exact reproduction to greatly simplified representations. For the latter, encoding the blobs with various derived parameters such as centroid and mass, or with a code indicating one of a set of patterns, along with size and orientation may be used. 
     One more accurate approximation (hereinafter referred to as the first approximate coding) involves the identification of all heads and tails which do not exceed N pels. Such runs are not encoded exactly. Rather, they are grouped together and the total number of pels in the group is encoded. Upon decoding, these pels are regenerated with near exact replacement. 
     Another good approximate process (hereinafter referred to as the second approximate coding) codes explicitly only a subset of the blob runs, called spines. Heads and tails are always spines. A spine other than these has the property that runs between it and the preceding spine (called fillers), as well as the spine itself (but not the run succeeding the spine), have left ends which are no more than J away from the left end of the preceding spine. The right ends of intermediate spines are characterized in an equivalent manner. In FIG. 8 an approximate blob with a head, tail and 4 intermediate spines is shown. Between two spines, only the total number of filler runs is encoded. As with the other blob parameters, a frequency count of the size of the fills between spines is made. Upon decoding, the filler runs are regenerated using a linear or special nonlinear interpolation process. 
     For line drawings and art illustrations, the use of both the first and second approximate processes together has been found to be very satisfactory. For fonts, the second approximate procedure alone is acceptable, though exact encoding is suggested for highest quality results. 
     DETAILED IMPLEMENTATION 
     As will be appreciated by those skilled in the art, the image coding, storage and regeneration processing and apparatus in accordance with the present invention are preferably realized using a programmed general purpose computer. Thus, FIG. 7, is a flowchart of an encoding process suitable for practice on a general purpose computer typified by the Honeywell 6000 Series general purpose computer. Similarly, apparatus for realizing a preferred embodiment of the present invention comprises a Honeywell 6000 Series general purpose computer as conditioned by programs to be described in the sequel, and their equivalents. 
     The general structure of the blob encoding program is diagrammed in FIG. 7. It comprises a main control program and six subprograms, called LINES, OPT, HUF, CODE, OUT, and BITPK. All programs except BITPK are conveniently implemented in FORTRAN. BITPK is a bit manipulating package written in the Honeywell 6000 (formerly General Electric 600) computer assembly language. See GE-600 Line FORTRAN IV Reference Manual, GE, 1970, for a description of an appropriate dialect of FORTRAN and GE-625/635  Programming Reference Manual, GE, 1969, for a description of an appropriate dialect of the assembler and the general programming environment of the cited machined. The functions of each program block will be described below. 
     The image is digitized, sampled form is assumed to be accessible on a peripheral device such as magnetic tape or disk, as indicated in block 15 in FIG. 7. It consists of successive black or white (1 or 0) brightness level samples, one per pel, obtained by a left to right, line by line scan. The following program descriptions proceed, in part, in terms of rectangular image windows, recognizing that an image may be placed on a constant background. Coding efficiencies result from stripping off and excluding from the encoding process any peripheral rectangular borders on one or more sides of the image, where all such borders consist of pels of like brightness level. 
     Decoding of the encoded data and regeneration of the brightness level samples corresponding to a digitized form of the image proceeds as a reverse process to the encoding process described above. Procedures to parse a bit stream encoded in Huffman or Elias codes and assign output code values are well known to those skilled in the art. However, the present invention includes new procedures to generate the approximate images described previously. Accordingly, included below is a description and a detailed FORTRAN program implementing this portion of the regeneration process. 
     MAIN CONTROL PROGRAM 
     At block 10, the main control program first reads in a number of numeric run-time parameters as indicated below. 
     
         ______________________________________Para-meter  Description______________________________________NLIN   This is the number of lines in the image in the  input file, assumed to be numbered 1 through NLIN  from top to bottom.NSAM   This is the number of samples or picture elements  (pels) per line in the image in the input file,  assumed to be numbered 1 through NSAM from left to  right.IWT    This is the line number of the top of a window of  the image in the input file. Only the specified  window is actually encoded. If the value read for  IWT is equal to 0, the program changes it to 1.IWB    This is the line number of the bottom of the window  to be encoded. If the value read for IWB is equal  to 0, the program changes it to the value of NLlN.IWL    This is the number of the left most sample in the  window. If the value read for IWL is equal to 0,  the program changes it to 1.IPOX   This indicates the type of encoding that is to be  done, as follows:0        Encode image exactly.1        Encode image using &#34;first&#34; type of    approximation only, i.e., remove all blob    head and tail runs that are less than or    equal to the amount ISNOW in length.2        Encode image using &#34;second&#34; type of    approximation where only a subset of the blob    runs are encoded exactly. In addition, if    ISNOW, is not 0, then use the &#34;first&#34; type of    approximation process as well.ISNOW  This is the maximum number of pels in a blob head  or tail run to be encoded in grouped form if the  first approximation process is operative.IBACK  This indicates how the background gray level is to  be determined. If IBACK &lt; 0, the program is to  determine the background level to be that level  requiring the most number of bits to encode. If  IBACK ≧ 0, then IBACK indicates the level to be  used as the background level.INC    This is the absolute value of the number of pels  difference between the left end of two successive  runs in a blob, and between the right ends of two  successive runs in a blob.ISTKSZ This is the number of computer words alotted to the  ISTK stack.______________________________________ 
    
     After reading in the foregoing parameters, the main control program then initializes a number of program variables. It then reads in at block 20 the samples of an image indicated at block 15, a line at a time. For each line of samples, it calls the LINES subroutine at block 25 for detailed processing. After all the lines in the specified window have been read by the main program and processed by the LINES subroutine, the main program then calls in succession the OPT subroutine at block 35 and the CODE subroutine at block 50, and finally terminates the job at block 75. 
     LINES SUBROUTINE (BLOCK 25) 
     This subroutine identifies the blobs. A blob is a set of runs of like gray level on successive lines such that for any two successive runs, the left ends of the runs are no more than INC pels apart, and similarly the right ends are no more than INC pels apart. If an approximation type of encoding is specified, the subroutine operates upon the blobs to effect the approximation. In addition, this subroutine collects statistics on the various blob parameters, as indicated below: 
     
         ______________________________________Para-meter  Description______________________________________NPOS   This is the number of blob &#34;position&#34; values by  magnitude by gray level. For this embodiment the  maximum position value may be 20,000. If this  value is exceeded for a particular image, the  program is aborted.NHEAD  This is the number of blob head run lengths by  magnitude by gray level. This embodiment uses  43 magnitude categories for each gray level. The  categories 1-40 respectively correspond to the head  run lengths of 1-40 pels respectively. The 41.sup.st  category includes head run lengths of 41-72. The  42.sup.nd category includes head run lengths of 73-200.  The 43.sup.rd category includes head run lengths of  201-1024.NINC   This is the number of explicitly encoded runs other  than the head runs in the blobs, by connection  pattern by gray level. The connection pattern is a  code indicating the way in which a run connects to  the last previous explicitly encoded run in a blob.  These codes are discussed further below. For both  exact and approximate type of encodings, any two  successive runs in a blob are such that their left  ends are no more than INC pels apart, and similarly  for their right ends as indicated above. However,  for the second type of approximation encoding, only  a subset of the runs following the head run are  explicitly encoded. These runs are called spines,  and have the following property. All runs in a  blob following a given spine up to and including  the next spine, but not including the run following  the next spine, connect to the first given spine by  one of the standard connection patterns. The set  of blob runs between two successive spines is  called a filler. The runs comprising a filler are  not encoded explicitly. For each filler, only the  number of runs in the filler is encoded.NFILL  This is the number of fillers by number of runs by  gray level if the second approximation type of  encoding is operative. This embodiment uses  18 magnitude categories for each gray level. The  categories 1-16 respectively correspond to the  filler lengths of 0-15 runs respectively. The 17.sup.th  category includes filler lengths of 16-31 runs, and  the 18.sup.th category includes filler lengths of 32-255  runs.NSNOW  This is the total number of head and tail pels  removed if the first approximation type of encoding  is operative.______________________________________ 
    
     The LINES subroutine maintains fifteen arrays, five each for the current line, called the C line, the first line prior to the current line, called the B line, and the second line prior to the current line, called the A line. For each current line, the LINES subroutine identifies runs of like gray level. For each run, the program determines if the run connects to a run of the same gray level in the first previous or B line. If the first approximation type encoding is operative, the subroutine determines for each head or tail run in the B line, whether or not it is to be removed. If a head is removed, the next run in the blob, if any, is called a subhead. Similarly, if a tail is removed, the previous run in the blob is called a subtail. In addition, if the second type approximation encoding is operative, the subroutine determines for each run in the A line if it is a spine or a filler run. It is a spine if it is the last run in a blob, or, if the run it connects to in the B line does not connect to the last previously identified spine or head run in the blob. The data concerning the prior spine is contained in the A line arrays. The five arrays for each of the A, B, C lines contain the information indicated below. The elements of these arrays are cross-related, i.e. the k th  elements of the five arrays all refer to the k th  run in the indicated line. 
     
         ______________________________________Array Number     Description______________________________________1         This contains a pointer, relative to the     start of the next line, of the next run in     the blob, if any.2         Gray level3         This contains a code indicating the type of     run, and, if it is a spine, the connection     pattern between the spine and the previous     spine. It assumes the following values:   Value  Meaning    0     Run is an empty item, i.e., it is          a head or tail that has been          removed.   1-49   Run is a spine or filler; value          of code gives connection pattern          to previous run in blob.   50     Run is a subhead.   51     Run is a head.4         This contains the number of pels from the     left end of the line up to and including     the left end of the run. If the second     approximation type of encoding is     operative, and this is the A line, it also     contains (a) the number of filler runs     between this run and the last previous     spine, and (b) the number of pels from the     left end of the line up to and including     the left end of the last previous spine.5         This contains the number of pels from the     left end of the line up to and including     the right end of the run. If the second     approximation type of encoding is     operative, and this is the A line, it also     contains the number of pels from the left     end of the line up to and including the     right end of the previous spine.______________________________________ 
    
     After the LINES subroutine enters the pertinent items for a line in the five arrays for the C line, it compresses and transfers the information for the A line to the ISTK stack (Block 30). For each picture line, this stack contains one word giving the number of runs in the line, and one word for each of the runs in the line. If the ISTK stack fills up, the LINES subroutine writes it out onto a peripheral device and resets the stack pointer to the top of the stack. 
     After entering the information from the A line onto the ISTK stack, the B line becomes the A line, and the C line becomes the B line, leaving the C line arrays open for the next line to be processed. This switching of arrays is done by using three separate CALL statements in the main control program, rather than by actually moving data within main memory or by switching indices. We note also that this embodiment uses working arrays for three picture lines for all types of encoding. The full three are required only where the second approximation type of encoding is operative. For the other types of encoding, arrays for two picture lines would suffice. 
     OPT SUBROUTINE (BLOCK 40) 
     In general, for each of the gray levels, and for each of the blob parameters, this subroutine determines which of the two codes, namely, the Elias run-length code, or a Huffman code requires the smaller number of bits. This determination is based on the statistics compiled by the LINES subroutine. For Huffman codes, this embodiment uses individual codebooks for each picture, rather than codebooks for an ensemble of pictures. Additional specifications are indicated below: 
     (1) As described previously, the frequency counts for head lengths assume 43 categories. The last three of these include a range of head lengths. Accordingly, the Huffman codes derived for each of these three categories respectively is actually a prefix code, which is followed by a fixed length code of 5, 7 and 10 bits respectively. The fixed length code gives the position of the given head length within the range of head lengths covered by the indicated category. A similar operation is made for the last two categories of filler lengths, where the fixed length codes are 4 and 8 bits respectively. 
     (2) The codes for the connection patterns must be distinct from the blob end code. Accordingly, these are considered in conjunction with each other in both the Elias and Huffman coding methods. In addition, for the Elias encoding, the end code is assigned a smaller value than the connection pattern codes if the number of end codes is less than the frequency counts of each of the connection patterns. Otherwise it is assigned a larger value than any of the connection pattern codes. 
     (3) For the connection pattern code, the OPT subroutine actually inspects four possibilities resulting from using the first or second extension for the connection pattern, in combination with the Elias and Huffman codes. In the first extension, the connection pattern between two successive spines in a blob is encoded with two codewords, one each for the left ends and the right ends. Each of these codewords assumes one of seven values. In the second extension, the connection patterns between two successive spines is encoded with one codeword, which assumes one of forty-nine values, representing the combination of seven possibilities for the left end connection with seven possibilities for the right end connection. The second extension capitalizes on correlation between the joint movement of left and right ends of successive runs in a blob. 
     (4) For the blob positions, the OPT subroutine inspects the Elias coding and the modified form of the Huffman coding, called Huffman Modulo Coding, disclosed herein. In this new form of encoding, the original frequency distribution of the position parameter obtained from the LINES subroutine is operated upon to form two other frequency distributions, which when taken together contain the same information as the original frequency distribution. This is done by dividing each term of the original frequency distribution by a base, B, thus obtaining a positive multiple, and a positive remainder less than B. Separate frequency counts are made of the occurrence of particular multiples and particular remainders. Huffman codes are then obtained for each of these derived distributions separately. Using this method, a source symbol is then encoded with two codewords, one for the multiple and one for the remainder. In general, the sum of the number of terms in the multiple and remainder distributions is less than the number of terms in the original distribution. This results in less bits to encode the codebook, and slightly increased bits for the codewords for the source symbols. Of all the possible bases, B, there exists one which minimizes the sum of the codebook bits and the codeword bits. In this embodiment we form an algorithmic approximation to that base which gives the minimum number of total bits. We do this by first computing the number of bits to store the codebook using a base of 1. We call this number of bits JBITMD. The algorithmic approximation to the base then is: 
     
         ( - 1 + √ 1 + 0.8(JBITMD) ) /2 
    
     after determining the optimum codes for each of the blob parameters, the OPT subroutine enters on the encoded output bit stream a number of &#34;signal&#34; bits which indicate the code choices made. For those choices involving Huffman codes, the OPT subroutine calls the HUF subroutine, which in turn enters the associated codebooks on the output bit stream in compressed form. The final function of the OPT subroutine is to generate a table of the Elias codes for the values 1 through 121. This speeds the blob encoding process carried out by the subroutine CODE. 
     HUF SUBROUTINE (BLOCK 45) 
     Given a frequency distribution, this subroutine computes: 
     (a) an array containing the Huffman codes. 
     (b) an array containing the lengths in bits of each of the Huffman codes. 
     (c) the number of bits to encode the codebook. This is based on a run-length encoding of the data in (b) above. 
     The HUF subroutine may also actually encode and output the codebook. 
     CODE SUBROUTINE 
     This subroutine encodes and outputs the codes for the various blob parameters. It starts processing the ISTK stack with the first blob head or subhead item. It encodes and outputs the position of the blob and the length of the head. It then determines if another spine follows in the blob. If so, it retrieves the succeeding spine item from the stack, and encodes and outputs the connection pattern. If the second approximation type of encoding is operative, it encodes and outputs the number of filler runs between the last two processed spines, or between the last spine and the head or subhead. We note here that a distinct filler code is also required to indicate the condition of no filler runs between two spines, or between a spine and a head or subhead. All successive spines in the blob are retrieved, encoded, and outputted as just indicated. After outputting the last run in the blob, the blob end code is outputted. 
     After outputting a blob as described above, the CODE subroutine then returns to the ISTK stack entry following the head item of the blob last processed, and searches sequentially until the next head or subhead is found. If another head or subhead is found, it and the other runs constituting the blob are encoded and outputted as indicated above. This process of searching for the next head or subhead, and tracing through the stack for the various runs comprising a blob, is continued until all the blobs are encoded. 
     OUT SUBROUTINE (BLOCK 60) 
     The OUT subroutine extracts a variable number of bits from the right hand end of a given word, and packs them into the next available bit positions of a one word buffer. Whenever the one word buffer is filled, the subroutine writes it onto an output device, and clears the buffer word. 
     The OUT subroutine is called by the OPT subroutine to output the &#34;signal&#34; bits, and by the HUF subroutine to output codebooks, and by the CODE subroutine to output the codewords for the blob parameters. (Block 70). 
     BITPK PACKAGE (BLOCK 65) 
     The BITPK package is called by the OUT subroutine to extract bit data from a computer word, and to place bit data into a computer word. 
     PROGRAM TO GENERATE APPROXIMATE IMAGES 
     This program operates upon a stack containing encoded blob data, and constructs a series of brightness level values which correspond to the digitized samples of an image which approximates a given input image. The stack is of the same form as the ISTK stack produced by the aforementioned LINES subroutine, which includes the first and second approximation processes. The stack contains one entry for each image scan line, and one entry for each run of contiguous like-brightness-level pels in the image, where such runs are assumed to extend over one image scan line only. The lines and runs entries are in a line-by-line, left-to-right scan order. In this implementation, each stack entry comprises a 36 bit word, containing the following fields, progressing from the high order to the low-order bit positions. 
     
         ______________________________________Number ofBits    Parameter    Description______________________________________1                    This indicates the type of ISTK                stack entry; a 0 indicates a                &#34;runs&#34; entry, and a 1 indicates                a &#34;lines&#34; entry.4       IGL          This is the gray or brightness                level.2       ITYP         This indicates the type of runs                item, as follows:                0 Filler run.                1 Exactly encoded run, other                  than the first exactly encoded                  run in a blob.                2 First exactly encoded run in                  a blob.                3 A header tail run that is                  encoded in grouped form.9       ICON         This is a pointer to the ISTK                stack entry of the next run in                the blob, relative to the position                in the ISTK stack of this run.                If there is no succeeding run, this                field has a value of 0.10      IXL          This is the number of pels from                the left end of the line up to                and including the left end of                the run.10      IXR          This is the number of pels from                the left end of the line up to                and including the right end of                the run.______________________________________ 
    
     The generation of the approximated image proceeds as follows. First, the program initializes a number of program variables, and reads in a number of numeric run-time parameters as indicated below. 
     
         ______________________________________Parameter    Description______________________________________NSAM     This is the number of samples or pels per    image line.INC      This is the absolute value of the    number of pels difference between the    left end of two successive runs in a    blob, and between the right ends of    two successive runs in a blob, as    employed in the encoding process.IPOX     This indicates the type of image    encoding embodied in the stack    entries, as follows:  1   The first approximation type of      encoding only applies, i.e., all      the blob head and tail runs in      the original image are encoded      in a grouped form.  2   The second approximation type of      encoding applies, in which only a      subset of the blob runs are encoded      exactly, and the remaining runs,      called fillers are encoded in a      grouped form. In addition, if      ISNOW is not zero, then the first      approximation type of encoding      applies as well.ISNOW    This is the maximum number of pels in    a blob head or tail that are encoded    in a grouped form if the first approximation    type of encoding applies.INL      This amount, when added to the left    end position of the first or last    exactly encoded run in a blob    respectively, gives the extreme leftmost    possible position of the left end    of an approximated head or tail    respectively.    This amount may be positive or    negative.INR      This amount, when added to the    right end position of the first or    last exactly encoded run in a blob    respectively, gives the extreme rightmost    possible position of the right end    of an approximated head or tail    respectively.    This amount may be positive or negative.NSNOW    This is the total number of pels    in the head and tail runs encoded in    a grouped form where the first    approximation type of encoding    applies.IBACK    This is the brightness level of the    background pels, determined in the    encoding process to yield the    minimum encoded bits.INTERP   This indicates the type of    interpolation to use in generating    the approximate filler runs.    It has the values of 0 and 1    for a linear and a special non-linear    interpolation respectively.______________________________________ 
    
     After reading in the above parameter values, the program then reads in and processes a stack, a segment at a time, from an appropriate peripheral device in which it is stored. Next, if the second approximation process applies, the program identifies each filler entry in the stack segment, computes the leftmost left end and the rightmost right end of the approximated filler run, and enters them into the associated stack entry. It does this by interpolating in a linear or a special non-linear fashion between the left ends, and between the right ends of two successive spines in each blob, for all such pairs of spines separated by at least one filler run. The fillers so approximated may be shortened by subsequent processing as described further below. 
     The program then builds an image line at a time in the LNB array, which has one word for the brightness level of each pel in an image line. Initially the entire LNB array is set equal to the background level. Then the program progresses through the ISTK stack entries for the current image line, and processes each entry according to the type of the entry, as follows. 
     (a) For an exactly encoded run, the corresponding entries in the LNB array from the left to the right ends of the run are set equal to the non-background level. 
     (b) If the first approximation process applies and the exactly encoded run is also the first exactly encoded run in a blob, the program determines if an approximated head run to the blob can be generated in the prior image line, so that the head run attaches to the given blob satisfying certain conditions, and so that it does not violate any flanking blob structures. To determine the latter the program performs various tests on an array called LNA, which contains the brightness levels of the pels for the image line immediately prior to the one being built in the array LNB. Since these tests are best understood in immediate context, the description of them is reserved for the attached detailed fully commented program listing. If indeed an approximated head can be generated, it is entered into the LNA array, and the number of pels in the approximated head is deducted from the parameter NSNOW. The original value of NSNOW is the total number of pels in those blob heads and tails in the original image which were encoded in a grouped form. If NSNOW reduces to zero during the execution of the program, generation of approximated heads and tails ceases. 
     (c) For a filler run, the program performs various tests on the flanking non-background runs in the LNB array, and if necessary shortens the filler run. If the filler run is not thus entirely eliminated, the program enters the approximated run into the LNB array. 
     (d) After performing all of the processing indicated above for a current image line, the program progresses through the ISTK stack entries for the prior image line, and determines if there are any exactly encoded runs in the prior image line which are also the last exactly encoded runs in a blob. For each such run, the program determines if an approximated tail run to the blob can be generated in the current image line in the array LNB, so that the tail run attaches to the given blob satisfying certain conditions, and so that it does not violate any flanking blob structures. To determine the latter, the program performs various tests on the LNB array. If an approximated tail can be generated, it is entered into the LNB array, and the number of pels in the approximated tail is deducted from the parameter NSNOW. 
     At the end of the above processing for any particular line, the program writes out the LNA array to a peripheral device, moves the LNB array to the LNA array, and updates the pointers to the ISTK stack positions of the current and prior image lines. The ISTK stack segments are originally encoded so that they contain integral image lines, and so that blobs do not span across ISTK stack segments. In generation, the program does not generate approximate heads attaching to runs in the first image line in a segment, and it does not generate approximate tails attaching to runs in the last image line in a segment. The processing of each ISTK stack segment ends with writing out the last image line in the segment. In effect, segmenting of the ISTK stack permits running the program in a small amount of computer main memory, but causes the images to be processed in slices where each blob is confined to be within one such slice. In general, this increases the number of blobs, thereby yielding a less efficient encoding than if the entire image is treated as one entity. The maximum encoding efficiency can be obtained by using an ISTK stack which is at least equal in size to the number of image lines plus the number of runs plus 1. 
     DETAILED PROGRAM LISTING 
     Program listings for each of the functional blocks described above appear as an appendix. 
     As noted previously, all of the programs except the BITPK subroutine are written in FORTRAN; BITPK is written in Honeywell 6000 assembly language code. 
     MODIFICATIONS AND EXTENSIONS 
     While the use in accordance with the present invention of the blob identification and coding methods and apparatus in high fidelity images has been emphasized, no such use need be exclusive. Lower fidelity images of the type commonly used in standard facsimile transmission systems may profit from the use of the present inventive methods and apparatus as well. 
     While the preferred embodiment of the present invention has been described in terms of a programmed general purpose computer, it is clear to those skilled in the art that equivalent special purpose apparatus may be constructed which is functionally equivalent to the general purpose programmed machine embodiment actually described. 
     While particular parameter values for defining codes and connectivity constraints have been used in the description above, it is clear that no such values are fundamental to the present invention. For example, in particular cases blobs may be defined using any convenient value for the parameter J. Similarly, though horizontal scanning has been emphasized, it should be understood that no such limitation is fundamental to the present invention. In particular cases vertical or other scanning regimes may be followed. 
     The particular codes described, e.g., Huffman, Elias or the new Huffman Modulo Codes, should be considered merely to be typical. Other codes may be used where the statistics of the image subject matter or other factors suggest such use. Though the data to be processed by the several program blocks described in detail above has been assumed to be stored on a disk or tape file, no such storage is fundamental to the present invention. In particular, the scanned data may be read in and processed in real time. The particular machine and programing languages recited in the preferred embodiments likewise may be replaced by other particular languages and machines, depending upon availability, desired operating speed, economics and other generally relevant data processing considerations. 
     While the present description has been presented in terms of two-valued images, it is clear that images having any number of brightness levels (and/or colors) may be accommodated. Thus, the grouping of runs of like brightness level (and/or color) is accomplished for each such level (and/or color), thereby to identify blobs. In the above-described detailed embodiment, this requires one additional code per blob for specifying the brightness level (and/or color) of the blob. Minimal statistical encoding for these codes proceeds as described previously for other blob parameters. Similarly, though two-dimensional images and scanning were described, three-dimensional images and scanning may also readily be used. 
     Additional background and theoretical factors relating to the general subject matter of the present invention may be found in Frank, &#34;High Fidelity Encoding of Two-Level, High Resolution Images,&#34; Proceedings 1973 International Conference on Communications, IEEE, June 1973, which is hereby incorporated in its entirety by reference. ##SPC1## ##SPC2## ##SPC3## ##SPC4## ##SPC5## ##SPC6##