data2/LocalFaceRecognition.git

/**
 * @license
 * Copyright 2019 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
import { ENGINE } from '../engine';
import { env } from '../environment';
import { Draw, FromPixels } from '../kernel_names';
import { getKernel } from '../kernel_registry';
import { Tensor } from '../tensor';
import { convertToTensor } from '../tensor_util_env';
import { cast } from './cast';
import { op } from './operation';
import { tensor3d } from './tensor3d';
let fromPixels2DContext;
let hasToPixelsWarned = false;
/**
 * Creates a `tf.Tensor` from an image.
 *
 * ```js
 * const image = new ImageData(1, 1);
 * image.data[0] = 100;
 * image.data[1] = 150;
 * image.data[2] = 200;
 * image.data[3] = 255;
 *
 * tf.browser.fromPixels(image).print();
 * ```
 *
 * @param pixels The input image to construct the tensor from. The
 * supported image types are all 4-channel. You can also pass in an image
 * object with following attributes:
 * `{data: Uint8Array; width: number; height: number}`
 * @param numChannels The number of channels of the output tensor. A
 * numChannels value less than 4 allows you to ignore channels. Defaults to
 * 3 (ignores alpha channel of input image).
 *
 * @returns A Tensor3D with the shape `[height, width, numChannels]`.
 *
 * Note: fromPixels can be lossy in some cases, same image may result in
 * slightly different tensor values, if rendered by different rendering
 * engines. This means that results from different browsers, or even same
 * browser with CPU and GPU rendering engines can be different. See discussion
 * in details:
 * https://github.com/tensorflow/tfjs/issues/5482
 *
 * @doc {heading: 'Browser', namespace: 'browser', ignoreCI: true}
 */
function fromPixels_(pixels, numChannels = 3) {
    // Sanity checks.
    if (numChannels > 4) {
        throw new Error('Cannot construct Tensor with more than 4 channels from pixels.');
    }
    if (pixels == null) {
        throw new Error('pixels passed to tf.browser.fromPixels() can not be null');
    }
    let isPixelData = false;
    let isImageData = false;
    let isVideo = false;
    let isImage = false;
    let isCanvasLike = false;
    let isImageBitmap = false;
    if (pixels.data instanceof Uint8Array) {
        isPixelData = true;
    }
    else if (typeof (ImageData) !== 'undefined' && pixels instanceof ImageData) {
        isImageData = true;
    }
    else if (typeof (HTMLVideoElement) !== 'undefined' &&
        pixels instanceof HTMLVideoElement) {
        isVideo = true;
    }
    else if (typeof (HTMLImageElement) !== 'undefined' &&
        pixels instanceof HTMLImageElement) {
        isImage = true;
        // tslint:disable-next-line: no-any
    }
    else if (pixels.getContext != null) {
        isCanvasLike = true;
    }
    else if (typeof (ImageBitmap) !== 'undefined' && pixels instanceof ImageBitmap) {
        isImageBitmap = true;
    }
    else {
        throw new Error('pixels passed to tf.browser.fromPixels() must be either an ' +
            `HTMLVideoElement, HTMLImageElement, HTMLCanvasElement, ImageData ` +
            `in browser, or OffscreenCanvas, ImageData in webworker` +
            ` or {data: Uint32Array, width: number, height: number}, ` +
            `but was ${pixels.constructor.name}`);
    }
    // If the current backend has 'FromPixels' registered, it has a more
    // efficient way of handling pixel uploads, so we call that.
    const kernel = getKernel(FromPixels, ENGINE.backendName);
    if (kernel != null) {
        const inputs = { pixels };
        const attrs = { numChannels };
        return ENGINE.runKernel(FromPixels, inputs, attrs);
    }
    const [width, height] = isVideo ?
        [
            pixels.videoWidth,
            pixels.videoHeight
        ] :
        [pixels.width, pixels.height];
    let vals;
    if (isCanvasLike) {
        vals =
            // tslint:disable-next-line:no-any
            pixels.getContext('2d').getImageData(0, 0, width, height).data;
    }
    else if (isImageData || isPixelData) {
        vals = pixels.data;
    }
    else if (isImage || isVideo || isImageBitmap) {
        if (fromPixels2DContext == null) {
            if (typeof document === 'undefined') {
                if (typeof OffscreenCanvas !== 'undefined' &&
                    typeof OffscreenCanvasRenderingContext2D !== 'undefined') {
                    // @ts-ignore
                    fromPixels2DContext = new OffscreenCanvas(1, 1).getContext('2d');
                }
                else {
                    throw new Error('Cannot parse input in current context. ' +
                        'Reason: OffscreenCanvas Context2D rendering is not supported.');
                }
            }
            else {
                fromPixels2DContext = document.createElement('canvas').getContext('2d', { willReadFrequently: true });
            }
        }
        fromPixels2DContext.canvas.width = width;
        fromPixels2DContext.canvas.height = height;
        fromPixels2DContext.drawImage(pixels, 0, 0, width, height);
        vals = fromPixels2DContext.getImageData(0, 0, width, height).data;
    }
    let values;
    if (numChannels === 4) {
        values = new Int32Array(vals);
    }
    else {
        const numPixels = width * height;
        values = new Int32Array(numPixels * numChannels);
        for (let i = 0; i < numPixels; i++) {
            for (let channel = 0; channel < numChannels; ++channel) {
                values[i * numChannels + channel] = vals[i * 4 + channel];
            }
        }
    }
    const outShape = [height, width, numChannels];
    return tensor3d(values, outShape, 'int32');
}
// Helper functions for |fromPixelsAsync| to check whether the input can
// be wrapped into imageBitmap.
function isPixelData(pixels) {
    return (pixels != null) && (pixels.data instanceof Uint8Array);
}
function isImageBitmapFullySupported() {
    return typeof window !== 'undefined' &&
        typeof (ImageBitmap) !== 'undefined' &&
        window.hasOwnProperty('createImageBitmap');
}
function isNonEmptyPixels(pixels) {
    return pixels != null && pixels.width !== 0 && pixels.height !== 0;
}
function canWrapPixelsToImageBitmap(pixels) {
    return isImageBitmapFullySupported() && !(pixels instanceof ImageBitmap) &&
        isNonEmptyPixels(pixels) && !isPixelData(pixels);
}
/**
 * Creates a `tf.Tensor` from an image in async way.
 *
 * ```js
 * const image = new ImageData(1, 1);
 * image.data[0] = 100;
 * image.data[1] = 150;
 * image.data[2] = 200;
 * image.data[3] = 255;
 *
 * (await tf.browser.fromPixelsAsync(image)).print();
 * ```
 * This API is the async version of fromPixels. The API will first
 * check |WRAP_TO_IMAGEBITMAP| flag, and try to wrap the input to
 * imageBitmap if the flag is set to true.
 *
 * @param pixels The input image to construct the tensor from. The
 * supported image types are all 4-channel. You can also pass in an image
 * object with following attributes:
 * `{data: Uint8Array; width: number; height: number}`
 * @param numChannels The number of channels of the output tensor. A
 * numChannels value less than 4 allows you to ignore channels. Defaults to
 * 3 (ignores alpha channel of input image).
 *
 * @doc {heading: 'Browser', namespace: 'browser', ignoreCI: true}
 */
export async function fromPixelsAsync(pixels, numChannels = 3) {
    let inputs = null;
    // Check whether the backend needs to wrap |pixels| to imageBitmap and
    // whether |pixels| can be wrapped to imageBitmap.
    if (env().getBool('WRAP_TO_IMAGEBITMAP') &&
        canWrapPixelsToImageBitmap(pixels)) {
        // Force the imageBitmap creation to not do any premultiply alpha
        // ops.
        let imageBitmap;
        try {
            // wrap in try-catch block, because createImageBitmap may not work
            // properly in some browsers, e.g.
            // https://bugzilla.mozilla.org/show_bug.cgi?id=1335594
            // tslint:disable-next-line: no-any
            imageBitmap = await createImageBitmap(pixels, { premultiplyAlpha: 'none' });
        }
        catch (e) {
            imageBitmap = null;
        }
        // createImageBitmap will clip the source size.
        // In some cases, the input will have larger size than its content.
        // E.g. new Image(10, 10) but with 1 x 1 content. Using
        // createImageBitmap will clip the size from 10 x 10 to 1 x 1, which
        // is not correct. We should avoid wrapping such resouce to
        // imageBitmap.
        if (imageBitmap != null && imageBitmap.width === pixels.width &&
            imageBitmap.height === pixels.height) {
            inputs = imageBitmap;
        }
        else {
            inputs = pixels;
        }
    }
    else {
        inputs = pixels;
    }
    return fromPixels_(inputs, numChannels);
}
function validateImgTensor(img) {
    if (img.rank !== 2 && img.rank !== 3) {
        throw new Error(`toPixels only supports rank 2 or 3 tensors, got rank ${img.rank}.`);
    }
    const depth = img.rank === 2 ? 1 : img.shape[2];
    if (depth > 4 || depth === 2) {
        throw new Error(`toPixels only supports depth of size ` +
            `1, 3 or 4 but got ${depth}`);
    }
    if (img.dtype !== 'float32' && img.dtype !== 'int32') {
        throw new Error(`Unsupported type for toPixels: ${img.dtype}.` +
            ` Please use float32 or int32 tensors.`);
    }
}
function validateImageOptions(imageOptions) {
    const alpha = (imageOptions === null || imageOptions === void 0 ? void 0 : imageOptions.alpha) || 1;
    if (alpha > 1 || alpha < 0) {
        throw new Error(`Alpha value ${alpha} is suppoed to be in range [0 - 1].`);
    }
}
/**
 * Draws a `tf.Tensor` of pixel values to a byte array or optionally a
 * canvas.
 *
 * When the dtype of the input is 'float32', we assume values in the range
 * [0-1]. Otherwise, when input is 'int32', we assume values in the range
 * [0-255].
 *
 * Returns a promise that resolves when the canvas has been drawn to.
 *
 * @param img A rank-2 tensor with shape `[height, width]`, or a rank-3 tensor
 * of shape `[height, width, numChannels]`. If rank-2, draws grayscale. If
 * rank-3, must have depth of 1, 3 or 4. When depth of 1, draws
 * grayscale. When depth of 3, we draw with the first three components of
 * the depth dimension corresponding to r, g, b and alpha = 1. When depth of
 * 4, all four components of the depth dimension correspond to r, g, b, a.
 * @param canvas The canvas to draw to.
 *
 * @doc {heading: 'Browser', namespace: 'browser'}
 */
export async function toPixels(img, canvas) {
    let $img = convertToTensor(img, 'img', 'toPixels');
    if (!(img instanceof Tensor)) {
        // Assume int32 if user passed a native array.
        const originalImgTensor = $img;
        $img = cast(originalImgTensor, 'int32');
        originalImgTensor.dispose();
    }
    validateImgTensor($img);
    const [height, width] = $img.shape.slice(0, 2);
    const depth = $img.rank === 2 ? 1 : $img.shape[2];
    const data = await $img.data();
    const multiplier = $img.dtype === 'float32' ? 255 : 1;
    const bytes = new Uint8ClampedArray(width * height * 4);
    for (let i = 0; i < height * width; ++i) {
        const rgba = [0, 0, 0, 255];
        for (let d = 0; d < depth; d++) {
            const value = data[i * depth + d];
            if ($img.dtype === 'float32') {
                if (value < 0 || value > 1) {
                    throw new Error(`Tensor values for a float32 Tensor must be in the ` +
                        `range [0 - 1] but encountered ${value}.`);
                }
            }
            else if ($img.dtype === 'int32') {
                if (value < 0 || value > 255) {
                    throw new Error(`Tensor values for a int32 Tensor must be in the ` +
                        `range [0 - 255] but encountered ${value}.`);
                }
            }
            if (depth === 1) {
                rgba[0] = value * multiplier;
                rgba[1] = value * multiplier;
                rgba[2] = value * multiplier;
            }
            else {
                rgba[d] = value * multiplier;
            }
        }
        const j = i * 4;
        bytes[j + 0] = Math.round(rgba[0]);
        bytes[j + 1] = Math.round(rgba[1]);
        bytes[j + 2] = Math.round(rgba[2]);
        bytes[j + 3] = Math.round(rgba[3]);
    }
    if (canvas != null) {
        if (!hasToPixelsWarned) {
            const kernel = getKernel(Draw, ENGINE.backendName);
            if (kernel != null) {
                console.warn('tf.browser.toPixels is not efficient to draw tensor on canvas. ' +
                    'Please try tf.browser.draw instead.');
                hasToPixelsWarned = true;
            }
        }
        canvas.width = width;
        canvas.height = height;
        const ctx = canvas.getContext('2d');
        const imageData = new ImageData(bytes, width, height);
        ctx.putImageData(imageData, 0, 0);
    }
    if ($img !== img) {
        $img.dispose();
    }
    return bytes;
}
/**
 * Draws a `tf.Tensor` to a canvas.
 *
 * When the dtype of the input is 'float32', we assume values in the range
 * [0-1]. Otherwise, when input is 'int32', we assume values in the range
 * [0-255].
 *
 * @param image The tensor to draw on the canvas. Must match one of
 * these shapes:
 *   - Rank-2 with shape `[height, width`]: Drawn as grayscale.
 *   - Rank-3 with shape `[height, width, 1]`: Drawn as grayscale.
 *   - Rank-3 with shape `[height, width, 3]`: Drawn as RGB with alpha set in
 *     `imageOptions` (defaults to 1, which is opaque).
 *   - Rank-3 with shape `[height, width, 4]`: Drawn as RGBA.
 * @param canvas The canvas to draw to.
 * @param options The configuration arguments for image to be drawn and the
 *     canvas to draw to.
 *
 * @doc {heading: 'Browser', namespace: 'browser'}
 */
export function draw(image, canvas, options) {
    let $img = convertToTensor(image, 'img', 'draw');
    if (!(image instanceof Tensor)) {
        // Assume int32 if user passed a native array.
        const originalImgTensor = $img;
        $img = cast(originalImgTensor, 'int32');
        originalImgTensor.dispose();
    }
    validateImgTensor($img);
    validateImageOptions(options === null || options === void 0 ? void 0 : options.imageOptions);
    const inputs = { image: $img };
    const attrs = { canvas, options };
    ENGINE.runKernel(Draw, inputs, attrs);
}
export const fromPixels = /* @__PURE__ */ op({ fromPixels_ });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../../../../../tfjs-core/src/ops/browser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {ENGINE} from '../engine';\nimport {env} from '../environment';\nimport {Draw, DrawAttrs, DrawInputs, FromPixels, FromPixelsAttrs, FromPixelsInputs} from '../kernel_names';\nimport {getKernel, NamedAttrMap} from '../kernel_registry';\nimport {Tensor, Tensor2D, Tensor3D} from '../tensor';\nimport {NamedTensorMap} from '../tensor_types';\nimport {convertToTensor} from '../tensor_util_env';\nimport {DrawOptions, ImageOptions, PixelData, TensorLike} from '../types';\n\nimport {cast} from './cast';\nimport {op} from './operation';\nimport {tensor3d} from './tensor3d';\n\nlet fromPixels2DContext: CanvasRenderingContext2D;\nlet hasToPixelsWarned = false;\n\n/**\n * Creates a `tf.Tensor` from an image.\n *\n * ```js\n * const image = new ImageData(1, 1);\n * image.data[0] = 100;\n * image.data[1] = 150;\n * image.data[2] = 200;\n * image.data[3] = 255;\n *\n * tf.browser.fromPixels(image).print();\n * ```\n *\n * @param pixels The input image to construct the tensor from. The\n * supported image types are all 4-channel. You can also pass in an image\n * object with following attributes:\n * `{data: Uint8Array; width: number; height: number}`\n * @param numChannels The number of channels of the output tensor. A\n * numChannels value less than 4 allows you to ignore channels. Defaults to\n * 3 (ignores alpha channel of input image).\n *\n * @returns A Tensor3D with the shape `[height, width, numChannels]`.\n *\n * Note: fromPixels can be lossy in some cases, same image may result in\n * slightly different tensor values, if rendered by different rendering\n * engines. This means that results from different browsers, or even same\n * browser with CPU and GPU rendering engines can be different. See discussion\n * in details:\n * https://github.com/tensorflow/tfjs/issues/5482\n *\n * @doc {heading: 'Browser', namespace: 'browser', ignoreCI: true}\n */\nfunction fromPixels_(\n    pixels: PixelData|ImageData|HTMLImageElement|HTMLCanvasElement|\n    HTMLVideoElement|ImageBitmap,\n    numChannels = 3): Tensor3D {\n  // Sanity checks.\n  if (numChannels > 4) {\n    throw new Error(\n        'Cannot construct Tensor with more than 4 channels from pixels.');\n  }\n  if (pixels == null) {\n    throw new Error('pixels passed to tf.browser.fromPixels() can not be null');\n  }\n  let isPixelData = false;\n  let isImageData = false;\n  let isVideo = false;\n  let isImage = false;\n  let isCanvasLike = false;\n  let isImageBitmap = false;\n  if ((pixels as PixelData).data instanceof Uint8Array) {\n    isPixelData = true;\n  } else if (\n      typeof (ImageData) !== 'undefined' && pixels instanceof ImageData) {\n    isImageData = true;\n  } else if (\n      typeof (HTMLVideoElement) !== 'undefined' &&\n      pixels instanceof HTMLVideoElement) {\n    isVideo = true;\n  } else if (\n      typeof (HTMLImageElement) !== 'undefined' &&\n      pixels instanceof HTMLImageElement) {\n    isImage = true;\n    // tslint:disable-next-line: no-any\n  } else if ((pixels as any).getContext != null) {\n    isCanvasLike = true;\n  } else if (\n      typeof (ImageBitmap) !== 'undefined' && pixels instanceof ImageBitmap) {\n    isImageBitmap = true;\n  } else {\n    throw new Error(\n        'pixels passed to tf.browser.fromPixels() must be either an ' +\n        `HTMLVideoElement, HTMLImageElement, HTMLCanvasElement, ImageData ` +\n        `in browser, or OffscreenCanvas, ImageData in webworker` +\n        ` or {data: Uint32Array, width: number, height: number}, ` +\n        `but was ${(pixels as {}).constructor.name}`);\n  }\n  // If the current backend has 'FromPixels' registered, it has a more\n  // efficient way of handling pixel uploads, so we call that.\n  const kernel = getKernel(FromPixels, ENGINE.backendName);\n  if (kernel != null) {\n    const inputs: FromPixelsInputs = {pixels};\n    const attrs: FromPixelsAttrs = {numChannels};\n    return ENGINE.runKernel(\n        FromPixels, inputs as unknown as NamedTensorMap,\n        attrs as unknown as NamedAttrMap);\n  }\n\n  const [width, height] = isVideo ?\n      [\n        (pixels as HTMLVideoElement).videoWidth,\n        (pixels as HTMLVideoElement).videoHeight\n      ] :\n      [pixels.width, pixels.height];\n  let vals: Uint8ClampedArray|Uint8Array;\n\n  if (isCanvasLike) {\n    vals =\n        // tslint:disable-next-line:no-any\n        (pixels as any).getContext('2d').getImageData(0, 0, width, height).data;\n  } else if (isImageData || isPixelData) {\n    vals = (pixels as PixelData | ImageData).data;\n  } else if (isImage || isVideo || isImageBitmap) {\n    if (fromPixels2DContext == null) {\n      if (typeof document === 'undefined') {\n        if (typeof OffscreenCanvas !== 'undefined' &&\n            typeof OffscreenCanvasRenderingContext2D !== 'undefined') {\n          // @ts-ignore\n          fromPixels2DContext = new OffscreenCanvas(1, 1).getContext('2d');\n        } else {\n          throw new Error(\n              'Cannot parse input in current context. ' +\n              'Reason: OffscreenCanvas Context2D rendering is not supported.');\n        }\n      } else {\n        fromPixels2DContext = document.createElement('canvas').getContext(\n            '2d', {willReadFrequently: true});\n      }\n    }\n    fromPixels2DContext.canvas.width = width;\n    fromPixels2DContext.canvas.height = height;\n    fromPixels2DContext.drawImage(\n        pixels as HTMLVideoElement, 0, 0, width, height);\n    vals = fromPixels2DContext.getImageData(0, 0, width, height).data;\n  }\n  let values: Int32Array;\n  if (numChannels === 4) {\n    values = new Int32Array(vals);\n  } else {\n    const numPixels = width * height;\n    values = new Int32Array(numPixels * numChannels);\n    for (let i = 0; i < numPixels; i++) {\n      for (let channel = 0; channel < numChannels; ++channel) {\n        values[i * numChannels + channel] = vals[i * 4 + channel];\n      }\n    }\n  }\n  const outShape: [number, number, number] = [height, width, numChannels];\n  return tensor3d(values, outShape, 'int32');\n}\n\n// Helper functions for |fromPixelsAsync| to check whether the input can\n// be wrapped into imageBitmap.\nfunction isPixelData(pixels: PixelData|ImageData|HTMLImageElement|\n                     HTMLCanvasElement|HTMLVideoElement|\n                     ImageBitmap): pixels is PixelData {\n  return (pixels != null) && ((pixels as PixelData).data instanceof Uint8Array);\n}\n\nfunction isImageBitmapFullySupported() {\n  return typeof window !== 'undefined' &&\n      typeof (ImageBitmap) !== 'undefined' &&\n      window.hasOwnProperty('createImageBitmap');\n}\n\nfunction isNonEmptyPixels(pixels: PixelData|ImageData|HTMLImageElement|\n                          HTMLCanvasElement|HTMLVideoElement|ImageBitmap) {\n  return pixels != null && pixels.width !== 0 && pixels.height !== 0;\n}\n\nfunction canWrapPixelsToImageBitmap(pixels: PixelData|ImageData|\n                                    HTMLImageElement|HTMLCanvasElement|\n                                    HTMLVideoElement|ImageBitmap) {\n  return isImageBitmapFullySupported() && !(pixels instanceof ImageBitmap) &&\n      isNonEmptyPixels(pixels) && !isPixelData(pixels);\n}\n\n/**\n * Creates a `tf.Tensor` from an image in async way.\n *\n * ```js\n * const image = new ImageData(1, 1);\n * image.data[0] = 100;\n * image.data[1] = 150;\n * image.data[2] = 200;\n * image.data[3] = 255;\n *\n * (await tf.browser.fromPixelsAsync(image)).print();\n * ```\n * This API is the async version of fromPixels. The API will first\n * check |WRAP_TO_IMAGEBITMAP| flag, and try to wrap the input to\n * imageBitmap if the flag is set to true.\n *\n * @param pixels The input image to construct the tensor from. The\n * supported image types are all 4-channel. You can also pass in an image\n * object with following attributes:\n * `{data: Uint8Array; width: number; height: number}`\n * @param numChannels The number of channels of the output tensor. A\n * numChannels value less than 4 allows you to ignore channels. Defaults to\n * 3 (ignores alpha channel of input image).\n *\n * @doc {heading: 'Browser', namespace: 'browser', ignoreCI: true}\n */\nexport async function fromPixelsAsync(\n    pixels: PixelData|ImageData|HTMLImageElement|HTMLCanvasElement|\n    HTMLVideoElement|ImageBitmap,\n    numChannels = 3) {\n  let inputs: PixelData|ImageData|HTMLImageElement|HTMLCanvasElement|\n      HTMLVideoElement|ImageBitmap = null;\n\n  // Check whether the backend needs to wrap |pixels| to imageBitmap and\n  // whether |pixels| can be wrapped to imageBitmap.\n  if (env().getBool('WRAP_TO_IMAGEBITMAP') &&\n      canWrapPixelsToImageBitmap(pixels)) {\n    // Force the imageBitmap creation to not do any premultiply alpha\n    // ops.\n    let imageBitmap;\n\n    try {\n      // wrap in try-catch block, because createImageBitmap may not work\n      // properly in some browsers, e.g.\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=1335594\n      // tslint:disable-next-line: no-any\n      imageBitmap = await (createImageBitmap as any)(\n          pixels as ImageBitmapSource, {premultiplyAlpha: 'none'});\n    } catch (e) {\n      imageBitmap = null;\n    }\n\n    // createImageBitmap will clip the source size.\n    // In some cases, the input will have larger size than its content.\n    // E.g. new Image(10, 10) but with 1 x 1 content. Using\n    // createImageBitmap will clip the size from 10 x 10 to 1 x 1, which\n    // is not correct. We should avoid wrapping such resouce to\n    // imageBitmap.\n    if (imageBitmap != null && imageBitmap.width === pixels.width &&\n        imageBitmap.height === pixels.height) {\n      inputs = imageBitmap;\n    } else {\n      inputs = pixels;\n    }\n  } else {\n    inputs = pixels;\n  }\n\n  return fromPixels_(inputs, numChannels);\n}\n\nfunction validateImgTensor(img: Tensor2D|Tensor3D) {\n  if (img.rank !== 2 && img.rank !== 3) {\n    throw new Error(\n        `toPixels only supports rank 2 or 3 tensors, got rank ${img.rank}.`);\n  }\n  const depth = img.rank === 2 ? 1 : img.shape[2];\n\n  if (depth > 4 || depth === 2) {\n    throw new Error(\n        `toPixels only supports depth of size ` +\n        `1, 3 or 4 but got ${depth}`);\n  }\n\n  if (img.dtype !== 'float32' && img.dtype !== 'int32') {\n    throw new Error(\n        `Unsupported type for toPixels: ${img.dtype}.` +\n        ` Please use float32 or int32 tensors.`);\n  }\n}\n\nfunction validateImageOptions(imageOptions: ImageOptions) {\n  const alpha = imageOptions ?.alpha || 1;\n  if (alpha > 1 || alpha < 0) {\n    throw new Error(`Alpha value ${alpha} is suppoed to be in range [0 - 1].`);\n  }\n}\n\n/**\n * Draws a `tf.Tensor` of pixel values to a byte array or optionally a\n * canvas.\n *\n * When the dtype of the input is 'float32', we assume values in the range\n * [0-1]. Otherwise, when input is 'int32', we assume values in the range\n * [0-255].\n *\n * Returns a promise that resolves when the canvas has been drawn to.\n *\n * @param img A rank-2 tensor with shape `[height, width]`, or a rank-3 tensor\n * of shape `[height, width, numChannels]`. If rank-2, draws grayscale. If\n * rank-3, must have depth of 1, 3 or 4. When depth of 1, draws\n * grayscale. When depth of 3, we draw with the first three components of\n * the depth dimension corresponding to r, g, b and alpha = 1. When depth of\n * 4, all four components of the depth dimension correspond to r, g, b, a.\n * @param canvas The canvas to draw to.\n *\n * @doc {heading: 'Browser', namespace: 'browser'}\n */\nexport async function toPixels(\n    img: Tensor2D|Tensor3D|TensorLike,\n    canvas?: HTMLCanvasElement): Promise<Uint8ClampedArray> {\n  let $img = convertToTensor(img, 'img', 'toPixels');\n  if (!(img instanceof Tensor)) {\n    // Assume int32 if user passed a native array.\n    const originalImgTensor = $img;\n    $img = cast(originalImgTensor, 'int32');\n    originalImgTensor.dispose();\n  }\n  validateImgTensor($img);\n\n  const [height, width] = $img.shape.slice(0, 2);\n  const depth = $img.rank === 2 ? 1 : $img.shape[2];\n  const data = await $img.data();\n  const multiplier = $img.dtype === 'float32' ? 255 : 1;\n  const bytes = new Uint8ClampedArray(width * height * 4);\n\n  for (let i = 0; i < height * width; ++i) {\n    const rgba = [0, 0, 0, 255];\n\n    for (let d = 0; d < depth; d++) {\n      const value = data[i * depth + d];\n\n      if ($img.dtype === 'float32') {\n        if (value < 0 || value > 1) {\n          throw new Error(\n              `Tensor values for a float32 Tensor must be in the ` +\n              `range [0 - 1] but encountered ${value}.`);\n        }\n      } else if ($img.dtype === 'int32') {\n        if (value < 0 || value > 255) {\n          throw new Error(\n              `Tensor values for a int32 Tensor must be in the ` +\n              `range [0 - 255] but encountered ${value}.`);\n        }\n      }\n\n      if (depth === 1) {\n        rgba[0] = value * multiplier;\n        rgba[1] = value * multiplier;\n        rgba[2] = value * multiplier;\n      } else {\n        rgba[d] = value * multiplier;\n      }\n    }\n\n    const j = i * 4;\n    bytes[j + 0] = Math.round(rgba[0]);\n    bytes[j + 1] = Math.round(rgba[1]);\n    bytes[j + 2] = Math.round(rgba[2]);\n    bytes[j + 3] = Math.round(rgba[3]);\n  }\n\n  if (canvas != null) {\n    if (!hasToPixelsWarned) {\n      const kernel = getKernel(Draw, ENGINE.backendName);\n      if (kernel != null) {\n        console.warn(\n            'tf.browser.toPixels is not efficient to draw tensor on canvas. ' +\n            'Please try tf.browser.draw instead.');\n        hasToPixelsWarned = true;\n      }\n    }\n\n    canvas.width = width;\n    canvas.height = height;\n    const ctx = canvas.getContext('2d');\n    const imageData = new ImageData(bytes, width, height);\n    ctx.putImageData(imageData, 0, 0);\n  }\n  if ($img !== img) {\n    $img.dispose();\n  }\n  return bytes;\n}\n\n/**\n * Draws a `tf.Tensor` to a canvas.\n *\n * When the dtype of the input is 'float32', we assume values in the range\n * [0-1]. Otherwise, when input is 'int32', we assume values in the range\n * [0-255].\n *\n * @param image The tensor to draw on the canvas. Must match one of\n * these shapes:\n *   - Rank-2 with shape `[height, width`]: Drawn as grayscale.\n *   - Rank-3 with shape `[height, width, 1]`: Drawn as grayscale.\n *   - Rank-3 with shape `[height, width, 3]`: Drawn as RGB with alpha set in\n *     `imageOptions` (defaults to 1, which is opaque).\n *   - Rank-3 with shape `[height, width, 4]`: Drawn as RGBA.\n * @param canvas The canvas to draw to.\n * @param options The configuration arguments for image to be drawn and the\n *     canvas to draw to.\n *\n * @doc {heading: 'Browser', namespace: 'browser'}\n */\nexport function draw(\n    image: Tensor2D|Tensor3D|TensorLike, canvas: HTMLCanvasElement,\n    options?: DrawOptions): void {\n  let $img = convertToTensor(image, 'img', 'draw');\n  if (!(image instanceof Tensor)) {\n    // Assume int32 if user passed a native array.\n    const originalImgTensor = $img;\n    $img = cast(originalImgTensor, 'int32');\n    originalImgTensor.dispose();\n  }\n  validateImgTensor($img);\n  validateImageOptions(options?.imageOptions);\n\n  const inputs: DrawInputs = {image: $img};\n  const attrs: DrawAttrs = {canvas, options};\n  ENGINE.runKernel(\n      Draw, inputs as unknown as NamedTensorMap,\n      attrs as unknown as NamedAttrMap);\n}\n\nexport const fromPixels = /* @__PURE__ */ op({fromPixels_});\n"]}