@tensorflow/tfjs-core
Version:
Hardware-accelerated JavaScript library for machine intelligence
238 lines • 10 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var TextureType;
(function (TextureType) {
TextureType[TextureType["FLOAT"] = 0] = "FLOAT";
TextureType[TextureType["UNSIGNED_BYTE"] = 1] = "UNSIGNED_BYTE";
})(TextureType = exports.TextureType || (exports.TextureType = {}));
function getUnpackedMatrixTextureShapeWidthHeight(rows, columns) {
return [columns, rows];
}
exports.getUnpackedMatrixTextureShapeWidthHeight = getUnpackedMatrixTextureShapeWidthHeight;
function getUnpackedArraySizeFromMatrixSize(matrixSize, channelsPerTexture) {
return matrixSize * channelsPerTexture;
}
exports.getUnpackedArraySizeFromMatrixSize = getUnpackedArraySizeFromMatrixSize;
function getColorMatrixTextureShapeWidthHeight(rows, columns) {
return [columns * 4, rows];
}
exports.getColorMatrixTextureShapeWidthHeight = getColorMatrixTextureShapeWidthHeight;
function getMatrixSizeFromUnpackedArraySize(unpackedSize, channelsPerTexture) {
if (unpackedSize % channelsPerTexture !== 0) {
throw new Error("unpackedSize (" + unpackedSize + ") must be a multiple of " +
("" + channelsPerTexture));
}
return unpackedSize / channelsPerTexture;
}
exports.getMatrixSizeFromUnpackedArraySize = getMatrixSizeFromUnpackedArraySize;
function encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture) {
var requiredSize = getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture);
if (unpackedArray.length < requiredSize) {
throw new Error("unpackedArray length (" + unpackedArray.length + ") must be >= " +
("" + requiredSize));
}
var dst = 0;
for (var src = 0; src < matrix.length; ++src) {
unpackedArray[dst] = matrix[src];
dst += channelsPerTexture;
}
}
exports.encodeMatrixToUnpackedArray = encodeMatrixToUnpackedArray;
exports.FLOAT_MAX = 20000;
exports.FLOAT_MIN = -exports.FLOAT_MAX;
var FLOAT_RANGE = (exports.FLOAT_MAX - exports.FLOAT_MIN) / 255;
var FLOAT_DELTAS = [1, 1 / 255, 1 / (255 * 255), 1 / (255 * 255 * 255)];
var FLOAT_POWERS = [1, 255, 255 * 255];
exports.BYTE_NAN_VALUE = 0;
function encodeFloatArray(floatArray) {
var uintArray = new Uint8Array(floatArray.length * 4);
var _loop_1 = function (i) {
var value = floatArray[i / 4];
if (isNaN(value)) {
uintArray[i] = exports.BYTE_NAN_VALUE;
uintArray[i + 1] = exports.BYTE_NAN_VALUE;
uintArray[i + 2] = exports.BYTE_NAN_VALUE;
uintArray[i + 3] = exports.BYTE_NAN_VALUE;
return "continue";
}
var normalizedValue = (value - exports.FLOAT_MIN) / FLOAT_RANGE;
var enc = FLOAT_POWERS.map(function (pow) { return pow * normalizedValue; });
var buckets = enc.map(function (value) { return Math.floor((value % 1) * 255); });
uintArray[i] = Math.floor(normalizedValue);
uintArray[i + 1] = buckets[0];
uintArray[i + 2] = buckets[1];
uintArray[i + 3] = buckets[2];
};
for (var i = 0; i < uintArray.length; i += 4) {
_loop_1(i);
}
return uintArray;
}
exports.encodeFloatArray = encodeFloatArray;
function decodeToFloatArray(uintArray) {
var floatArray = new Float32Array(uintArray.length / 4);
var _loop_2 = function (i) {
if (uintArray[i] === exports.BYTE_NAN_VALUE &&
uintArray[i + 1] === exports.BYTE_NAN_VALUE &&
uintArray[i + 2] === exports.BYTE_NAN_VALUE &&
uintArray[i + 3] === exports.BYTE_NAN_VALUE) {
floatArray[i / 4] = NaN;
return "continue";
}
var dot = 0;
FLOAT_DELTAS.forEach(function (delta, j) {
dot += delta * uintArray[i + j];
});
var value = dot * FLOAT_RANGE + exports.FLOAT_MIN;
floatArray[i / 4] = value;
};
for (var i = 0; i < uintArray.length; i += 4) {
_loop_2(i);
}
return floatArray;
}
exports.decodeToFloatArray = decodeToFloatArray;
function decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture) {
var requiredSize = getMatrixSizeFromUnpackedArraySize(unpackedArray.length, channelsPerTexture);
if (matrix.length < requiredSize) {
throw new Error("matrix length (" + matrix.length + ") must be >= " + requiredSize);
}
var dst = 0;
for (var src = 0; src < unpackedArray.length; src += channelsPerTexture) {
matrix[dst++] = unpackedArray[src];
}
}
exports.decodeMatrixFromUnpackedArray = decodeMatrixFromUnpackedArray;
function decodeMatrixFromUnpackedColorRGBAArray(unpackedArray, matrix, channels) {
var requiredSize = unpackedArray.length * channels / 4;
if (matrix.length < requiredSize) {
throw new Error("matrix length (" + matrix.length + ") must be >= " + requiredSize);
}
var dst = 0;
for (var src = 0; src < unpackedArray.length; src += 4) {
for (var c = 0; c < channels; c++) {
matrix[dst++] = unpackedArray[src + c];
}
}
}
exports.decodeMatrixFromUnpackedColorRGBAArray = decodeMatrixFromUnpackedColorRGBAArray;
function getPackedMatrixTextureShapeWidthHeight(rows, columns) {
return [Math.ceil(columns / 2), Math.ceil(rows / 2)];
}
exports.getPackedMatrixTextureShapeWidthHeight = getPackedMatrixTextureShapeWidthHeight;
function getPackedRGBAArraySizeFromMatrixShape(rows, columns) {
var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1];
return w * h * 4;
}
exports.getPackedRGBAArraySizeFromMatrixShape = getPackedRGBAArraySizeFromMatrixShape;
function encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA) {
var requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns);
if (packedRGBA.length < requiredSize) {
throw new Error("packedRGBA length (" + packedRGBA.length + ") must be >= " + requiredSize);
}
var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1];
var oddWidth = (columns % 2) === 1;
var oddHeight = (rows % 2) === 1;
var widthInFullBlocks = Math.floor(columns / 2);
var heightInFullBlocks = Math.floor(rows / 2);
{
var dstStride = (oddWidth ? 4 : 0);
var oneRow = columns;
var dst = 0;
for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) {
var matrixSrcRow = (blockY * 2 * columns);
for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) {
var matrixSrcCol = blockX * 2;
var src = matrixSrcRow + matrixSrcCol;
packedRGBA[dst] = matrix[src];
packedRGBA[dst + 1] = matrix[src + 1];
packedRGBA[dst + 2] = matrix[src + oneRow];
packedRGBA[dst + 3] = matrix[src + oneRow + 1];
dst += 4;
}
dst += dstStride;
}
}
if (oddWidth) {
var src = columns - 1;
var dst = (textureWidth - 1) * 4;
var srcStride = 2 * columns;
var dstStride = textureWidth * 4;
for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) {
packedRGBA[dst] = matrix[src];
packedRGBA[dst + 2] = matrix[src + columns];
src += srcStride;
dst += dstStride;
}
}
if (oddHeight) {
var src = (rows - 1) * columns;
var dst = (textureHeight - 1) * textureWidth * 4;
for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) {
packedRGBA[dst++] = matrix[src++];
packedRGBA[dst++] = matrix[src++];
dst += 2;
}
}
if (oddWidth && oddHeight) {
packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1];
}
return packedRGBA;
}
exports.encodeMatrixToPackedRGBA = encodeMatrixToPackedRGBA;
function decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix) {
var requiredSize = rows * columns;
if (requiredSize < matrix.length) {
throw new Error("matrix length (" + matrix.length + ") must be >= " + requiredSize);
}
var oddWidth = (columns % 2) === 1;
var oddHeight = (rows % 2) === 1;
var widthInFullBlocks = Math.floor(columns / 2);
var heightInFullBlocks = Math.floor(rows / 2);
var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1];
{
var srcStride = oddWidth ? 4 : 0;
var dstStride = columns + (oddWidth ? 1 : 0);
var src = 0;
var dstRow1 = 0;
var dstRow2 = columns;
for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) {
for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) {
matrix[dstRow1++] = packedRGBA[src++];
matrix[dstRow1++] = packedRGBA[src++];
matrix[dstRow2++] = packedRGBA[src++];
matrix[dstRow2++] = packedRGBA[src++];
}
src += srcStride;
dstRow1 += dstStride;
dstRow2 += dstStride;
}
}
if (oddWidth) {
var src = (textureWidth - 1) * 4;
var dst = columns - 1;
var srcStride = textureWidth * 4;
var dstStride = 2 * columns;
for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) {
matrix[dst] = packedRGBA[src];
matrix[dst + columns] = packedRGBA[src + 2];
src += srcStride;
dst += dstStride;
}
}
if (oddHeight) {
var src = (textureHeight - 1) * textureWidth * 4;
var dst = (rows - 1) * columns;
for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) {
matrix[dst++] = packedRGBA[src++];
matrix[dst++] = packedRGBA[src++];
src += 2;
}
}
if (oddWidth && oddHeight) {
matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4];
}
return matrix;
}
exports.decodeMatrixFromPackedRGBA = decodeMatrixFromPackedRGBA;
//# sourceMappingURL=tex_util.js.map