scanbot-web-sdk 6.0.0-dev.2 → 6.0.0-dev.3

package/@types/utils/browser-cameras.d.ts

@@ -0,0 +1,92 @@
+import { CameraFacingMode, CameraInfo } from "../model/camera-info";
+/**
+ * The {@link BrowserCameras} can provide information about the browser's cameras in two different ways.
+ *
+ *  - `SLOW`:
+ *       Slow but accurate.
+ *       This mode discovers camera information by starting a camera stream for each of the cameras that the
+ *       browsers offers access to. This is done because the browser offers the most accurate information about
+ *       a camera only when a stream of that camera is running.
+ *       Using this data, {@link BrowserCameras.getMainCamera} can make the best possible predictions of which
+ *       camera is the "main" one.
+ *       On most devices, this method of starting all camera streams will cause the "camera is running" indicator
+ *       light or notification to be displayed. Other effects like clicking camera lenses might also be observable.
+ *       This process can be slow. On some devices, this mode has a running time of several seconds.
+ *
+ *  - `FAST`:
+ *       Fast but less accurate.
+ *       This mode discovers camera information by guess-parsing the browser-provided camera labels.
+ *       Using this data, {@link BrowserCameras.getMainCamera} can make good predictions of which camera is the "main" one.
+ *       However, this technique is limited and cannot provide information about the torch control capabilities.
+ *       Additionally, information about the camera resolution might be missing.
+ *       On most devices, this mode has a runtime of less than 500ms.
+ */
+export type DiscoverCameraMode = 'FAST' | 'SLOW';
+/**
+ * Describes the strategy used to obtain information about the browser's cameras in {@link BrowserCameras}.
+ * This information is used to automatically choose the best (=main) camera on devices with multiple cameras.
+ * - If `SLOW_DEFERRED` or `FAST_DEFERRED` is used, the camera information is obtained when a scanner is opened for the
+ *   first time. Because querying the camera information takes some time, this might cause a small delay when the
+ *   scanner is opened.
+ * - If `SLOW` or `FAST` is used, the camera information is being gathered in the background as soon as you start the
+ *   SDK's initialization. When you open a scanner a bit later, the necessary camera information might already be
+ *   gathered and the scanner opens a bit faster than with the `*_DEFERRED` modes.
+ *   Please note that this might trigger the user's camera permission dialog when you initialize the SDK.
+ * - If `NONE` is used, no additional camera information is gathered. On multi-camera devices, the choice of the
+ *   camera is left to the browser. On a few devices, the browser chooses a camera with a 'fish-eye' or telephoto lens
+ *   which is usually undesirable for scans.
+ *
+ * For the difference between `SLOW` and `FAST` see {@link DiscoverCameraMode}.
+ *
+ * @default `SLOW_DEFERRED`
+ *
+ * @see {@link BrowserCameras.load}
+ */
+export type CameraDetectionStrategy = 'SLOW' | 'FAST' | 'SLOW_DEFERRED' | 'FAST_DEFERRED' | 'NONE';
+/**
+ * This class has two purposes:
+ *   1.  It provides a list of the cameras that the browser offers access to.
+ *   2.  It tries to answer the difficult question of "which of these cameras is the main one".
+ */
+export declare class BrowserCameras {
+    private static _INSTANCE?;
+    static get INSTANCE(): BrowserCameras;
+    /**
+     * @internal
+     * Most likely, you want to use {@link INSTANCE} instead.
+     * */
+    constructor();
+    /** Call {@link load} to populate this list. */
+    listOfCameras: CameraInfo[];
+    private loadSlowResult?;
+    private loadFastResult?;
+    private strategy;
+    /** @internal */
+    initialize(strategy?: CameraDetectionStrategy): void;
+    /**
+     * This method populates the internally cached list of cameras.
+     * Results to this method are cached and subsequent calls will faster.
+     * See {@link DiscoverCameraMode} for a detailed description of this function's behavior.
+     * If no value for `mode` is given, the global default set during SDK initialization is used.
+     * @returns The gathered camera information
+     */
+    load(mode?: DiscoverCameraMode): Promise<CameraInfo[]>;
+    private loadSlow;
+    private loadFast;
+    /**
+     * You need to call {@link load} before calling this function to populate the list of cameras.
+     * @return The "main" camera of the device. Typically, this is the camera with the highest resolution. Typically, it
+     *         has a "regular" lens (i.e. not fish-eye or telephoto lens).
+     */
+    getMainCamera(facingMode: 'front' | 'back'): CameraInfo | null;
+    private getVideoDevices;
+    private stopStream;
+    private static guessparseCameraLabelFacingMode;
+    private static guessparseCameraLabelMaxNumPixels;
+    private assertPermissionsAreOk;
+    /** @internal */
+    static getCameraInfoFromStream(stream: MediaStream): CameraInfo;
+    private getUserMedia;
+}
+export declare function parseFacingMode(browserFacingMode?: string): CameraFacingMode;
+export declare function getMaxNumPixelsFromCapabilities(capabilities?: MediaTrackCapabilities): number | undefined;

package/@types/utils/dto/Polygon.d.ts

@@ -1,2 +1,3 @@
 import { Point } from "./Point";
-export type Polygon = [Point, Point, Point, Point];
+/** Quads described by exactly four points are the only supported polygon type. */
+export type Polygon = Point[];

package/@types/utils/stats.d.ts

@@ -0,0 +1,4 @@
+export declare class Stats {
+    static INSTANCE: Stats;
+    values: Map<string, any>;
+}

package/@types/utils/video-stream.d.ts

@@ -1,6 +1,6 @@
 import React, { ReactNode } from 'react';
 export interface VideoStreamProps {
-    videoConstraints: any;
+    videoConstraints: MediaTrackConstraints;
     preferredCamera?: string;
     onReady: () => void;
     onStreamChanged: (stream: MediaStream) => void;
@@ -14,11 +14,11 @@ export interface VideoStreamState {
 export default class VideoStream extends React.Component<VideoStreamProps, VideoStreamState> {
     constructor(props: VideoStreamProps);
     orientationChanged(e: Event): void;
-    setDeviceIdInConstraints(constraints: any): Promise<any>;
+    setDeviceIdInConstraints(constraints: MediaTrackConstraints): Promise<MediaTrackConstraints>;
     private readonly orientationchangeCallback;
     componentDidMount(): Promise<void>;
     refreshStream(): Promise<void>;
-    stopCurrentStreams(): Promise<void>;
+    stopCurrentStreams(): void;
     componentWillUnmount(): void;
     /**
      * Base class that does not specifically require a render function.

package/@types/utils/video-to-image-data/two-d-video-to-image-data.d.ts

@@ -0,0 +1,8 @@
+import type { VideoToImageData } from "./video-to-image-data";
+export declare class TwoDVideoToImageData implements VideoToImageData {
+    _type: string;
+    private readonly canvas;
+    private readonly ctx;
+    constructor();
+    getImageData(source: HTMLVideoElement | HTMLCanvasElement, sourceCropOffsetX: number, sourceCropOffsetY: number, sourceCropWidth: number, sourceCropHeight: number, targetWidth: number, targetHeight: number, reuseBufferIfPossible: Uint8ClampedArray | null): ImageData;
+}

package/@types/utils/video-to-image-data/video-to-image-data.d.ts

@@ -0,0 +1,5 @@
+export interface VideoToImageData {
+    getImageData(source: HTMLVideoElement | HTMLCanvasElement, sourceCropOffsetX: number, sourceCropOffsetY: number, sourceCropWidth: number, sourceCropHeight: number, targetWidth: number, targetHeight: number, reuseBufferIfPossible: Uint8ClampedArray | null): ImageData;
+    _type: string;
+}
+export declare function createVideoToImageData(): VideoToImageData;

package/@types/utils/video-to-image-data/webgl-video-to-image-data.d.ts

@@ -0,0 +1,21 @@
+import type { VideoToImageData } from "./video-to-image-data";
+/**
+ * Extracts single video frames as ImageData objects.
+ * Supports cropping and scaling.
+ **/
+export declare class WebGLVideoToImageData implements VideoToImageData {
+    _type: string;
+    private readonly canvas;
+    private readonly gl;
+    private readonly program;
+    static isSupported(): boolean;
+    /**
+     * While WebGL easily allows us to read a video into a texture, there are no ready-to-use methods for
+     * scaling and cropping the texture to our desired size.
+     * Therefore, we write a custom shader that does this for us. It works by mapping the desired part of the texture
+     * onto a screen-filling quad.
+     * Adapted from https://stackoverflow.com/questions/52507592/how-to-scale-a-texture-in-webgl
+     */
+    constructor();
+    getImageData(source: HTMLVideoElement | HTMLCanvasElement, sourceCropOffsetX: number, sourceCropOffsetY: number, sourceCropWidth: number, sourceCropHeight: number, targetWidth: number, targetHeight: number, reuseBufferIfPossible: Uint8ClampedArray | null): ImageData;
+}

package/@types/view/barcode-polygon/animated-barcode-selection-overlay.d.ts

@@ -26,6 +26,7 @@ export declare class SelectionOverlayProps {
     labelComponentConfig: {} | AROverlayBarcodeInfoConfig;
 }
 export default class AnimatedBarcodeSelectionOverlay extends React.Component<SelectionOverlayProps, any> {
+    container: HTMLDivElement;
     constructor(props: SelectionOverlayProps);
     update(finderRect: Frame, camera: ScanbotCameraView, originalImageSize: Size, codes: BarcodeScannerTypes.BarcodeItem[]): void;
     onPolygonClick(model: BarcodeOverlay): void;

package/@types/view/scanbot-camera-view.d.ts

@@ -4,6 +4,7 @@ import { Size } from "../utils/dto/Size";
 import { Frame } from "../utils/dto/Frame";
 import { CameraInfo } from "../model/camera-info";
 import { ScannerConfiguration } from "../model/configuration/scanner-configuration";
+import { VideoToImageData } from "../utils/video-to-image-data/video-to-image-data";
 export interface ScanbotCameraViewProps {
     configuration?: ScannerConfiguration;
     videoConstraints: MediaTrackConstraints;
@@ -21,7 +22,7 @@ export interface ScanbotCameraViewState {
 export default class ScanbotCameraView extends React.Component<ScanbotCameraViewProps, ScanbotCameraViewState> {
     video: HTMLVideoElement | null;
     videoStream: VideoStream | null;
-    canvas: HTMLCanvasElement | null;
+    canvas: VideoToImageData | null;
     videoLoaded: boolean;
     reloadCanvas: boolean;
     swapCameraEnabled: boolean;
@@ -38,8 +39,13 @@ export default class ScanbotCameraView extends React.Component<ScanbotCameraView
     zoom(): number;
     private capture?;
     private imageCapture;
+    private _reusableImageBuffer;
+    /**
+     * If set and the provided buffer has the correct size, `createImageData` will write the ImageData into this buffer.
+     *  Otherwise, `createImageData` will create a new Buffer.
+     **/
+    set reusableImageBuffer(buffer: Uint8ClampedArray);
     createImageData(maxLargerLength?: number, useImageCaptureAPI?: boolean): Promise<ImageData>;
-    drawVideoOnCanvasAndExtractFrameFromIt(frame: Frame): Promise<void>;
     windowSize(): Frame;
     /**
      * The max size of the video frame that will be extracted from the video stream.
@@ -52,7 +58,7 @@ export default class ScanbotCameraView extends React.Component<ScanbotCameraView
         coef: number;
     };
     calculateFrameSize(maxLargerLength: number, videoWidth: number, videoHeight: number): Size;
-    getCanvasRenderingContext(): CanvasRenderingContext2D;
+    getCanvasRenderingContext(): VideoToImageData;
     releaseCanvas(): void;
     componentWillUnmount(): void;
     onStreamChanged: (stream: MediaStream) => void;