spot-sdk-ts/dist/bosdyn/api/graph_nav/map_processing.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.ProcessAnchoringResponse = exports.ProcessAnchoringRequest_Params_Weights = exports.ProcessAnchoringRequest_Params_MeasurementParams = exports.ProcessAnchoringRequest_Params_OptimizerParams = exports.ProcessAnchoringRequest_Params = exports.ProcessAnchoringRequest = exports.AnchoringHint = exports.WorldObjectAnchorHint = exports.WaypointAnchorHint = exports.AnchorHintUncertainty = exports.PoseBounds = exports.ProcessTopologyResponse = exports.ProcessTopologyRequest_Params = exports.ProcessTopologyRequest_CollisionCheckingParams = exports.ProcessTopologyRequest_FiducialLoopClosureParams = exports.ProcessTopologyRequest_OdometryLoopClosureParams = exports.ProcessTopologyRequest_ICPParams = exports.ProcessTopologyRequest = exports.processAnchoringResponse_StatusToJSON = exports.processAnchoringResponse_StatusFromJSON = exports.ProcessAnchoringResponse_Status = exports.processTopologyResponse_StatusToJSON = exports.processTopologyResponse_StatusFromJSON = exports.ProcessTopologyResponse_Status = exports.protobufPackage = void 0;
/* eslint-disable */
const header_1 = require("../header");
const map_1 = require("./map");
const geometry_1 = require("../geometry");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
const wrappers_1 = require("../../../google/protobuf/wrappers");
exports.protobufPackage = "bosdyn.api.graph_nav";
var ProcessTopologyResponse_Status;
(function (ProcessTopologyResponse_Status) {
    /** STATUS_UNKNOWN - Programming error. */
    ProcessTopologyResponse_Status[ProcessTopologyResponse_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_OK - Success. */
    ProcessTopologyResponse_Status[ProcessTopologyResponse_Status["STATUS_OK"] = 1] = "STATUS_OK";
    /** STATUS_MISSING_WAYPOINT_SNAPSHOTS - Not all of the waypoint snapshots exist on the server. Upload them to continue. */
    ProcessTopologyResponse_Status[ProcessTopologyResponse_Status["STATUS_MISSING_WAYPOINT_SNAPSHOTS"] = 2] = "STATUS_MISSING_WAYPOINT_SNAPSHOTS";
    /** STATUS_INVALID_GRAPH - The graph is invalid topologically, for example containing missing waypoints referenced by edges. */
    ProcessTopologyResponse_Status[ProcessTopologyResponse_Status["STATUS_INVALID_GRAPH"] = 3] = "STATUS_INVALID_GRAPH";
    /** STATUS_MAP_MODIFIED_DURING_PROCESSING - Tried to write the anchoring after processing, but another client may have modified the map. Try again */
    ProcessTopologyResponse_Status[ProcessTopologyResponse_Status["STATUS_MAP_MODIFIED_DURING_PROCESSING"] = 4] = "STATUS_MAP_MODIFIED_DURING_PROCESSING";
    ProcessTopologyResponse_Status[ProcessTopologyResponse_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ProcessTopologyResponse_Status = exports.ProcessTopologyResponse_Status || (exports.ProcessTopologyResponse_Status = {}));
function processTopologyResponse_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return ProcessTopologyResponse_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_OK":
            return ProcessTopologyResponse_Status.STATUS_OK;
        case 2:
        case "STATUS_MISSING_WAYPOINT_SNAPSHOTS":
            return ProcessTopologyResponse_Status.STATUS_MISSING_WAYPOINT_SNAPSHOTS;
        case 3:
        case "STATUS_INVALID_GRAPH":
            return ProcessTopologyResponse_Status.STATUS_INVALID_GRAPH;
        case 4:
        case "STATUS_MAP_MODIFIED_DURING_PROCESSING":
            return ProcessTopologyResponse_Status.STATUS_MAP_MODIFIED_DURING_PROCESSING;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ProcessTopologyResponse_Status.UNRECOGNIZED;
    }
}
exports.processTopologyResponse_StatusFromJSON = processTopologyResponse_StatusFromJSON;
function processTopologyResponse_StatusToJSON(object) {
    switch (object) {
        case ProcessTopologyResponse_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case ProcessTopologyResponse_Status.STATUS_OK:
            return "STATUS_OK";
        case ProcessTopologyResponse_Status.STATUS_MISSING_WAYPOINT_SNAPSHOTS:
            return "STATUS_MISSING_WAYPOINT_SNAPSHOTS";
        case ProcessTopologyResponse_Status.STATUS_INVALID_GRAPH:
            return "STATUS_INVALID_GRAPH";
        case ProcessTopologyResponse_Status.STATUS_MAP_MODIFIED_DURING_PROCESSING:
            return "STATUS_MAP_MODIFIED_DURING_PROCESSING";
        case ProcessTopologyResponse_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.processTopologyResponse_StatusToJSON = processTopologyResponse_StatusToJSON;
var ProcessAnchoringResponse_Status;
(function (ProcessAnchoringResponse_Status) {
    /** STATUS_UNKNOWN - Programming error. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_OK - Success. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_OK"] = 1] = "STATUS_OK";
    /** STATUS_MISSING_WAYPOINT_SNAPSHOTS - Not all of the waypoint snapshots exist on the server. Upload them to continue. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_MISSING_WAYPOINT_SNAPSHOTS"] = 2] = "STATUS_MISSING_WAYPOINT_SNAPSHOTS";
    /** STATUS_INVALID_GRAPH - The graph is invalid topologically, for example containing missing waypoints referenced by edges. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_INVALID_GRAPH"] = 3] = "STATUS_INVALID_GRAPH";
    /** STATUS_OPTIMIZATION_FAILURE - The optimization failed due to local minima or an ill-conditioned problem definition. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_OPTIMIZATION_FAILURE"] = 4] = "STATUS_OPTIMIZATION_FAILURE";
    /** STATUS_INVALID_PARAMS - The parameters passed to the optimizer do not make sense (e.g negative weights). */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_INVALID_PARAMS"] = 5] = "STATUS_INVALID_PARAMS";
    /** STATUS_CONSTRAINT_VIOLATION - One or more anchors were moved outside of the desired constraints. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_CONSTRAINT_VIOLATION"] = 6] = "STATUS_CONSTRAINT_VIOLATION";
    /** STATUS_MAX_ITERATIONS - The optimizer reached the maximum number of iterations before converging. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_MAX_ITERATIONS"] = 7] = "STATUS_MAX_ITERATIONS";
    /** STATUS_MAX_TIME - The optimizer timed out before converging. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_MAX_TIME"] = 8] = "STATUS_MAX_TIME";
    /** STATUS_INVALID_HINTS - One or more of the hints passed in to the optimizer are invalid (do not correspond to real waypoints or objects). */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_INVALID_HINTS"] = 9] = "STATUS_INVALID_HINTS";
    /** STATUS_MAP_MODIFIED_DURING_PROCESSING - Tried to write the anchoring after processing, but another client may have modified the map. Try again. */
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["STATUS_MAP_MODIFIED_DURING_PROCESSING"] = 10] = "STATUS_MAP_MODIFIED_DURING_PROCESSING";
    ProcessAnchoringResponse_Status[ProcessAnchoringResponse_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ProcessAnchoringResponse_Status = exports.ProcessAnchoringResponse_Status || (exports.ProcessAnchoringResponse_Status = {}));
function processAnchoringResponse_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return ProcessAnchoringResponse_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_OK":
            return ProcessAnchoringResponse_Status.STATUS_OK;
        case 2:
        case "STATUS_MISSING_WAYPOINT_SNAPSHOTS":
            return ProcessAnchoringResponse_Status.STATUS_MISSING_WAYPOINT_SNAPSHOTS;
        case 3:
        case "STATUS_INVALID_GRAPH":
            return ProcessAnchoringResponse_Status.STATUS_INVALID_GRAPH;
        case 4:
        case "STATUS_OPTIMIZATION_FAILURE":
            return ProcessAnchoringResponse_Status.STATUS_OPTIMIZATION_FAILURE;
        case 5:
        case "STATUS_INVALID_PARAMS":
            return ProcessAnchoringResponse_Status.STATUS_INVALID_PARAMS;
        case 6:
        case "STATUS_CONSTRAINT_VIOLATION":
            return ProcessAnchoringResponse_Status.STATUS_CONSTRAINT_VIOLATION;
        case 7:
        case "STATUS_MAX_ITERATIONS":
            return ProcessAnchoringResponse_Status.STATUS_MAX_ITERATIONS;
        case 8:
        case "STATUS_MAX_TIME":
            return ProcessAnchoringResponse_Status.STATUS_MAX_TIME;
        case 9:
        case "STATUS_INVALID_HINTS":
            return ProcessAnchoringResponse_Status.STATUS_INVALID_HINTS;
        case 10:
        case "STATUS_MAP_MODIFIED_DURING_PROCESSING":
            return ProcessAnchoringResponse_Status.STATUS_MAP_MODIFIED_DURING_PROCESSING;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ProcessAnchoringResponse_Status.UNRECOGNIZED;
    }
}
exports.processAnchoringResponse_StatusFromJSON = processAnchoringResponse_StatusFromJSON;
function processAnchoringResponse_StatusToJSON(object) {
    switch (object) {
        case ProcessAnchoringResponse_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case ProcessAnchoringResponse_Status.STATUS_OK:
            return "STATUS_OK";
        case ProcessAnchoringResponse_Status.STATUS_MISSING_WAYPOINT_SNAPSHOTS:
            return "STATUS_MISSING_WAYPOINT_SNAPSHOTS";
        case ProcessAnchoringResponse_Status.STATUS_INVALID_GRAPH:
            return "STATUS_INVALID_GRAPH";
        case ProcessAnchoringResponse_Status.STATUS_OPTIMIZATION_FAILURE:
            return "STATUS_OPTIMIZATION_FAILURE";
        case ProcessAnchoringResponse_Status.STATUS_INVALID_PARAMS:
            return "STATUS_INVALID_PARAMS";
        case ProcessAnchoringResponse_Status.STATUS_CONSTRAINT_VIOLATION:
            return "STATUS_CONSTRAINT_VIOLATION";
        case ProcessAnchoringResponse_Status.STATUS_MAX_ITERATIONS:
            return "STATUS_MAX_ITERATIONS";
        case ProcessAnchoringResponse_Status.STATUS_MAX_TIME:
            return "STATUS_MAX_TIME";
        case ProcessAnchoringResponse_Status.STATUS_INVALID_HINTS:
            return "STATUS_INVALID_HINTS";
        case ProcessAnchoringResponse_Status.STATUS_MAP_MODIFIED_DURING_PROCESSING:
            return "STATUS_MAP_MODIFIED_DURING_PROCESSING";
        case ProcessAnchoringResponse_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.processAnchoringResponse_StatusToJSON = processAnchoringResponse_StatusToJSON;
function createBaseProcessTopologyRequest() {
    return { header: undefined, params: undefined, modifyMapOnServer: false };
}
exports.ProcessTopologyRequest = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.header !== undefined) {
            header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
        }
        if (message.params !== undefined) {
            exports.ProcessTopologyRequest_Params.encode(message.params, writer.uint32(18).fork()).ldelim();
        }
        if (message.modifyMapOnServer === true) {
            writer.uint32(24).bool(message.modifyMapOnServer);
        }
        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 = createBaseProcessTopologyRequest();
        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.params = exports.ProcessTopologyRequest_Params.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.modifyMapOnServer = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            header: isSet(object.header)
                ? header_1.RequestHeader.fromJSON(object.header)
                : undefined,
            params: isSet(object.params)
                ? exports.ProcessTopologyRequest_Params.fromJSON(object.params)
                : undefined,
            modifyMapOnServer: isSet(object.modifyMapOnServer)
                ? Boolean(object.modifyMapOnServer)
                : false,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.params !== undefined &&
            (obj.params = message.params
                ? exports.ProcessTopologyRequest_Params.toJSON(message.params)
                : undefined);
        message.modifyMapOnServer !== undefined &&
            (obj.modifyMapOnServer = message.modifyMapOnServer);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseProcessTopologyRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.params =
            object.params !== undefined && object.params !== null
                ? exports.ProcessTopologyRequest_Params.fromPartial(object.params)
                : undefined;
        message.modifyMapOnServer = object.modifyMapOnServer ?? false;
        return message;
    },
};
function createBaseProcessTopologyRequest_ICPParams() {
    return { icpIters: undefined, maxPointMatchDistance: undefined };
}
exports.ProcessTopologyRequest_ICPParams = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.icpIters !== undefined) {
            wrappers_1.Int32Value.encode({ value: message.icpIters }, writer.uint32(10).fork()).ldelim();
        }
        if (message.maxPointMatchDistance !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maxPointMatchDistance }, 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 = createBaseProcessTopologyRequest_ICPParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.icpIters = wrappers_1.Int32Value.decode(reader, reader.uint32()).value;
                    break;
                case 2:
                    message.maxPointMatchDistance = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            icpIters: isSet(object.icpIters) ? Number(object.icpIters) : undefined,
            maxPointMatchDistance: isSet(object.maxPointMatchDistance)
                ? Number(object.maxPointMatchDistance)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.icpIters !== undefined && (obj.icpIters = message.icpIters);
        message.maxPointMatchDistance !== undefined &&
            (obj.maxPointMatchDistance = message.maxPointMatchDistance);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseProcessTopologyRequest_ICPParams();
        message.icpIters = object.icpIters ?? undefined;
        message.maxPointMatchDistance = object.maxPointMatchDistance ?? undefined;
        return message;
    },
};
function createBaseProcessTopologyRequest_OdometryLoopClosureParams() {
    return {
        maxLoopClosurePathLength: undefined,
        minLoopClosurePathLength: undefined,
        maxLoopClosureHeightChange: undefined,
        maxLoopClosureEdgeLength: undefined,
        numExtraLoopClosureIterations: undefined,
    };
}
exports.ProcessTopologyRequest_OdometryLoopClosureParams = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.maxLoopClosurePathLength !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maxLoopClosurePathLength }, writer.uint32(10).fork()).ldelim();
        }
        if (message.minLoopClosurePathLength !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.minLoopClosurePathLength }, writer.uint32(18).fork()).ldelim();
        }
        if (message.maxLoopClosureHeightChange !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maxLoopClosureHeightChange }, writer.uint32(26).fork()).ldelim();
        }
        if (message.maxLoopClosureEdgeLength !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maxLoopClosureEdgeLength }, writer.uint32(34).fork()).ldelim();
        }
        if (message.numExtraLoopClosureIterations !== undefined) {
            wrappers_1.Int32Value.encode({ value: message.numExtraLoopClosureIterations }, writer.uint32(42).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 = createBaseProcessTopologyRequest_OdometryLoopClosureParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.maxLoopClosurePathLength = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 2:
                    message.minLoopClosurePathLength = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 3:
                    message.maxLoopClosureHeightChange = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 4:
                    message.maxLoopClosureEdgeLength = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 5:
                    message.numExtraLoopClosureIterations = wrappers_1.Int32Value.decode(reader, reader.uint32()).value;
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            maxLoopClosurePathLength: isSet(object.maxLoopClosurePathLength)
                ? Number(object.maxLoopClosurePathLength)
                : undefined,
            minLoopClosurePathLength: isSet(object.minLoopClosurePathLength)
                ? Number(object.minLoopClosurePathLength)
                : undefined,
            maxLoopClosureHeightChange: isSet(object.maxLoopClosureHeightChange)
                ? Number(object.maxLoopClosureHeightChange)
                : undefined,
            maxLoopClosureEdgeLength: isSet(object.maxLoopClosureEdgeLength)
                ? Number(object.maxLoopClosureEdgeLength)
                : undefined,
            numExtraLoopClosureIterations: isSet(object.numExtraLoopClosureIterations)
                ? Number(object.numExtraLoopClosureIterations)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.maxLoopClosurePathLength !== undefined &&
            (obj.maxLoopClosurePathLength = message.maxLoopClosurePathLength);
        message.minLoopClosurePathLength !== undefined &&
            (obj.minLoopClosurePathLength = message.minLoopClosurePathLength);
        message.maxLoopClosureHeightChange !== undefined &&
            (obj.maxLoopClosureHeightChange = message.maxLoopClosureHeightChange);
        message.maxLoopClosureEdgeLength !== undefined &&
            (obj.maxLoopClosureEdgeLength = message.maxLoopClosureEdgeLength);
        message.numExtraLoopClosureIterations !== undefined &&
            (obj.numExtraLoopClosureIterations =
                message.numExtraLoopClosureIterations);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseProcessTopologyRequest_OdometryLoopClosureParams();
        message.maxLoopClosurePathLength =
            object.maxLoopClosurePathLength ?? undefined;
        message.minLoopClosurePathLength =
            object.minLoopClosurePathLength ?? undefined;
        message.maxLoopClosureHeightChange =
            object.maxLoopClosureHeightChange ?? undefined;
        message.maxLoopClosureEdgeLength =
            object.maxLoopClosureEdgeLength ?? undefined;
        message.numExtraLoopClosureIterations =
            object.numExtraLoopClosureIterations ?? undefined;
        return message;
    },
};
function createBaseProcessTopologyRequest_FiducialLoopClosureParams() {
    return {
        minLoopClosurePathLength: undefined,
        maxLoopClosureEdgeLength: undefined,
        maxFiducialDistance: undefined,
        maxLoopClosureHeightChange: undefined,
    };
}
exports.ProcessTopologyRequest_FiducialLoopClosureParams = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.minLoopClosurePathLength !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.minLoopClosurePathLength }, writer.uint32(10).fork()).ldelim();
        }
        if (message.maxLoopClosureEdgeLength !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maxLoopClosureEdgeLength }, writer.uint32(18).fork()).ldelim();
        }
        if (message.maxFiducialDistance !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maxFiducialDistance }, writer.uint32(26).fork()).ldelim();
        }
        if (message.maxLoopClosureHeightChange !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maxLoopClosureHeightChange }, 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 = createBaseProcessTopologyRequest_FiducialLoopClosureParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.minLoopClosurePathLength = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 2:
                    message.maxLoopClosureEdgeLength = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 3:
                    message.maxFiducialDistance = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 4:
                    message.maxLoopClosureHeightChange = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            minLoopClosurePathLength: isSet(object.minLoopClosurePathLength)
                ? Number(object.minLoopClosurePathLength)
                : undefined,
            maxLoopClosureEdgeLength: isSet(object.maxLoopClosureEdgeLength)
                ? Number(object.maxLoopClosureEdgeLength)
                : undefined,
            maxFiducialDistance: isSet(object.maxFiducialDistance)
                ? Number(object.maxFiducialDistance)
                : undefined,
            maxLoopClosureHeightChange: isSet(object.maxLoopClosureHeightChange)
                ? Number(object.maxLoopClosureHeightChange)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.minLoopClosurePathLength !== undefined &&
            (obj.minLoopClosurePathLength = message.minLoopClosurePathLength);
        message.maxLoopClosureEdgeLength !== undefined &&
            (obj.maxLoopClosureEdgeLength = message.maxLoopClosureEdgeLength);
        message.maxFiducialDistance !== undefined &&
            (obj.maxFiducialDistance = message.maxFiducialDistance);
        message.maxLoopClosureHeightChange !== undefined &&
            (obj.maxLoopClosureHeightChange = message.maxLoopClosureHeightChange);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseProcessTopologyRequest_FiducialLoopClosureParams();
        message.minLoopClosurePathLength =
            object.minLoopClosurePathLength ?? undefined;
        message.maxLoopClosureEdgeLength =
            object.maxLoopClosureEdgeLength ?? undefined;
        message.maxFiducialDistance = object.maxFiducialDistance ?? undefined;
        message.maxLoopClosureHeightChange =
            object.maxLoopClosureHeightChange ?? undefined;
        return message;
    },
};
function createBaseProcessTopologyRequest_CollisionCheckingParams() {
    return {
        checkEdgesForCollision: undefined,
        collisionCheckRobotRadius: undefined,
        collisionCheckHeightVariation: undefined,
    };
}
exports.ProcessTopologyRequest_CollisionCheckingParams = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.checkEdgesForCollision !== undefined) {
            wrappers_1.BoolValue.encode({ value: message.checkEdgesForCollision }, writer.uint32(10).fork()).ldelim();
        }
        if (message.collisionCheckRobotRadius !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.collisionCheckRobotRadius }, writer.uint32(18).fork()).ldelim();
        }
        if (message.collisionCheckHeightVariation !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.collisionCheckHeightVariation }, 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 = createBaseProcessTopologyRequest_CollisionCheckingParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.checkEdgesForCollision = wrappers_1.BoolValue.decode(reader, reader.uint32()).value;
                    break;
                case 2:
                    message.collisionCheckRobotRadius = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 3:
                    message.collisionCheckHeightVariation = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            checkEdgesForCollision: isSet(object.checkEdgesForCollision)
                ? Boolean(object.checkEdgesForCollision)
                : undefined,
            collisionCheckRobotRadius: isSet(object.collisionCheckRobotRadius)
                ? Number(object.collisionCheckRobotRadius)
                : undefined,
            collisionCheckHeightVariation: isSet(object.collisionCheckHeightVariation)
                ? Number(object.collisionCheckHeightVariation)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.checkEdgesForCollision !== undefined &&
            (obj.checkEdgesForCollision = message.checkEdgesForCollision);
        message.collisionCheckRobotRadius !== undefined &&
            (obj.collisionCheckRobotRadius = message.collisionCheckRobotRadius);
        message.collisionCheckHeightVariation !== undefined &&
            (obj.collisionCheckHeightVariation =
                message.collisionCheckHeightVariation);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseProcessTopologyRequest_CollisionCheckingParams();
        message.checkEdgesForCollision = object.checkEdgesForCollision ?? undefined;
        message.collisionCheckRobotRadius =
            object.collisionCheckRobotRadius ?? undefined;
        message.collisionCheckHeightVariation =
            object.collisionCheckHeightVariation ?? undefined;
        return message;
    },
};
function createBaseProcessTopologyRequest_Params() {
    return {
        doOdometryLoopClosure: undefined,
        odometryLoopClosureParams: undefined,
        icpParams: undefined,
        doFiducialLoopClosure: undefined,
        fiducialLoopClosureParams: undefined,
        collisionCheckParams: undefined,
        timeoutSeconds: 0,
    };
}
exports.ProcessTopologyRequest_Params = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.doOdometryLoopClosure !== undefined) {
            wrappers_1.BoolValue.encode({ value: message.doOdometryLoopClosure }, writer.uint32(10).fork()).ldelim();
        }
        if (message.odometryLoopClosureParams !== undefined) {
            exports.ProcessTopologyRequest_OdometryLoopClosureParams.encode(message.odometryLoopClosureParams, writer.uint32(18).fork()).ldelim();
        }
        if (message.icpParams !== undefined) {
            exports.ProcessTopologyRequest_ICPParams.encode(message.icpParams, writer.uint32(26).fork()).ldelim();
        }
        if (message.doFiducialLoopClosure !== undefined) {
            wrappers_1.BoolValue.encode({ value: message.doFiducialLoopClosure }, writer.uint32(34).fork()).ldelim();
        }
        if (message.fiducialLoopClosureParams !== undefined) {
            exports.ProcessTopologyRequest_FiducialLoopClosureParams.encode(message.fiducialLoopClosureParams, writer.uint32(42).fork()).ldelim();
        }
        if (message.collisionCheckParams !== undefined) {
            exports.ProcessTopologyRequest_CollisionCheckingParams.encode(message.collisionCheckParams, writer.uint32(50).fork()).ldelim();
        }
        if (message.timeoutSeconds !== 0) {
            writer.uint32(57).double(message.timeoutSeconds);
        }
        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 = createBaseProcessTopologyRequest_Params();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.doOdometryLoopClosure = wrappers_1.BoolValue.decode(reader, reader.uint32()).value;
                    break;
                case 2:
                    message.odometryLoopClosureParams =
                        exports.ProcessTopologyRequest_OdometryLoopClosureParams.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.icpParams = exports.ProcessTopologyRequest_ICPParams.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.doFiducialLoopClosure = wrappers_1.BoolValue.decode(reader, reader.uint32()).value;
                    break;
                case 5:
                    message.fiducialLoopClosureParams =
                        exports.ProcessTopologyRequest_FiducialLoopClosureParams.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.collisionCheckParams =
                        exports.ProcessTopologyRequest_CollisionCheckingParams.decode(reader, reader.uint32());
                    break;
                case 7:
                    message.timeoutSeconds = reader.double();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            doOdometryLoopClosure: isSet(object.doOdometryLoopClosure)
                ? Boolean(object.doOdometryLoopClosure)
                : undefined,
            odometryLoopClosureParams: isSet(object.odometryLoopClosureParams)
                ? exports.ProcessTopologyRequest_OdometryLoopClosureParams.fromJSON(object.odometryLoopClosureParams)
                : undefined,
            icpParams: isSet(object.icpParams)
                ? exports.ProcessTopologyRequest_ICPParams.fromJSON(object.icpParams)
                : undefined,
            doFiducialLoopClosure: isSet(object.doFiducialLoopClosure)
                ? Boolean(object.doFiducialLoopClosure)
                : undefined,
            fiducialLoopClosureParams: isSet(object.fiducialLoopClosureParams)
                ? exports.ProcessTopologyRequest_FiducialLoopClosureParams.fromJSON(object.fiducialLoopClosureParams)
                : undefined,
            collisionCheckParams: isSet(object.collisionCheckParams)
                ? exports.ProcessTopologyRequest_CollisionCheckingParams.fromJSON(object.collisionCheckParams)
                : undefined,
            timeoutSeconds: isSet(object.timeoutSeconds)
                ? Number(object.timeoutSeconds)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.doOdometryLoopClosure !== undefined &&
            (obj.doOdometryLoopClosure = message.doOdometryLoopClosure);
        message.odometryLoopClosureParams !== undefined &&
            (obj.odometryLoopClosureParams = message.odometryLoopClosureParams
                ? exports.ProcessTopologyRequest_OdometryLoopClosureParams.toJSON(message.odometryLoopClosureParams)
                : undefined);
        message.icpParams !== undefined &&
            (obj.icpParams = message.icpParams
                ? exports.ProcessTopologyRequest_ICPParams.toJSON(message.icpParams)
                : undefined);
        message.doFiducialLoopClosure !== undefined &&
            (obj.doFiducialLoopClosure = message.doFiducialLoopClosure);
        message.fiducialLoopClosureParams !== undefined &&
            (obj.fiducialLoopClosureParams = message.fiducialLoopClosureParams
                ? exports.ProcessTopologyRequest_FiducialLoopClosureParams.toJSON(message.fiducialLoopClosureParams)
                : undefined);
        message.collisionCheckParams !== undefined &&
            (obj.collisionCheckParams = message.collisionCheckParams
                ? exports.ProcessTopologyRequest_CollisionCheckingParams.toJSON(message.collisionCheckParams)
                : undefined);
        message.timeoutSeconds !== undefined &&
            (obj.timeoutSeconds = message.timeoutSeconds);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseProcessTopologyRequest_Params();
        message.doOdometryLoopClosure = object.doOdometryLoopClosure ?? undefined;
        message.odometryLoopClosureParams =
            object.odometryLoopClosureParams !== undefined &&
                object.odometryLoopClosureParams !== null
                ? exports.ProcessTopologyRequest_OdometryLoopClosureParams.fromPartial(object.odometryLoopClosureParams)
                : undefined;
        message.icpParams =
            object.icpParams !== undefined && object.icpParams !== null
                ? exports.ProcessTopologyRequest_ICPParams.fromPartial(object.icpParams)
                : undefined;
        message.doFiducialLoopClosure = object.doFiducialLoopClosure ?? undefined;
        message.fiducialLoopClosureParams =
            object.fiducialLoopClosureParams !== undefined &&
                object.fiducialLoopClosureParams !== null
                ? exports.ProcessTopologyRequest_FiducialLoopClosureParams.fromPartial(object.fiducialLoopClosureParams)
                : undefined;
        message.collisionCheckParams =
            object.collisionCheckParams !== undefined &&
                object.collisionCheckParams !== null
                ? exports.ProcessTopologyRequest_CollisionCheckingParams.fromPartial(object.collisionCheckParams)
                : undefined;
        message.timeoutSeconds = object.timeoutSeconds ?? 0;
        return message;
    },
};
function createBaseProcessTopologyResponse() {
    return {
        header: undefined,
        status: 0,
        newSubgraph: undefined,
        mapOnServerWasModified: false,
        missingSnapshotIds: [],
        missingWaypointIds: [],
        timedOut: false,
    };
}
exports.ProcessTopologyResponse = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.header !== undefined) {
            header_1.ResponseHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
        }
        if (message.status !== 0) {
            writer.uint32(16).int32(message.status);
        }
        if (message.newSubgraph !== undefined) {
            map_1.Graph.encode(message.newSubgraph, writer.uint32(26).fork()).ldelim();
        }
        if (message.mapOnServerWasModified === true) {
            writer.uint32(32).bool(message.mapOnServerWasModified);
        }
        for (const v of message.missingSnapshotIds) {
            writer.uint32(82).string(v);
        }
        for (const v of message.missingWaypointIds) {
            writer.uint32(90).string(v);
        }
        if (message.timedOut === true) {
            writer.uint32(96).bool(message.timedOut);
        }
        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 = createBaseProcessTopologyResponse();
        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.status = reader.int32();
                    break;
                case 3:
                    message.newSubgraph = map_1.Graph.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.mapOnServerWasModified = reader.bool();
                    break;
                case 10:
                    message.missingSnapshotIds.push(reader.string());
                    break;
                case 11:
                    message.missingWaypointIds.push(reader.string());
                    break;
                case 12:
                    message.timedOut = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            header: isSet(object.header)
                ? header_1.ResponseHeader.fromJSON(object.header)
                : undefined,
            status: isSet(object.status)
                ? processTopologyResponse_StatusFromJSON(object.status)
                : 0,
            newSubgraph: isSet(object.newSubgraph)
                ? map_1.Graph.fromJSON(object.newSubgraph)
                : undefined,
            mapOnServerWasModified: isSet(object.mapOnServerWasModified)
                ? Boolean(object.mapOnServerWasModified)
                : false,
            missingSnapshotIds: Array.isArray(object?.missingSnapshotIds)
                ? object.missingSnapshotIds.map((e) => String(e))
                : [],
            missingWaypointIds: Array.isArray(object?.missingWaypointIds)
                ? object.missingWaypointIds.map((e) => String(e))
                : [],
            timedOut: isSet(object.timedOut) ? Boolean(object.timedOut) : false,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.status !== undefined &&
            (obj.status = processTopologyResponse_StatusToJSON(message.status));
        message.newSubgraph !== undefined &&
            (obj.newSubgraph = message.newSubgraph
                ? map_1.Graph.toJSON(message.newSubgraph)
                : undefined);
        message.mapOnServerWasModified !== undefined &&
            (obj.mapOnServerWasModified = message.mapOnServerWasModified);
        if (message.missingSnapshotIds) {
            obj.missingSnapshotIds = message.missingSnapshotIds.map((e) => e);
        }
        else {
            obj.missingSnapshotIds = [];
        }
        if (message.missingWaypointIds) {
            obj.missingWaypointIds = message.missingWaypointIds.map((e) => e);
        }
        else {
            obj.missingWaypointIds = [];
        }
        message.timedOut !== undefined && (obj.timedOut = message.timedOut);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseProcessTopologyResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.status = object.status ?? 0;
        message.newSubgraph =
            object.newSubgraph !== undefined && object.newSubgraph !== null
                ? map_1.Graph.fromPartial(object.newSubgraph)
                : undefined;
        message.mapOnServerWasModified = object.mapOnServerWasModified ?? false;
        message.missingSnapshotIds = object.missingSnapshotIds?.map((e) => e) || [];
        message.missingWaypointIds = object.missingWaypointIds?.map((e) => e) || [];
        message.timedOut = object.timedOut ?? false;
        return message;
    },
};
function createBasePoseBounds() {
    return { xBounds: 0, yBounds: 0, zBounds: 0, yawBounds: 0 };
}
exports.PoseBounds = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.xBounds !== 0) {
            writer.uint32(9).double(message.xBounds);
        }
        if (message.yBounds !== 0) {
            writer.uint32(17).double(message.yBounds);
        }
        if (message.zBounds !== 0) {
            writer.uint32(25).double(message.zBounds);
        }
        if (message.yawBounds !== 0) {
            writer.uint32(33).double(message.yawBounds);
        }
        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 = createBasePoseBounds();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.xBounds = reader.double();
                    break;
                case 2:
                    message.yBounds = reader.double();
                    break;
                case 3:
                    message.zBounds = reader.double();
                    break;
                case 4:
                    message.yawBounds = reader.double();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            xBounds: isSet(object.xBounds) ? Number(object.xBounds) : 0,
            yBounds: isSet(object.yBounds) ? Number(object.yBounds) : 0,
            zBounds: isSet(object.zBounds) ? Number(object.zBounds) : 0,
            yawBounds: isSet(object.yawBounds) ? Number(object.yawBounds) : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.xBounds !== undefined && (obj.xBounds = message.xBounds);
        message.yBounds !== undefined && (obj.yBounds = message.yBounds);
        message.zBounds !== undefined && (obj.zBounds = message.zBounds);
        message.yawBounds !== undefined && (obj.yawBounds = message.yawBounds);
        return obj;
    },
    fromPartial(object) {
        const message = createBasePoseBounds();
        message.xBounds = object.xBounds ?? 0;
        message.yBounds = object.yBounds ?? 0;
        message.zBounds = object.zBounds ?? 0;
        message.yawBounds = object.yawBounds ?? 0;
        return message;
    },
};
function createBaseAnchorHintUncertainty() {
    return { se3Covariance: undefined, confidenceBounds: undefined };
}
exports.AnchorHintUncertainty = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.se3Covariance !== undefined) {
            geometry_1.SE3Covariance.encode(message.se3Covariance, writer.uint32(10).fork()).ldelim();
        }
        if (message.confidenceBounds !== undefined) {
            exports.PoseBounds.encode(message.confidenceBounds, 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 = createBaseAnchorHintUncertainty();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.se3Covariance = geometry_1.SE3Covariance.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.confidenceBounds = exports.PoseBounds.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            se3Covariance: isSet(object.se3Covariance)
                ? geometry_1.SE3Covariance.fromJSON(object.se3Covariance)
                : undefined,
            confidenceBounds: isSet(object.confidenceBounds)
                ? exports.PoseBounds.fromJSON(object.confidenceBounds)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.se3Covariance !== undefined &&
            (obj.se3Covariance = message.se3Covariance
                ? geometry_1.SE3Covariance.toJSON(message.se3Covariance)
                : undefined);
        message.confidenceBounds !== undefined &&
            (obj.confidenceBounds = message.confidenceBounds
                ? exports.PoseBounds.toJSON(message.confidenceBounds)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseAnchorHintUncertainty();
        message.se3Covariance =
            object.se3Covariance !== undefined && object.se3Covariance !== null
                ? geometry_1.SE3Covariance.fromPartial(object.se3Covariance)
                : undefined;
        message.confidenceBounds =
            object.confidenceBounds !== undefined && object.confidenceBounds !== null
                ? exports.PoseBounds.fromPartial(object.confidenceBounds)
                : undefined;
        return message;
    },
};
function createBaseWaypointAnchorHint() {
    return {
        waypointAnchor: undefined,
        seedTformWaypointUncertainty: undefined,
        seedTformWaypointConstraint: undefined,
    };
}
exports.WaypointAnchorHint = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.waypointAnchor !== undefined) {
            map_1.Anchor.encode(message.waypointAnchor, writer.uint32(10).fork()).ldelim();
        }
        if (message.seedTformWaypointUncertainty !== undefined) {
            exports.AnchorHintUncertainty.encode(message.seedTformWaypointUncertainty, writer.uint32(18).fork()).ldelim();
        }
        if (message.seedTformWaypointConstraint !== undefined) {
            exports.PoseBounds.encode(message.seedTformWaypointConstraint, 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 = createBaseWaypointAnchorHint();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.w