spot-sdk-ts/dist/bosdyn/api/image.js

TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GetImageResponse = exports.ImageResponse = exports.GetImageRequest = exports.ImageRequest = exports.ListImageSourcesResponse = exports.ListImageSourcesRequest = exports.ImageSource_PinholeModel_CameraIntrinsics = exports.ImageSource_PinholeModel = exports.ImageSource = exports.ImageCapture = exports.CaptureParameters = exports.Image = exports.imageResponse_StatusToJSON = exports.imageResponse_StatusFromJSON = exports.ImageResponse_Status = exports.imageSource_ImageTypeToJSON = exports.imageSource_ImageTypeFromJSON = exports.ImageSource_ImageType = exports.image_PixelFormatToJSON = exports.image_PixelFormatFromJSON = exports.Image_PixelFormat = exports.image_FormatToJSON = exports.image_FormatFromJSON = exports.Image_Format = exports.protobufPackage = void 0;
/* eslint-disable */
const timestamp_1 = require("../../google/protobuf/timestamp");
const duration_1 = require("../../google/protobuf/duration");
const geometry_1 = require("./geometry");
const header_1 = require("./header");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
var Image_Format;
(function (Image_Format) {
    /** FORMAT_UNKNOWN - Unknown image format. */
    Image_Format[Image_Format["FORMAT_UNKNOWN"] = 0] = "FORMAT_UNKNOWN";
    /**
     * FORMAT_JPEG - Color/greyscale formats.
     * JPEG format.
     */
    Image_Format[Image_Format["FORMAT_JPEG"] = 1] = "FORMAT_JPEG";
    /** FORMAT_RAW - Uncompressed.  Requires pixel_format. */
    Image_Format[Image_Format["FORMAT_RAW"] = 2] = "FORMAT_RAW";
    /** FORMAT_RLE - 1 byte run-length before each pixel value. */
    Image_Format[Image_Format["FORMAT_RLE"] = 3] = "FORMAT_RLE";
    Image_Format[Image_Format["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(Image_Format = exports.Image_Format || (exports.Image_Format = {}));
function image_FormatFromJSON(object) {
    switch (object) {
        case 0:
        case "FORMAT_UNKNOWN":
            return Image_Format.FORMAT_UNKNOWN;
        case 1:
        case "FORMAT_JPEG":
            return Image_Format.FORMAT_JPEG;
        case 2:
        case "FORMAT_RAW":
            return Image_Format.FORMAT_RAW;
        case 3:
        case "FORMAT_RLE":
            return Image_Format.FORMAT_RLE;
        case -1:
        case "UNRECOGNIZED":
        default:
            return Image_Format.UNRECOGNIZED;
    }
}
exports.image_FormatFromJSON = image_FormatFromJSON;
function image_FormatToJSON(object) {
    switch (object) {
        case Image_Format.FORMAT_UNKNOWN:
            return "FORMAT_UNKNOWN";
        case Image_Format.FORMAT_JPEG:
            return "FORMAT_JPEG";
        case Image_Format.FORMAT_RAW:
            return "FORMAT_RAW";
        case Image_Format.FORMAT_RLE:
            return "FORMAT_RLE";
        case Image_Format.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.image_FormatToJSON = image_FormatToJSON;
var Image_PixelFormat;
(function (Image_PixelFormat) {
    /** PIXEL_FORMAT_UNKNOWN - Unspecified value -- should not be used. */
    Image_PixelFormat[Image_PixelFormat["PIXEL_FORMAT_UNKNOWN"] = 0] = "PIXEL_FORMAT_UNKNOWN";
    /** PIXEL_FORMAT_GREYSCALE_U8 - One byte per pixel. */
    Image_PixelFormat[Image_PixelFormat["PIXEL_FORMAT_GREYSCALE_U8"] = 1] = "PIXEL_FORMAT_GREYSCALE_U8";
    /** PIXEL_FORMAT_RGB_U8 - Three bytes per pixel. */
    Image_PixelFormat[Image_PixelFormat["PIXEL_FORMAT_RGB_U8"] = 3] = "PIXEL_FORMAT_RGB_U8";
    /** PIXEL_FORMAT_RGBA_U8 - Four bytes per pixel. */
    Image_PixelFormat[Image_PixelFormat["PIXEL_FORMAT_RGBA_U8"] = 4] = "PIXEL_FORMAT_RGBA_U8";
    /** PIXEL_FORMAT_DEPTH_U16 - Little-endian uint16 z-distance from camera (mm). */
    Image_PixelFormat[Image_PixelFormat["PIXEL_FORMAT_DEPTH_U16"] = 5] = "PIXEL_FORMAT_DEPTH_U16";
    /** PIXEL_FORMAT_GREYSCALE_U16 - Two bytes per pixel. */
    Image_PixelFormat[Image_PixelFormat["PIXEL_FORMAT_GREYSCALE_U16"] = 6] = "PIXEL_FORMAT_GREYSCALE_U16";
    Image_PixelFormat[Image_PixelFormat["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(Image_PixelFormat = exports.Image_PixelFormat || (exports.Image_PixelFormat = {}));
function image_PixelFormatFromJSON(object) {
    switch (object) {
        case 0:
        case "PIXEL_FORMAT_UNKNOWN":
            return Image_PixelFormat.PIXEL_FORMAT_UNKNOWN;
        case 1:
        case "PIXEL_FORMAT_GREYSCALE_U8":
            return Image_PixelFormat.PIXEL_FORMAT_GREYSCALE_U8;
        case 3:
        case "PIXEL_FORMAT_RGB_U8":
            return Image_PixelFormat.PIXEL_FORMAT_RGB_U8;
        case 4:
        case "PIXEL_FORMAT_RGBA_U8":
            return Image_PixelFormat.PIXEL_FORMAT_RGBA_U8;
        case 5:
        case "PIXEL_FORMAT_DEPTH_U16":
            return Image_PixelFormat.PIXEL_FORMAT_DEPTH_U16;
        case 6:
        case "PIXEL_FORMAT_GREYSCALE_U16":
            return Image_PixelFormat.PIXEL_FORMAT_GREYSCALE_U16;
        case -1:
        case "UNRECOGNIZED":
        default:
            return Image_PixelFormat.UNRECOGNIZED;
    }
}
exports.image_PixelFormatFromJSON = image_PixelFormatFromJSON;
function image_PixelFormatToJSON(object) {
    switch (object) {
        case Image_PixelFormat.PIXEL_FORMAT_UNKNOWN:
            return "PIXEL_FORMAT_UNKNOWN";
        case Image_PixelFormat.PIXEL_FORMAT_GREYSCALE_U8:
            return "PIXEL_FORMAT_GREYSCALE_U8";
        case Image_PixelFormat.PIXEL_FORMAT_RGB_U8:
            return "PIXEL_FORMAT_RGB_U8";
        case Image_PixelFormat.PIXEL_FORMAT_RGBA_U8:
            return "PIXEL_FORMAT_RGBA_U8";
        case Image_PixelFormat.PIXEL_FORMAT_DEPTH_U16:
            return "PIXEL_FORMAT_DEPTH_U16";
        case Image_PixelFormat.PIXEL_FORMAT_GREYSCALE_U16:
            return "PIXEL_FORMAT_GREYSCALE_U16";
        case Image_PixelFormat.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.image_PixelFormatToJSON = image_PixelFormatToJSON;
var ImageSource_ImageType;
(function (ImageSource_ImageType) {
    /** IMAGE_TYPE_UNKNOWN - Unspecified image type. */
    ImageSource_ImageType[ImageSource_ImageType["IMAGE_TYPE_UNKNOWN"] = 0] = "IMAGE_TYPE_UNKNOWN";
    /** IMAGE_TYPE_VISUAL - Color or greyscale intensity image. */
    ImageSource_ImageType[ImageSource_ImageType["IMAGE_TYPE_VISUAL"] = 1] = "IMAGE_TYPE_VISUAL";
    /** IMAGE_TYPE_DEPTH - Pixel values represent distances to objects/surfaces. */
    ImageSource_ImageType[ImageSource_ImageType["IMAGE_TYPE_DEPTH"] = 2] = "IMAGE_TYPE_DEPTH";
    ImageSource_ImageType[ImageSource_ImageType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ImageSource_ImageType = exports.ImageSource_ImageType || (exports.ImageSource_ImageType = {}));
function imageSource_ImageTypeFromJSON(object) {
    switch (object) {
        case 0:
        case "IMAGE_TYPE_UNKNOWN":
            return ImageSource_ImageType.IMAGE_TYPE_UNKNOWN;
        case 1:
        case "IMAGE_TYPE_VISUAL":
            return ImageSource_ImageType.IMAGE_TYPE_VISUAL;
        case 2:
        case "IMAGE_TYPE_DEPTH":
            return ImageSource_ImageType.IMAGE_TYPE_DEPTH;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ImageSource_ImageType.UNRECOGNIZED;
    }
}
exports.imageSource_ImageTypeFromJSON = imageSource_ImageTypeFromJSON;
function imageSource_ImageTypeToJSON(object) {
    switch (object) {
        case ImageSource_ImageType.IMAGE_TYPE_UNKNOWN:
            return "IMAGE_TYPE_UNKNOWN";
        case ImageSource_ImageType.IMAGE_TYPE_VISUAL:
            return "IMAGE_TYPE_VISUAL";
        case ImageSource_ImageType.IMAGE_TYPE_DEPTH:
            return "IMAGE_TYPE_DEPTH";
        case ImageSource_ImageType.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.imageSource_ImageTypeToJSON = imageSource_ImageTypeToJSON;
var ImageResponse_Status;
(function (ImageResponse_Status) {
    /**
     * STATUS_UNKNOWN - UNKNOWN should never be used.
     * An internal ImageService issue has happened if UNKNOWN is set.
     * None of the other fields are filled out.
     */
    ImageResponse_Status[ImageResponse_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_OK - Call succeeded at filling out all the fields. */
    ImageResponse_Status[ImageResponse_Status["STATUS_OK"] = 1] = "STATUS_OK";
    /** STATUS_UNKNOWN_CAMERA - Image source name in request is unknown.  Other fields are not filled out. */
    ImageResponse_Status[ImageResponse_Status["STATUS_UNKNOWN_CAMERA"] = 2] = "STATUS_UNKNOWN_CAMERA";
    /** STATUS_SOURCE_DATA_ERROR - Failed to fill out ImageSource.  All the other fields are not filled out. */
    ImageResponse_Status[ImageResponse_Status["STATUS_SOURCE_DATA_ERROR"] = 3] = "STATUS_SOURCE_DATA_ERROR";
    /** STATUS_IMAGE_DATA_ERROR - There was a problem with the image data.  Only the ImageSource is filled out. */
    ImageResponse_Status[ImageResponse_Status["STATUS_IMAGE_DATA_ERROR"] = 4] = "STATUS_IMAGE_DATA_ERROR";
    /**
     * STATUS_UNSUPPORTED_IMAGE_FORMAT_REQUESTED - The requested image format is unsupported for the image-source named. The image data will
     * not be filled out. Note, if an image request has "FORMAT_UNKNOWN", the service should choose the
     * best format to provide the data in.
     */
    ImageResponse_Status[ImageResponse_Status["STATUS_UNSUPPORTED_IMAGE_FORMAT_REQUESTED"] = 5] = "STATUS_UNSUPPORTED_IMAGE_FORMAT_REQUESTED";
    /**
     * STATUS_UNSUPPORTED_PIXEL_FORMAT_REQUESTED - The requested pixel format is unsupported for the image-source named. The image data will
     * not be filled out. Note, if an image request has "PIXEL_FORMAT_UNKNOWN", the service
     * should choose the best format to provide the data in.
     */
    ImageResponse_Status[ImageResponse_Status["STATUS_UNSUPPORTED_PIXEL_FORMAT_REQUESTED"] = 6] = "STATUS_UNSUPPORTED_PIXEL_FORMAT_REQUESTED";
    /** STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED - The requested ratio is out of bounds [0,1] or unsupported by the image service */
    ImageResponse_Status[ImageResponse_Status["STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED"] = 7] = "STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED";
    ImageResponse_Status[ImageResponse_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ImageResponse_Status = exports.ImageResponse_Status || (exports.ImageResponse_Status = {}));
function imageResponse_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return ImageResponse_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_OK":
            return ImageResponse_Status.STATUS_OK;
        case 2:
        case "STATUS_UNKNOWN_CAMERA":
            return ImageResponse_Status.STATUS_UNKNOWN_CAMERA;
        case 3:
        case "STATUS_SOURCE_DATA_ERROR":
            return ImageResponse_Status.STATUS_SOURCE_DATA_ERROR;
        case 4:
        case "STATUS_IMAGE_DATA_ERROR":
            return ImageResponse_Status.STATUS_IMAGE_DATA_ERROR;
        case 5:
        case "STATUS_UNSUPPORTED_IMAGE_FORMAT_REQUESTED":
            return ImageResponse_Status.STATUS_UNSUPPORTED_IMAGE_FORMAT_REQUESTED;
        case 6:
        case "STATUS_UNSUPPORTED_PIXEL_FORMAT_REQUESTED":
            return ImageResponse_Status.STATUS_UNSUPPORTED_PIXEL_FORMAT_REQUESTED;
        case 7:
        case "STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED":
            return ImageResponse_Status.STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ImageResponse_Status.UNRECOGNIZED;
    }
}
exports.imageResponse_StatusFromJSON = imageResponse_StatusFromJSON;
function imageResponse_StatusToJSON(object) {
    switch (object) {
        case ImageResponse_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case ImageResponse_Status.STATUS_OK:
            return "STATUS_OK";
        case ImageResponse_Status.STATUS_UNKNOWN_CAMERA:
            return "STATUS_UNKNOWN_CAMERA";
        case ImageResponse_Status.STATUS_SOURCE_DATA_ERROR:
            return "STATUS_SOURCE_DATA_ERROR";
        case ImageResponse_Status.STATUS_IMAGE_DATA_ERROR:
            return "STATUS_IMAGE_DATA_ERROR";
        case ImageResponse_Status.STATUS_UNSUPPORTED_IMAGE_FORMAT_REQUESTED:
            return "STATUS_UNSUPPORTED_IMAGE_FORMAT_REQUESTED";
        case ImageResponse_Status.STATUS_UNSUPPORTED_PIXEL_FORMAT_REQUESTED:
            return "STATUS_UNSUPPORTED_PIXEL_FORMAT_REQUESTED";
        case ImageResponse_Status.STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED:
            return "STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED";
        case ImageResponse_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.imageResponse_StatusToJSON = imageResponse_StatusToJSON;
function createBaseImage() {
    return {
        cols: 0,
        rows: 0,
        data: new Uint8Array(),
        format: 0,
        pixelFormat: 0,
    };
}
exports.Image = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.cols !== 0) {
            writer.uint32(16).int32(message.cols);
        }
        if (message.rows !== 0) {
            writer.uint32(24).int32(message.rows);
        }
        if (message.data.length !== 0) {
            writer.uint32(34).bytes(message.data);
        }
        if (message.format !== 0) {
            writer.uint32(40).int32(message.format);
        }
        if (message.pixelFormat !== 0) {
            writer.uint32(48).int32(message.pixelFormat);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseImage();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 2:
                    message.cols = reader.int32();
                    break;
                case 3:
                    message.rows = reader.int32();
                    break;
                case 4:
                    message.data = reader.bytes();
                    break;
                case 5:
                    message.format = reader.int32();
                    break;
                case 6:
                    message.pixelFormat = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            cols: isSet(object.cols) ? Number(object.cols) : 0,
            rows: isSet(object.rows) ? Number(object.rows) : 0,
            data: isSet(object.data)
                ? bytesFromBase64(object.data)
                : new Uint8Array(),
            format: isSet(object.format) ? image_FormatFromJSON(object.format) : 0,
            pixelFormat: isSet(object.pixelFormat)
                ? image_PixelFormatFromJSON(object.pixelFormat)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.cols !== undefined && (obj.cols = Math.round(message.cols));
        message.rows !== undefined && (obj.rows = Math.round(message.rows));
        message.data !== undefined &&
            (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
        message.format !== undefined &&
            (obj.format = image_FormatToJSON(message.format));
        message.pixelFormat !== undefined &&
            (obj.pixelFormat = image_PixelFormatToJSON(message.pixelFormat));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseImage();
        message.cols = object.cols ?? 0;
        message.rows = object.rows ?? 0;
        message.data = object.data ?? new Uint8Array();
        message.format = object.format ?? 0;
        message.pixelFormat = object.pixelFormat ?? 0;
        return message;
    },
};
function createBaseCaptureParameters() {
    return { exposureDuration: undefined, gain: 0 };
}
exports.CaptureParameters = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.exposureDuration !== undefined) {
            duration_1.Duration.encode(message.exposureDuration, writer.uint32(10).fork()).ldelim();
        }
        if (message.gain !== 0) {
            writer.uint32(17).double(message.gain);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCaptureParameters();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.exposureDuration = duration_1.Duration.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.gain = reader.double();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            exposureDuration: isSet(object.exposureDuration)
                ? duration_1.Duration.fromJSON(object.exposureDuration)
                : undefined,
            gain: isSet(object.gain) ? Number(object.gain) : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.exposureDuration !== undefined &&
            (obj.exposureDuration = message.exposureDuration
                ? duration_1.Duration.toJSON(message.exposureDuration)
                : undefined);
        message.gain !== undefined && (obj.gain = message.gain);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseCaptureParameters();
        message.exposureDuration =
            object.exposureDuration !== undefined && object.exposureDuration !== null
                ? duration_1.Duration.fromPartial(object.exposureDuration)
                : undefined;
        message.gain = object.gain ?? 0;
        return message;
    },
};
function createBaseImageCapture() {
    return {
        acquisitionTime: undefined,
        transformsSnapshot: undefined,
        frameNameImageSensor: "",
        image: undefined,
        captureParams: undefined,
    };
}
exports.ImageCapture = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.acquisitionTime !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.acquisitionTime), writer.uint32(242).fork()).ldelim();
        }
        if (message.transformsSnapshot !== undefined) {
            geometry_1.FrameTreeSnapshot.encode(message.transformsSnapshot, writer.uint32(250).fork()).ldelim();
        }
        if (message.frameNameImageSensor !== "") {
            writer.uint32(42).string(message.frameNameImageSensor);
        }
        if (message.image !== undefined) {
            exports.Image.encode(message.image, writer.uint32(26).fork()).ldelim();
        }
        if (message.captureParams !== undefined) {
            exports.CaptureParameters.encode(message.captureParams, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseImageCapture();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 30:
                    message.acquisitionTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 31:
                    message.transformsSnapshot = geometry_1.FrameTreeSnapshot.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.frameNameImageSensor = reader.string();
                    break;
                case 3:
                    message.image = exports.Image.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.captureParams = exports.CaptureParameters.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            acquisitionTime: isSet(object.acquisitionTime)
                ? fromJsonTimestamp(object.acquisitionTime)
                : undefined,
            transformsSnapshot: isSet(object.transformsSnapshot)
                ? geometry_1.FrameTreeSnapshot.fromJSON(object.transformsSnapshot)
                : undefined,
            frameNameImageSensor: isSet(object.frameNameImageSensor)
                ? String(object.frameNameImageSensor)
                : "",
            image: isSet(object.image) ? exports.Image.fromJSON(object.image) : undefined,
            captureParams: isSet(object.captureParams)
                ? exports.CaptureParameters.fromJSON(object.captureParams)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.acquisitionTime !== undefined &&
            (obj.acquisitionTime = message.acquisitionTime.toISOString());
        message.transformsSnapshot !== undefined &&
            (obj.transformsSnapshot = message.transformsSnapshot
                ? geometry_1.FrameTreeSnapshot.toJSON(message.transformsSnapshot)
                : undefined);
        message.frameNameImageSensor !== undefined &&
            (obj.frameNameImageSensor = message.frameNameImageSensor);
        message.image !== undefined &&
            (obj.image = message.image ? exports.Image.toJSON(message.image) : undefined);
        message.captureParams !== undefined &&
            (obj.captureParams = message.captureParams
                ? exports.CaptureParameters.toJSON(message.captureParams)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseImageCapture();
        message.acquisitionTime = object.acquisitionTime ?? undefined;
        message.transformsSnapshot =
            object.transformsSnapshot !== undefined &&
                object.transformsSnapshot !== null
                ? geometry_1.FrameTreeSnapshot.fromPartial(object.transformsSnapshot)
                : undefined;
        message.frameNameImageSensor = object.frameNameImageSensor ?? "";
        message.image =
            object.image !== undefined && object.image !== null
                ? exports.Image.fromPartial(object.image)
                : undefined;
        message.captureParams =
            object.captureParams !== undefined && object.captureParams !== null
                ? exports.CaptureParameters.fromPartial(object.captureParams)
                : undefined;
        return message;
    },
};
function createBaseImageSource() {
    return {
        name: "",
        cols: 0,
        rows: 0,
        depthScale: 0,
        pinhole: undefined,
        imageType: 0,
        pixelFormats: [],
        imageFormats: [],
    };
}
exports.ImageSource = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.name !== "") {
            writer.uint32(18).string(message.name);
        }
        if (message.cols !== 0) {
            writer.uint32(32).int32(message.cols);
        }
        if (message.rows !== 0) {
            writer.uint32(40).int32(message.rows);
        }
        if (message.depthScale !== 0) {
            writer.uint32(49).double(message.depthScale);
        }
        if (message.pinhole !== undefined) {
            exports.ImageSource_PinholeModel.encode(message.pinhole, writer.uint32(66).fork()).ldelim();
        }
        if (message.imageType !== 0) {
            writer.uint32(72).int32(message.imageType);
        }
        writer.uint32(82).fork();
        for (const v of message.pixelFormats) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(90).fork();
        for (const v of message.imageFormats) {
            writer.int32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseImageSource();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 2:
                    message.name = reader.string();
                    break;
                case 4:
                    message.cols = reader.int32();
                    break;
                case 5:
                    message.rows = reader.int32();
                    break;
                case 6:
                    message.depthScale = reader.double();
                    break;
                case 8:
                    message.pinhole = exports.ImageSource_PinholeModel.decode(reader, reader.uint32());
                    break;
                case 9:
                    message.imageType = reader.int32();
                    break;
                case 10:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.pixelFormats.push(reader.int32());
                        }
                    }
                    else {
                        message.pixelFormats.push(reader.int32());
                    }
                    break;
                case 11:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.imageFormats.push(reader.int32());
                        }
                    }
                    else {
                        message.imageFormats.push(reader.int32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            name: isSet(object.name) ? String(object.name) : "",
            cols: isSet(object.cols) ? Number(object.cols) : 0,
            rows: isSet(object.rows) ? Number(object.rows) : 0,
            depthScale: isSet(object.depthScale) ? Number(object.depthScale) : 0,
            pinhole: isSet(object.pinhole)
                ? exports.ImageSource_PinholeModel.fromJSON(object.pinhole)
                : undefined,
            imageType: isSet(object.imageType)
                ? imageSource_ImageTypeFromJSON(object.imageType)
                : 0,
            pixelFormats: Array.isArray(object?.pixelFormats)
                ? object.pixelFormats.map((e) => image_PixelFormatFromJSON(e))
                : [],
            imageFormats: Array.isArray(object?.imageFormats)
                ? object.imageFormats.map((e) => image_FormatFromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        message.name !== undefined && (obj.name = message.name);
        message.cols !== undefined && (obj.cols = Math.round(message.cols));
        message.rows !== undefined && (obj.rows = Math.round(message.rows));
        message.depthScale !== undefined && (obj.depthScale = message.depthScale);
        message.pinhole !== undefined &&
            (obj.pinhole = message.pinhole
                ? exports.ImageSource_PinholeModel.toJSON(message.pinhole)
                : undefined);
        message.imageType !== undefined &&
            (obj.imageType = imageSource_ImageTypeToJSON(message.imageType));
        if (message.pixelFormats) {
            obj.pixelFormats = message.pixelFormats.map((e) => image_PixelFormatToJSON(e));
        }
        else {
            obj.pixelFormats = [];
        }
        if (message.imageFormats) {
            obj.imageFormats = message.imageFormats.map((e) => image_FormatToJSON(e));
        }
        else {
            obj.imageFormats = [];
        }
        return obj;
    },
    fromPartial(object) {
        const message = createBaseImageSource();
        message.name = object.name ?? "";
        message.cols = object.cols ?? 0;
        message.rows = object.rows ?? 0;
        message.depthScale = object.depthScale ?? 0;
        message.pinhole =
            object.pinhole !== undefined && object.pinhole !== null
                ? exports.ImageSource_PinholeModel.fromPartial(object.pinhole)
                : undefined;
        message.imageType = object.imageType ?? 0;
        message.pixelFormats = object.pixelFormats?.map((e) => e) || [];
        message.imageFormats = object.imageFormats?.map((e) => e) || [];
        return message;
    },
};
function createBaseImageSource_PinholeModel() {
    return { intrinsics: undefined };
}
exports.ImageSource_PinholeModel = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.intrinsics !== undefined) {
            exports.ImageSource_PinholeModel_CameraIntrinsics.encode(message.intrinsics, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseImageSource_PinholeModel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.intrinsics = exports.ImageSource_PinholeModel_CameraIntrinsics.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            intrinsics: isSet(object.intrinsics)
                ? exports.ImageSource_PinholeModel_CameraIntrinsics.fromJSON(object.intrinsics)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.intrinsics !== undefined &&
            (obj.intrinsics = message.intrinsics
                ? exports.ImageSource_PinholeModel_CameraIntrinsics.toJSON(message.intrinsics)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseImageSource_PinholeModel();
        message.intrinsics =
            object.intrinsics !== undefined && object.intrinsics !== null
                ? exports.ImageSource_PinholeModel_CameraIntrinsics.fromPartial(object.intrinsics)
                : undefined;
        return message;
    },
};
function createBaseImageSource_PinholeModel_CameraIntrinsics() {
    return { focalLength: undefined, principalPoint: undefined, skew: undefined };
}
exports.ImageSource_PinholeModel_CameraIntrinsics = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.focalLength !== undefined) {
            geometry_1.Vec2.encode(message.focalLength, writer.uint32(10).fork()).ldelim();
        }
        if (message.principalPoint !== undefined) {
            geometry_1.Vec2.encode(message.principalPoint, writer.uint32(18).fork()).ldelim();
        }
        if (message.skew !== undefined) {
            geometry_1.Vec2.encode(message.skew, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseImageSource_PinholeModel_CameraIntrinsics();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.focalLength = geometry_1.Vec2.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.principalPoint = geometry_1.Vec2.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.skew = geometry_1.Vec2.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            focalLength: isSet(object.focalLength)
                ? geometry_1.Vec2.fromJSON(object.focalLength)
                : undefined,
            principalPoint: isSet(object.principalPoint)
                ? geometry_1.Vec2.fromJSON(object.principalPoint)
                : undefined,
            skew: isSet(object.skew) ? geometry_1.Vec2.fromJSON(object.skew) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.focalLength !== undefined &&
            (obj.focalLength = message.focalLength
                ? geometry_1.Vec2.toJSON(message.focalLength)
                : undefined);
        message.principalPoint !== undefined &&
            (obj.principalPoint = message.principalPoint
                ? geometry_1.Vec2.toJSON(message.principalPoint)
                : undefined);
        message.skew !== undefined &&
            (obj.skew = message.skew ? geometry_1.Vec2.toJSON(message.skew) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseImageSource_PinholeModel_CameraIntrinsics();
        message.focalLength =
            object.focalLength !== undefined && object.focalLength !== null
                ? geometry_1.Vec2.fromPartial(object.focalLength)
                : undefined;
        message.principalPoint =
            object.principalPoint !== undefined && object.principalPoint !== null
                ? geometry_1.Vec2.fromPartial(object.principalPoint)
                : undefined;
        message.skew =
            object.skew !== undefined && object.skew !== null
                ? geometry_1.Vec2.fromPartial(object.skew)
                : undefined;
        return message;
    },
};
function createBaseListImageSourcesRequest() {
    return { header: undefined };
}
exports.ListImageSourcesRequest = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.header !== undefined) {
            header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseListImageSourcesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.header = header_1.RequestHeader.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            header: isSet(object.header)
                ? header_1.RequestHeader.fromJSON(object.header)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseListImageSourcesRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        return message;
    },
};
function createBaseListImageSourcesResponse() {
    return { header: undefined, imageSources: [] };
}
exports.ListImageSourcesResponse = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.header !== undefined) {
            header_1.ResponseHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.imageSources) {
            exports.ImageSource.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseListImageSourcesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.header = header_1.ResponseHeader.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.imageSources.push(exports.ImageSource.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            header: isSet(object.header)
                ? header_1.ResponseHeader.fromJSON(object.header)
                : undefined,
            imageSources: Array.isArray(object?.imageSources)
                ? object.imageSources.map((e) => exports.ImageSource.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        if (message.imageSources) {
            obj.imageSources = message.imageSources.map((e) => e ? exports.ImageSource.toJSON(e) : undefined);
        }
        else {
            obj.imageSources = [];
        }
        return obj;
    },
    fromPartial(object) {
        const message = createBaseListImageSourcesResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.imageSources =
            object.imageSources?.map((e) => exports.ImageSource.fromPartial(e)) || [];
        return message;
    },
};
function createBaseImageRequest() {
    return {
        imageSourceName: "",
        qualityPercent: 0,
        imageFormat: 0,
        resizeRatio: 0,
        pixelFormat: 0,
    };
}
exports.ImageRequest = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.imageSourceName !== "") {
            writer.uint32(10).string(message.imageSourceName);
        }
        if (message.qualityPercent !== 0) {
            writer.uint32(17).double(message.qualityPercent);
        }
        if (message.imageFormat !== 0) {
            writer.uint32(24).int32(message.imageFormat);
        }
        if (message.resizeRatio !== 0) {
            writer.uint32(33).double(message.resizeRatio);
        }
        if (message.pixelFormat !== 0) {
            writer.uint32(40).int32(message.pixelFormat);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseImageRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.imageSourceName = reader.string();
                    break;
                case 2:
                    message.qualityPercent = reader.double();
                    break;
                case 3:
                    message.imageFormat = reader.int32();
                    break;
                case 4:
                    message.resizeRatio = reader.double();
                    break;
                case 5:
                    message.pixelFormat = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            imageSourceName: isSet(object.imageSourceName)
                ? String(object.imageSourceName)
                : "",
            qualityPercent: isSet(object.qualityPercent)
                ? Number(object.qualityPercent)
                : 0,
            imageFormat: isSet(object.imageFormat)
                ? image_FormatFromJSON(object.imageFormat)
                : 0,
            resizeRatio: isSet(object.resizeRatio) ? Number(object.resizeRatio) : 0,
            pixelFormat: isSet(object.pixelFormat)
                ? image_PixelFormatFromJSON(object.pixelFormat)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.imageSourceName !== undefined &&
            (obj.imageSourceName = message.imageSourceName);
        message.qualityPercent !== undefined &&
            (obj.qualityPercent = message.qualityPercent);
        message.imageFormat !== undefined &&
            (obj.imageFormat = image_FormatToJSON(message.imageFormat));
        message.resizeRatio !== undefined &&
            (obj.resizeRatio = message.resizeRatio);
        message.pixelFormat !== undefined &&
            (obj.pixelFormat = image_PixelFormatToJSON(message.pixelFormat));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseImageRequest();
        message.imageSourceName = object.imageSourceName ?? "";
        message.qualityPercent = object.qualityPercent ?? 0;
        message.imageFormat = object.imageFormat ?? 0;
        message.resizeRatio = object.resizeRatio ?? 0;
        message.pixelFormat = object.pixelFormat ?? 0;
        return message;
    },
};
function createBaseGetImageRequest() {
    return { header: undefined, imageRequests: [] };
}
exports.GetImageRequest = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.header !== undefined) {
            header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.imageRequests) {
            exports.ImageRequest.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetImageRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.header = header_1.RequestHeader.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.imageRequests.push(exports.ImageRequest.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            header: isSet(object.header)
                ? header_1.RequestHeader.fromJSON(object.header)
                : undefined,
            imageRequests: Array.isArray(object?.imageRequests)
                ? object.imageRequests.map((e) => exports.ImageRequest.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        if (message.imageRequests) {
            obj.imageRequests = message.imageRequests.map((e) => e ? exports.ImageRequest.toJSON(e) : undefined);
        }
        else {
            obj.imageRequests = [];
        }
        return obj;
    },
    fromPartial(object) {
        const message = createBaseGetImageRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.imageRequests =
            object.imageRequests?.map((e) => exports.ImageRequest.fromPartial(e)) || [];
        return message;
    },
};
function createBaseImageResponse() {
    return { shot: undefined, source: undefined, status: 0 };
}
exports.ImageResponse = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.shot !== undefined) {
            exports.ImageCapture.encode(message.shot, writer.uint32(10).fork()).ldelim();
        }
        if (message.source !== undefined) {
            exports.ImageSource.encode(message.source, writer.uint32(18).fork()).ldelim();
        }
        if (message.status !== 0) {
            writer.uint32(32).int32(message.status);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseImageResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.shot = exports.ImageCapture.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.source = exports.ImageSource.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.status = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            shot: isSet(object.shot) ? exports.ImageCapture.fromJSON(object.shot) : undefined,
            source: isSet(object.source)
                ? exports.ImageSource.fromJSON(object.source)
                : undefined,
            status: isSet(object.status)
                ? imageResponse_StatusFromJSON(object.status)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.shot !== undefined &&
            (obj.shot = message.shot ? exports.ImageCapture.toJSON(message.shot) : undefined);
        message.source !== undefined &&
            (obj.source = message.source
                ? exports.ImageSource.toJSON(message.source)
                : undefined);
        message.status !== undefined &&
            (obj.status = imageResponse_StatusToJSON(message.status));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseImageResponse();
        message.shot =
            object.shot !== undefined && object.shot !== null
                ? exports.ImageCapture.fromPartial(object.shot)
                : undefined;
        message.source =
            object.source !== undefined && object.source !== null
                ? exports.ImageSource.fromPartial(object.source)
                : undefined;
        message.status = object.status ?? 0;
        return message;
    },
};
function createBaseGetImageResponse() {
    return { header: undefined, imageResponses: [] };
}
exports.GetImageResponse = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.header !== undefined) {
            header_1.ResponseHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.imageResponses) {
            exports.ImageResponse.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetImageResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.header = header_1.ResponseHeader.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.imageResponses.push(exports.ImageResponse.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {