JP2023024994A - Method and apparatus for decoding symbol with insufficient resolution - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method, an apparatus, and a computer readable medium configured to decode symbols in a digital image.

SOLUTION: A method receives a digital image in a part of a symbol. The digital image includes a grid of pixels, and the symbol includes a grid of modules. A space mapping between a contiguous subset of the module in the grid of the modules and the grid of the pixels is determined. By using the space mapping, a causal relation is determined between each of the modules and the grid of the pixels. By using the causal relation, a set of valid combinations of values of the adjacent modules in the contiguous subset of the modules is tested against the grid of the pixels. Based on the tested set of the valid combinations, a value of at least one module of two or more adjacent modules is determined. Based on the determined value of at least one module, the symbol is decoded.

SELECTED DRAWING: Figure 11

COPYRIGHT: (C)2023,JPO&INPIT

Description

RELATED APPLICATIONS This application is a continuation-in-part claiming the benefit under 35 U.S.C. This application is a continuation-in-part claiming benefit under 35 U.S.C. The application claims benefit under 35 U.S.C. §120 of U.S. patent application Ser. This is a claimed continuation-in-part application, the entire disclosure of which is incorporated herein by reference.

TECHNICAL FIELD The technology described herein relates generally to decoding low resolution 2D symbols such as 2D barcodes.

Various types of symbols can be used to encode information for various purposes such as automated part identification. A barcode is a type of symbol that encodes information using a binary spatial pattern, usually rectangular. A one-dimensional barcode encodes information in one or more spatially continuous arrays of alternating parallel bars and spaces (eg, elements) of varying width. For certain types of one-dimensional barcodes (eg, often called multi-value width barcodes), the width of each element is an integer multiple of modules. Two-dimensional barcodes typically encode information as a uniform grid of modular elements, each element can be black or white.

Bar codes are typically created by printing (such as ink) or marking (such as etching) bars or module elements on a uniform reflective substrate (such as paper or metal). Bars or dark modules are usually less reflective than the substrate and therefore appear darker than the space between them (such as printing a bar code with black ink on white paper). But barcodes can be printed in other ways, such as by printing with white paint on a black object. In order to more easily distinguish the bar code from the background, the symbols are usually placed relatively far from other printed or visible structures. Such distances are often quiet both before the first bar and after the last bar (eg for 1D barcodes) or around the grid of elements of the module (eg for 2D barcodes). Create white space called zones. Alternatively, the spaces and quiet zones can be printed or marked and the bars implicitly formed by the substrate.

However, barcode readers often have undersampled barcodes (e.g. due to low sampling rate or insufficient resolution sensor) or blurry barcodes (e.g. due to poor reader focus, motion effects, etc.). , it may be difficult to decode low-resolution barcodes.

In accordance with the disclosed subject matter, apparatus, systems and methods are provided for decoding under-resolution symbols such as one-dimensional (1D) multi-level symbologies and two-dimensional (2D) symbols. The inventors have recognized that existing techniques for decoding 2D symbols cannot adequately decode under-resolution 2D symbols. In addition, we have found that existing techniques used for decoding under-resolution 1D symbols are not sufficient for decoding under-resolution 2D symbols (e.g. (because the solution set can be exponentially large), or to decode most of the multi-level 1D symbols without splitting them into separate characters. The inventors have discovered a multilevel wide 1D symbol or 2D symbol based on known aspects of the symbol and/or mathematical relationships determined between pixels of a grid of pixels and pixels in a grid of pixels of an image. An alternative technique was developed to determine the initial set of modules. The first determined set of modules is utilized to determine a sufficient number of remaining module values to enable the system to decode the symbol. In some embodiments, the technique first leverages known aspects of the symbol to determine a first set of modules of the symbol, and then determines the first set of modules and/or pixels in the image. determine (e.g., iteratively) a second set of modules for the symbol based on the mathematical relationship between and the modules for the symbols, and then for only the remaining subset of modules not yet estimated ( determining a third set of modules for the lattice of modules by trying valid combinations (e.g., leveraging previously determined module values); Such techniques decode a sufficient number of modules for a symbol so that the system can decode the entire symbol.

Some aspects relate to computerized methods for decoding symbols in digital images. The method includes: receiving a digital image of a portion of a symbol, wherein the digital image includes a grid of pixels and the symbol includes a grid of modules; determining a spatial mapping between the grid; using the spatial mapping to determine a causal relationship between each module in the contiguous subset of modules and the grid of pixels, where each causal relationship is: Represents the degree to which the value of a module affects each of the values of a subset of pixels in a grid of pixels; testing the set against a grid of pixels; determining the value of at least one of the two or more adjacent modules based on the set of valid combinations; and determining the value of at least one of the modules. Decoding a symbol based on the value obtained.

In some examples, two or more adjacent modules in a contiguous subset of modules within the grid of modules comprise a 3×3 sub-grid of the grid of modules. At least one module of the two or more modules can be the central module of the 3x3 sub-grid.

In some examples, the contiguous subset of modules includes at least one predetermined module having a known value, and the set of valid combinations of values of two or more adjacent modules comprises at least one predetermined module Include only combinations that have known values for . The predetermined module can be a module within the symbol's finder pattern or timing pattern. A known value of a given module is a pixel because a single pixel has a dominant causal relationship with the given module compared to the causality between other pixels in the subset of pixels and the given module. can be estimated based only on the value of a single pixel in the grid. A given module can include any module that has a previously determined value.

In some examples, determining a causal relationship includes using a spatial relationship to identify the extent to which each module in a contiguous subset of modules overlaps with each pixel in a grid of pixels to determine the degree of overlap. , including generating a set of The extent to which each module in the contiguous subset of modules overlaps with each pixel in the grid of pixels can be represented by a set of sampling factors and as part of a sampling matrix.

In some examples, both the grid of pixels and the grid of modules are two-dimensional.

In some examples, the grid of pixels is a one-dimensional grid of samples from a one-dimensional scan through the two-dimensional image, and the grid of modules is a one-dimensional grid of modules.

In some examples, the symbols are selected from the group consisting of one-dimensional (1D) barcodes and two-dimensional (2D) barcodes.

Some aspects relate to an apparatus for decoding symbols within a digital image. The device includes a processor in communication with memory. The processor is configured to execute instructions stored in the memory that cause the processor to: receive a digital image of a portion of the symbol, where the digital image comprises a grid of pixels and the symbol includes a grid of modules; determining a spatial mapping between a contiguous subset of modules within the grid of modules and a grid of pixels; , where each causal relationship represents the extent to which the value of the module affects each of the values of a subset of pixels in the grid of pixels; testing a set of valid combinations of values of two or more adjacent modules in a contiguous subset of against a grid of pixels; testing two or more adjacent modules based on the set of valid combinations tested; and decoding the symbol based on the determined value of the at least one module.

In some examples, two or more adjacent modules in a contiguous subset of modules within the grid of modules comprise a 3×3 sub-grid of the grid of modules.

In some examples, the contiguous subset of modules includes at least one predetermined module with known values, and a set of valid combinations of values of two or more adjacent modules are associated with at least one predetermined module. Include only combinations that have known values for

In some examples, determining causality involves using spatial relationships to identify the extent to which each module in a contiguous subset of modules overlaps with each pixel in a grid of pixels to determine the degree of overlap. Including generating a set of degrees.

In some examples, both the grid of pixels and the grid of modules are two-dimensional.

In some examples, the grid of pixels is a one-dimensional grid of samples from a one-dimensional scan through the two-dimensional image, and the grid of modules is a one-dimensional grid of modules.

In some examples, the symbols are selected from the group consisting of one-dimensional (1D) barcodes and two-dimensional (2D) barcodes.

Some embodiments relate to at least one non-transitory computer-readable storage medium. The non-transitory computer-readable medium stores processor-executable instructions that, when executed by at least one computer hardware processor, cause the at least one computer hardware processor to perform the following actions: Receiving a digital image of a portion of the symbol, wherein the digital image comprises a grid of pixels and the symbol comprises a grid of modules; a spatial mapping between a contiguous subset of modules within the grid of modules and the grid of pixels; determining; using the spatial mapping to determine a causal relationship between each module in a contiguous subset of modules and a grid of pixels, where each causal relationship is the value of the module in the grid of pixels; using causality to determine the set of valid combinations of two or more adjacent module values in a consecutive subset of modules against a grid of pixels determining the value of at least one of the two or more adjacent modules based on the set of valid combinations tested; symbolically based on the determined value of the at least one module; to decode.

The foregoing has outlined rather broadly features of the disclosed subject matter so that they may be better understood and the contributions to the art of the present invention may be better appreciated in the detailed description that follows. It is for There are, of course, additional features of the disclosed subject matter which will be described hereinafter and which form the subject of the claims appended hereto. It is to be understood that the phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting.

In the drawings, each identical or nearly identical component that is illustrated in various figures is represented by a same reference numeral. Not all components are shown in each drawing for clarity. The drawings are not necessarily to scale, emphasis instead being placed on illustrating various aspects of the techniques and apparatus described herein.

2 shows a bar code generated using a binary width symbology; The dimensions of the binary width symbology are shown. 2 shows a bar code generated using a multi-level symbology; 4 shows an exemplary scan signal; FIG. 4 illustrates exemplary scanline subsampling and sampling factors for a multi-level width barcode at 1 SPM and 0 phase for decoding the barcode, according to some embodiments; FIG. 4 illustrates exemplary scanline subsampling and sampling factors for a multi-level width barcode at 1 SPM and 0 phase for decoding the barcode, according to some embodiments; FIG. 4 illustrates exemplary scanline subsampling and sampling factors for a multi-level width barcode at 1 SPM and 0.5 phase for decoding the barcode, according to some embodiments; 4 illustrates exemplary scanline subsampling and sampling factors for a multi-level width barcode at 1 SPM and -0.25 phase for decoding the barcode, according to some embodiments. FIG. 10 illustrates exemplary scanline subsampling and sampling factor percentages for a multi-level width barcode at 1.33 SPM and 0.33 phase for decoding the barcode, according to some embodiments; FIG. 6 illustrates exemplary scanline subsampling and sampling factors of a multi-level barcode at 0.75 SPM and -0.25 phase for decoding the barcode, according to some embodiments; FIG. 11 illustrates exemplary scanline subsampling and sampling factors of a binary width barcode at 0.84 SPM, 2.1 width (W) and −0.16 phase for decoding the barcode, according to some embodiments; FIG. . 4 illustrates an exemplary computerized method of a generic image-based decoding algorithm for decoding barcodes, according to some embodiments; 4 illustrates an exemplary computerized method of a laser scanner decoding algorithm for decoding barcodes, according to some embodiments; 4 illustrates an exemplary computerized method for decoding barcodes from scan signals, according to some embodiments; 4 illustrates an exemplary computerized method for decoding barcodes from scan signals, according to some embodiments; 4 illustrates an exemplary computerized method for locating and decoding a first delimiter for decoding a barcode, according to some embodiments; 4 illustrates an exemplary computerized method for locating and decoding a first delimiter for decoding a barcode, according to some embodiments; 4 illustrates an exemplary computerized method for locating and decoding a first delimiter for decoding a barcode, according to some embodiments; 4 illustrates an exemplary computerized method for determining unit sampling factors for decoding barcodes, according to some embodiments. 4 illustrates an exemplary computerized method for scoring characters from scan signals for decoding barcodes, according to some embodiments. 4 illustrates a computerized method for decoding characters from a multi-level barcode scan signal for decoding barcodes, according to some embodiments. 4 illustrates an exemplary computerized method for decoding characters from a scan signal of a binary or multi-wide barcode for decoding barcodes, according to some embodiments. 4 illustrates an exemplary Data Matrix 2D symbol, according to some examples; 4 shows an exemplary QR Code symbol, according to some examples; 4 illustrates an exemplary computerized method for decoding under-resolution 2D symbols, according to some embodiments. 4 illustrates an exemplary image of a 2D symbol, according to some embodiments; 22 illustrates an exemplary grid of modules for a 2D symbol overlaid on top of the image of FIG. 21, according to some embodiments; FIG. 11 illustrates an example sampling matrix portion showing the percentage by which pixels in a grid of pixels overlap with exemplary modules of a grid of modules, according to some embodiments; FIG. 23 illustrates the exemplary grid of modules in FIG. 22 filled with known structure values of 2D symbols, according to some embodiments; FIG. 11 illustrates pixels of an exemplary grid of pixels estimated based on relationships between modules and pixels, according to some embodiments; FIG. 4 illustrates new white and black module values determined based on known modules, according to some embodiments; 25B shows additional module values determined based on the new modules determined in FIG. 25A, according to some embodiments; 4 shows an exemplary image of a multi-level 1D symbol, according to some embodiments; 27 illustrates an exemplary grid of modules for the 1D multi-level width symbology overlaid on top of the image of FIG. 26, according to some embodiments; FIG. 5 is an exemplary illustration of the degree of overlap between pixels of a grid of pixels and pixels of an image, according to some embodiments; FIG. 11 illustrates an example of a lattice of modules estimation module for an arbitrary pattern of modules, according to some embodiments; FIG. FIG. 11 illustrates pixels of an exemplary grid of pixels estimated based on relationships between modules and pixels, according to some embodiments; FIG. FIG. 11 illustrates pixels of an exemplary grid of pixels estimated based on relationships between modules and pixels, according to some embodiments; FIG. 4 illustrates additional modules in a lattice of modules determined based on known modules, according to some embodiments. 4 illustrates an example of an undirected constraint graph, according to some embodiments;

The techniques described herein can be used to decode under-resolution symbols (eg, under-sampled and/or blurred symbols). The inventors have recognized that 1D and 2D symbol decoding techniques often require some degree of image resolution, e.g. single black or white element). The inventors have developed techniques to improve symbol decoding techniques that decode symbols using lower resolution images, as described further herein. For example, this technique can be used to decode 1D symbols (such as multilevel 1D symbols) and/or 2D symbols acquired at resolutions of 1 pixel per module or less, eg, 0.8 pixels per module and less.

In the following description, numerous specific details are set forth regarding the systems and methods of the disclosed subject matter, the environments in which such systems and methods can operate, etc. in order to provide a thorough understanding of the disclosed subject matter. . Additionally, it will be appreciated that the examples provided below are illustrative and that there are other systems and methods within the scope of the disclosed subject matter.

A barcode can use any one of a number of barcode designs called symbologies. Each symbology can specify size constraints for bars, spaces, and quiet zones, as well as how exactly the information is encoded. Examples of barcode symbologies include Code 128, Code 93, Code 39, Codabar, I2 of 5, MSI, Code 2 of 5, UPC-EAN. Barcodes can include traditional "linear" symbologies (such as Code 128 and Code 39) in which all information is encoded along one dimension. Barcodes can also contain individual rows of “stacked” 2D symbols (e.g. data bars, PDF417, microPDF, and the 2D components of some composite symbols), which all stack barcodes on top of each other. can be stacked to encode more information.

Many bar code symbologies fall into two categories: binary and multi-level symbologies. Examples of binary width symbologies are eg Code 39, Interleaved 2 of 5, Codabar, MSI, Code 2 of 5 and Pharmacode. Each element in the binary symbology is thin or thick. The width of the narrow element is equal to the minimum feature size X. The width of the thick element is equal to the thick element size W. The size W of the fat element is usually a fixed real multiple of the minimum feature size. This allows a two-level symbology to allow each element to represent one of two possible values of X or W.

Multilevel symbologies include, for example, Code 128, Code 93, UPC-EAN, PDF417, MicroPDF and DataBar. Each element of the multi-level width symbology is an integer multiple n of the minimum feature size (eg, n is an integer from 1 to the maximum width of the element, depending on the symbology). The term module is often used to refer to the minimum feature size of a multilevel barcode, each element of a multilevel barcode symbol being composed of an integer number of modules. n ranges from 1 to 4 for many multilevel symbologies (Code 128, Code 93, UPC-EAN, etc.), but there are others (e.g., databars have n ranging from 1 to 9). ).

Element array data in a binary or multi-width barcode is encoded by a corresponding array of quantized element widths. An array of element widths for an element array is often called the element width pattern of the element array. The element width pattern for a binary width element array is a binary pattern composed of narrow elements (“X”) and wide elements (“W”). For example, bar (W), space (X) bar (X), space (X), bar (X), space (W), bar (X), space (X), bar (W) is represented as WXXXXWXXW , where X is the minimum feature size and W is the fat element width. An element width pattern for a multi-level width element array is a pattern of integers that indicate the width of the module of each corresponding element in the array. For example, bar (n=1), space (n=1), bar (n=1), space (n=3), bar (n=2), space (n=3) element width pattern 111323. be.

Barcode elements are often grouped into a series of characters (alphanumeric, etc.) that can be decoded from each element to an alphanumeric value. In some embodiments, the data is determined directly from an element-wide full array (eg, a pharmacocode barcode). The possible characters that can be encoded in a particular symbology are called a character set. Character sets have several different types of characters, such as delimiters and data characters, depending on the symbology. While there are typically only a few different possible delimiter patterns, there are many possible data character element width patterns. It is the string of data property values represented from one end of the barcode to the other that primarily defines the encoded string for the entire barcode.

Delimiters, sometimes called guard patterns, often appear at the beginning and end of barcodes. Delimiters allow a barcode reader to detect symbols, determine where to start and stop reading, and/or determine the type of symbology, for example. Delimiters placed at the beginning and end of a barcode are often called start and stop characters, respectively. Some symbologies (such as UPC-A and Databar) have delimiter patterns within the symbol to separate sections of data characters. Finally, some symbologies (such as Code 128) have different starting delimiters that determine how the data characters are interpreted.

Data characters are characters that encode the actual information in the barcode. Element width patterns for data characters are associated with alphanumeric values. A special data character called a checksum character is often specified. The value of this character is essentially the sum of the values of all other data characters, allowing the bar code reader to detect misread strings. An array of alphanumeric values for all data characters forms a raw string, which is then converted into the actual encoded element set for the barcode using special formatting rules.

Each character value in the character set, regardless of type, is associated with a unique element width pattern. For example, the element width patterns for "A" and "B" in the Code 39 character set are WXXXXWXXW and XXWXXWXXW, respectively. As explained above, the element width pattern WXXXXWXXW for 'A' is therefore bar(W), space(X) bar(X), space(X), bar(X), space(W), bar(X ), space (X), bar (W), where X is the minimum feature size and W is the width of the thick element. The element width patterns for "A" and "B" in the Code 128 character set are 111323 and 131123 respectively.

It is important to note that in most symbologies, all characters of a particular type have the same physical bar code width. For example, characters in binary symbologies usually have a fixed number of narrow bars, narrow spaces, wide bars, wide spaces, and usually begin with a bar element. Characters of certain binary width symbologies (such as code 39) also end with bars, and special spaces of consistent but arbitrary width, called intercharacter gaps, are used to separate individual characters. Such symbologies with intercharacter gaps between characters are commonly referred to as discrete symbologies, and symbologies without such gaps are referred to as continuous symbologies. In contrast, multi-level symbology characters often have a fixed total number of modules, each exactly one module wide, and they have a fixed number of bars and spaces, usually with bars. Begins and ends with a space (so there are no intercharacter gaps).

FIG. 1A shows a barcode 100 generated using a binary symbology code 39. FIG. Barcode 100 includes a set of element sequences 102A, 102B, 102C through 102N (collectively referred to herein as element sequences 102). This set of element arrays encodes the string PATENT104. Each character of string PATENT 104 is encoded using a data character, such as element array 102B encoding data character P and element array 102C encoding data A. Element arrays 102A and 102N encode delimiters indicated by *. Element arrays 102A and 102N thus mark the beginning and end of barcode 100. FIG. As shown in FIG. 1A, each array of elements 102 has the same physical width in barcode 100 .

FIG. 1B is an enlarged view of element array 102A. Element array 102A includes elements 154 that are spaces of minimum feature size X; The element array 102A includes elements 152 that are thick spaces of element size W. FIG. Element array 102A includes elements 156 that are bars of X minimum feature size. Element array 102A includes elements 158, which are bars with a wide element size W. FIG.

FIG. 2 shows a barcode 200 generated using the multi-level symbology code 128 . Barcode 200 includes a set of element arrays 202A, 202B, 202C, 202D, 202E (collectively referred to herein as character arrays 202). This set of element arrays encodes the string PATENT 204 . Similar to FIG. 1A, each character in string PATENT 204 is encoded using a data character, such as element array 202B encoding data character P and element array 202C encoding data character A. FIG. Element array 202A encodes the starting delimiter array of barcode 200 . Element array 202E encodes the stop delimiter array of barcode 200 . Delimiter element arrays 202A and 202E thus mark the beginning and end of barcode 200 .

As shown in FIG. 2, each element array 202A-E has the same physical width in barcode 200. As shown in FIG. FIG. 2 shows the element width pattern for string 202 . The element width pattern for the starting delimiter element array 202A is 11010010000. The element width pattern for P data character element array 202B is 11101110110. The element width pattern for A data character element array 202C is 10100011000. The element width pattern for T data character element array 202D is 11011100010. The element width pattern for stop delimiter element array 202E is 1100011101011.

Barcode readers, devices that automatically decode barcodes, generally fall into two categories: laser scanners or image-based barcode readers. For both types of barcode readers, decoding is typically done along one or more scans across either the physical barcode or a separate image of the barcode, along the edges of the barcode element. It is performed by measuring one-dimensional (1D) position. Each scan is usually a line segment, but can be any continuous straight line contour.

For each barcode reader scan of a barcode, a separate signal (eg, often called a scan signal) is first extracted. A scan signal typically consists of intensity measurements that are sampled sequentially along the scan, referred to herein as scan samples. Each scan sample shall represent the reflectance (relative darkness or lightness measured in reflected light) measured at a small area of the barcode or scan sample area centered at the corresponding position along the scan. can be done. The pattern of scan sample locations along the scan is referred to herein as the scan sampling grid. This grid is often substantially uniform, meaning that the distance between sample locations along the scan, or scan sampling pitch, is substantially constant. The scan sampling pitch essentially determines the scan sampling resolution of the sampled signal, usually measured as the number of scan samples per module (as used here module is synonymous with the minimum feature size of a binary symbology). . However, the effective scan sampling pitch is substantially continuous from one end of the scan to the other due to perspective effects caused by the bar code being viewed at an angle or wrapped around non-flat objects (e.g. bottles). may actually change.

The width of the scan sample area of each sample relative to the scan sample pitch can affect the amount of overlap between samples along the scan. Increasing the overlap between samples can increase the blurring of the scan signal. Reducing the overlap between samples can increase the likelihood of not measuring important features of the signal. The height of each scan sample area determines the amount of information integrated perpendicular to the scan. A large scan sample height makes the edges of elements in the signal sharper when the scan is perpendicular to the bars (so that, for example, the scan can take advantage of the redundant information of the bars in the vertical direction). However, as the scan angle to the bar increases and is no longer perpendicular to the bar, these edges become more and more blurry.

In the case of a laser scanner, the scan signal represents the reflected intensity of the laser over time as the laser sweeps along the scan contour through the physical bar code (e.g., as the laser sweeps along a line through the bar code). extracted by sampling Each sample area is essentially a laser "spot" at one instant in time. Because the shape of the laser spot is typically elliptical, with the major axis oriented perpendicular to the scan, the aforementioned width and height of the sample area can be traded off. Since the sampled signal is analog, the sampling rate over time can affect the resolution or sampling pitch. A laser's sampling rate over time may be limited, for example, by the laser's resolution (eg, how well the laser can be focused to a small spot), the maximum temporal sampling rate, and/or the print quality of the barcode.

For image-based barcode readers, separate images of the barcode are captured, such as by using camera optics or an imaging sensor (such as a CCD array). The resulting image may be a 2D sampling of the entire barcode. Each image sample or pixel of the image is itself a measure of the average reflectance of a small area of the barcode centered on the corresponding point in the image sampling grid. This grid is often uniform or nearly uniform, meaning that the distance between image sample locations or the image sampling pitch is constant. This sampling pitch essentially determines the resolution of the image, usually measured as pixels per module (“PPM”). However, similar to laser scanning, perspective effects can actually cause the effective image sampling pitch to vary substantially and continuously from one end of the bar code to the other.

The scan signal can then be extracted for scanning the entire image of the bar code by sub-sampling the image along the scan (eg, sampling the already sampled signal). The scan sampling pitch is determined by the spatial sampling rate (not time as in laser scanners, for example). Those skilled in the art will appreciate that there are many ways to perform this subsampling operation. For example, projection image processing techniques can be used on the scan line. In the case of projection, the height of the projection essentially determines the height of the scan sample area for each sample and integrates the information perpendicular to the scan. As another example, the techniques described in U.S. patent application Ser. The entire disclosure is incorporated herein by reference. For example, the effective scan sample area for each scan sample can be elliptical, similar to the elliptical spot sizes used in laser scanners.

FIG. 3 shows an exemplary scan signal for an array of elements 302, which consists of barcode elements 302A-302K, collectively referred to as barcode elements. Scan 304 is perpendicular to barcode element 302 . FIG. 3 shows scan signal 306 derived from scan 304 . Scan signal 306 includes scan samples 308 A, 308 B through 308 N, collectively referred to herein as scan samples 308 . Each scan sample 308 represents the reflectance measured at a corresponding elliptical scan sample area s0 310A through sn 310N, which are within a 1D range along scan line 304 from scan sample bins s0 310A through sn 310N. corresponds to For example, scan sample 308A represents the reflectance measured at scan sample area 311A corresponding to scan sample bin 310A, and scan sample 308B represents the reflectance measured at scan sample area 311B corresponding to scan sample bin 310B. and scan sample 308N represents reflectance measured at scan sample area 311N corresponding to scan sample bin 310N. Because sample 310A is sampled by scan sample area 311A lying entirely within space element 302A, scan sample 308A has a high reflectance indicated by "h". Scan sample 308B has low reflectance because sample area 308B is not entirely within space element 302A and also integrates information from bar element 302B.

However, an important difference from laser scanners is that the sampling resolution of scanned signals extracted using image-based barcode readers is inherently limited by the underlying sampling resolution (pixels, etc.) of the acquired image. That is. That is, there is no means of recovering additional fine detail beyond that contained in each pixel for the subsampled scan signal. As described in US patent application Ser. No. 13/336,275, this limitation is that the 1D scan was oriented with a pixel grid (e.g., perfectly horizontal or perpendicular to the pixel grid of the acquired image). It is often worse when it is a line segment. In contrast, the best possible scan sampling pitch would be equal to the underlying image sampling pitch. This limitation can therefore be improved with larger off-axis scan line angles. In some embodiments, the best possible scan sampling pitch of (1/sqrt(2)) times the image sampling pitch can be achieved for line segments where the scan is oriented at 45 degrees to the grid of pixels. , which reflects more information than is often found when the barcode is oriented at an angle. This general drawback of limited resolution can therefore often be compensated for by the ability to cover and analyze much larger areas than is possible with laser scanners. Nevertheless, it is often necessary to deal with such resolution limitations.

Both image-based barcode readers and laser scanners have to deal with problems when they cannot get a sharp signal (eg, a non-blurred signal). Both image-based barcode readers and laser scanners often have a limited depth of field, which is essentially the range of distances from the barcode reader where the acquired image or laser scanning signal is focused. is. Image-based barcode readers can be blurry in addition to depth-of-field limitations. Blurring refers to the amount by which a 1D scan signal is blurred due to lack of focus or other effects. For example, a 1D scan signal may be blurred due to the process of extracting from the low resolution image. Another example is blur caused by velocity-dependent motion of the barcoded object relative to the exposure time required to obtain an image of adequate contrast under available lighting conditions. can be caused.

Regardless of the type of barcode reader or method of extracting the scan signals, a typical method of decoding barcodes is to determine the 1D positions of all element edges (also called boundaries) along one or more of these scan signals. It is to detect and measure. The position of each edge detected along the scan is the product of their fractional position in the scan signal and the scan sampling pitch. Such edges can be used to directly infer the width of a barcode element. These barcode elements can then be further classified into discrete element sizes (eg, thin, thick, 1X, 2X, etc., depending on the type of symbology used). However, more generally in multi-level symbologies, consecutive distances between adjacent edges of the same polarity (light-to-dark or dark-to-light transitions) are computed, sorted (1X, 2X, etc.) and then It is used to infer characters from "edges to similar edges" patterns, as is known in the art. This indirect calculation is used to correct misclassification (misrecognition) due to noticeable print fatness, which typically appears as thick bars and thin spaces due to ink spreading, or vice versa, due to the printing process. can be avoided. Binary width symbology avoids print fat by classifying bars and spaces separately.

Element edges can be detected using a number of techniques known in the art, including, for example, discrete methods of locating the maximum first derivative, or zero crossings of the second derivative, and/or decomposition A wave shaping method is included that identifies the boundaries of the truncated elements.

Edge detection, however, can be complicated by image acquisition noise and print defects. Image acquisition noise and/or print defects can cause false edge detection, and can also cause problems such as low contrast (due to poor lighting, laser intensity, etc.) or blurring (due to motion or poor focus), making certain Edges may not be detected at all. Various methods have been devised to increase the sensitivity of the measurement to true edges, such as signal pre-filtering (smoothing, etc.) or enhancement (deblurring, sharpening, etc.), filtering false edges or peaks and valleys. However, even with such a method, the reduced signal resolution requires greater measurement sensitivity, increasing the problem of distinguishing false edges from true edges and measuring their locations with the required accuracy. becomes more difficult to balance.

Adding the ability to combine or integrate decoded characters or edge information between multiple scans over the same barcode can be useful (such as when the barcode is locally damaged). However, even with such integration, image-based decoders using edge-based techniques still require one module per scanline depending on image quality, focus, and orientation of the barcode with respect to the grid of pixels. .3-1.5 pixels (PPM) tend to start to fail.

Essentially, as the effective resolution of the scan signal decreases, it becomes more difficult to resolve the individual elements of the bar code, accompanied by both scan sampling resolution and blurring. Fine elements are particularly difficult to resolve, and at some resolution such fine elements eventually blend together at points where the transitions between them are not at all apparent. The difficulty of decomposition is especially problematic for undersampled signals. For example, if a transition between two elements (e.g. between a bar and a space) is moved towards the scan sample center (exactly e.g. ^1/2 sample out of phase), then the scan sample will be the result of the individual bars and _spaces . Rather than being the average reflectance of the high or low reflectance, the sample value is effectively the average reflectance of both elements. As a problematic example, the resolution is approximately 1 sample per module, and multiple fine elements coincide with successive samples that are ^1/2 out of phase, so the scan signal has uniform _reflectance values and edges are not quite obvious. do not have.

In addition to the problem of detecting edges and distinguishing them from noise, the accuracy with which the scan positions of such transitions can be measured can also be degraded, and this is due to the sampling resolution (e.g. samples of each edge transition are taken from where the transition occurs). ) and/or blurring (eg, because gradual transitions along blurred edges are more difficult to measure in the presence of noise). As a result, it may be impossible to distinguish, for example, thin and thick bars from edges. Techniques that attempt to deal with blurring inaccuracies have been devised to focus on locating the center of each element using, for example, the location of edge pairs. The center of each element is more stable, at least to the effects of blurring, and the relative positions between these center locations rather than the distance between edges are used to decode the symbol. However, the center of the measured element edge boundary is usually more stable only if the apparent edge positions have errors in opposite directions. For example, obvious edge locations may have errors in the opposite direction to blurred elements with sufficient resolution (e.g., 1.5 PPM or better), but this is not necessarily the case if the signal is undersampled, and quantization effects Edge error due to is often overwhelmingly a function of the local phase (relative position) of the scan sampling grid with respect to the grid of pixels and element boundaries.

In an effort to alleviate the resolution limitation, several methods have been devised to attempt to estimate the location of the missing thin element after determining the center and width of the thick element. These methods can use a constraint on the number of thin elements between thick elements, which is different for binary and multi-level barcodes but is common. Methods have also been devised that attempt to recognize characters from edges, but this also allows for undetected edges. For example, probabilistic techniques can be employed to decode characters by edge-based (geometrically) deformable template matching. However, such methods are usually devised for blurry barcodes with sufficient sampling resolution, not undersampled barcodes. In fact, such techniques may specify that standard edge-based decoding techniques should be used when the signal is considered to be in focus. If we continue to rely on edge (boundary) determination, it becomes difficult to identify and measure the width of even the thickest elements as the SPM decreases below 1.1 samples per module. Additionally, some algorithms cannot be implemented efficiently enough for practical use in industrial barcode readers.

Compounding these problems is the trend to employ image-based barcode readers instead of laser scanners (e.g., due to their broader coverage benefits) and the reduction in size and number of barcode readers. There is a trend to reduce the cost of image-based reader systems by minimizing the cost. This is the case, for example, in logistics applications, where barcodes must be read on often randomly oriented boxes or parcels on wide conveyor belts. Minimizing the number of barcode readers requires maximizing the amount of volume (such as area and depth) that each barcode reader must cover. This reduces relative image resolution (PPM) and increases blurring (due to depth-of-field limitations), both of which reduce the effective image sampling resolution.

Beyond simply blurry barcodes, there is a need to improve the low-resolution decoding capabilities of barcode readers (e.g., especially for image-based barcode readers). Moreover, since edge-based methods have difficulty at low resolutions (eg, less than 1.1 PPM), there is a need for methods that can directly analyze scan signal values to decode barcodes. A technique that has attempted to overcome these limitations is to use pattern matching techniques. Some pattern matching techniques attempt to decode barcodes by modeling each character in the barcode as a 1D deformable template. The 1D deformable template can be horizontally scaled (e.g., to accommodate unknown module sizes), horizontally translated (e.g., to uncertain positions along the scanline), and vertically stretched (e.g., unknown ), and translated vertically (eg, for unknown background illumination intensity). However, such pattern matching techniques cannot cope with the severe undersampling of barcodes, eg, quantization effects below 1.0 PPM. For example, due to under-sampling, the pattern can be unrecognizably distorted relative to the template.

A barcode can be viewed as consisting of a series of barcode units, each unit having an associated width and binary encoded value. For binary width barcodes, for example, a barcode unit can have either of two widths, a thin "X" or a wide "W". As another example, in the case of multi-value width barcodes, a barcode unit can have a width corresponding to a multiple of X, n. A binary encoded value can indicate whether a barcode unit is part of a bar or space. For example, B can be used to indicate that the barcode unit is for bars, and S for spaces. Numeric values may be used in some embodiments, such as B=0 and S=1, or B=−1 and S=1. Therefore, each element width pattern can be associated with a unit width pattern and a unit encoding pattern.

In some examples, the barcode unit can be an element, in which case the unit width pattern is an element width pattern and the associated unit encoding pattern is a pattern of alternating bar and space values (e.g., BSBSBSBSB). , bars, or spaces with appropriate starting values (eg, because elements always alternate between bars and spaces, except for inter-character gaps).

In some examples, each barcode unit is selected to uniform the unit width pattern. For example, in the case of a binary width barcode, the barcode unit cannot be smaller than the element, because generally the thick element cannot be further reduced to an integral number of thin elements. For example, in the case of a multi-value width barcode, the width of each element consists of an integral number of module widths, so the unit can be made as small as the module. The use of modular units results in narrow uniform unit width patterns. In some embodiments, a particular multilevel unit width pattern consists of an array of uniform modules, and the associated unit encoding pattern consists of bar and space values that together represent the encoded data for that array. For example, XXXXXXXXXXXX is the unit width pattern for all unit width patterns for modules of length 11, but the unit encode pattern is different for each element width pattern. For example, BBSSSSBBSSS is a unique unit encoding pattern for the 11X element width pattern 111323.

In some embodiments, for binary width symbologies, the information in the element width patterns is encoded directly by the unit width patterns, and the unit encoding patterns alternate. For example, as described above, the unit encoding pattern is a pattern of alternating bar values and space values (eg, BSBSBSBSB). In some embodiments, the information in the element width pattern is indirectly encoded by the unit encoding pattern for multi-level width symbologies, the unit width pattern consisting of uniform minimum features. For example, XXXXXXXXXXXX is the unit width pattern for all unit width patterns of a module of length 11, so it indirectly encodes the element width pattern, as the element width pattern cannot be inferred without more information. However, a unit width pattern (eg, BBSSSSBBSSS for 11X element width pattern 111323) contains 11 features (eg, 11 Bs and Ss).

Advantageously, analyzing binary or multi-level symbologies using element units allows each unique data character in the symbology to be associated with a unique unit (eg, element) array. The unit encoding pattern can be an alternating binary pattern of the same size for all characters. Analyzing a multi-level symbology using modular units allows each unique data character in the symbology to be associated with a unique unit (e.g. module) pattern, and the unit (e.g. module) sequence is the same for all characters. can be

For example, when using modular units for binary symbology code 39, the unique unit width pattern for "A" is its element width pattern WXXXXWXXW, and the unique unit width pattern for "B" is its element width pattern XXWXXWXXW. is. However, all Code 39 data characters are associated with the same length 9 binary unit encoded pattern BBSBSBSSB. Similarly for code 128, when element units are used, the unique unit width pattern for "A" is its element width pattern 111323, and the unit width pattern for "B" is its element width pattern 131123. However, all code 128 characters are associated with the same length 6 binary unit encoding pattern BSBSBS.

As another example, when using modular units for the multi-level symbology code 128, the unit width pattern for all characters is the same uniform array of length 11 XXXXXXXXXX, but the unique unit encoding pattern for "A" is BBSSSSBBSSS (eg, corresponding to element width pattern 111323), the unique unit encoding pattern for "B" is BSSSBWBBSSS (eg, corresponding to element width pattern 131123).

Sampling quantization effects can be mathematically modeled by representing barcodes and barcode characters as structured units. For example, a model can be generated based on:

(1) (a) a contiguous array of barcode elements (eg, no inter-character gaps), and (b) an associated quantization width for each barcode element represented as an element width pattern.
(2) the starting position of the first element of the barcode element array in sample coordinates (eg, in fractions of the sampling pitch, the fractional part is essentially the starting "phase" relative to the sampling grid);
(3) Minimum feature size (X) and wide element width (W) measured in fractions of samples (or equivalently thin-to-wide ratio), if applicable.

Using such information, the relationship between these barcode elements and the raw signal can be expressed using a single matrix equation.
A*b=s Equation 1
here,
A is the unit cell-dependent unit sampling coefficient matrix, ie a sparse matrix of sampling coefficients, defining the position of the unit boundary along the scan, consisting of:
〇Unit sub-array spanning the barcode element array 〇Minimum feature size, X
〇Thick element size, W (if applicable)
o The starting position of the first barcode element in the array.
• b is an encoded pattern in binary units of bar and space values.
• s is a vector representing the normalized scan samples.

Each row of the sampling coefficient matrix A can correspond to one sample, and each column can correspond to one unit (eg, module for multi-level barcodes, or element for binary-level barcodes). Each row value can be selected to add to 1.0 and each column value can be selected to add to the width (eg X or W) of the respective unit (such as module or element).

The i-th normalized vector sample s,s(i) can be given by
s(i)=B+[(r(i)-l(i))×(SB)]/(h(i)-l(i)) Equation 2
here,
• r is a vector representing the continuous portion of the scan signal across the sample bins.
• h and l are vectors of values representing a discrete approximation of the signal envelope of r.
o h(i) is the estimate of the space reflectance at sample i.
o l(i) is the estimate for the reflectance of the bar at sample i.

The vector r can be assumed to cover the position range of the entire identity subarray. In some embodiments, the value of r can be a measured reflectance value. Each row i of A can be a vector of respective percentages of barcode units in the unit width pattern binned for sample i to obtain reflectance measurements for the scanned sample. In some embodiments, the unit coefficients depend on the unit cell, and the unit cell can represent the location of transitions between units. A unit cell may be affected by phase (eg, starting point), minimum feature size, print fatness, thickness ratio (if any), and/or the like.

FIG. 4 shows exemplary scanline subsampling and sampling factors for a multi-level barcode with one sample per module (“SPM”) and 0 phase for decoding the barcode, according to some embodiments; . FIG. 4 shows an A data character module 400 consisting of barcode modules b1 402B, b2 402C, b3 402D, b4 402E, b5 402F, b6 402G, b7 402H, b8 402I, b9 402J, b10 402K, and b11 402L. Character unit 402 includes, in addition to these modules, a preceding character last module b0 402A (space) and a preceding character first module b12 402M (bar).

FIG. 4 shows scan signal 406 derived from scan 404 . Scan signal 406 includes scan samples 408 A, 408 B through 408 N, collectively referred to herein as scan samples 408 . Scan samples 408 include corresponding scan sample bins s 0 410 A, s 1 410 B through s 12 410 N, collectively referred to as scan sample bins 410 . For example, scan sample 408A represents the scan sample for scan sample bin s0 410A. Since each scan sample bin 410 is aligned with the start of character unit 402 , scan sample bin 410 has zero (0) phase with respect to character unit 402 . FIG. 4 also shows unit sampling factor matrix 420 . Each row s1 412A through s11 412Nm (collectively referred to herein as rows 412) of unit sampling coefficient matrix 420 corresponds to one sample and is a vector of sampling coefficients for character units within a unit width pattern. Each column 422A through 422N (collectively columns 422) of the unit sampling coefficient matrix 420 corresponds to one unit (eg, module). As shown in FIG. 4, the sampling pitch is exactly the module width, so the width of each scan sample bin 410 corresponds to the module width of the barcode character 400 . Unit sampling coefficient matrix 420 contains zeros everywhere except those shown containing ones (all zeros are not shown for simplicity). Row s1 412A contains a 1 in the second column 422B because scan sample bin s1 410B matches entire module b1 402B, and row s2 412B contains a 1 in the second column 422B because scan sample bin s2 410B matches entire module b2 402C. 3 contains a 1 in column 422C, and so on.

FIG. 5 shows exemplary scanline subsampling and sampling factors for a multi-level width barcode at 1 SPM and 0 phase for decoding the barcode, according to some embodiments. FIG. 5 shows a B data character element array 500 which includes barcode modules b1 502B, b2 502C, b3 502D, b4 502E, b5 502F, b6 502G, b7 502H, b8 502I, b9 502J, b10 502K and b11 502L. Character unit 502 includes, in addition to these modules, the last module (space) of preceding character b0 502A and the first module (bar) of preceding character b12 502M.

FIG. 5 shows scan signal 506 derived from scan 504 . Scan signal 506 includes scan samples 508 A, 508 B through 508 N, collectively referred to herein as scan samples 508 . Scan samples 508 represent samples for corresponding scan sample bins s0 510A, s1 510B through s12 510N. For example, scan sample 508A represents the scan sample for scan sample bin s0 510A. FIG. 5 also shows unit sampling factor matrix 520 . Since each scan sample 510 is aligned with the start of barcode module 502 , unit 502 has zero (0) phase with respect to scan sample bin 510 . Each row s1 512A through s11 512N (collectively referred to herein as rows 512) of unit sampling coefficient matrix 520 corresponds to one sample and is a vector of sampling coefficients for barcode units within a unit width pattern. Each column 522A through 522N of the unit sampling coefficient matrix 520 corresponds to one unit (eg, module). As in FIG. 4, the width of each scan sample bin 510 corresponds to the width of a module of barcode 500 . Unit sampling coefficient matrix 520 contains zeros everywhere except those shown containing ones (all zeros are not shown for simplicity). Row s1 512A contains a 1 in the second column 522B because scan sample bin s1 510B matches entire module b1 502B, and row s2 512B contains a 1 in the second column 522B because scan sample bin s2 510B matches entire module b2 502C. 3 contains a 1 in column 522C, and so on. Note that the resulting unitary sampling factor matrix 520 is the same as the unitary sampling factor matrix 420 of FIG. 4 because unit 502 is at zero phase with respect to scan sample bin 510 and module size is exactly equal to module size.

FIG. 6 shows exemplary scanline sub-sampling and sampling factors of a multi-level width barcode at 1 SPM and 0.5 phase for decoding the barcode, according to some embodiments. FIG. 6 shows the A data character module array 400 from FIG. FIG. 6 shows scan signal 606 derived from scan 604 . Scan signal 606 includes scan samples 608 A, 608 B through 608 N, collectively referred to herein as scan samples 608 . Scan samples 608 represent samples for corresponding scan sample bins s0 610A, s1 610B through s11 610N. For example, scan sample 608A represents the scan sample for scan sample bin s0 610A, which is between high and low because half of its area is covered by b0 and half of its area is covered by b1. . Each unit 402 is (0.5 ) phase.

FIG. 6 also shows a unit sampling factor matrix 620. FIG. Each row s0 612A through s11 612N (collectively referred to herein as rows 612) of the unit sampling factor matrix 620 corresponds to one sample and is a vector of sampling factors per barcode within a unit width pattern. Each column 622A through 622N (collectively columns 622) of the unit sampling coefficient matrix 620 corresponds to one unit (eg, module). The width of each scanned sample bin 610 is equal to the width of each barcode module, while each scanned sample bin 610 is half covered by each of two consecutive barcode elements 402 . The unity sampling factor matrix 620 contains zeros everywhere except those shown including half (1/2) (all zeros are not shown for simplicity). Row s0 612A contains 0.5 in the first column 622A because scan sample bin s0 610A is half covered by bar b0 402A, and the second row 622A because scan sample bin s0 610A is half covered by bar b1 402B. Column 622B contains 0.5. Row s1 612B contains 0.5 in the second column 622B because scan sample bin s1 610B is half covered by bar b1 402B, and the third Column 622C contains 0.5.

FIG. 7 shows exemplary scanline sub-sampling and sampling factors of a multi-level barcode at 1 SPM and −0.25 phase for decoding the barcode, according to some embodiments. FIG. 7 shows the A data character element array 400 from FIG. Figure 4. FIG. 7 shows scan signal 706 derived from scan 704 . Scan signal 706 includes scan samples 708 A, 708 B through 708 N, collectively referred to herein as scan samples 708 . Scan samples 708 represent samples for corresponding scan sample bins s0 710A, s1710B through s11 710N. For example, scan sample 708A represents the scan sample for scan sample bin s0 710A, which is 0.75% of scan sample bin s0 is covered by module b0 with reflectance h and 0.25% of scan sample bin s0 is covered by module b0 with reflectance h. three-quarters of the way from low to high because it is covered by module b1 with Each unit 402 is offset backward from the start of each scan sampling bin 410 by one quarter of the width of the module, so that the unit 402 is (−0.25) phase with respect to the scan sample bin 710 .

FIG. 7 also shows a unit sampling factor matrix 720 . Each row s0 712A through s11 712N (collectively referred to herein as rows 712) of unit sampling factor matrix 720 corresponds to one sample and is a vector of sampling factors for barcode units within a unit width pattern. Each column 722A through 722N (collectively columns 722) of the unit sampling coefficient matrix 720 corresponds to one unit (eg, module). The width of each scan sample bin 710 is equal to the width of each barcode module, while each scan sample bin 710 is 0.75% and 0.75% respectively by two consecutive barcode units 402 due to the -0.25 phase. 25% covered. Unit sampling coefficient matrix 720 contains zeros everywhere except those shown containing non-zero values (all zeros are not shown for simplicity). Row s0 712A contains 0.75 in first column 722A because scan sample bin s0 710A is 3/4 covered by module b0 402A and scan sample bin s0 710A is 1/4 covered by module b1 402B Therefore, the second column 722B contains 0.75. Row s1 712B contains 0.75 in second column 722B because scan sample bin s1 710B is 3/4 covered by module b1 402B and scan sample bin s1 710B is 1/4 covered by module b1 402C. Therefore, the third column 722B contains 0.25.

FIG. 8 shows exemplary scanline sub-sampling and sampling factors of a multi-level width barcode at 1.33 SPM and 1/3 phase for decoding the barcode, according to some embodiments. FIG. 8 shows the A data character module array 400 from FIG. FIG. 8 shows scan signal 806 derived from scan 804 . Scan signal 806 includes scan samples 808 A, 808 B through 808 N, collectively referred to herein as scan samples 808 . Scan samples 808 represent samples for corresponding scan sample bins s0 810A, s1 810B through s16 810N. For example, scan sample 808A represents the scan sample of scan sample bin s0 810A, which is a high value because scan sample bin s0 is completely covered by b0. As another example, scan sample 808B represents the scan sample for scan sample bin s1 810B, which means that scan sample bin s1 is 1/3 covered by b0 reflectance and 2/3 covered by b1 reflectance. 2/3 of the way from high to low. Since unit 402B (beginning of character module) begins to the right of s1 810B, unit 402 is one-third (⅓) phase with respect to scan sample bin 810 .

FIG. 8 also shows unit sampling factor matrix 820 . Each row s0 812A through s16 812N (collectively referred to herein as rows 812) of unit sampling coefficient matrix 820 corresponds to one scan sample and is a vector of sampling coefficients per barcode within a unit width pattern. Each column 822A through 822N (collectively columns 822) of the unit sampling coefficient matrix 820 corresponds to one unit (eg, module). The width of each scan sample bin 810 is equal to 2/3 of a barcode module for 1.33 SPM. Unit sampling coefficient matrix 820 contains zeros everywhere except those shown containing non-zero values (all zeros are not shown for simplicity). For example, row s0 812A contains 1.0 in the first column 822A because scan sample bin s0 810A is completely covered by module b0 402A (and no part of the other modules). Row s1 812B contains 0.33 in first column 822A because scan sample bin s1 810B is 1/3 covered by unit b0 402A and scan sample bin s1 810B is 2/3 covered by module b2 402C Therefore, the second column 822B contains 0.66.

FIG. 9 shows exemplary scanline subsampling and sampling factors of a multi-level barcode at 0.75 SPM and −0.25 phase for decoding the barcode, according to some embodiments. FIG. 9 shows the A data character module array 400 from FIG. FIG. 9 shows scan signal 906 derived from scan 904 . Scan signal 906 includes scan samples 908 A, 908 B through 908 N, collectively referred to herein as scan samples 908 . Scan samples 908 represent samples for corresponding scan sample bins s0 910A, s1 910B through s9 910N. For example, scan sample 908A represents the scan sample of scan sample bin s0 910A, which is a value representing 0.75 reflectance of b0 402A and 0.25 reflectance of b1 402B. As another example, scan sample 908B represents the scan sample for scan sample bin s1 910B, which is half covered by module b0 and half covered by module b1. Since unit 402B (the first unit of character module s) begins at sampling pitch 0.25 to the left of s1 910B, unit 402 is in minus quarter (-1/4) phase with respect to scan sample bin 910. .

FIG. 9 also shows unit sampling factor matrix 920 . Each row s0 912A through s9 912N (collectively referred to herein as rows 912) of unit sampling coefficient matrix 920 corresponds to one scan sample and is a vector of sampling coefficients per barcode within a unit width pattern. Each column 922A through 922N (collectively columns 922) of the unit sampling coefficient matrix 920 corresponds to one unit (eg, module). The width of each scan sample bin 910 is equal to 1 and 1/3 bar code elements for 0.75 SPM. The unity sampling coefficient matrix 920 contains zeros everywhere except those shown containing non-zero values (all zeros are not shown for simplicity). For example, row s0 912A contains 0.75 in the first column 922A because scan sample bin s0 910A is 3/4 covered by unit b0 402A, and scan sample bin s0 910A is 1/4 covered by unit b1 402B. second column 922B contains 0.25. Row s1 912B contains 0.5 in first column 822A because scan sample bin s1 810B is 1/2 covered by unit b1 402B and scan sample unit s1 910B is 1/2 covered by unit b2 402C. Therefore, the second column 922B contains 0.5.

FIG. 10 illustrates an exemplary scanline sub-scan of a binary width barcode at 0.84 SPM, width (W) of 2.1, and -0.16 phase for decoding the barcode, according to some embodiments. Sampling and sampling factors are indicated. FIG. 10 shows barcode elements b0 1002A, b1 1002B, b2 1002C, b3 1002D, b4 1002E, b5 1002F, b6 1002G, b7 1002H, b8 1002I, b9 1002J, and b10, collectively referred to as barcode units (elements) 1002. A data character element array 1000 consisting of 1002K is shown.

FIG. 10 shows scan signal 1006 derived from scan 1004 . Scan signal 1006 includes scan samples 1008 A, 1008 B through 1008 N, collectively referred to herein as scan samples 1008 . Scan samples 1008 represent samples for corresponding scan sample bins s0 1010A, s1 1010B through s9 1010N. For example, scan sample 1008A represents the scan sample for scan sample bin s0 1010A, which is a value representing reflectance of unit b0 1002A of 0.84 and reflectance of unit b1 1002B of 0.16. As another example, scan sample 1008B represents the scan sample for scan sample bin s1 1010B that is completely covered by unit b1 1002B. Unit 1002B (the first element of the character) begins to the left of scan sample bin s1 1010B, so unit 1002 is -0.16 phase relative to scan sample bin 1010. FIG.

FIG. 10 also shows unit sampling factor matrix 1020 . Each row s0 1012A through s12 1012N (collectively referred to herein as rows 1012) of the unit sampling factor matrix 1020 corresponds to one scan sample and is a vector of sampling factors per barcode within a unit width pattern. Each column 1022A through 1022N (collectively columns 1022) of the unit sampling coefficient matrix 1020 corresponds to one unit (eg, element). Unit sampling coefficient matrix 1020 contains zeros everywhere except those shown containing non-zero values (all zeros are not shown for simplicity). For example, row s0 1012A contains 0.84 in the first column 1022A because 84% of scan bin s0 1010A is covered by unit b0 1002A and 16% of scan sample bin s0 1010A is covered by unit b1 1002B. Therefore, the second column 1022B contains 0.16. Row s1 1012B contains 1.0 in the second column 1022B because all of scan sample bin s1 910B is covered by unit b1 1002B.

In some embodiments, the multi-level symbology uses modular units, as shown in FIGS. There is one unit sampling coefficient matrix for a particular section of the symbol where the apparent module size is constant, since the unit width pattern (and thus the unit cell) can be the same for all possible element width patterns. (eg single character, multiple characters or the entire barcode). Decoding a section of such a bar code involves, for example, solving a system of linear equations for the actual unit encoded pattern (e.g., module value), then converting it to an element width pattern, and finally to its associated alphanumeric value. It can be done by converting In some embodiments, decoding can be performed by using elements of the multi-level symbology, which are further described below.

FIG. 11 illustrates an exemplary computerized method 1100 of a generic image-based decoding algorithm for decoding barcodes, according to some embodiments. At step 1102, the barcode reader locates barcode candidate regions within the captured image (eg, of barcodes on items on a conveyor belt). At step 1104, the barcode reader selects the next barcode candidate region. For example, the next candidate region is the region with the most bar-like features. A barcode reader can initialize the integrated string for this candidate. At step 1106, the barcode reader selects the next scan from the set of scans through the candidate region (eg scan 404 in FIG. 4). A scan can be, for example, a line segment that is generally parallel to another scan and extends from one end of the barcode candidate to the other. Barcode readers can select scans using different orders. For example, a barcode reader can select the next scan in order from top to bottom, center to outside, and so on.

At step 1108, the barcode reader acquires a scan signal (eg, scan signal 406), such as by using projection. At step 1110, the barcode reader decodes the barcode from the scan signal. The decoding process is further explained in connection with FIG. At step 1112, the barcode reader assembles the scan strings. For example, a barcode reader can combine the decoded string (including the character score) from the scan with the previously integrated string for this candidate scan. At step 1114, the barcode reader determines whether the barcode was reliably decoded (eg, based on a confidence threshold). If the barcode reader determines that the barcode is not reliably decoded, the barcode reader returns to step 1106 and performs steps 1108 through 1112 on the next selected scan (if any remain). If additional candidate regions remain, method 1100 returns to step 1104 . Upon completion, method 1100 reports the barcode string. Barcode strings may include barcodes that were not reliably decoded, barcodes that were partially decoded, and the like.

FIG. 12 illustrates an exemplary computerized method 1200 of a laser scanner decoding algorithm for decoding barcodes, according to some embodiments. At step 1202, the laser scanner acquires an analog return signal. The analog reflectance signal is the reflectance of the barcode along a linear scan across the barcode as measured by the laser and detector. At step 1204, the laser scanner samples the reflected signal (eg, by extracting discrete digital scan signals by temporal sampling). At step 1206, the laser scanner decodes the barcode from the scan signal. The decoding process is further explained in connection with FIG. At step 1208, the laser scanner consolidates the scan string. At step 1210, the laser scanner determines whether the barcode was successfully decoded. If the laser scanner determines that the barcode is not reliably decoded, the laser scanner returns to step 1202 to obtain a new analog return signal. Otherwise, method 1200 proceeds to step 1212 and reports the consolidated string.

13A-B illustrate an exemplary computerized method 1300 for decoding barcodes from scan signals, according to some embodiments. At step 1302, the barcode reader detects edges (eg, 1D positions of transitions between elements) in the scan signal. Those skilled in the art will appreciate that edges can be detected using a variety of techniques, such as using derivative peaks, second derivative zero-crossings, peak/valley transitions (ANSI edges), and/or other edge detection methods. At step 1304, the barcode reader filters the edges. For example, the barcode reader can filter out false edges (eg, based on contrast) and/or add missing edges if the minimum feature size is known. At step 1306, the barcode reader locates and decodes the first delimiter. In some embodiments, the barcode reader can locate and decode the delimiter in a reverse direction along the scan (eg, by reversing the scan signal).

At step 1308, the barcode reader advances to the next character position. For example, the barcode reader adds the measured character length of the current character (eg, which becomes the delimiter pattern at the start of step 1306) plus the measured integer character gap to give the start of the current character. position can be determined. If the current character was not properly decoded (eg, not within the confidence range), the barcode reader can use an estimate of the character size. At step 1310, the barcode reader estimates the character unit cell. In some embodiments, the character unit cell includes a starting position (eg, phase), a minimum feature size (eg, X), a thin-to-thickness ratio (if applicable), and an inter-character gap. In some embodiments, the barcode reader can be configured to use the last measured statistics of previously decoded characters to account for the number of characters that could not be decoded later. In some embodiments, the first edge distance can be used to measure the inter-character gap for the first character beyond the delimiter.

At step 1312, the barcode reader uses the edges to decode the characters. One skilled in the art will be able to use techniques this is known in the art, such as measuring the distance from an edge to a similar edge, classifying the distance from an edge to a similar edge (e.g. the nearest integer of X or W (including rounding each edge distance to a multiple of X); updating how well the edges match, such as by using the fractional difference of . At step 1314, the barcode reader determines if the last delimiter has been decoded or if the maximum number of characters for the symbology has been exceeded. If the answer is 'no', the method returns to step 1308 . If the answer is yes, the method proceeds to step 1320 of Figure 13B. At step 1320, the barcode reader determines whether all characters were successfully decoded. If the answer is yes, method 1300 proceeds to step 1322 and reports the consolidated string. If the answer is no, method 1300 proceeds to step 1324 and excludes characters that were not reliably decoded. For example, bar code readers can be configured to prevent misreads. A barcode reader can be set with a high confidence threshold to detect potential misreads (eg, mark such characters as not decoded). For example, such characters may include characters preceding the character that were not decoded (eg, due to errors in character unit cell estimates and/or missing edges and/or extra edges).

At step 1326, the barcode reader advances to the next undecoded character. For example, a barcode reader can start at the beginning of a string and advance to the next undecoded character. At step 1328, the barcode reader estimates the character unit cell. At step 1330, the barcode reader decodes the characters from the scan signal. If the character is not decoded, the method returns to step 1326 . If the character is decoded, the method proceeds to step 1334 to refine the character unit cell. In some embodiments, step 1334 is optional. A barcode reader can look for small perturbations in each of the character unit cell measurements to assess how the score of a decoded character changes. The barcode reader can select the character unit cell that yields the best score, thereby modifying the starting position, inter-character gap (if applicable), minimum feature size, and/or thickness ratio (if applicable). ). If undecoded characters remain, the method proceeds to step 1326 . Otherwise, the method proceeds to step 1322 and reports the consolidated string.

Referring to step 1330, decoding distinct characters results in scan sampling that varies as a function of position along the scan, such as those caused by perspective effects and/or non-linear warping of symbols around curved objects. Can handle pitches. Bar code readers can thus be configured to use a constant scan sampling pitch over a relatively narrow range of character positions. For example, a single minimum feature size measured in scan sample pitch units and a thick bar width (if applicable) can be used to describe the unit cell of a character. Advantageously, using characters, the barcode reader examines all possible combinations of each unit encoding pattern (e.g. 103 combinations for the multi-level code 128) and results in the predicted (e.g. predicted Solve each character-wise encoding pattern by selecting the unit-encoding pattern that results in the normalized scan sample Ab (which is the closest match to the portion of the measured normalized scan sample s) becomes possible.

In some embodiments, the barcode reader can be configured to solve the unit-encoded pattern directly using standard linear algebra techniques (e.g., using the standard least-squares formula b=(A ^T A) ⁻¹ s method , which would minimize the Euclidean length of Abs). A becomes numerically unstable when the module size approaches 1.0, and becomes singular below 1.0. Therefore, this technique can be used to stabilize the solution. For example, constraint minimization can be used to stabilize the solution (eg, using Lagrangian multipliers to incorporate other linear constraints). As another example, a pseudo-inverse (eg, b=A ⁺ s) can be used to stabilize the solution. The solution can be constrained in any of a number of other ways, such as by mathematically restricting the solution to binary vectors. Some constraints, however, may result in a set of non-linear equations that are not easily or efficiently solvable, and may not be as beneficial as others.

Character-by-character techniques can be used to decode binary width barcodes and/or decode multi-width characters (such as when using unit elements). The barcode reader therefore gives the best score (e.g., essentially the one that best matches the sample scan) when multiplied by the binary unit-encoded pattern vector representing alternating bars and spaces (as well as for all possible characters). ) (and associated element width patterns and character values, etc.).

In some embodiments, the barcode reader determines the scan signal envelope vectors 1 and H before and/or during the process of finding the best matching character (thereby resulting, for example, measured and predicted (allows direct comparison of scanned signal values). In some embodiments, the barcode reader is configured to assume that the scan signal envelope is constant over a single character (eg, for ease of calculation). For example, a barcode reader could use a set of envelope values l and h rather than vectors. For example, using such a configuration, one can basically assume that the underlying illumination of the barcode does not change much over the course of a single character.

In some embodiments, the barcode reader can be configured to assume that the signal envelope is not significantly different from the previously decoded character envelope. After decoding, the barcode reader can refine the envelope by measuring the minimum and maximum signal values within the wide bars of the decoded characters. In some embodiments, the barcode reader can directly determine the envelope parameters l and h for each potential character as part of the matching process. For example, a barcode reader can be configured to directly match the expected Ab to the actual measured raw signal r (eg, by allowing an arbitrary uniform scale and a single offset). In some embodiments, the barcode reader can be configured to select values of scalars a and c that minimize the sum _i (ar(i)+c−s(i)) ² (eg, i , where n is the length of the portion of the scan signal). Then, using the relationships a=(SB)/(hl) and c=B−al, we can determine h and l, yielding:
l=(DB−v _c )/v _a
h=l+D(SB)/va _Equations 3 and 4
here,
・_va = m ₂ y ₂ - ny ₁
・v _c =m ₂ y ₁ -m ₁ y ₂
・D = m ₂ ² - nm ₁
・m ₁ =sum(r(i) ² )
・m ₂ =sum(r(i))
・y ₁ =sum(s(i)r(i))
・y ₂ =sum(s(i))

In some embodiments, the barcode reader can be configured to verify the calculated l and h against the expected range for these numbers (e.g., based on nearby characters), so that As , the barcode reader can determine if the character corresponding to b needs to be considered further.

Figures 14A-C illustrate an exemplary computerized method 1400 for locating and decoding a first delimiter for decoding a barcode, according to some embodiments. At step 1402, the barcode reader identifies possible delimiter starting points. For example, a barcode reader can consider each edge as a possible starting position, where the polarity of the edge (dark over light or light over dark) corresponds to the polarity of the barcode (light on dark or dark). write, on write). As another example, a barcode reader may only consider edges with a reasonable quiet zone (eg, no significant features (edges, etc.) at a distance corresponding to the trailing edge distance in the preceding scan signal).

At step 1404, the barcode reader selects the next possible delimiter start from among the remaining identified possible delimiter start points. At step 1406, the barcode reader uses the edges to decode the characters. At step 1408, method 1400 determines whether the delimiter has been decoded. If the answer is yes, the method proceeds to step 1446 of Figure 14C. At step 1410, the barcode reader identifies possible delimiters. For example, some symbologies have multiple start or stop patterns. In some of the embodiments described above, the stopping pattern can be detected in the backward direction along the scan signal because the decoding operation can occur in the backward direction. At step 1412, the barcode reader selects the next possible delimiter.

At step 1414, the barcode reader deduces a possible rough character unit cell. For example, a barcode reader can estimate the minimum possible feature size and thickness ratio (if applicable) from the portion of the signal at the end of the barcode. For example, a barcode reader can be assumed to have approximately 0 print fat and an inter-character gap (if applicable) of 1X. Another estimate is to identify the possible measured edges that initiate the pattern edge correspondence, assuming that some edges may be missing, e.g. It can be done by performing a square fit. The correspondence with the best fit (eg exceeding the error threshold) is selected and associated with the best fit character grid. In some embodiments, this estimation can alternatively be achieved without edges by locating the center of the thick element for the binary width symbology and performing similar corresponding operations.

At step 1416 the barcode reader selects the next coarse character unit cell and the method proceeds to step 1420 . At step 1420, the barcode reader selects the next character unit cell perturbation. For example, a barcode reader can select a character unit cell that is different from the estimated value but within the estimated maximum error. In some embodiments, the barcode reader can change one parameter (eg, minimum feature size, etc.) in small steps. At step 1422, the barcode reader computes a unit sampling factor matrix, which is further illustrated in FIG. At step 1424, the barcode reader scores characters from the unitary sampling factor matrix, which is further illustrated in FIG. If the barcode reader determines that the score is sufficient (eg, better than a predetermined threshold), the barcode reader can record the score for that character and the associated character unit cell.

At step 1426, the barcode reader determines if any grid perturbations remain. If grid perturbations remain, the barcode reader proceeds to step 1420 . If the answer is no, the method proceeds to step 1428 to determine if any coarse character grid remains. If character grids remain, the method proceeds to step 1416 of FIG. 14A. If no character grids remain, the method proceeds to step 1430 to determine if any possible delimiters remain. If there are remaining possible delimiters, the method proceeds to step 1412 of FIG. 14A.

If there are no possible delimiters remaining, the method proceeds to step 1440 of Figure 14C. At step 1440, the barcode reader scores the best matching characters. For example, a barcode reader can select the letter/grid combination with the best score. At step 1442, the barcode reader determines if the best character score is sufficient. For example, if the best matching character score is not sufficient, or if the next best possible character score is below the confidence threshold or more, the barcode reader may determine that the delimiter was not found. If the best character score is sufficient, the barcode reader proceeds to step 1446; If the best character score is not sufficient, the barcode reader proceeds to step 1444 to determine if any possible delimiter start positions remain. If there are remaining possible delimiter start positions, the method proceeds to step 1404 of FIG. 14A. If there are no more possible delimiter start positions left, the method proceeds to step 1446 and (optionally) refines the character grid. For example, a barcode reader can look for small perturbations in each character grid measurement to assess how scores change for decoded characters. In some embodiments, the barcode reader selects the character grid that yields the best score, resulting in modified starting positions, inter-character gaps (if applicable), minimum feature sizes, and/or thickness-to-thickness ratios. (if applicable).

FIG. 15 illustrates an exemplary computerized method 1500 for determining unit sampling factors for decoding barcodes, according to some embodiments. At step 1502, the barcode reader initializes the unit sampling factor. The size of the unit sampling coefficient matrix is nxm, where n is the number of actual 1D signal values and m is the number of modules (e.g. for multi-level symbols) or elements within a character (e.g. binary symbols, or elements For multi-value widths using units) plus 2 (representing, for example, elements before and after characters or inter-character gaps). The barcode reader initializes all values to 0. In the preferred embodiment, the coefficient matrix is displayed using a sparse matrix representation.

At step 1504, the barcode reader determines the sample range. For example, a barcode reader may determine the first and last samples that have centers that are within characters (e.g., centers within one character module or element, not preceding or following elements or intercharacter gaps). can. At step 1506, the barcode reader advances to the next scan sample in range. For example, if not already considered, this is the first sample in the range. As above, the samples can correspond to rows of the coefficient matrix with the same index. Samples are typically associated with bins, which are the range of scanline positions that are presumed to integrate information. The sample bins can be centered around the sample location and can have a width equal to the sample interval.

At step 1508, the barcode reader determines the character-by-character overlap. For example, a barcode reader uses a character-by-character grid to calculate the percentage of sample bins that overlap on each character-by-character basis (eg, takes print gain g into account). For multi-level symbologies, bar code readers can use units equal to modules. For binary symbologies, bar code readers can use units equal to elements. A barcode reader can record these values in sequence across the rows of the coefficient matrix associated with the sample. In some embodiments, if Xg > 0.5 sample pitch, there can be at most 3 non-zero percentages per row, and overlap identifies module i closest to sample j. , the coefficient matrix A can be determined by specifying:
q(i)=(w(i)-1)/2 (equation 5-8)
A(j,i−1)=max(+d(i,j)−q(i)+g/2,0)
A(j,i+1)=max(-d(i,j)-q(i)+g/2,0)
A(j,i)=1-A(j,i-1)-A(j,i+1)
here,
w(i) is the width of element i (e.g. X for narrow elements or modules, W for wide elements)
d(i,j) is the signed difference between the center of unit i and the center of sample j (eg all positions are real valued sample coordinates).

At step 1510, the barcode reader determines if there are any scan samples remaining within range. If scan samples remain within range, the method proceeds to step 1506 . If there are no more scan samples left within range, the method proceeds to step 1512 and ends.

In some embodiments, the barcode reader is configured to determine scores for characters using an error function e=s−Ab. Examples of this function include sum of squared errors, sum of absolute errors, maximum error, and/or the like. In some embodiments, the error is "backpropagated" through the coefficient matrix to compute the original character-by-character (module or element) error. Backpropagation can be achieved by calculating the unit error vector e(b) according to the following equation.
e(b)=A ^T e' Equation 9
here,
• e(b) is the unit error vector.
• e' is the vector of absolute signal errors defined by e'(i) = |e(i)|

The overall error for pattern b can be calculated using, for example, sum of squared unit errors, sum of unit errors, maximum unit error, and/or the like. In some embodiments, the sum of squared unit errors is used for data characters (eg, because even one unit incorrect can lead to costly misinterpretations). In some embodiments, the sum of the unit errors is used for delimiters (eg, where misreading is less harmful, but missing delimiters do not even attempt to decode the symbol).

FIG. 16 illustrates an exemplary computerized method 1600 for scoring characters from scan signals for decoding barcodes, according to some embodiments. At step 1602, the barcode reader creates a character-by-character pattern. For example, in some embodiments, a barcode reader identifies binary unit encoder patterns associated with characters. For example, for multi-width characters, the unit encoding pattern is a pattern of modules that can be part of bars or spaces derived from the character element width pattern. For binary width characters, for example, the unit encoding pattern is a pattern of element values that always begin with the appropriate value (bar or space) and are an array of alternating bar and space values.

At step 1604, the barcode reader performs unit sampling factor multiplication. For example, a barcode reader can multiply the unitary sampling coefficient matrix by the unitary encoding pattern to obtain the predicted (or expected) signal vector. At step 1606, the barcode reader can compare the expected signal and the measured signal. In some embodiments, the barcode reader can be configured to generate one or more character scores indicating how well the predicted signal matches the measured signal as a result of the comparison. This can be accomplished in a variety of ways, as discussed above. In some embodiments, the barcode reader outputs two values after normalizing the actual signal with the local signal envelope (e.g., the minimum and maximum signal range corresponding to the apparent reflectance of bars and spaces in the signal). can be subtracted.

FIG. 17 illustrates an exemplary computerized method 1700 for decoding characters from a multi-level barcode scan signal for decoding barcodes, according to some embodiments. Referring to step 1702, the barcode reader determines unit sampling factors, eg, as described in FIG. At step 1704, the barcode reader identifies possible data characters. Some codes, for example Code 128, would allow all data characters. Other codes, such as UPC-EAN, would only allow characters of the appropriate subgroup (A, B, or C). At step 1706, the barcode reader selects the next possible data character. At step 1708, the barcode reader scores the characters using a unit sampling factor.

At step 1710, the barcode reader determines if the score is high enough. If the score is not high enough, the method proceeds to step 1706; If the score is high enough, the barcode reader proceeds to step 1712 and records the letter and score. At step 1714, the barcode reader determines if there are any remaining possible data characters. If there are remaining possible data characters, the barcode reader proceeds to step 1706; If no data characters may remain, the barcode reader proceeds to step 1716 where the barcode reader determines whether the best score is better than the second best score (if any) by at least a confidence threshold. do. Once the barcode reader believes it has identified the best character, it proceeds to step 1720 and records the best character and score. If the barcode reader is not convinced, the characters are not decoded.

FIG. 18 illustrates an exemplary computerized method 1800 for decoding characters from a bi-level or multi-level barcode scan signal for decoding barcodes, according to some embodiments. At step 1802, the method identifies possible data characters. Some codes, for example Code 39, would allow all data characters. Other codes, such as Codabar, only allow characters of moderate length. At step 1804, the method selects the next possible data character. At step 1806, the method determines unit sampling factors (eg, as described in connection with FIG. 15). At step 1808, the method scores the characters using unit sampling factors (eg, as described in connection with FIG. 16).

At step 1810, the barcode reader determines whether the score exceeds a predetermined threshold. If the score does not exceed the predetermined threshold, the method returns to step 1804. If the score exceeds the predetermined threshold, the method proceeds to step 1812 and records the letter and score. At step 1814, the method determines whether any possible data characters remain. If there are remaining possible data characters, the method proceeds to step 1804 . If there are no more possible data characters left, the method proceeds to step 1816 . At step 1816, the barcode reader determines whether the best score is better than the second best score (if any) by at least a confidence threshold. Once the barcode reader believes it has identified the best character, it proceeds to step 1720 and records the best character and score. If the barcode reader is not convinced, the character is not decoded and the method ends at step 1818.

Various 2D symbologies can be used to encode information such as Data Matrix, QR Codes, Aztec Codes, Maxicodes, Vericodes and other 2D symbols as described above. FIG. 19A shows an exemplary Data Matrix 2D symbol 1900, according to some embodiments. The leftmost column 1902 and bottommost row 1904 form the Data Matrix "L", which exists for every Data Matrix symbol and locates the Data Matrix symbol within the image and its Used to determine orientation. Data Matrix symbol 1900 is made up of a set of modules (eg, black and white modules such as black module 1906 and white module 1908) used to encode information for the symbol. FIG. 19B shows an exemplary QR Code symbol 1950, according to some examples. Instead of the "L" pattern in Data Matrix symbol 1900, QR Code symbol 1950 includes three bullseyes 1952, 1954 and 1956, which represent the location of QR Code symbol 1950 in the image. is used to identify and determine its orientation. Similar to Data Matrix symbol 1900 , QR Code symbol 1950 is used to encode information for symbols such as black module 1958 and white module 1960 .

A variety of multi-level wide 1D symbols can be used to encode information, such as Code 128, Code 93, UPC-EAN, PDF417, micro PDF, data bars, and other symbols. As mentioned above, FIG. 2 shows an exemplary barcode 200 generated using the multi-level symbology code 128 having a set of modules 202A-202E.

As noted above, there are several reasons why an imaging application may acquire under-resolved symbols, such as under-sampling or blurring. For example, some imaging applications use sensors attached to image objects moving along a conveyor belt. Such sensors can be mounted far enough away from the conveyor belt (and objects carried by the conveyor belt) to achieve a larger field of view (FOV). However, the price to achieve a larger FOV is a reduced resolution of objects and/or symbols on objects, resulting in poor images of objects and symbols. As another example, the symbols can be located toward the bottom side of the object, but the resulting code is further away from the sensor, etc., again leading to a poorly resolved image of the symbol. Therefore, it may be desirable to use techniques to decode under-resolution 1D and 2D symbols.

Techniques exist for decoding under-resolution 1D symbols. For 1D symbols, this technique can take advantage of the character aspect of the symbol. Also, since there are significantly fewer possible values for 1D symbol characters compared to 2D symbols, 1D techniques can try all possible valid value combinations to decode symbols. For example, for a 128 code barcode, there are 103 standard character patterns, so given this limited set of patterns, some 1D techniques essentially just try all character patterns. For example, the techniques described herein provide decoding of under-resolution 1D symbols.

Unlike 1D symbols, it is often not feasible to determine unknown module values by simply trying all possible combinations of module values. For example, it is often impractical to enumerate and evaluate all possible binary 2D patterns for a 2D symbol (2 ⁿ , where n is the number of modules in the symbol), and the results can be evaluated in a realistic time It cannot be created within a frame. Running through all possible binary 2D patterns is also less sensitive to modular errors. Because one module is a very small percentage of the total pattern, its effect on the overall error is small compared to the effect of error due to inaccuracies in the specified positions of the symbols. . As another example, it is similarly impractical to enumerate and evaluate all possible multi-value width patterns for a 1D symbol without considering each character individually.

The techniques described herein provide decoding of under-resolution images of symbols such as the 2D barcodes shown in FIGS. 19A-19B and the multi-level barcode shown in FIG. As described further herein, the technique may involve establishing a mathematical relationship between known pixel values and unknown (black or white) module values within the image of the symbol. For example, in some non-limiting embodiments, an underconstrained set of linear equations can be represented as a sparse sampling matrix. Each coefficient element (i,j) of the sampling matrix can be an estimate of the overlap ratio between the i th pixel in the image and the j th module in the symbol. This technique involves analyzing coefficients and values for pixels where the modules overlap, logically deducing module possibilities, and/or filling the module values in an iterative manner. Considering the 2D symbol modules iteratively can quickly reduce the overall number of possibilities (eg, less than 2n), making determination of unknown 2D module values feasible.

FIG. 20 illustrates an exemplary computerized method 2000 for decoding under-resolution symbols, according to some embodiments. At step 2002, an image processor receives a digital image of a portion of a symbol. The image processor may be a barcode reader, an external computing device coupled to the barcode reader, and/or some other computing device configured to perform the techniques discussed herein. At step 2004, the image processor determines a spatial mapping between a contiguous subset of modules in the grid of modules and the grid of pixels. At step 2006, the image processor uses spatial mapping to determine causal relationships between each module in the contiguous subset of modules and the grid of pixels. Each causal relationship can represent the extent to which the value of the module affects each of the values of a subset of pixels in the grid of pixels. In step 2008, the image processor uses causality to test the set of valid combinations of values of two or more adjacent modules in a contiguous subset of modules against a grid of pixels. At step 2010, the image processor determines the value of at least one of the two or more adjacent modules based on the set of valid combinations tested. At step 2012, the image processor decodes the symbols based on the determined values of the at least one module.

Referring to step 2002, a symbol reader, such as a barcode reader, is a device that automatically decodes symbols. Symbol readers include image-based symbol readers that obtain discrete images of barcodes, such as by using camera optics or imaging sensors (such as CCD arrays). The resulting image is a 1D or 2D sampling of the entire barcode. Each image sample or pixel of the image is itself a measure of the average reflectance of a small area of the barcode.

21-25B are used as illustrative examples of applying the techniques disclosed herein to a two-dimensional barcode. FIG. 21 shows an exemplary image 2100 of 2D symbols, according to some embodiments. Image 2100 includes a set of pixels (eg, pixels 2102 and 2104) with associated pixel values that indicate the darkness of each pixel. Each image may have a set of pixel values that can have values within a predetermined luminance range, such as 0-255 for 8-bit values. In some examples, such as grayscale images, 0 can represent black and 255 can represent white. In practice, however, the imaging system may not be able to achieve the gamut of colors, and as a result the gamut may be more limited than the values normally allowed for pixels in the image.

In some embodiments, the technique uses the envelope of the image signal to decode the symbols. The envelope contains the maximum and minimum pixel values of the signal across the image. The maximum value of the envelope indicates white in the image (but does not necessarily correspond to e.g. the theoretical maximum allowed for the image) and the minimum value indicates black in the image (but e.g. does not necessarily correspond to the maximum value). Thus, pixel values can be mapped between the local foreground (dark) and the local background (light) to produce pixel values ranging from 0 to 1. The system can thus normalize the signal values by a particular envelope of the image to determine a measure of how "black" or "white" a pixel is for a particular application. For example, a symbol in an image may have a gradient due to the angle of illumination, where one side of the symbol is a uniform gray while the other side is black. Determining the signal envelope can, for example, normalize lighting differences between different parts of the image, shadows and/or the like. The signal envelope can be determined, for example, in a similar manner as described herein, but using 2D processing rather than 1D processing. As another example, the signal envelope can be determined by computing the tail of the histogram within the local region around each pixel.

Referring to step 2004, FIG. 22A shows an exemplary grid of modules superimposed on top of image 2100 from FIG. 21, according to some embodiments. In this particular example, the module grid pitch (eg, module size) is approximately the same as the pixel grid pitch, ie, the resolution is about 1 pixel per module. However, this is not always the case. In extremely low resolution images the module pitch is significantly larger than the pixel grid pitch, and in high resolution images the module grid pitch is much smaller than the image grid pitch. This technique involves first locating a grid of symbolic modules relative to a grid of pixels of the image. For 2D symbols, for example, a finder pattern on the symbol (eg, the 'L' pattern for Data Matrix symbols, or the bull's eye pattern for QR codes) can be used to locate the grid.

The image processor can store one or more grids of modules for the 2D symbol, which represent the two-dimensional layout of the modules for the symbol. The image processor can locate the grid of modules 2200 relative to the image 2100 to determine the spatial mapping between the modules in the grid of modules and the grid of pixels in the image. The relationship between the grid of modules 2200 and the grid of pixels in the image 2100 can reflect how much each module overlaps pixels in the image 2100, for example. FIG. 22A illustrates such a relationship at a high level by showing a 2D grid of modules 2200 superimposed on a grid of pixels. Therefore, the relationship between the grid of modules 2200 and the grid of pixels of the image 2100 can reflect how much each module affects each pixel. Most of the effect will be zero (eg at the majority of pixels in the image that do not overlap with a particular module).

FIG. 22B shows an example portion of a sampling matrix 2270, which shows the percentage by which each pixel in pixel grid 2250 is overlapped by an exemplary module 2262 in module grid 2260, according to some embodiments. . In some embodiments, the percentage for a particular module can be approximately the module size. In this example the module size is approximately 1 and more approximately 0.9. In some embodiments, the percentages across all modules for a particular pixel can add up to approximately 100%. As shown, module 2262 has four pixels overlapping in pixel grid 2250: pixels 2252, 2254, 2256 and 2258. FIG. Sampling matrix portion 2270 shows the overlap percentages, namely 15%, 20%, 25%, 30%, which indicate that module 2262 overlaps pixels 2252, 2254, 2256 and 2258 respectively ( each portion of these pixels is covered by module 2262). The remaining values in sampling matrix portion 2270 are 0% because module 2262 does not overlap any other pixels in grid of pixels 2250 . For simplicity, FIG. 22B shows only a portion of pixel grid 2250 and sampling matrix 2270, as indicated by the dashed arrows. In some embodiments, as discussed further herein, a smaller sampling matrix is used instead of representing the entire image, such as a 3x3 sampling matrix and/or a 1x9 sampling matrix. Such small sampling matrices can be stored as is or derived from larger sampling matrices.

In some embodiments, the relationship between the grid of modules and the grid of pixels can be determined using one or more localization techniques. This technique can be determined based on pixels per module (PPM), for example. For example, specific techniques can be used for specific PPM values or ranges until one technique can identify specific characteristics of symbols in an image (e.g., individually, sequentially and/or in a similar way). In some embodiments, the PPM may not be known. In such cases, one or more techniques may be performed to locate the grid of modules and determine the PPM, as discussed further herein. For example, the technique used in the image with the highest PPM may be tried first, then the technique for the next higher PPM, until the position and orientation of the symbol within the image are determined.

The following examples describe various techniques used for different PPM ranges. This example is for illustrative purposes only and different ranges, range numbers, values, etc. may be used without departing from the spirit of the technology described herein. According to this non-limiting example, the grid relationships of modules can be determined by locating known patterns within the symbol down to a particular PPM (eg, 2 PPM). For a Data Matrix symbol, for example, the technique can locate the "L" pattern on two sides of the symbol. Once the 'L' patterns are located, the technique can find the timing patterns on each of the other two sides by detecting edges along the 1D scan that passes through them. One example of such a technique is the reference code algorithm described in the ISO/IEC 16022 standard for the Data Matrix symbology, which is hereby incorporated by reference in its entirety. Although this example is for a Data Matrix symbology, it should be appreciated that decoding of other symbologies can be performed in a similar manner by locating known features within the symbol. For example, QR codes can be determined in a similar manner by locating the bullseye portion, which is specified in the "QR Code 2005 Reference Decoding Algorithm" section of the ISO/IEC 18004 standard for the QR Code symbology. , which is incorporated herein by reference in its entirety. Lattice size can also be determined in the manner described in the reference decoding algorithm.

At low resolutions (eg, 2PPM to 1.2PPM), this technique may not be able to locate known symbol patterns (eg, 'L' patterns for Data Matrix symbols). For example, the system may not be able to locate known symbol patterns due to under-sampling of symbol aspects such as symbol edges. This technique may perform pixel processing first to enhance symbol features, such as image upsampling, in order to increase the visibility of symbol features. Upsampling involves, for example, non-linearly interpolating values between pixels. For example, polynomial interpolation can be used.

At even lower resolutions (eg, less than 1.2 PPM), image degradation (aliasing) is so severe that it may be nearly impossible to detect particular symbol features, even with pixel processing, for example. For example, the system may not be able to detect known features and/or timing patterns. If the technique associated with higher PPM fails, the technique locates the outer rectangle of the symbol (e.g., with sub-pixel accuracy) and determines the grid size using the grayscale digital waveform rather than looking for edges. can be configured as Visual techniques such as blob analysis, generalized Hough transform, etc., can be used to locate the boundaries (eg, rectangles as shown in FIGS. 19A and 19B) of 2D symbols. In some embodiments, the technique used may depend on the lighting conditions of a particular vision system. For example, a more robust method can be used. For example, in some embodiments, the system detects edges, groups the edges by contour, reduces the number of vertices in the resulting polyline (e.g., using techniques such as the Lemer-Douglas-Poiker algorithm), and the resulting Analyzing the shape of the image obtained as , we recognize polygons with four corners with angles of approximately 90 degrees. Subpixel positions on the four sides of the rectangle could then be determined by fitting a line to each group of subpixel edges along the four sides of the rectangle.

In some embodiments, the lattice size of the symbol is known prior to decoding the symbol. For example, the grid size can be fixed and/or the grid size can be trained with previous images. For example, the system can be trained on high resolution images (eg high PPM images). At runtime, the system can assume that the symbols have the same size as the trained grid, even if the system cannot easily determine the number of rows in the grid from very low resolution images.

If the grid size is not known, the system can be configured to automatically determine the grid size along each dimension. For example, the grid size can be determined by performing a 1D projection and scanning two opposite sides of the rectangle (eg, inside from the outer boundary of the rectangle). In some embodiments, scanning can be performed in much the same way that a 1D barcode is scanned, for example. Techniques for scanning, for example, 1D barcodes are described above. Once the system has determined the starting and ending positions of the timing patterns, it can simply try all the timing patterns corresponding to each of the sensible integer number of modules in between. This technique can only be used in certain situations, such as certain PPM ranges. For example, it can be used for codes with a PPM below the upper PPM limit (eg, 1.2 handled by the retry above), for codes with a practical lower PPM limit that can be decoded (eg, 0.8). The minimum number of modules can be determined based on the integer closest to the timing pattern length divided by the PPM upper bound (e.g., 1.2 to continue the example above), while the maximum is the length below the lower bound. It is obtained by division (again, say 0.8). Such constraints can be used, for example, to minimize the number of possible patterns to try.

In some embodiments, to determine which of the possible module size patterns is the best, the system determines a sampling factor matrix for each timing pattern and uses the sampling factor matrix to determine the score. can be configured as The highest scoring pattern can be determined to correspond to the correct module size for that dimension of the symbol. Such techniques are described above for decoding characters in 1D barcode symbols.

Once the system has determined the grid relationships of the modules, the system can set the module values corresponding to the known structure of the symbol. FIG. 23 shows the exemplary modular lattice 2200 of FIG. 22A filled with known structure values of 2D symbols, according to some embodiments. In this example, the leftmost column 2302 of the grid of modules 2200 is filled with the top of the 'L' of the Data Matrix symbology, the bottom row 2304 is filled with the bottom of the 'L', and the rightmost column 2306 is filled with the bottom of the 'L'. and the top row 2308 are filled with timing patterns. While this embodiment injects the known structure of the Data Matrix symbology, it is understood that it is also possible to inject the known structure of other symbologies being decoded, such as the bullseye pattern of the QR Code symbology. sea bream.

Known structures can be embedded in a grid of modules based on the orientation of the symbols. In some embodiments, the system learns the orientation of the grid, for example, whether the "L" is in the bottom left, as shown in FIG. 23, or whether it is in a different position, such as the top right of the symbol. etc. can be determined. In some embodiments, orientation can be determined during training. In some embodiments, other techniques can be used to determine where a known feature is in the image (eg, is the 'L' at the bottom left of the symbol). For example, if the system already knows the grid size but does not know the orientation of the symbols, the system can be configured to identify the orientation using techniques once the grid is identified. In some embodiments, the system may average the pixels below the grid location along the top, bottom, left, and right sides, and let the average with the lowest gray value correspond to the L pattern. Other techniques can be used to identify known features of the symbol to determine orientation.

In some embodiments, some of the known structures may be data modules of symbols determined with high confidence in previous images acquired from the same physical symbol. These modules may have been determined in high-resolution images (e.g., because the symbols are moving away from the camera over time) or in low-resolution images (e.g., using one or more of the techniques described). For the low resolutions, in many cases the symbols were somehow not successfully decoded, but certain modules were estimated with high accuracy, and those estimated modules are the number of pixels in the current acquired image. Estimation is difficult due to large deviations of the module grid relative to the grid.

Referring to step 2006, the image processor can use the determined causal relationships between the modules in the grid of modules and the pixels in the image to infer the first set of modules (e.g. modules with a high degree of overlap). FIG. 24 shows modules of an exemplary grid of modules 2200 estimated based on relationships between modules and pixels, according to some embodiments. The estimation shown in FIG. 24 includes estimated white modules such as module 2402 and estimated black modules such as module 2404 . For example, the image processor may inject modules with a very high degree of overlap, eg modules whose sampling factor exceeds the overlap threshold. For example, with the overlap threshold set to 90% (or some other percentage), the system determines that 90% of the area of the module overlaps with one or more sets of pixels that are all within 90% of each other. Can be configured to set the module when The threshold may be much less than 90%. For example, a module with only a 30% overlap ratio (eg, the percentage by which pixels are overlapped by the module) may be sufficient to determine the value of the module. Lower thresholds can be used, for example, depending on the accuracy of the grid. As a general matter, this technique uses logic to take advantage of the fact that a module has one value, and pixels that this module substantially overlaps are unlikely to have the value corresponding to its exact opposite. be able to. For example, a black module that significantly overlaps a pixel will result in a gray or black (but not white) pixel value, and a white module that significantly overlaps a pixel will result in a gray or white (but not black) pixel value. be a value. Thus, modules with some overlap with foreground (darkest) pixels can be set to black, and modules with some overlap with background (lightest) pixels can be set to white.

The modules estimated in this step can be associated with pixels near the foreground and/or near the background. Thus, in some embodiments, the pixels populated in step 2006 can be modules associated with solid black or white regions of the image. As noted above, when referring to pixels as "white" or "black," the measure of whether a pixel is black or white can be determined in relation to the signal envelope of the image. Thus, in some embodiments, all darkest modules associated with the darkest pixels of the signal envelope are estimated, and all light modules associated with the brightest pixels of the signal envelope are estimated. Therefore, the signal envelope of the image can be used to normalize the white and black pixel ranges to determine the specific pixel range of the signal envelope.

Still referring to step 2006, the image processor can utilize known modules to determine other unknown modules. 25A and 25B illustrate examples of additional modules for an exemplary lattice of modules determined based on known modules, according to some embodiments. FIG. 25A shows new white module values (eg, including module value 2502) and new black module values (eg, including module value 2504) determined based on known modules, including the module determined in step 2004. show. Similarly, FIG. 25B shows additional module values determined, including a new white module value (eg, module value 2552) and a new black module value (eg, module value 2554), which are shown in FIG. It can be determined based on the new module determined in 25A. The image processor may look for pixels with gray values in the center of the range (eg, between the foreground and background of the signal envelope). For example, the image processor can infer additional modules by determining pixels that associate pixels with a particular number of modules. For pixels that are (a) mostly overlapped by only two modules and (b) have one of the module values already determined, the image processor will have the value of the other of these two modules and the value of the other module already determined. Can be set to the opposite value of what is known.

New module values can be determined based on known module values based on PPM. For example, for codes with PPM greater than 0.5, up to 9 modules may overlap a given pixel. The image processor can rank each of the 9 closest modules in the arranged grid by the overlap ratio, ie, how much the pixels are overlapped by each module. The image processor can add the top two percentages (the modules with the most overlap) and determine whether the sum exceeds a threshold (eg, a threshold of 90%). If the threshold is met and the value of only one of these two modules has already been determined, then the value of the other of these two modules can be set to the opposite value. For example, if one module has a value that is white, which largely overlaps with a gray module, the value of the other module is determined to be black (otherwise we would consider gray pixels rather than light pixels). ). This estimation technique can include variations of the previous examples. For example, the threshold could instead be compared to the three modules with the greatest overlap, and if two of them had known and identical values, the other one could have the opposite value. There must be. This technique can therefore use the known module and, in combination with the degree of overlap between the module and the pixel, estimate the value of the new module.

As an illustrative example, using the sampling matrix shown in FIG. 22B, the coefficients of the sampling matrix are percentages indicating the degree to which each pixel is overlapped by the associated module (e.g., each pixel covered by the associated module). percentage of a pixel). By using this overlap ratio, already estimated module values (eg, values associated with known features of the symbol) can be leveraged to figure out other neighboring modules around the known module. For example, for a sampling matrix with 9 coefficients, pixels that are mostly overlapped by only 2 modules are approximately equal to each other (eg, about 0.5 each) and the other 7 coefficients (eg, about 0.5 for the remainder). 0) has two coefficients much greater than

As new modules are determined, the image processor can iteratively determine additional sets of unknown modules. By leveraging the known module values, this technique can capture additional values based on pixel/module overlap as discussed herein. Initially, there may be many groups of unknown adjacent modules, but once the module values are determined by iteratively searching for pixels/modules with some overlap, these determined Additional values can be used to fill in different modal values.

With reference to steps 2008 and 2010, when no more module values can be estimated (eg, as described above with respect to steps 2004 and 2006), the image processor tests a set of valid combinations of values to find more unknowns. module can be determined. In some embodiments, the search space for the remaining modules is reduced now that the current set of pixels has been determined. The image processor can (eg, iteratively) determine the now smaller set of remaining unknown modules.

In some embodiments, for each module, the image processor may try the remaining valid combinations (e.g., 2x2, 3x3, etc.) of module patterns containing one or more of the determined pixels. . For example, the image processor can try a 3x3 module pattern with an unknown module in the center until it fails to make such an estimate. Using the 3×3 pattern as an example, there are 2 ⁹ =512 possibilities for each module. However, in many cases it will be much less than the maximum combination. For example, a 3x3 pattern of module values that have already been determined can reduce the number of possibilities. As another example, some of the coefficients for a particular 3×3 module can be small enough that the module value has little effect on the calculation. In some embodiments, possible modular patterns could be implemented in the manner described above for multi-level 1D symbologies.

Even if many modules have been determined in previous steps, recursively testing all possibilities can still be very time consuming. Testing all combinations may also be frustrating, for example because it may be difficult to distinguish between errors between correct patterns and parts of incorrect patterns. In some embodiments, a sampling matrix can be used to determine additional modules. For example, for each pixel that is overlapped by an undetermined module, a 1x9 sampling matrix can be used to determine the module value. The system can determine the modulus value by multiplying the 1x9 sampling matrix by an unknown vector of the 9 nearest binary (0 or 1) modulus values (representing the 3x3 modulus pattern). A pixel sampling matrix can be a section of rows of a larger sparse sampling matrix that associates every pixel in the image with every module of the grid, where each element (i,j) in the matrix is: It represents the percentage by which the pixel corresponding to matrix row i is overlapped or covered by the module corresponding to matrix column j. For each possible combination of binary values for the 9 modules of e.g. You can calculate the error in pixel values that occurs when multiplying by a factor. Any combination that yields a pixel value error that is within the acceptable error threshold can be considered a possible solution, while combinations that yield an error that exceeds the error threshold are excluded from consideration. If there is only one combination below the error threshold, the unknown module value of the corresponding 3x3 module pattern can be set accordingly. If there are multiple patterns, each combination that results in an error below the error threshold is recorded as a 9-bit integer for that pixel.

In some embodiments, the system can be configured to process a particular pixel first (eg, so that the module value is more likely to be decoded). For example, the system can be configured to first process pixels that have a number of overlapping modules that have already been determined. For example, the system can be configured to first focus on processing pixels in the outer perimeter of the symbol (eg, near the timing pattern and L finder pattern for which modules are determined). Using such a technique, at each iteration the values of the modules are determined progressively closer to the interior of the symbol and/or towards the interior of the otherwise large space of the unknown module.

After all pixels within the region of the grid have been considered and their 9-bit integers recorded, additional modules can be determined by an exclusion process. For example, the system can check the consistency of the remaining possible combinations of each pixel against the remaining possible combinations of each adjacent pixel associated with the module. For example, the system can take advantage of the fact that the 3x3 module pattern for a pixel substantially overlaps its eight neighbors to check the alignment of eight neighbors for a particular module. . In fact, the system can use the fact that each possible combination of a particular pixel is only compatible with a particular combination of neighboring pixels to determine the correct combination.

In some embodiments, a comparison of such a module with its neighboring modules can be used to generate an undirected constraint graph. The 9-bit integers representing the conserved combinations of binary values for the 9 modules of the 3x3 module pattern for each module can be populated as nodes in the graph, and the linkage with each matching 9-bit integer for the adjacent module is It can be an edge in the graph. Two nodes are considered consistent if the overlap region between each 3×3 module pattern in the grid of modules has the same combination of binary values.

Determining the remaining modules can therefore involve determining a consistent and unique set of edges between each pixel and its eight neighbors, so that only one node is found in each pixel. , excluding other nodes and their edges. The system can use the nodes selected for the pixels to determine the correct combination of overlapping modulus values. The system can exclude certain nodes in the graph and their associated edges. For example, the system can exclude nodes that are not connected by at least one edge to at least one node in each adjacent pixel. Excluding such nodes can eliminate some nodes in the graph, especially nodes for pixels that are adjacent to other pixels that have only one node. Exclusion of such nodes can be performed iteratively until there are no such nodes in the graph. Even after excluding a specific node as described above, there may still be multiple nodes (combination) remaining at a specific pixel. In some embodiments, the system can be configured to test for exclusion of certain options. For example, the system can be configured to select a node for one of the pixels (eg, pixels with only two possibilities) by random selection. The system can exclude other nodes for that pixel and repeat the node exclusion process described above. As a result of performing such selections and exclusions, other pixels can be determined or all nodes for other pixels can be excluded. In the latter case, the system can determine that the selected node should be excluded. Otherwise, the system attempts to decode the module by computing the module values of all possible choices stored for this one pixel (and/or other pixels) and determines whether the decoding succeeds. It can be configured to determine whether The system can rely on built-in error correction to prevent the system from misreading symbols. If the symbol is not decoded, the system once again realizes that the selected node was incorrect and should therefore be excluded.

Below is an example of determining the constraint graph. Let G be the (n+2)×(m+2) matrix of module values estimated so far for the 2D symbols, where n is the number of rows and m the number of columns of the symbol. In some embodiments, there are additional rows and/or columns (e.g. 2 additional rows and 2 additional columns) in the matrix, which are used on (both) sides of the symbol to increase the module width of the quiet zone. part can be encoded.

Each element of G can be denoted g(k,l), where k ranges from 0 to n+1, l ranges from 0 to m+1, and g(k,l)=0 (dark), 1 (light), or ? (unknown). For each module (k,l), let S(k,l) be a 3x3 submatrix of G centered on the module k,l. Each element of S(k,l) is denoted s(k,l,i,j), where i is the row index and ranges from -1 to 1, and dj is the column index and ranges from -1 to 1. is in the range of Also note that s(k,l,i,j)=m(k+l,i+j) for all i and j.

For a given submatrix S(k,l), there are 2 ^u possible pattern combinations, where u(k,l) is the number of unknown elements in S(k,l). is (the number of i,j coordinates of s(k,l,i,j)=?)). Denote each possible pattern by a 3×3 matrix M(k,l,z), where z ranges from 1 to u(k,l). Each element of M(k, l, z) is denoted by m(k, l, z, i, j)=0 or 1 where (k, l, z, i, j) is 0 or 1 (known ), then m(k, l, z, i, j) = s(k, l, z, i, j) (eg, if only the unknown values can change).

The system illuminates each of the matrix patterns M(k,l,z) against the image pixels according to a sampling matrix relating each element m(k,l,z,i,j) to a grid of pixels to fall below an error threshold. You can check whether

The 8 directions from any module (k, l) are represented with row offsets d _r ranging from -1 to 1 and column offsets d _c ranging from -1 to 1 (both d _r and d _c are 0 or it will not be the direction from module (k,l)). In other words, the 8 directions are (d _r and d _c )=(0,1), (0,−1), (1,0), (−1,0), (1,1), (1,− 1), (−1,1) and (−1,−1).

For each pattern M(k,l,z) below the error threshold, establish a node N(k,l,z). Edges can then be established in the undirected graph that link the nodes together. For any pair of nodes N(k, l, z ₁ ) and N(k+d _r , l+d _c , z 2 ), where (k+dr, l+d _c ) are the possible eight directions from module (k, l) _Link L(k, l _, z ₁ , k+d _r , l+d _c , z2) are established only if the overlapping subpatterns are the same. That is, for all i=i _min to i _max and for all j=j _min to j _max , m(k, l, z ₁ , i, j)=m(k+d _r , l+d _c , z ₂ , id _r , jd _c ). where i _min , i _max , j _min , j _max are determined based on the following directions:
i _min =−1 if d _r ≦0, 0 otherwise
i _max =1 if d _r ≧0, 0 otherwise
j _min =−1 if d _c ≦0, 0 otherwise
j _max =1 if d _c ≧0, 0 otherwise
If d _r =0, the overlap area is 3×2, if d _c =0, the overlap area is 2×3, and if diagonal, the overlap area is 2×2.

Nodes that cannot be linked to at least one other node in each of all eight directions are excluded from further consideration. As nodes are excluded, their respective links are also excluded, thereby excluding more nodes not linked to each of the eight directions, and so on. This exclusion process allows only one node to remain for each module (l, k), so all module values are known at that time. However, even if there is only one node left in one or more modules, there will be only one option in each module that is 8-way connected in each module. In such situations, an additional search can be performed to determine such nodes (eg, exhaustively searching all remaining combinations).

FIG. 32 illustrates an example of an undirected constraint graph according to some embodiments. A portion of the lattice of modules 3200 contains several estimated modules and the remaining three modules to be estimated, shown as modules 3202 , 3204 and 3206 . Box 3208 highlights the modules surrounding the center of the portion of the grid 3200 of modules, and box 3210 highlights the modules adjacent to the southeast in the portion of the grid 3200 of modules. The modules surrounding the center have 3 unknown modules, leaving 8 possible combinations. Specifically, the possible combinations of the centrally located modules are possible combination 3212 (three unknown modules all white), possible combination 3214 (unknown module 3204 black, unknown modules 3202 and 3206 white). , possible combination 3216 (unknown module 3202 black, unknown modules 3204 and 3206 white), possible combination 3218 (unknown modules 3202 and 3204 black, unknown module 3206 white), possible combination 3220 ( Unknown modules 3202 and 3204 are white, unknown modules 3206 are black), possible combinations 3222 (unknown modules 3202 are white, unknown modules 3204 and 3206 are black), possible combinations 3224 (unknown modules 3202 and 3206 are black, unknown module 3204 is white), and possible combinations 3226 (all three unknown modules are black). The southeast module has only two unknown modules, leaving four possible combinations. Possible combinations for the module located southeast are possible combination 3230 (both modules white), possible combination 3232 (unknown module 3204 black, unknown module 3206 white), possible combination 3234 (unknown module 3204 is shown as white, unknown module 3206 is black), and possible combination 3236 (both unknown modules are black).

In this example, the image processor performs an error test on the remaining combinations of each set of modules and eliminates possible combinations 3212, 3216, 3218, 3224 and 3234. The image processor eliminates possible combination 3220 from consideration because possible combination 3220 is unlikely to match the remaining combinations (possible combinations 3232 or 3236) for the southeast module. After such processing, there is a first possible match 3240 between possible combination 3214 and possible combination 3232, and a second possible match 3242 between possible combination 3222 and possible combination 3236. There is a third possible match 3244 between possible combination 3226 and possible combination 3236 .

At step 2012, the image processor decodes the symbol based on the determined module values, including the values determined at steps 2004-2010. All modules may have been determined at this point, but some module values may still be unknown (such as low-resolution images). For example, an undetermined module can be associated with pixels in a uniform gray region, such as when pixels straddling the module flip back and forth between black and white values. However, the image processor can decode the symbols even if all modules are not completed. For example, most 2D symbols are encoded with some degree of redundancy, such as using Reed-Solomon error correction and/or other error corrections. As another example, an unknown module is often given a higher error rate (eg, twice the error rate) as an erroneously determined module. Thus, in step 2012, the image processor can decode a sufficient number of modules to decode the symbol, even if not all modules.

26-31 are used as illustrative examples of applying the techniques discussed herein to decode a multi-level 1D barcode (eg, the 1D barcode shown in FIG. 2). FIG. 26 shows an exemplary 1D image 2600 of a multilevel 1D symbol according to some embodiments. 1D image 2600 can be obtained in a manner similar to that described above by sampling along scanlines through a 2D image obtained as described above for image 2100 of FIG. Image 2600, like image 2100, includes a set of pixels (eg, pixels 2602, 2604) associated with a pixel value indicating the darkness of each pixel. Pixels 2602, 2604 are referred to as pixels (eg, extracted using a laser scanner), whereas in some embodiments each pixel may be a sample as described above. In such embodiments, image 2600 is processed to compute the samples. As described herein above and further discussed below, the envelope of the image signal can be used to decode a 1D barcode.

The method 2000 described in FIG. 20 can be used to decode multi-level 1D symbols. FIG. 27 shows an exemplary grid of modules 2700 for multi-level 1D symbols superimposed on top of image 2600 from FIG. 26, according to some embodiments. Referring to step 2004 , similar to 2D barcodes, the system determines the spatial mapping between modules in grid 2700 of modules and pixels of image 2600 . For example, the grid of modules 2700 may need to be shifted and/or scaled to map to the pixels of image 2600 . The relationship between the grid of modules 2700 and the grid of pixels of image 2600 can reflect how each module affects each of the pixels. FIG. 28 is an exemplary illustration of the degree of overlap between modules of grid of modules 2700 and pixels of image 2600, according to some embodiments. Thick solid arrows (eg, arrows 2802, 2804 and 2806) indicate a large degree of overlap, and thin dotted arrows (eg, arrows 2808, 2810) indicate a small degree of overlap. As discussed herein, the above description applies to a 1D signal of samples (e.g., a one-dimensional image (or single row) of pixels in image 2600) for a one-dimensional grid (e.g., a one-dimensional grid of pixels 2700) is provided.

This technique may involve first locating a grid of modules of the symbol with respect to a grid of pixels of the image. As explained above, any modular pattern can be inferred without having to examine each character individually. In the case of 1D symbols, the positions of the grid can be arbitrary, such as delimiters (such as the leftmost and rightmost characters of a 1D symbol) and/or known aspects of characters (such as the end and/or beginning of a character bar or space). Can be identified using the module pattern. FIG. 29 illustrates an example of estimating modules of a lattice of modules 2700 for arbitrary module patterns, according to some embodiments. Modules 2902 and 2906 are assumed to be spaces (white modules) and modules 2904 and 2908 are assumed to be bars (black modules). For example, for a Code 128 symbol, a character begins with a bar (such as bar 2904) and ends with a space (such as space 2906), the preceding character ends with a space (such as space 2902), and the following character ends with a bar (such as bar 2908). begin.

30A and 30B show modules of an exemplary grid of modules 2700 inferred based on relationships between modules and pixels, according to some embodiments. Referring to step 2006 of FIG. 20, the image processor uses the causality determined between the modules in the grid of modules and the pixels in the image to determine whether this step is performed on the 2D barcode. A first set of modules (eg, modules that have a high degree of overlap with the relevant pixel) can be estimated in a similar manner. The estimation shown in FIG. 30A includes additionally estimated white modules 3002, 3004 and 3006 (eg, in addition to the pattern of any modules estimated in connection with step 2004), and FIG. and black modules 3008 and 3010 . For example, as described in relation to 2D barcodes, the image processing device injects modules with a very high degree of overlap (e.g., 90%, 30%, etc.), such as modules whose sampling factor exceeds the overlap threshold. can. FIG. 30A shows overlapping by arrows 3050, 3052 and 3054 as an example. As noted above, this technique uses logic to take advantage of the fact that a module has one value and pixels that this module substantially overlaps are unlikely to have their opposite corresponding values. can be done. Thus, modules with some overlap with foreground (darkest) pixels can be set to black (e.g. modules 3008, 3010) and modules with some overlap with background (lightest) pixels can be set to white (e.g. modules 3002, 3010). 3004 and 3006). As noted above, when a pixel is referred to as being "white" or "black", the measure of whether the pixel is black or white can be determined in relation to the signal envelope of the image (e.g. A specific pixel range for the signal envelope can be determined by normalizing the white and black pixel ranges using the signal envelope of the image).

FIG. 31 illustrates additional modules in a grid 2700 of modules determined based on known modules, according to some embodiments. This technique can leverage the first set of modules decoded in the previous step to decode the second set of modules. Referring to steps 2008 and 2010 of FIG. 20, when no more module values can be estimated (eg, as described above with respect to steps 2004 and 2006), the image processor tests a set of valid combinations of values. can further determine unknown modules. In some embodiments, the search space for the remaining modules is reduced now that the current set of pixels has been determined. The image processor can (eg, iteratively) determine the now smaller set of remaining unknown modules. As shown in Figure 31, modules 3102, 3104, 3106 are estimated in this step. In this example, logic can be used to determine the remaining modules, as described more generally below. For example, modules 3102 , 3104 and 3106 in this example alternate to produce uniform gray values for associated pixels 3150 and 3152 . Module 3106 is white (space) to produce an associated uniform gray pixel value 3154 with adjacent black module 3008 . Module 3108 is space to produce an associated light gray pixel value 3156 .

In some embodiments, the image processor may, for each module, try the remaining valid combinations (eg, 1×2, 1×3, etc.) of module patterns containing one or more determined pixels. For example, the image processor can try a 1x3 module pattern with an unknown module in the center until no more such guesses are possible. Using the 1×3 pattern as an example, each module has 2 ³ =8 possibilities. In addition, the number of possibilities can be reduced because known modules reduce the number of possibilities as described above for 2D barcodes.

As noted above, even if many modules have been determined in previous steps, recursively testing all possibilities may still be very time consuming and/or do not work well. In some embodiments, a sampling matrix can be used to determine additional modules. For example, for each pixel that is overlapped by an undetermined module, a 1x3 sampling matrix can be used to determine the module value. The system can determine the modulus value by multiplying the 1×3 sampling matrix by an unknown vector of the three nearest binary (0 or 1) modulus values. As described above, for each possible combination of binary values, the error between the actual pixel value and the pixel value resulting from multiplying the sampling factor can be calculated. Any combination of pixel values yielding an error within the acceptable error threshold can be considered as a possible solution, while those yielding an error exceeding the error threshold are excluded from consideration. If there is only one pattern below the error threshold, the unknown module value of the combination can be set appropriately. Otherwise, possible solutions can be recorded as 3-bit integers.

As noted above, in some embodiments, the system may be configured to process certain pixels first (eg, so that the module value is more likely to be decoded). For example, the system can be configured to first process pixels that have a number of overlapping modules that have already been determined. For example, the system may be configured to first focus on processing pixels around the outside of the symbol (e.g., near delimiters and/or character start/end modules whose modules are determined as described above). can. Using such a technique, at each iteration the values of the modules are determined progressively closer to the interior of the symbol and/or towards the interior of the otherwise large space of the unknown module.

After all pixels within the region of the grid have been considered and their 3-bit integers recorded, additional modules can be determined by an exclusion process. For example, the system can check the consistency of the remaining possible combinations of each pixel against the remaining possible combinations of each adjacent pixel associated with the module. For example, the system can take advantage of the fact that the 1x3 module pattern for a pixel substantially overlaps its two neighboring pixels to check the alignment of two neighboring pixels for a particular module. In fact, the system can use the fact that each possible combination of a particular pixel is only compatible with a particular combination of neighboring pixels to determine the correct combination. In fact, the system can use the fact that each possible combination of a particular pixel is only compatible with a particular combination of neighboring pixels to determine the correct combination.

As described above with respect to 2D, in some embodiments, a comparison of a module with its neighboring modules can be used to generate an undirected constraint graph. The 3-bit integers representing the conserved combinations of binary values for the 3 modules of each module's 1×3 module pattern can be populated as nodes in the graph, and the linkage with each consistent 3-bit integer for the adjacent module is It can be an edge in the graph. Two nodes are considered consistent if the overlap region between each 1×3 module pattern in the grid of modules has the same combination of binary values. Determining the remaining modules may therefore involve determining a consistent and unique set of edges between each pixel and its two neighbors, so that only one node is present in each pixel , excluding other nodes and their edges. The system can use the nodes selected for the pixels to determine the correct combination of overlapping modulus values. As described above, the system can exclude certain nodes in the graph and their associated edges.

Techniques operating in accordance with the principles described herein may be implemented in any suitable manner. The processing and decision blocks in the above flowcharts represent steps and actions that can be included in algorithms that perform these various processes. Algorithms derived from these processes can be implemented as software integrated with one or more dedicated or general-purpose processors to direct its operation, functioning as digital signal processing (DSP) circuits or application-specific integrated circuits (ASICs). may be implemented as a substantially equivalent circuit, or may be implemented in any other suitable manner. It should be understood that the flowcharts contained herein do not represent the syntax or operation of any specific circuitry or any specific programming language or class of programming languages. Rather, these flow charts are illustrative of functional information that can be used by those skilled in the art to fabricate circuits or implement computer software algorithms to perform the processing of a particular device that performs the types of techniques described herein. is. Unless stated otherwise herein, the specific sequence of steps and/or actions set forth in each flowchart is merely an example of algorithms that may be implemented and may vary in implementations and embodiments of the principles described herein. It should also be understood that it is possible.

Thus, in some embodiments, the techniques described herein are computer-executable software implemented as software including application software, system software, firmware, middleware, embedded code, or any other suitable type of computer code. Can be instantiated in an instruction. Such computer-executable instructions can be written using any of a number of suitable programming languages and/or programming or scripting tools, executable machine language code or May be compiled as intermediate code.

When the techniques described herein are embodied as computer-executable instructions, these computer-executable instructions may be implemented in any suitable manner, including numerous convenience features, each of which is a provides one or more operations for completing execution of an algorithm that operates according to. However, an instantiated "convenience function" is a structural element of a computer system that, when integrated and executed with one or more computers, causes one or more computers to perform specific operational roles. Convenience functions may be part or all of the software elements. For example, convenience functions may be implemented as functions of processes, or as separate processes, or other suitable units of processing. Where the techniques described herein are implemented as multiple convenience functions, each convenience function may be implemented in its own way and need not all be implemented in the same way. Further, these convenience functions may be executed in parallel and/or serially as desired, and may be executed using the shared memory of the computer on which they are executing, using a message passing protocol, or in any other suitable manner. can pass information between each other.

Convenience functions generally include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. In general, the functionality of convenience features can be combined and distributed as desired in the systems in which they operate. In some implementations, one or more convenience functions that perform the techniques herein can together form a complete software package. These convenience functions may be adapted to interact with other unrelated convenience functions and/or processes to implement software program applications in alternative embodiments.

Several exemplary convenience features have been described herein for performing one or more tasks. However, the convenience functions and task divisions described are merely illustrative of the types of convenience functions with which the exemplary techniques described herein can be implemented, and embodiments may include any particular number, division, or type of convenience functions. It should be understood that it is not limited to functionality. In some implementations, all functionality may be implemented in a single convenience function. Also, in some implementations, some of the convenience features described herein may be implemented together with other convenience features or separately (i.e., as a single unit or separate units); some may not be implemented.

Computer-executable instructions that implement the techniques described herein (when implemented as one or more convenience features or otherwise) are, in some embodiments, encoded on one or more computer-readable media and can provide functionality to The computer readable medium may be magnetic media such as hard disk drives, optical media such as compact discs (CDs) and digital versatile discs (DVDs), persistent or non-persistent solid state memory (flash memory, magnetic RAM, etc.), or Including other suitable storage media. Such computer-readable media may be implemented in any suitable way. As used herein, "computer-readable medium" (also called "computer-readable storage medium") refers to tangible storage media. A tangible storage medium is non-transitory and has at least one physical structural element. As used herein, "computer-readable medium" refers to at least one physical, structuring element that describes a process that creates a medium in which information is embedded, a process that records information on the medium, or encodes a medium that contains information. It has at least one physical property that can be altered in some way during the process. For example, the magnetization state of some of the physical structures of the computer-readable medium can be changed during the recording process.

Moreover, some of the techniques described above involve acts that store information (eg, data and/or instructions) in some way for use by those techniques. In some implementations of these techniques—such as those in which the techniques are implemented as computer-executable instructions—information is encoded on computer-readable storage media. Where specific structures are described herein as advantageous formats for storing this information, these structures can be used to provide the physical organization of the information when encoded on storage media. . These advantageous structures, in turn, can impart functionality to the storage medium by influencing the operation of one or more processors interacting with the information, eg, by increasing the efficiency of computer operations performed by the processors.

In some implementations, but not all implementations, where the techniques may be embodied as computer-executable instructions, those instructions may be executed by one or more suitable computing devices running on any suitable computer system; Any of the above computing devices (or one or more processors of one or more computing devices) can be programmed to execute computer-executable instructions. A computing device or processor may store data stores or the like in such a way that the instructions are accessible to the computing device or processor (e.g., on-chip cache or instruction registers, computer readable storage media accessible via a bus, via one or more networks). computer-readable storage medium accessible by the device/processor) to execute instructions. Convenience features containing these computer-executable instructions may be combined into a single multipurpose programmable digital computing device, two or more multipurpose computing devices that share processing power and jointly perform the techniques described herein. A collaborative system, a single computing device dedicated to performing the techniques described herein or a collaborative system of computing devices (co-located or geographically distributed), performing the techniques described herein It can be integrated with one or more Field Programmable Gate Arrays (FPGAs) for or any other suitable system to direct its operation.

A computing device may include at least one processor, a network adapter, and a computer-readable storage medium. A computing device may be, for example, a desktop or laptop personal computer, a personal digital assistant (PDA), a smart phone, a mobile phone, a server, or any other suitable computing device. A network adapter is any suitable hardware and/or enabling a computing device to communicate wiredly and/or wirelessly with any other suitable computing device over any suitable computing network. or software. A computing network includes wireless access points, switches, routers, gateways, and/or other network equipment, and any suitable wired and/or wireless communication medium for exchanging data between two or more computers, including the Internet. OK. A computer-readable medium may be adapted to store data to be processed and/or instructions to be executed by a processor. Processors enable the processing of data and the execution of instructions. Data and instructions may be stored in a computer-readable storage medium.

A computing device may also have one or more components and peripherals, including input/output devices. These devices can be used, among other things, to provide a user interface. Examples of output devices that can be used to provide a user interface include printers or display screens for visually displaying output and speakers or other sound generating devices for audibly displaying output. Examples of input devices that can be used for user interfaces include keyboards, pointing devices such as mice and touch pads, and digitizing tablets. As another example, a computing device may receive input information in speech recognition or other audible form.

The described embodiments are techniques implemented in circuits and/or computer-executable instructions. It should be appreciated that some embodiments may be in the form of methods of which at least one example has been provided. The acts performed as part of the method may be ordered in any suitable manner. Thus, although illustrated embodiments are shown as sequential operations, embodiments may be configured to perform the operations in a different order than illustrated, including performing some operations simultaneously. you can

Various aspects of the above embodiments can be used singly, in combination, or in various arrangements not specifically discussed in the above embodiments and are therefore noted in the above description in their application. or to the details and arrangements of components shown in the drawings. For example, aspects described in one embodiment may be combined in any manner with aspects described in other embodiments.

The use of ordinal numbers such as "first," "second," "third," etc. to modify claim elements in a claim does not, in itself, give precedence or predominance of one claim element over another. or order, or the chronological order in which the method acts are performed, but merely to distinguish claim elements from one another with the same name (except for the use of ordinal numbers). It is used only as a label to distinguish elements of

Also, the phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting. The use of "including," "having," "having," "including," "accompanied by," and variations thereof herein encompasses the items listed thereafter and their equivalents, as well as additional items. means to

The word "exemplary" is used herein to mean serving as an example, instance, or illustration. Thus, the embodiments, implementations, processes, features, etc., described herein as illustrative are to be understood as illustrative examples, and unless otherwise specified, are to be understood as preferred or advantageous examples. shouldn't.

Having thus described several aspects of at least one embodiment, it is to be appreciated various alterations, modifications, and improvements will readily occur to those skilled in the art. Such alterations, modifications, and improvements are intended to be part of this disclosure, and are intended to be within the spirit and scope of the principles described herein. Accordingly, the above description and drawings are exemplary only.

Claims (40)

A computerized method for decoding symbols in a digital image comprising:
The method comprises receiving a digital image of a portion of the symbol, wherein the digital image comprises a grid of pixels, the symbol comprises a grid of modules;
The method comprises determining a spatial mapping between a contiguous subset of modules within the grid of modules and the grid of pixels;
The method comprises using the spatial mapping to determine a causal relationship between each module in the contiguous subset of modules and the grid of pixels, wherein the causal relationship is a represents the degree to which a value affects each of the values of a subset of pixels in a grid of pixels,
The method comprises using the causality to test a set of valid combinations of values of two or more adjacent modules in the contiguous subset of modules against the grid of pixels;
The method comprises determining the value of at least one of the two or more adjacent modules based on the set of valid combinations tested, and the method comprises: decoding the symbol based on the determined value of the module of
above method. 2. The method of claim 1, wherein the two or more adjacent modules in a contiguous subset of modules within a grid of modules comprise a 3x3 sub-grid of the grid of modules. 3. The method of claim 2, wherein at least one module of said two or more modules is a center module of said 3x3 sub-grid. The contiguous subset of modules includes at least one predetermined module having known values, and a set of valid combinations of values of the two or more adjacent modules is known for the at least one predetermined module. 2. The method of claim 1, including only combinations having values of . 5. The method of claim 4, wherein the predetermined module is a module within a symbol's finder pattern or timing pattern. The known value of the given module determines that a single pixel has a dominant causal relationship with the given module compared to causality between other pixels in the subset of pixels and the given module. 5. The method of claim 4, wherein the estimation is based only on the value of the single pixel in the grid of pixels because it has 5. The method of claim 4, wherein said predetermined module comprises any module having a previously determined value. Determining the causal relationship includes using spatial relationships to identify the extent to which each module in the contiguous subset of modules overlaps with each pixel in the grid of pixels to determine a set of extents of overlap. 2. The method of claim 1, generating. 9. The method of claim 8, wherein the degree to which each module in the contiguous subset of modules overlaps each pixel in a grid of pixels is represented by a set of sampling factors and as part of a sampling matrix. 2. The method of claim 1, wherein both the grid of pixels and the grid of modules are two-dimensional. 2. The method of claim 1, wherein the grid of pixels is a one-dimensional grid of samples from a one-dimensional scan through a two-dimensional image and the grid of modules is a one-dimensional grid of modules. 2. The method of claim 1, wherein said symbols are selected from the group consisting of one-dimensional (1D) barcodes and two-dimensional (2D) barcodes. An apparatus for decoding symbols in a digital image, comprising a processor in communication with memory, said processor being configured to execute instructions stored in memory, said instructions being:
causing the processor to receive a digital image of a portion of a symbol, wherein the digital image comprises a grid of pixels and the symbol comprises a grid of modules;
causing the processor to determine a spatial mapping between a contiguous subset of modules within the grid of modules and the grid of pixels;
cause the processor to determine a causal relationship between each module in the contiguous subset of modules and the grid of pixels using the spatial mapping, wherein the causal relationship is a represents the degree of influence on each of the values of a subset of pixels in the grid,
causing the processor to use the causality to test a set of valid combinations of values of two or more adjacent modules in the contiguous subset of modules against the grid of pixels;
causing the processor to determine the value of at least one of the two or more adjacent modules based on the set of valid combinations tested; and causing the processor to determine the at least one module. is the one that causes the symbols to be decoded, based on the value obtained,
the above equipment. 14. The apparatus of claim 13, wherein the two or more adjacent modules in a contiguous subset of modules within a grid of modules comprise a 3x3 sub-grid of the grid of modules. The contiguous subset of modules includes at least one predetermined module having known values, and a set of valid combinations of values of the two or more adjacent modules is known for the at least one predetermined module. 14. The apparatus of claim 13, comprising only combinations having values of .
Determining the causal relationship includes using spatial relationships to identify the extent to which each module in the contiguous subset of modules overlaps with each pixel in the grid of pixels to determine a set of extents of overlap. 14. The apparatus of claim 13, comprising generating. 14. The apparatus of claim 13, wherein both the grid of pixels and the grid of modules are two-dimensional. 14. The apparatus of claim 13, wherein the grid of pixels is a one-dimensional grid of samples from a one-dimensional scan through a two-dimensional image and the grid of modules is a one-dimensional grid of modules. 14. The apparatus of claim 13, wherein said symbols are selected from the group consisting of one-dimensional (1D) barcodes and two-dimensional (2D) barcodes. At least one non-transitory computer-readable storage medium storing processor-executable instructions, said instructions being executed by at least one computer hardware processor:
causing said at least one computer hardware processor to receive a digital image of a portion of a symbol, wherein the digital image comprises a grid of pixels and the symbol comprises a grid of modules;
causing the at least one computer hardware processor to determine a spatial mapping between a contiguous subset of modules within the grid of modules and the grid of pixels;
causing the at least one computer hardware processor to use the spatial mapping to determine a causal relationship between each module in the contiguous subset of modules and the grid of pixels, wherein the causal relationship is: represents the degree to which the value of the modulus affects each of the values of a subset of pixels in a grid of pixels,
causing the at least one computer hardware processor to use the causality to test a set of valid combinations of values of two or more adjacent modules in the contiguous subset of modules against the grid of pixels;
causing the at least one computer hardware processor to determine the value of at least one of the two or more adjacent modules based on the set of valid combinations tested; and causing a hardware processor to decode symbols based on the determined values of the at least one module;
The above non-transitory computer-readable storage medium. A computerized method comprising:
The method comprises receiving a digital image and a spatial mapping of a portion of a symbol, wherein the digital image comprises a grid of pixels, the symbol comprises a grid of modules, and the spatial mapping is a grid of modules. relating a contiguous subset of modules to the grid of pixels;
The method comprises determining a set of valid combinations of values of two or more adjacent modules within said contiguous subset of modules, each valid combination of values in said set of valid combinations of values. teeth:
using the spatial mapping to determine (i) the degree of overlap between the first set of modules and respective grids in the grid of pixels; and/or (ii) among the first set of modules. for a first set of modules in the contiguous subset of modules determined based in part on a predetermined value for adjacent modules overlapping each pixel mapped to at least one of a value for a first module in said two or more adjacent modules that is from a set of values; and said second if contained in a different valid combination of values in said set of valid combinations of values. a first valid value for a second module in said two or more adjacent modules that is different than a second valid value for a module of;
The method uses a causal relationship between each module in the contiguous subset of modules and the grid of pixels to identify the valid combinations of values of two or more adjacent modules in the contiguous subset of modules. testing a set against said grid of pixels, wherein each causal relationship of a module within said contiguous subset of modules on the value of each of a subset of pixels in said grid of pixels; indicates the degree of influence the value has;
The method comprises decoding symbols based on at least one tested valid combination of values from a set of valid combinations of values of the two or more adjacent modules, wherein and at least one tested valid combination of said values includes the final value of said second module in said two or more adjacent modules;
above method. 22. The method of claim 21, wherein the two or more adjacent modules in a contiguous subset of modules within a grid of modules comprise a 3x3 sub-grid of the grid of modules. 23. The method of claim 22, wherein the second module of the two or more adjacent modules is the center module of the 3x3 sub-grid. 22. The method of claim 21, wherein the adjacent modules are modules within a symbol's finder pattern or timing pattern. Due to a single pixel having a dominant causal relationship with the adjacent module when compared to causal relationships between other pixels in the subset of pixels and the adjacent module, the adjacent 22. The method of claim 21, wherein the predetermined value of module is estimated based on the value of the single pixel in the grid of pixels. Determining the causal relationship is done by using the spatial mapping to identify the degree to which each module in the contiguous subset of modules overlaps with each pixel in the grid of pixels, whereby overlapping 22. The method of claim 21, wherein a set of degrees of is generated. 27. The method of claim 26, wherein the degree to which each module in the contiguous subset of modules overlaps each pixel in the grid of pixels is represented by a set of sampling factors and as part of a sampling matrix. . 22. The method of claim 21, wherein both the grid of pixels and the grid of modules are two-dimensional. 22. The method of claim 21, wherein the grid of pixels is a one-dimensional grid of samples from a one-dimensional scan through a two-dimensional image and the grid of modules is a one-dimensional grid of modules. 22. The method of claim 21, wherein said symbols are selected from the group consisting of one-dimensional (1D) barcodes and two-dimensional (2D) barcodes. An apparatus comprising a processor in communication with a memory, the processor configured to execute instructions stored in the memory, the instructions comprising:
causing said processor to receive a digital image and a spatial mapping of a portion of a symbol, wherein said digital image comprises a grid of pixels, said symbol comprises a grid of modules, and said spatial mapping is a succession of modules in said grid of modules; relating a subset to the grid of pixels;
causing said processor to determine a set of valid combinations of values of two or more adjacent modules in said contiguous subset of modules, wherein each valid combination of values in said set of valid combinations of values; teeth:
using the spatial mapping to determine (i) the degree of overlap between the first set of modules and respective grids in the grid of pixels; and/or (ii) among the first set of modules. for a first set of modules in the contiguous subset of modules determined based in part on a predetermined value for adjacent modules overlapping each pixel mapped to at least one of a value for a first module in said two or more adjacent modules that is from a set of values; and said second if contained in a different valid combination of values in said set of valid combinations of values. a first valid value for a second module in said two or more adjacent modules that is different than a second valid value for a module of;
instructing the processor to identify the valid combinations of values of two or more adjacent modules in the contiguous subset of modules using causality between each module in the contiguous subset of modules and the grid of pixels; causing a set to be tested against said grid of pixels, wherein each causal relationship has the value of a module within said contiguous subset of modules on the value of each of a subset of pixels in said grid of pixels; indicating the degree of impact;
cause the processor to decode symbols based on at least one tested valid combination of values from a set of valid combinations of values of the two or more adjacent modules; at least one tested valid combination of includes the final value of said second module in said two or more adjacent modules;
the above equipment. 32. The apparatus of claim 31, wherein the two or more adjacent modules within the contiguous subset of modules within the grid of modules comprise a 3x3 sub-grid of the grid of modules. 33. The apparatus of claim 32, wherein said second module of said two or more adjacent modules is a center module of said 3x3 sub-grid. Due to a single pixel having a dominant causal relationship with the adjacent module when compared to causal relationships between other pixels in the subset of pixels and the adjacent module, the adjacent 32. The apparatus of claim 31, wherein the predetermined value of module is estimated based on the value of the single pixel in the grid of pixels. Determining the causality is done by using the spatial mapping to identify the extent to which each module in the contiguous subset of modules overlaps with each pixel in the grid of pixels, thereby overlapping 32. The apparatus of claim 31, wherein a set of degrees of is generated. 36. The apparatus of claim 35, wherein the degree to which each module in the contiguous subset of modules overlaps each pixel in the grid of pixels is represented by a set of sampling factors and as part of a sampling matrix. . 32. The apparatus of claim 31, wherein both the grid of pixels and the grid of modules are two-dimensional. 32. The apparatus of claim 31, wherein the grid of pixels is a one-dimensional grid of samples from a one-dimensional scan through a two-dimensional image and the grid of modules is a one-dimensional grid of modules. 32. The apparatus of claim 31, wherein said symbols are selected from the group consisting of one-dimensional (1D) barcodes and two-dimensional (2D) barcodes. At least one non-transitory computer-readable storage medium storing processor-executable instructions, said instructions being executed by at least one computer hardware processor:
causing said at least one computer hardware processor to receive a digital image and a spatial mapping of portions of a symbol, wherein said digital image comprises a grid of pixels, said symbol comprises a grid of modules, and said spatial mapping comprises said modules; relating a contiguous subset of modules in the grid of the pixels to the grid of pixels;
causing said at least one computer hardware processor to determine a set of valid combinations of values of two or more adjacent modules within said contiguous subset of modules, wherein the values in said set of valid combinations of values; Each valid combination of is:
using the spatial mapping to determine (i) the degree of overlap between the first set of modules and respective grids in the grid of pixels; and/or (ii) among the first set of modules. for a first set of modules in the contiguous subset of modules determined based in part on a predetermined value for adjacent modules overlapping each pixel mapped to at least one of a value for a first module in said two or more adjacent modules that is from a set of values; and said second if contained in a different valid combination of values in said set of valid combinations of values. a first valid value for a second module in said two or more adjacent modules that is different than a second valid value for a module of;
instructing the at least one computer hardware processor to use the causal relationship between each module in the contiguous subset of modules and the grid of pixels to determine the values of two or more adjacent modules in the contiguous subset of modules; are tested against the grid of pixels, wherein each causal relationship is on the value of each of a subset of pixels in the grid of pixels within the contiguous subset of modules indicates the degree of influence that the value of the module of
cause the at least one computer hardware processor to decode symbols based on at least one tested valid combination of values from a set of valid combinations of values of the two or more adjacent modules; , wherein at least one tested valid combination of said values includes the final value of said second module in said two or more adjacent modules;
The above non-transitory computer-readable storage medium.

Images