You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1116 lines
41 KiB
TypeScript
1116 lines
41 KiB
TypeScript
declare module "common/polyfills" {
|
|
export function polyfills(): void;
|
|
const _default: void;
|
|
export default _default;
|
|
}
|
|
declare module "common/point" {
|
|
export interface Point {
|
|
x: number;
|
|
y: number;
|
|
}
|
|
}
|
|
declare module "common/image-debug" {
|
|
import { Point } from "common/point";
|
|
export const ImageDebug: {
|
|
drawPath(path: Point[], context: CanvasRenderingContext2D, color: string, lineWidth: number): void;
|
|
drawImage(imageData: Uint8Array, width: number, height: number, context: CanvasRenderingContext2D): boolean;
|
|
};
|
|
}
|
|
declare module "common/box" {
|
|
import { Point } from "common/point";
|
|
export type Box = [Point, Point, Point, Point];
|
|
}
|
|
declare module "common/moment" {
|
|
export interface Moment {
|
|
x?: number;
|
|
y?: number;
|
|
m00?: number;
|
|
m01?: number;
|
|
m10?: number;
|
|
m11?: number;
|
|
m02?: number;
|
|
m20?: number;
|
|
theta?: number;
|
|
rad?: number;
|
|
}
|
|
}
|
|
declare module "common/hsv2rgb" {
|
|
export type HSV = [number, number, number];
|
|
export type RGB = [number, number, number];
|
|
export function hsv2rgb(hsv: HSV, rgb?: RGB): RGB;
|
|
}
|
|
declare module "common/image-wrapper" {
|
|
import { Moment } from "common/moment";
|
|
import { Point } from "common/point";
|
|
type ArrayType = Array<number> | Uint8Array | Int32Array;
|
|
/**
|
|
* Represents a basic image combining the data and size.
|
|
* In addition, some methods for manipulation are contained.
|
|
*/
|
|
export class ImageWrapper<T extends ArrayType = Uint8Array> {
|
|
data: T | Uint8Array;
|
|
size: Point;
|
|
/**
|
|
* @param size The size of the image in pixel
|
|
* @param data If given, a flat array containing the pixel data
|
|
* @param arrayType If given, the desired DataType of the Array (may be typed/non-typed)
|
|
* @param initialize Indicating if the array should be initialized on creation.
|
|
*/
|
|
constructor(size: Point, data?: T, arrayType?: {
|
|
new (_: number): T | Uint8Array;
|
|
}, initialize?: boolean);
|
|
/**
|
|
* Tests if a position is within the image with a given offset
|
|
* @param point The location to test
|
|
* @param border The padding value in pixels
|
|
* @returns true if location inside the image's border, false otherwise
|
|
* @see cvd/image.h
|
|
*/
|
|
inImageWithBorder(point: Point, border: number): boolean;
|
|
/**
|
|
* Creates an {ImageWrapper) and copies the needed underlying image-data area
|
|
* @param imageWrapper The target {ImageWrapper} where the data should be copied
|
|
* @param fromX The horizontal position where to copy from
|
|
* @param fromY The vertical position where to copy from
|
|
*/
|
|
subImageAsCopy(imageWrapper: ImageWrapper, fromX: number, fromY: number): void;
|
|
/**
|
|
* Retrieves a given pixel position from the image
|
|
* @param x The x-position
|
|
* @param y The y-position
|
|
* @returns The grayscale value at the pixel-position
|
|
*/
|
|
get(x: number, y: number): number;
|
|
/**
|
|
* Sets a given pixel position in the image
|
|
* @param x The x-position
|
|
* @param y The y-position
|
|
* @param value The grayscale value to set
|
|
* @returns The Image itself (for possible chaining)
|
|
*/
|
|
set(x: number, y: number, value: number): ImageWrapper<T>;
|
|
/**
|
|
* Sets the border of the image (1 pixel) to zero
|
|
*/
|
|
zeroBorder(): void;
|
|
/**
|
|
* Inverts a binary image in place
|
|
*/
|
|
invert(): void;
|
|
moments(labelCount: number): Array<Moment>;
|
|
/**
|
|
* Displays the {ImageWrapper} in a given canvas
|
|
* @param context The rendering context to write to
|
|
* @param scale Scale which is applied to each pixel-value
|
|
*/
|
|
show(context: CanvasRenderingContext2D, scale: number): void;
|
|
/**
|
|
* Displays the part of the image in a given canvas
|
|
* @param context The rendering context to write to
|
|
* @param scale Scale which is applied to each pixel-value
|
|
* @param fromX The horizontal position where to overlay from
|
|
* @param fromY The vertical position where to overlay from
|
|
*/
|
|
overlay(context: CanvasRenderingContext2D, scale: number, fromX: number, fromY: number): void;
|
|
}
|
|
}
|
|
declare module "reader/barcode-reader" {
|
|
export enum BarcodeDirection {
|
|
Forward = 1,
|
|
Reverse = -1
|
|
}
|
|
export type BarcodeFormat = string;
|
|
export type BarcodeReaderType = string;
|
|
export type BarcodeReaderDeclaration = BarcodeReaderType | {
|
|
format: BarcodeReaderType;
|
|
config: BarcodeReaderConfig;
|
|
};
|
|
export interface BarcodeReaderConfig {
|
|
normalizeBarSpaceWidth?: boolean;
|
|
supplements?: Array<BarcodeReaderType>;
|
|
}
|
|
export interface BarcodeCorrection {
|
|
bar: number;
|
|
space: number;
|
|
}
|
|
export interface BarcodeInfo {
|
|
code?: number;
|
|
correction?: BarcodeCorrection;
|
|
end?: number;
|
|
endCounter?: number;
|
|
error?: number;
|
|
start?: number;
|
|
startCounter?: number;
|
|
}
|
|
export interface Barcode {
|
|
code?: string;
|
|
codeset?: number;
|
|
correction?: BarcodeCorrection;
|
|
decodedCodes?: Array<string | BarcodeInfo>;
|
|
direction?: BarcodeDirection;
|
|
end?: number;
|
|
endInfo?: BarcodeInfo;
|
|
format?: BarcodeFormat;
|
|
start?: number;
|
|
startInfo?: BarcodeInfo;
|
|
supplement?: Barcode;
|
|
}
|
|
export abstract class BarcodeReader {
|
|
protected _singleCodeError: number;
|
|
protected _averageCodeError: number;
|
|
protected _format: BarcodeFormat;
|
|
protected _row: Array<number>;
|
|
config: BarcodeReaderConfig;
|
|
supplements: Array<BarcodeReader>;
|
|
static readonly Exception: {
|
|
StartNotFoundException: string;
|
|
CodeNotFoundException: string;
|
|
PatternNotFoundException: string;
|
|
};
|
|
readonly SINGLE_CODE_ERROR: number;
|
|
readonly AVERAGE_CODE_ERROR: number;
|
|
readonly FORMAT: BarcodeFormat;
|
|
constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>);
|
|
abstract decode(row?: Array<number>, start?: number): Barcode;
|
|
protected _findPattern(pattern: ReadonlyArray<number>, offset: number, isWhite: 0 | 1, tryHarder: boolean): BarcodeInfo;
|
|
protected _nextUnset(line: ReadonlyArray<number>, start?: number): number;
|
|
protected _nextSet(line: ReadonlyArray<number>, start?: number): number;
|
|
protected _matchRange(start: number, end: number, value: number): boolean;
|
|
protected _matchPattern(counter: ReadonlyArray<number>, code: ReadonlyArray<number>, maxSingleError?: number): number;
|
|
protected _correctBars(counter: Array<number>, correction: number, indices: Array<number>): void;
|
|
decodePattern(pattern: Array<number>): Barcode;
|
|
_fillCounters(offset: number, end: number, isWhite: 0 | 1): Array<number>;
|
|
protected _toCounters(start: number, counters: Uint16Array): Uint16Array;
|
|
}
|
|
}
|
|
declare module "reader/code-128-reader" {
|
|
import { Barcode, BarcodeCorrection, BarcodeInfo, BarcodeReader } from "reader/barcode-reader";
|
|
export class Code128Reader extends BarcodeReader {
|
|
constructor();
|
|
protected _decodeCode(start: number, correction: BarcodeCorrection): BarcodeInfo;
|
|
private _correct;
|
|
protected _findStart(): {
|
|
error: number;
|
|
code: number;
|
|
start: number;
|
|
end: number;
|
|
correction: {
|
|
bar: number;
|
|
space: number;
|
|
};
|
|
};
|
|
decode(): Barcode;
|
|
protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
|
|
private _calculateCorrection;
|
|
}
|
|
}
|
|
declare module "reader/code-39-reader" {
|
|
import { Barcode, BarcodeInfo, BarcodeReader } from "reader/barcode-reader";
|
|
export class Code39Reader extends BarcodeReader {
|
|
constructor();
|
|
decode(): Barcode;
|
|
protected _patternToChar(pattern: any): string;
|
|
private _verifyTrailingWhitespace;
|
|
private _findNextWidth;
|
|
private _toPattern;
|
|
protected _findStart(): BarcodeInfo;
|
|
}
|
|
}
|
|
declare module "reader/code-39-vin-reader" {
|
|
import { Barcode } from "reader/barcode-reader";
|
|
import { Code39Reader } from "reader/code-39-reader";
|
|
export class Code39VINReader extends Code39Reader {
|
|
constructor();
|
|
/**
|
|
* @borrows
|
|
* https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java
|
|
*/
|
|
decode(): Barcode;
|
|
private _checkChecksum;
|
|
}
|
|
}
|
|
declare module "reader/codabar-reader" {
|
|
import { Barcode, BarcodeInfo, BarcodeReader } from "reader/barcode-reader";
|
|
export class CodabarReader extends BarcodeReader {
|
|
private _counters;
|
|
constructor();
|
|
decode(): Barcode;
|
|
protected _verifyWhitespace(startCounter: number, endCounter: number): boolean;
|
|
private _calculatePatternLength;
|
|
private _thresholdResultPattern;
|
|
private _charToPattern;
|
|
private _validateResult;
|
|
private _patternToChar;
|
|
private _computeAlternatingThreshold;
|
|
private _toPattern;
|
|
private _sumCounters;
|
|
protected _findStart(): BarcodeInfo;
|
|
}
|
|
}
|
|
declare module "common/merge" {
|
|
/**
|
|
* Performs a deep merge of objects and returns new object.
|
|
* Does not modify objects (immutable).
|
|
* @see https://stackoverflow.com/a/48218209
|
|
*
|
|
* @param objects - Objects to merge
|
|
* @returns New object with merged key/values
|
|
*/
|
|
export function merge(...objects: ReadonlyArray<any>): object;
|
|
}
|
|
declare module "reader/ean-reader" {
|
|
import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
|
|
export class EANReader extends BarcodeReader {
|
|
readonly CODE_L_START: number;
|
|
readonly CODE_G_START: number;
|
|
readonly START_PATTERN: Array<number>;
|
|
readonly STOP_PATTERN: Array<number>;
|
|
readonly MIDDLE_PATTERN: Array<number>;
|
|
constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>);
|
|
protected _decodeCode(start: number, coderange?: number): BarcodeInfo;
|
|
protected _findStart(): BarcodeInfo;
|
|
protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
|
|
protected _findEnd(offset: number, isWhite: 0 | 1): BarcodeInfo;
|
|
private _calculateFirstDigit;
|
|
protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo;
|
|
decode(): Barcode;
|
|
private _decodeExtensions;
|
|
protected _checksum(result: Array<number>): boolean;
|
|
}
|
|
}
|
|
declare module "reader/ean-8-reader" {
|
|
import { BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
|
|
import { EANReader } from "reader/ean-reader";
|
|
export class EAN8Reader extends EANReader {
|
|
constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>);
|
|
protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo;
|
|
}
|
|
}
|
|
declare module "reader/ean-2-reader" {
|
|
import { Barcode, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
|
|
import { EANReader } from "reader/ean-reader";
|
|
export class EAN2Reader extends EANReader {
|
|
constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>);
|
|
decode(row?: Array<number>, start?: number): Barcode;
|
|
}
|
|
}
|
|
declare module "reader/ean-5-reader" {
|
|
import { Barcode, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
|
|
import { EANReader } from "reader/ean-reader";
|
|
export class EAN5Reader extends EANReader {
|
|
readonly CHECK_DIGIT_ENCODINGS: Array<number>;
|
|
constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>);
|
|
decode(row?: Array<number>, start?: number): Barcode;
|
|
private _determineCheckDigit;
|
|
private _extensionChecksum;
|
|
}
|
|
}
|
|
declare module "reader/upc-reader" {
|
|
import { Barcode, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
|
|
import { EANReader } from "reader/ean-reader";
|
|
export class UPCReader extends EANReader {
|
|
constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>);
|
|
decode(): Barcode;
|
|
}
|
|
}
|
|
declare module "reader/upc-e-reader" {
|
|
import { BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
|
|
import { EANReader } from "reader/ean-reader";
|
|
export class UPCEReader extends EANReader {
|
|
readonly STOP_PATTERN: number[];
|
|
constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>);
|
|
protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo;
|
|
private _determineParity;
|
|
private _convertToUPCA;
|
|
protected _checksum(result: Array<number>): boolean;
|
|
protected _findEnd(offset: number, isWhite: 0 | 1): BarcodeInfo;
|
|
protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
|
|
}
|
|
}
|
|
declare module "reader/i2of5-reader" {
|
|
import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
|
|
export class I2of5Reader extends BarcodeReader {
|
|
private _barSpaceRatio;
|
|
constructor(config?: BarcodeReaderConfig);
|
|
decode(): Barcode;
|
|
protected _matchPattern(counter: Array<number>, code: ReadonlyArray<number>): number;
|
|
protected _findStart(): BarcodeInfo;
|
|
protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
|
|
protected _findEnd(): BarcodeInfo;
|
|
protected _decodeCode(counter: Array<number>): BarcodeInfo;
|
|
protected _decodePayload(counters: ReadonlyArray<number>, result: Array<number>, decodedCodes: Array<BarcodeInfo>): [BarcodeInfo, BarcodeInfo];
|
|
}
|
|
}
|
|
declare module "reader/2of5-reader" {
|
|
import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
|
|
export class TwoOfFiveReader extends BarcodeReader {
|
|
private _barSpaceRatio;
|
|
constructor(config?: BarcodeReaderConfig);
|
|
decode(): Barcode;
|
|
protected _findStart(): BarcodeInfo;
|
|
protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
|
|
protected _findEnd(): BarcodeInfo;
|
|
protected _decodeCode(counter: ReadonlyArray<number>): BarcodeInfo;
|
|
protected _decodePayload(counters: ReadonlyArray<number>, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo;
|
|
}
|
|
}
|
|
declare module "reader/code-93-reader" {
|
|
import { Barcode, BarcodeReader } from "reader/barcode-reader";
|
|
export class Code93Reader extends BarcodeReader {
|
|
constructor();
|
|
decode(): Barcode;
|
|
protected _patternToChar(pattern: number): string;
|
|
private _verifyEnd;
|
|
private _toPattern;
|
|
private _findStart;
|
|
private _decodeExtended;
|
|
private _verifyChecksums;
|
|
private _matchCheckChar;
|
|
}
|
|
}
|
|
declare module "reader/index" {
|
|
import { Code128Reader } from "reader/code-128-reader";
|
|
import { Code39Reader } from "reader/code-39-reader";
|
|
import { Code39VINReader } from "reader/code-39-vin-reader";
|
|
import { CodabarReader } from "reader/codabar-reader";
|
|
import { EANReader } from "reader/ean-reader";
|
|
import { EAN8Reader } from "reader/ean-8-reader";
|
|
import { EAN2Reader } from "reader/ean-2-reader";
|
|
import { EAN5Reader } from "reader/ean-5-reader";
|
|
import { UPCReader } from "reader/upc-reader";
|
|
import { UPCEReader } from "reader/upc-e-reader";
|
|
import { I2of5Reader } from "reader/i2of5-reader";
|
|
import { TwoOfFiveReader } from "reader/2of5-reader";
|
|
import { Code93Reader } from "reader/code-93-reader";
|
|
export const Readers: {
|
|
code_128_reader: typeof Code128Reader;
|
|
ean_reader: typeof EANReader;
|
|
ean_5_reader: typeof EAN5Reader;
|
|
ean_2_reader: typeof EAN2Reader;
|
|
ean_8_reader: typeof EAN8Reader;
|
|
code_39_reader: typeof Code39Reader;
|
|
code_39_vin_reader: typeof Code39VINReader;
|
|
codabar_reader: typeof CodabarReader;
|
|
upc_reader: typeof UPCReader;
|
|
upc_e_reader: typeof UPCEReader;
|
|
i2of5_reader: typeof I2of5Reader;
|
|
'2of5_reader': typeof TwoOfFiveReader;
|
|
code_93_reader: typeof Code93Reader;
|
|
};
|
|
}
|
|
declare module "decoder/bresenham" {
|
|
import { Point } from "common/point";
|
|
import { ImageWrapper } from "common/image-wrapper";
|
|
export interface BarcodeLine {
|
|
line: Array<number>;
|
|
max?: number;
|
|
min?: number;
|
|
threshold?: number;
|
|
}
|
|
export const Bresenham: {
|
|
/**
|
|
* Scans a line of the given image from point p1 to p2 and returns a result object containing
|
|
* gray-scale values (0-255) of the underlying pixels in addition to the min and max values.
|
|
* @param imageWrapper
|
|
* @param p1 The start point {x,y}
|
|
* @param p2 The end point {x,y}
|
|
* @returns {line, min, max}
|
|
*/
|
|
getBarcodeLine(imageWrapper: ImageWrapper<Uint8Array>, p1: Point, p2: Point): BarcodeLine;
|
|
/**
|
|
* Converts the result from getBarcodeLine into a binary representation
|
|
* also considering the frequency and slope of the signal for more robust results
|
|
* @param result {line, min, max}
|
|
*/
|
|
toBinaryLine(result: BarcodeLine): BarcodeLine;
|
|
};
|
|
}
|
|
declare module "decoder/barcode-decoder" {
|
|
import { Box } from "common/box";
|
|
import { ImageWrapper } from "common/image-wrapper";
|
|
import { Point } from "common/point";
|
|
import { Barcode, BarcodeReaderDeclaration } from "reader/barcode-reader";
|
|
export interface BarcodeDecoderConfig {
|
|
debug?: {
|
|
drawBoundingBox?: boolean;
|
|
drawScanline?: boolean;
|
|
showFrequency?: boolean;
|
|
showPattern?: boolean;
|
|
};
|
|
multiple?: boolean;
|
|
readers?: Array<BarcodeReaderDeclaration>;
|
|
}
|
|
type Line = [Point, Point];
|
|
export interface QuaggaBarcode {
|
|
angle?: number;
|
|
barcodes?: Array<QuaggaBarcode>;
|
|
box?: Box;
|
|
boxes?: Array<Box>;
|
|
codeResult?: Barcode;
|
|
frame?: string;
|
|
line?: Line;
|
|
pattern?: Array<number>;
|
|
threshold?: number;
|
|
}
|
|
export class BarcodeDecoder {
|
|
private _config;
|
|
private _inputImageWrapper;
|
|
private _frequencyCanvas;
|
|
private _patternCanvas;
|
|
private _overlayContext;
|
|
private _barcodeReaders;
|
|
constructor(config: BarcodeDecoderConfig, inputImageWrapper: ImageWrapper<Uint8Array>);
|
|
decodeFromBoundingBoxes(boxes: Array<Box>): QuaggaBarcode;
|
|
/**
|
|
* With the help of the configured readers this function tries to detect
|
|
* a valid barcode pattern within the given area.
|
|
* @param box The area to search in
|
|
* @returns The result {codeResult, line, angle, pattern, threshold}
|
|
*/
|
|
decodeFromBoundingBox(box: Box): QuaggaBarcode;
|
|
setReaders(readers: Array<BarcodeReaderDeclaration>): void;
|
|
private _initReaders;
|
|
/**
|
|
* extend the line on both ends
|
|
* @param line
|
|
* @param angle
|
|
*/
|
|
private _getExtendedLine;
|
|
private _getLine;
|
|
private _tryDecode;
|
|
/**
|
|
* This method slices the given area apart and tries to detect a barcode-pattern for each slice.
|
|
* It returns the decoded barcode, or null if nothing was found
|
|
* @param box
|
|
* @param line
|
|
* @param lineAngle
|
|
*/
|
|
private _tryDecodeBruteForce;
|
|
/**
|
|
* Used for development only
|
|
*/
|
|
private _printFrequency;
|
|
/**
|
|
* Used for development only
|
|
*/
|
|
private _printPattern;
|
|
private _drawPath;
|
|
}
|
|
}
|
|
declare module "analytics/result-collector" {
|
|
import { QuaggaBarcode } from "decoder/barcode-decoder";
|
|
import { Barcode } from "reader/barcode-reader";
|
|
export interface ResultCollectorConfig {
|
|
capacity?: number;
|
|
capture?: boolean;
|
|
blacklist?: Array<Barcode>;
|
|
filter?: (item: Barcode) => boolean;
|
|
}
|
|
export class ResultCollector {
|
|
private _canvas;
|
|
private _context;
|
|
private _config;
|
|
private _capacity;
|
|
private _capture;
|
|
private _results;
|
|
constructor(config: ResultCollectorConfig);
|
|
addResult(data: Uint8Array, imageWidth: number, imageHeight: number, codeResult: Barcode): void;
|
|
getResults(): Array<QuaggaBarcode>;
|
|
private _contains;
|
|
private _passesFilter;
|
|
}
|
|
}
|
|
declare module "common/events" {
|
|
export interface EventCallback {
|
|
(data: any): void;
|
|
}
|
|
export interface EventSubscription {
|
|
callback: EventCallback;
|
|
async?: boolean;
|
|
once?: boolean;
|
|
}
|
|
export class Events {
|
|
static subscribe(event: string, callback: EventSubscription | EventCallback, async?: boolean): void;
|
|
static publish(type: string, data?: any): void;
|
|
static once(event: string, callback: EventCallback, async?: boolean): void;
|
|
static unsubscribe(eventName?: string, callback?: EventCallback): void;
|
|
}
|
|
}
|
|
declare module "locator/barcode-locator-config" {
|
|
export type PatchSizeConfig = number | 'x-small' | 'small' | 'medium' | 'large' | 'x-large';
|
|
export interface BarcodeLocatorDebugConfig {
|
|
/**
|
|
* @default false
|
|
*/
|
|
showCanvas?: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
showPatches?: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
showFoundPatches?: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
showSkeleton?: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
showLabels?: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
showPatchLabels?: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
showRemainingPatchLabels?: boolean;
|
|
boxFromPatches?: {
|
|
/**
|
|
* @default false
|
|
*/
|
|
showTransformed?: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
showTransformedBox?: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
showBB?: boolean;
|
|
};
|
|
}
|
|
export interface BarcodeLocatorConfig {
|
|
debug?: BarcodeLocatorDebugConfig;
|
|
/**
|
|
* @default true
|
|
*/
|
|
halfSample?: boolean;
|
|
/**
|
|
* @default 'medium'
|
|
*/
|
|
patchSize?: PatchSizeConfig;
|
|
useWorker?: boolean;
|
|
}
|
|
}
|
|
declare module "input/input-stream-config" {
|
|
type InputStreamType = 'ImageStream' | 'LiveStream' | 'VideoStream';
|
|
export interface AreaConfig {
|
|
bottom?: string;
|
|
left?: string;
|
|
right?: string;
|
|
top?: string;
|
|
}
|
|
export interface InputStreamConfig {
|
|
area?: AreaConfig;
|
|
constraints?: MediaTrackConstraints;
|
|
halfSample?: boolean;
|
|
length?: number;
|
|
mime?: string;
|
|
name?: string;
|
|
sequence?: boolean;
|
|
singleChannel?: boolean;
|
|
size?: number;
|
|
src?: string;
|
|
target?: HTMLElement | string;
|
|
type?: InputStreamType;
|
|
}
|
|
}
|
|
declare module "config/config" {
|
|
import { BarcodeDecoderConfig } from "decoder/barcode-decoder";
|
|
import { BarcodeLocatorConfig } from "locator/barcode-locator-config";
|
|
import { InputStreamConfig } from "input/input-stream-config";
|
|
interface DebugConfig {
|
|
}
|
|
export interface QuaggaConfig {
|
|
debug?: DebugConfig;
|
|
decoder?: BarcodeDecoderConfig;
|
|
frequency?: number;
|
|
inputStream?: InputStreamConfig;
|
|
locate?: boolean;
|
|
locator?: BarcodeLocatorConfig;
|
|
numOfWorkers?: number;
|
|
src?: string;
|
|
}
|
|
export const config: QuaggaConfig;
|
|
}
|
|
declare module "common/media-devices" {
|
|
export function enumerateDevices(): Promise<Array<MediaDeviceInfo>>;
|
|
export function getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
|
|
}
|
|
declare module "input/camera-access" {
|
|
export const CameraAccess: {
|
|
/**
|
|
* Attempts to attach the camera-stream to a given video element
|
|
* and calls the callback function when the content is ready
|
|
* @param video
|
|
* @param videoConstraints
|
|
*/
|
|
request(video: HTMLVideoElement, videoConstraints: MediaTrackConstraints): Promise<void>;
|
|
release(): void;
|
|
enumerateVideoDevices(): Promise<MediaDeviceInfo[]>;
|
|
getActiveStreamLabel(): string;
|
|
getActiveTrack(): MediaStreamTrack;
|
|
pickConstraints(videoConstraints: MediaTrackConstraints): MediaStreamConstraints;
|
|
};
|
|
}
|
|
declare module "input/exif-helper" {
|
|
export const AvailableTags: Array<string>;
|
|
export interface Tags {
|
|
[key: string]: number | string;
|
|
}
|
|
export function findTagsInObjectURL(src: string, tags?: string[]): Promise<Tags>;
|
|
export function findTagsInBuffer(file: ArrayBuffer, selectedTags?: Array<string>): Tags;
|
|
}
|
|
declare module "input/image-loader" {
|
|
import { Tags } from "input/exif-helper";
|
|
export interface ImageInfo {
|
|
image: HTMLImageElement;
|
|
tags?: Tags;
|
|
}
|
|
export class ImageLoader {
|
|
static load(baseUri: string, callback: (_: Array<ImageInfo>) => void, offset: number, size: number, sequence: boolean): Promise<void>;
|
|
}
|
|
}
|
|
declare module "input/input-stream" {
|
|
import { Point } from "common/point";
|
|
import { ImageInfo } from "input/image-loader";
|
|
import { InputStreamConfig } from "input/input-stream-config";
|
|
export abstract class InputStream {
|
|
protected _calculatedHeight: number;
|
|
protected _calculatedWidth: number;
|
|
protected _canvasHeight: number;
|
|
protected _canvasWidth: number;
|
|
protected _config: InputStreamConfig;
|
|
protected _eventNames: Array<string>;
|
|
protected _eventHandlers: Map<string, Array<EventListener>>;
|
|
protected _topLeft: Point;
|
|
constructor();
|
|
abstract readonly realHeight: number;
|
|
abstract readonly realWidth: number;
|
|
height: number;
|
|
width: number;
|
|
topLeft: Point;
|
|
setCanvasSize(width: number, height: number): void;
|
|
readonly canvasHeight: number;
|
|
readonly canvasWidth: number;
|
|
abstract config: InputStreamConfig;
|
|
abstract readonly ended: boolean;
|
|
abstract setAttribute(name: string, value: string): void;
|
|
abstract pause(): void;
|
|
abstract play(): void;
|
|
abstract currentTime: number;
|
|
addEventListener(event: string, listener: EventListener, _options?: boolean): void;
|
|
clearEventHandlers(): void;
|
|
trigger(eventName: string, argArray?: any): void;
|
|
abstract getFrame(): HTMLVideoElement | ImageInfo;
|
|
}
|
|
}
|
|
declare module "input/frame-grabber" {
|
|
import { InputStream } from "input/input-stream";
|
|
export class FrameGrabber {
|
|
private _inputStream;
|
|
private _streamConfig;
|
|
private _canvas;
|
|
private _context;
|
|
private _data;
|
|
private _canvasHeight;
|
|
private _canvasWidth;
|
|
private _height;
|
|
private _width;
|
|
private _topLeft;
|
|
constructor(inputStream: InputStream, canvas: HTMLCanvasElement);
|
|
/**
|
|
* Fetches a frame from the input stream and puts into the frame buffer.
|
|
* The image data is converted to gray scale and then half-sampled if configured.
|
|
*/
|
|
grab(data: Uint8Array): boolean;
|
|
private _adjustCanvasSize;
|
|
private _grayAndHalfSampleFromCanvasData;
|
|
private _computeGray;
|
|
}
|
|
}
|
|
declare module "input/image-stream" {
|
|
import { ImageInfo } from "input/image-loader";
|
|
import { InputStream } from "input/input-stream";
|
|
import { InputStreamConfig } from "input/input-stream-config";
|
|
export class ImageStream extends InputStream {
|
|
private _baseUrl;
|
|
private _ended;
|
|
private _frameIndex;
|
|
private _height;
|
|
private _images;
|
|
private _loaded;
|
|
private _offset;
|
|
private _paused;
|
|
private _size;
|
|
private _width;
|
|
constructor();
|
|
readonly realHeight: number;
|
|
readonly realWidth: number;
|
|
config: InputStreamConfig;
|
|
readonly ended: boolean;
|
|
setAttribute(): void;
|
|
pause(): void;
|
|
play(): void;
|
|
currentTime: number;
|
|
getFrame(): HTMLVideoElement | ImageInfo;
|
|
private _loadImages;
|
|
}
|
|
}
|
|
declare module "input/video-stream" {
|
|
import { ImageInfo } from "input/image-loader";
|
|
import { InputStream } from "input/input-stream";
|
|
import { InputStreamConfig } from "input/input-stream-config";
|
|
export class VideoStream extends InputStream {
|
|
private _video;
|
|
constructor(video: HTMLVideoElement);
|
|
readonly realHeight: number;
|
|
readonly realWidth: number;
|
|
config: InputStreamConfig;
|
|
readonly ended: boolean;
|
|
setAttribute(name: string, value: string): void;
|
|
pause(): void;
|
|
play(): void;
|
|
currentTime: number;
|
|
addEventListener(event: string, listener: EventListener, options?: boolean): void;
|
|
clearEventHandlers(): void;
|
|
trigger(eventName: string, argArray?: any): void;
|
|
getFrame(): HTMLVideoElement | ImageInfo;
|
|
private _initSize;
|
|
}
|
|
export class LiveStream extends VideoStream {
|
|
constructor(video: HTMLVideoElement);
|
|
readonly ended: boolean;
|
|
}
|
|
}
|
|
declare module "input/live-stream" {
|
|
import { VideoStream } from "input/video-stream";
|
|
export class LiveStream extends VideoStream {
|
|
constructor(video: HTMLVideoElement);
|
|
readonly ended: boolean;
|
|
}
|
|
}
|
|
declare module "input/input-stream-utils" {
|
|
import { Point } from "common/point";
|
|
import { BarcodeLocatorConfig, PatchSizeConfig } from "locator/barcode-locator-config";
|
|
import { InputStream } from "input/input-stream";
|
|
import { AreaConfig } from "input/input-stream-config";
|
|
export interface Dimension {
|
|
unit: '%' | 'px';
|
|
value: number;
|
|
}
|
|
export function calculatePatchSize(patchSize: PatchSizeConfig, { x, y }: Point): Point;
|
|
export function checkImageConstraints(inputStream: InputStream, config: BarcodeLocatorConfig): boolean;
|
|
export function _parseCssDimensionValues(value: string): Dimension;
|
|
export const _dimensionsConverters: {
|
|
bottom: (dimension: Dimension, { height }: {
|
|
height: any;
|
|
}) => any;
|
|
left: (dimension: Dimension, { width }: {
|
|
width: any;
|
|
}) => number;
|
|
right: (dimension: Dimension, { width }: {
|
|
width: any;
|
|
}) => any;
|
|
top: (dimension: Dimension, { height }: {
|
|
height: any;
|
|
}) => number;
|
|
};
|
|
export function computeImageArea(inputWidth: number, inputHeight: number, area: AreaConfig): {
|
|
topLeft: {
|
|
x: number;
|
|
y: number;
|
|
};
|
|
width: number;
|
|
height: number;
|
|
};
|
|
}
|
|
declare module "common/cluster" {
|
|
import { Moment } from "common/moment";
|
|
/**
|
|
* Creates a cluster for grouping similar orientations of moments
|
|
*/
|
|
export class Cluster {
|
|
private _threshold;
|
|
private _moments;
|
|
private _center;
|
|
static clusterize(moments: Array<Moment>, threshold: number): Array<Cluster>;
|
|
constructor(threshold: number, moment: Moment);
|
|
add(point: Moment): void;
|
|
fits(moment: Moment): boolean;
|
|
readonly moments: Moment[];
|
|
}
|
|
}
|
|
declare module "locator/barcode-locator-utils" {
|
|
import { ImageWrapper } from "common/image-wrapper";
|
|
import { Point } from "common/point";
|
|
/**
|
|
* Invert matrix
|
|
* @param matrix the matrix to invert
|
|
* @returns the inverted matrix
|
|
*/
|
|
export function invert(matrix: Float32Array): Float32Array;
|
|
/**
|
|
* Transforms the vector with a matrix
|
|
* @param { x, y } vector to transform
|
|
* @param matrix matrix to transform with
|
|
* @returns the transformed vector
|
|
*/
|
|
export function transformWithMatrix({ x, y }: Point, matrix: Float32Array): Point;
|
|
export function otsuThreshold(imageWrapper: ImageWrapper, targetWrapper: ImageWrapper): number;
|
|
/**
|
|
* @param imageWrapper input image to be sampled
|
|
* @param outImageWrapper {ImageWrapper} to be stored in
|
|
*/
|
|
export function halfSample(imageWrapper: ImageWrapper, outImageWrapper: ImageWrapper): void;
|
|
}
|
|
declare module "locator/tracer" {
|
|
import { ImageWrapper } from "common/image-wrapper";
|
|
/**
|
|
* @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
|
|
*/
|
|
type Direction = number;
|
|
export const SearchDirections: Array<Array<Direction>>;
|
|
export interface ContourVertex {
|
|
x: number;
|
|
y: number;
|
|
dir: Direction;
|
|
next: ContourVertex;
|
|
prev: ContourVertex;
|
|
}
|
|
interface Current {
|
|
cx: number;
|
|
cy: number;
|
|
dir: Direction;
|
|
}
|
|
export class Tracer {
|
|
private _imageData;
|
|
private _labelData;
|
|
private _width;
|
|
constructor(imageWrapper: ImageWrapper, labelWrapper: ImageWrapper<Array<number>>);
|
|
trace(current: Current, color: number, label: number, edgeLabel: number): boolean;
|
|
contourTracing(sy: number, sx: number, label: number, color: number, edgeLabel: number): ContourVertex;
|
|
}
|
|
}
|
|
declare module "locator/rasterizer" {
|
|
/**
|
|
* @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
|
|
*/
|
|
import { ImageWrapper } from "common/image-wrapper";
|
|
import { ContourVertex } from "locator/tracer";
|
|
enum ContourDirection {
|
|
CW = 0,
|
|
CCW = 1,
|
|
Unknown = 2
|
|
}
|
|
interface Contour {
|
|
dir: ContourDirection;
|
|
index: number;
|
|
firstVertex: ContourVertex;
|
|
previousPeer?: Contour;
|
|
nextPeer?: Contour;
|
|
insideContours: Contour;
|
|
}
|
|
export interface RasterResult {
|
|
cc: Contour;
|
|
count: number;
|
|
}
|
|
export class Rasterizer {
|
|
private _width;
|
|
private _height;
|
|
private _tracer;
|
|
private _imageData;
|
|
private _labelData;
|
|
constructor(imageWrapper: ImageWrapper<Uint8Array>, labelWrapper: ImageWrapper<Array<number>>);
|
|
rasterize(depthLabel: number): RasterResult;
|
|
drawContour(canvas: HTMLCanvasElement, firstContour: Contour): void;
|
|
}
|
|
}
|
|
declare module "locator/barcode-locator" {
|
|
import { ImageWrapper } from "common/image-wrapper";
|
|
import { Point } from "common/point";
|
|
import { BarcodeLocatorConfig } from "locator/barcode-locator-config";
|
|
export class BarcodeLocator {
|
|
private _config;
|
|
private _inputImageWrapper;
|
|
private _currentImageWrapper;
|
|
private _skelImageWrapper;
|
|
private _subImageWrapper;
|
|
private _labelImageWrapper;
|
|
private _binaryImageWrapper;
|
|
private _patchGrid;
|
|
private _patchLabelGrid;
|
|
private _imageToPatchGrid;
|
|
private _patchSize;
|
|
private _binaryContext;
|
|
private _numPatches;
|
|
private _skeletonizer;
|
|
constructor(inputImageWrapper: ImageWrapper, config: BarcodeLocatorConfig);
|
|
locate(): [Point, Point, Point, Point][];
|
|
private _initBuffers;
|
|
private _initCanvas;
|
|
/**
|
|
* Creates a bounding box which encloses all the given patches
|
|
* @returns The minimal bounding box
|
|
*/
|
|
private _boxFromPatches;
|
|
/**
|
|
* Creates a binary image of the current image
|
|
*/
|
|
private _binarizeImage;
|
|
/**
|
|
* Iterate over the entire image, extract patches
|
|
*/
|
|
private _findPatches;
|
|
/**
|
|
* Finds those connected areas which contain at least 6 patches
|
|
* and returns them ordered DESC by the number of contained patches
|
|
* @param maxLabel
|
|
*/
|
|
private _findBiggestConnectedAreas;
|
|
/**
|
|
*
|
|
*/
|
|
private _findBoxes;
|
|
/**
|
|
* Find similar moments (via cluster)
|
|
* @param moments
|
|
*/
|
|
private _similarMoments;
|
|
private _skeletonize;
|
|
/**
|
|
* Extracts and describes those patches which seem to contain a barcode pattern
|
|
* @param moments
|
|
* @param index
|
|
* @param x
|
|
* @param y
|
|
* @returns list of patches
|
|
*/
|
|
private _describePatch;
|
|
private _notYetProcessed;
|
|
private _trace;
|
|
/**
|
|
* Finds patches which are connected and share the same orientation
|
|
* @param patchesFound
|
|
*/
|
|
private _rasterizeAngularSimilarity;
|
|
private _drawRect;
|
|
private _drawPath;
|
|
}
|
|
}
|
|
declare module "quagga" {
|
|
import { ResultCollector } from "analytics/result-collector";
|
|
import { EventCallback, EventSubscription } from "common/events";
|
|
import { ImageWrapper } from "common/image-wrapper";
|
|
import { Point } from "common/point";
|
|
import { QuaggaConfig } from "config/config";
|
|
import { QuaggaBarcode } from "decoder/barcode-decoder";
|
|
import { BarcodeReaderDeclaration } from "reader/barcode-reader";
|
|
export interface QuaggaCanvasContainer {
|
|
ctx: {
|
|
image: CanvasRenderingContext2D;
|
|
overlay: CanvasRenderingContext2D;
|
|
};
|
|
dom: {
|
|
image: HTMLCanvasElement;
|
|
overlay: HTMLCanvasElement;
|
|
};
|
|
}
|
|
const _default_1: {
|
|
init(config: QuaggaConfig, cb: () => void, imageWrapper?: ImageWrapper<Uint8Array>): void;
|
|
CameraAccess: {
|
|
request(video: HTMLVideoElement, videoConstraints: MediaTrackConstraints): Promise<void>;
|
|
release(): void;
|
|
enumerateVideoDevices(): Promise<MediaDeviceInfo[]>;
|
|
getActiveStreamLabel(): string;
|
|
getActiveTrack(): MediaStreamTrack;
|
|
pickConstraints(videoConstraints: MediaTrackConstraints): MediaStreamConstraints;
|
|
};
|
|
ImageDebug: {
|
|
drawPath(path: Point[], context: CanvasRenderingContext2D, color: string, lineWidth: number): void;
|
|
drawImage(imageData: Uint8Array, width: number, height: number, context: CanvasRenderingContext2D): boolean;
|
|
};
|
|
ImageWrapper: typeof ImageWrapper;
|
|
ResultCollector: typeof ResultCollector;
|
|
readonly canvas: QuaggaCanvasContainer;
|
|
start(): void;
|
|
stop(): void;
|
|
decodeSingle(config: QuaggaConfig, resultCallback: (_: QuaggaBarcode) => void): void;
|
|
pause(): void;
|
|
onDetected(callback: EventCallback | EventSubscription): void;
|
|
offDetected(callback: EventCallback): void;
|
|
onProcessed(callback: EventCallback | EventSubscription): void;
|
|
offProcessed(callback: EventCallback): void;
|
|
setReaders(readers: BarcodeReaderDeclaration[]): void;
|
|
registerResultCollector(resultCollector: ResultCollector): void;
|
|
};
|
|
export default _default_1;
|
|
}
|
|
declare module "config/config.dev" {
|
|
import { QuaggaConfig } from "config/config";
|
|
export const config: QuaggaConfig;
|
|
}
|
|
declare module "config/config.node" {
|
|
import { QuaggaConfig } from "config/config";
|
|
export const config: QuaggaConfig;
|
|
}
|
|
declare module "input/frame-grabber.node" {
|
|
import { InputStream } from "input/input-stream";
|
|
export class FrameGrabber {
|
|
private _inputStream;
|
|
private _streamConfig;
|
|
private _data;
|
|
private _canvasData;
|
|
private _grayData;
|
|
private _canvasImageArray;
|
|
private _grayImageArray;
|
|
private _targetImageArray;
|
|
private _canvasHeight;
|
|
private _canvasWidth;
|
|
private _videoHeight;
|
|
private _videoWidth;
|
|
private _height;
|
|
private _width;
|
|
private _stepSizeX;
|
|
private _stepSizeY;
|
|
private _topLeft;
|
|
constructor(inputStream: InputStream);
|
|
/**
|
|
* Fetches a frame from the input stream and puts into the frame buffer.
|
|
* The image data is converted to gray scale and then half-sampled if configured.
|
|
*/
|
|
grab(data: Uint8Array): boolean;
|
|
private _scaleAndCrop;
|
|
private _computeGray;
|
|
}
|
|
}
|
|
declare module "input/image-stream.node" {
|
|
import { ImageInfo } from "input/image-loader";
|
|
import { InputStream } from "input/input-stream";
|
|
import { InputStreamConfig } from "input/input-stream-config";
|
|
export class ImageStream extends InputStream {
|
|
private _baseUrl;
|
|
private _ended;
|
|
private _frame;
|
|
private _height;
|
|
private _loaded;
|
|
private _offset;
|
|
private _size;
|
|
private _width;
|
|
constructor();
|
|
readonly realHeight: number;
|
|
readonly realWidth: number;
|
|
config: InputStreamConfig;
|
|
readonly ended: boolean;
|
|
setAttribute(): void;
|
|
pause(): void;
|
|
play(): void;
|
|
currentTime: number;
|
|
getFrame(): HTMLVideoElement | ImageInfo;
|
|
private _loadImages;
|
|
}
|
|
}
|