spot-sdk-ts/dist/bosdyn/api/spot_cam/camera.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.Camera_SphericalLimits = exports.Camera_PinholeIntrinsics = exports.Camera = exports.protobufPackage = void 0;
/* eslint-disable */
const geometry_1 = require("../geometry");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api.spot_cam";
function createBaseCamera() {
    return {
        name: "",
        resolution: undefined,
        baseFrameName: "",
        baseTfromSensor: undefined,
        baseTformSensor: undefined,
        pinhole: undefined,
        spherical: undefined,
    };
}
exports.Camera = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.name !== "") {
            writer.uint32(10).string(message.name);
        }
        if (message.resolution !== undefined) {
            geometry_1.Vec2.encode(message.resolution, writer.uint32(18).fork()).ldelim();
        }
        if (message.baseFrameName !== "") {
            writer.uint32(26).string(message.baseFrameName);
        }
        if (message.baseTfromSensor !== undefined) {
            geometry_1.SE3Pose.encode(message.baseTfromSensor, writer.uint32(34).fork()).ldelim();
        }
        if (message.baseTformSensor !== undefined) {
            geometry_1.SE3Pose.encode(message.baseTformSensor, writer.uint32(58).fork()).ldelim();
        }
        if (message.pinhole !== undefined) {
            exports.Camera_PinholeIntrinsics.encode(message.pinhole, writer.uint32(42).fork()).ldelim();
        }
        if (message.spherical !== undefined) {
            exports.Camera_SphericalLimits.encode(message.spherical, writer.uint32(50).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 = createBaseCamera();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.resolution = geometry_1.Vec2.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.baseFrameName = reader.string();
                    break;
                case 4:
                    message.baseTfromSensor = geometry_1.SE3Pose.decode(reader, reader.uint32());
                    break;
                case 7:
                    message.baseTformSensor = geometry_1.SE3Pose.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.pinhole = exports.Camera_PinholeIntrinsics.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.spherical = exports.Camera_SphericalLimits.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            name: isSet(object.name) ? String(object.name) : "",
            resolution: isSet(object.resolution)
                ? geometry_1.Vec2.fromJSON(object.resolution)
                : undefined,
            baseFrameName: isSet(object.baseFrameName)
                ? String(object.baseFrameName)
                : "",
            baseTfromSensor: isSet(object.baseTfromSensor)
                ? geometry_1.SE3Pose.fromJSON(object.baseTfromSensor)
                : undefined,
            baseTformSensor: isSet(object.baseTformSensor)
                ? geometry_1.SE3Pose.fromJSON(object.baseTformSensor)
                : undefined,
            pinhole: isSet(object.pinhole)
                ? exports.Camera_PinholeIntrinsics.fromJSON(object.pinhole)
                : undefined,
            spherical: isSet(object.spherical)
                ? exports.Camera_SphericalLimits.fromJSON(object.spherical)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.name !== undefined && (obj.name = message.name);
        message.resolution !== undefined &&
            (obj.resolution = message.resolution
                ? geometry_1.Vec2.toJSON(message.resolution)
                : undefined);
        message.baseFrameName !== undefined &&
            (obj.baseFrameName = message.baseFrameName);
        message.baseTfromSensor !== undefined &&
            (obj.baseTfromSensor = message.baseTfromSensor
                ? geometry_1.SE3Pose.toJSON(message.baseTfromSensor)
                : undefined);
        message.baseTformSensor !== undefined &&
            (obj.baseTformSensor = message.baseTformSensor
                ? geometry_1.SE3Pose.toJSON(message.baseTformSensor)
                : undefined);
        message.pinhole !== undefined &&
            (obj.pinhole = message.pinhole
                ? exports.Camera_PinholeIntrinsics.toJSON(message.pinhole)
                : undefined);
        message.spherical !== undefined &&
            (obj.spherical = message.spherical
                ? exports.Camera_SphericalLimits.toJSON(message.spherical)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseCamera();
        message.name = object.name ?? "";
        message.resolution =
            object.resolution !== undefined && object.resolution !== null
                ? geometry_1.Vec2.fromPartial(object.resolution)
                : undefined;
        message.baseFrameName = object.baseFrameName ?? "";
        message.baseTfromSensor =
            object.baseTfromSensor !== undefined && object.baseTfromSensor !== null
                ? geometry_1.SE3Pose.fromPartial(object.baseTfromSensor)
                : undefined;
        message.baseTformSensor =
            object.baseTformSensor !== undefined && object.baseTformSensor !== null
                ? geometry_1.SE3Pose.fromPartial(object.baseTformSensor)
                : undefined;
        message.pinhole =
            object.pinhole !== undefined && object.pinhole !== null
                ? exports.Camera_PinholeIntrinsics.fromPartial(object.pinhole)
                : undefined;
        message.spherical =
            object.spherical !== undefined && object.spherical !== null
                ? exports.Camera_SphericalLimits.fromPartial(object.spherical)
                : undefined;
        return message;
    },
};
function createBaseCamera_PinholeIntrinsics() {
    return {
        focalLength: undefined,
        centerPoint: undefined,
        k1: 0,
        k2: 0,
        k3: 0,
        k4: 0,
    };
}
exports.Camera_PinholeIntrinsics = {
    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.centerPoint !== undefined) {
            geometry_1.Vec2.encode(message.centerPoint, writer.uint32(18).fork()).ldelim();
        }
        if (message.k1 !== 0) {
            writer.uint32(29).float(message.k1);
        }
        if (message.k2 !== 0) {
            writer.uint32(37).float(message.k2);
        }
        if (message.k3 !== 0) {
            writer.uint32(45).float(message.k3);
        }
        if (message.k4 !== 0) {
            writer.uint32(53).float(message.k4);
        }
        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 = createBaseCamera_PinholeIntrinsics();
        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.centerPoint = geometry_1.Vec2.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.k1 = reader.float();
                    break;
                case 4:
                    message.k2 = reader.float();
                    break;
                case 5:
                    message.k3 = reader.float();
                    break;
                case 6:
                    message.k4 = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            focalLength: isSet(object.focalLength)
                ? geometry_1.Vec2.fromJSON(object.focalLength)
                : undefined,
            centerPoint: isSet(object.centerPoint)
                ? geometry_1.Vec2.fromJSON(object.centerPoint)
                : undefined,
            k1: isSet(object.k1) ? Number(object.k1) : 0,
            k2: isSet(object.k2) ? Number(object.k2) : 0,
            k3: isSet(object.k3) ? Number(object.k3) : 0,
            k4: isSet(object.k4) ? Number(object.k4) : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.focalLength !== undefined &&
            (obj.focalLength = message.focalLength
                ? geometry_1.Vec2.toJSON(message.focalLength)
                : undefined);
        message.centerPoint !== undefined &&
            (obj.centerPoint = message.centerPoint
                ? geometry_1.Vec2.toJSON(message.centerPoint)
                : undefined);
        message.k1 !== undefined && (obj.k1 = message.k1);
        message.k2 !== undefined && (obj.k2 = message.k2);
        message.k3 !== undefined && (obj.k3 = message.k3);
        message.k4 !== undefined && (obj.k4 = message.k4);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseCamera_PinholeIntrinsics();
        message.focalLength =
            object.focalLength !== undefined && object.focalLength !== null
                ? geometry_1.Vec2.fromPartial(object.focalLength)
                : undefined;
        message.centerPoint =
            object.centerPoint !== undefined && object.centerPoint !== null
                ? geometry_1.Vec2.fromPartial(object.centerPoint)
                : undefined;
        message.k1 = object.k1 ?? 0;
        message.k2 = object.k2 ?? 0;
        message.k3 = object.k3 ?? 0;
        message.k4 = object.k4 ?? 0;
        return message;
    },
};
function createBaseCamera_SphericalLimits() {
    return { minAngle: undefined, maxAngle: undefined };
}
exports.Camera_SphericalLimits = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.minAngle !== undefined) {
            geometry_1.Vec2.encode(message.minAngle, writer.uint32(10).fork()).ldelim();
        }
        if (message.maxAngle !== undefined) {
            geometry_1.Vec2.encode(message.maxAngle, 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 = createBaseCamera_SphericalLimits();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.minAngle = geometry_1.Vec2.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.maxAngle = geometry_1.Vec2.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            minAngle: isSet(object.minAngle)
                ? geometry_1.Vec2.fromJSON(object.minAngle)
                : undefined,
            maxAngle: isSet(object.maxAngle)
                ? geometry_1.Vec2.fromJSON(object.maxAngle)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.minAngle !== undefined &&
            (obj.minAngle = message.minAngle
                ? geometry_1.Vec2.toJSON(message.minAngle)
                : undefined);
        message.maxAngle !== undefined &&
            (obj.maxAngle = message.maxAngle
                ? geometry_1.Vec2.toJSON(message.maxAngle)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseCamera_SphericalLimits();
        message.minAngle =
            object.minAngle !== undefined && object.minAngle !== null
                ? geometry_1.Vec2.fromPartial(object.minAngle)
                : undefined;
        message.maxAngle =
            object.maxAngle !== undefined && object.maxAngle !== null
                ? geometry_1.Vec2.fromPartial(object.maxAngle)
                : undefined;
        return message;
    },
};
function isSet(value) {
    return value !== null && value !== undefined;
}
//# sourceMappingURL=camera.js.map