spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
983 lines • 357 kB
TypeScript
import { RequestHeader, ResponseHeader } from "../header";
import { Graph, Anchor, AnchoredWorldObject } from "./map";
import { SE3Covariance, Vec3 } from "../geometry";
import _m0 from "protobufjs/minimal";
export declare const protobufPackage = "bosdyn.api.graph_nav";
/**
* Processes a GraphNav map by creating additional edges. After processing,
* a new subgraph is created containing additional edges to add to the map.
* Edges are created between waypoints that are near each other. These waypoint pairs
* are called "loop closures", and are found by different means.
* In general, if parameters are not provided, reasonable defaults will be used.
* Note that this can be used to merge disconnected subgraphs from multiple recording
* sessions so long as they share fiducial observations.
*/
export interface ProcessTopologyRequest {
/** Standard message header. */
header: RequestHeader | undefined;
/** Parameters. If not filled out, reasonable defaults will be used. */
params: ProcessTopologyRequest_Params | undefined;
/**
* If true, any processing should directly modify the map on the server.
* Otherwise, the client is expected to upload the processing results (newly created edges)
* back to the server. The processing service shares memory with a map container service
* (e.g the GraphNav service).
*/
modifyMapOnServer: boolean;
}
/**
* Parameters for how to refine loop closure edges using iterative
* closest point matching.
*/
export interface ProcessTopologyRequest_ICPParams {
/** The maximum number of iterations to run. Set to zero to skip ICP processing. */
icpIters: number | undefined;
/**
* The maximum distance between points in the point cloud we are willing to
* accept for matches.
*/
maxPointMatchDistance: number | undefined;
}
/**
* Parameters for how to close loops using odometry. This infers which waypoints
* should be connected to one another based on the odometry measurements in the map.
*/
export interface ProcessTopologyRequest_OdometryLoopClosureParams {
/**
* The maximum distance between waypoints found by walking a path from one
* waypoint to the other using only the existing edges in the map. Beyond
* this distance, we are unwilling to trust odometry.
*/
maxLoopClosurePathLength: number | undefined;
/**
* The minimum distance between waypoints found by walking a path from
* one waypoint to the other using only the existing edges in the map.
* Set this higher to avoid creating small shortcuts along the existing path.
* Note that this is a 2d path length.
*/
minLoopClosurePathLength: number | undefined;
/**
* The maximum apparent height change of the created edge that we are
* willing to accept between waypoints. This avoids closing loops up ramps,
* stairs, etc. or closing loops where there is significant odometry drift.
*/
maxLoopClosureHeightChange: number | undefined;
/**
* Once a loop closure candidate is found, the system creates an edge between the
* candidate waypoints. Only create the edge if it is shorter than this value.
* Note that this is a 3d edge length.
*/
maxLoopClosureEdgeLength: number | undefined;
/**
* Use prior loop closures to infer new odometry based loop closures. This is
* useful when other sources of loop closures (like fiducials) are being used.
* The existence of those loop closures allows the system to infer other nearby
* loop closures using odometry. Alternatively, the user may call the ProcessTopology
* RPC multiple times to achieve the same effect.
*/
numExtraLoopClosureIterations: number | undefined;
}
/**
* Parameters for how to close a loop using fiducials (AprilTags). This infers
* which waypoints should be connected to one another based on shared observations
* of AprilTags.
* Note that multiple disconnected subgraphs (for example from multiple recording sessions)
* can be merged this way.
*/
export interface ProcessTopologyRequest_FiducialLoopClosureParams {
/**
* The minimum distance between waypoints found by walking a path from
* one waypoint to the other using only the existing edges in the map.
* Set this higher to avoid creating small shortcuts along the existing path.
* Note that this is a 2d path length.
*/
minLoopClosurePathLength: number | undefined;
/**
* Once a loop closure candidate is found, the system creates an edge between the
* candidate waypoints. Only create the edge if it is shorter than this value.
* Note that this is a 3d edge length.
*/
maxLoopClosureEdgeLength: number | undefined;
/**
* Maximum distance to accept between a waypoint and a fiducial detection to
* use that fiducial detection for generating loop closure candidates.
*/
maxFiducialDistance: number | undefined;
/**
* The maximum apparent height change of the created edge that we are
* willing to accept between waypoints. This avoids closing loops up ramps,
* stairs, etc. or closing loops where there is significant odometry drift.
*/
maxLoopClosureHeightChange: number | undefined;
}
/**
* Parameters for how to check for collisions when creating loop closures. The system
* will avoid creating edges in the map that the robot cannot actually traverse due to
* the presence of nearby obstacles.
*/
export interface ProcessTopologyRequest_CollisionCheckingParams {
/** By default, this is true. */
checkEdgesForCollision: boolean | undefined;
/**
* Assume that the robot is a sphere with this radius. Only accept a
* loop closure if this spherical robot can travel in a straight line
* from one waypoint to the other without hitting obstacles.
*/
collisionCheckRobotRadius: number | undefined;
/**
* Consider significant height variations along the edge (like stairs or ramps)
* to be obstacles. The edge will not be created if there is a height change along
* it of more than this value according to the nearby sensor data.
*/
collisionCheckHeightVariation: number | undefined;
}
/**
* Parameters which control topology processing. In general, anything which isn't filled out
* will be replaced by reasonable defaults.
*/
export interface ProcessTopologyRequest_Params {
/** True by default -- generate loop closure candidates using odometry. */
doOdometryLoopClosure: boolean | undefined;
/** Parameters for generating loop closure candidates using odometry. */
odometryLoopClosureParams: ProcessTopologyRequest_OdometryLoopClosureParams | undefined;
/**
* Parameters for refining loop closure candidates using iterative closest point
* cloud matching.
*/
icpParams: ProcessTopologyRequest_ICPParams | undefined;
/** True by default -- generate loop closure candidates using fiducials. */
doFiducialLoopClosure: boolean | undefined;
/** Parameters for generating loop closure candidates using fiducials. */
fiducialLoopClosureParams: ProcessTopologyRequest_FiducialLoopClosureParams | undefined;
/**
* Parameters which control rejecting loop closure candidates which
* collide with obstacles.
*/
collisionCheckParams: ProcessTopologyRequest_CollisionCheckingParams | undefined;
/**
* Causes the processing to time out after this many seconds. If not set, a default of 45 seconds
* will be used. If this timeout occurs before the overall RPC timeout, a partial result will be
* returned with ProcessTopologyResponse.timed_out set to true. Processing can be continued by
* calling ProcessTopology again.
*/
timeoutSeconds: number;
}
/**
* Result of the topology processing RPC. If successful, contains a subgraph of new
* waypoints or edges created by this process.
*/
export interface ProcessTopologyResponse {
/** Standard message header. */
header: ResponseHeader | undefined;
/** Result of the processing. */
status: ProcessTopologyResponse_Status;
/**
* This graph contains the new edge(s) created by map processing. Note that these edges will be
* annotated with their creation method. Note that several subgraphs may be returned via
* streaming as the map is processed.
*/
newSubgraph: Graph | undefined;
/**
* If modify_map_on_server was set to true in the request, then the map currently on the server
* was modified using map processing. If this is set to false, then either an error occurred during
* processing, or modify_map_on_server was set to false in the request.
* When map_on_server_was_modified is set to false, the client is expected to upload the results
* back to the server to commit the changes.
*/
mapOnServerWasModified: boolean;
/**
* When there are missing waypoint snapshots, these are the IDs of the missing snapshots.
* Upload them to continue.
*/
missingSnapshotIds: string[];
/**
* When there are missing waypoints, these are the IDs of the missing waypoints. Upload them
* to continue.
*/
missingWaypointIds: string[];
/**
* If true, the processing timed out. Note that this is not considered an error. Run topology processing again
* to continue adding edges.
*/
timedOut: boolean;
}
export declare enum ProcessTopologyResponse_Status {
/** STATUS_UNKNOWN - Programming error. */
STATUS_UNKNOWN = 0,
/** STATUS_OK - Success. */
STATUS_OK = 1,
/** STATUS_MISSING_WAYPOINT_SNAPSHOTS - Not all of the waypoint snapshots exist on the server. Upload them to continue. */
STATUS_MISSING_WAYPOINT_SNAPSHOTS = 2,
/** STATUS_INVALID_GRAPH - The graph is invalid topologically, for example containing missing waypoints referenced by edges. */
STATUS_INVALID_GRAPH = 3,
/** STATUS_MAP_MODIFIED_DURING_PROCESSING - Tried to write the anchoring after processing, but another client may have modified the map. Try again */
STATUS_MAP_MODIFIED_DURING_PROCESSING = 4,
UNRECOGNIZED = -1
}
export declare function processTopologyResponse_StatusFromJSON(object: any): ProcessTopologyResponse_Status;
export declare function processTopologyResponse_StatusToJSON(object: ProcessTopologyResponse_Status): string;
/**
* Represents an interval in x, y, z and yaw around some center. Some value x
* will be within the bounds if center - x_bounds <= x >= center + x_bounds.
* If the values are left at zero, the bounds are considered to be unconstrained.
* The center of the bounds is left implicit, and should be whatever this message
* is packaged with.
*/
export interface PoseBounds {
/** Bounds on the x position in meters. */
xBounds: number;
/** Bounds on the y position in meters. */
yBounds: number;
/** Bounds on the z position in meters. */
zBounds: number;
/** Bounds on the yaw (rotation around z axis) in radians. */
yawBounds: number;
}
/** Controls how certain the user is of an anchor's pose. If left empty, a reasonable default will be chosen. */
export interface AnchorHintUncertainty {
/** A full 6x6 Gaussian covariance matrix representing uncertainty of an anchoring. */
se3Covariance: SE3Covariance | undefined;
/**
* Represents the 95 percent confidence interval on individual axes. This
* will be converted to a SE3Covariance internally by creating a diagonal
* matrix whose elements are informed by the confidence bounds.
*/
confidenceBounds: PoseBounds | undefined;
}
/**
* Waypoints may be anchored to a particular seed frame. The user may request that a waypoint
* be anchored in a particular place with some Gaussian uncertainty.
*/
export interface WaypointAnchorHint {
/**
* This is to be interpreted as the mean of a Gaussian distribution, representing
* the pose of the waypoint in the seed frame.
*/
waypointAnchor: Anchor | undefined;
/**
* This is the uncertainty of the anchor's pose in the seed frame.
* If left empty, a reasonable default uncertainty will be generated.
*/
seedTformWaypointUncertainty: AnchorHintUncertainty | undefined;
/**
* Normally, the optimizer will move the anchorings of waypoints based on context, to minimize the
* overall cost of the optimization problem. By providing a constraint on pose, the user can ensure
* that the anchors stay within a certain region in the seed frame.
* Leaving this empty will allow the optimizer to move the anchoring from the hint as far as it likes.
*/
seedTformWaypointConstraint: PoseBounds | undefined;
}
/**
* World objects (such as fiducials) may be anchored to a particular seed frame. The user may request that an object
* be anchored in a particular place with some Gaussian uncertainty.
*/
export interface WorldObjectAnchorHint {
/**
* This is to be interpreted as the mean of a Gaussian distribution, representing
* the pose of the object in the seed frame.
*/
objectAnchor: AnchoredWorldObject | undefined;
/**
* This is the uncertainty of the anchor's pose in the seed frame.
* If left empty, a reasonable default uncertainty will be generated.
*/
seedTformObjectUncertainty: AnchorHintUncertainty | undefined;
/**
* Normally, the optimizer will move the anchorings of object based on context, to minimize the
* overall cost of the optimization problem. By providing a constraint on pose, the user can ensure
* that the anchors stay within a certain region in the seed frame.
* Leaving this empty will allow the optimizer to move the anchoring from the hint as far as it likes.
*/
seedTformObjectConstraint: PoseBounds | undefined;
}
/**
* The user may assign a number of world objects and waypoints a guess at where they are in the seed frame.
* These hints will be respected by the ProcessAnchoringRequest.
*/
export interface AnchoringHint {
/** List of waypoints and hints as to where they are in the seed frame. */
waypointAnchors: WaypointAnchorHint[];
/** List of world objects and hints as to where they are in the seed frame. */
worldObjects: WorldObjectAnchorHint[];
}
/**
* Causes the server to optimize an existing anchoring, or generate a new anchoring for the map using the given parameters.
* In general, if parameters are not provided, reasonable defaults will be used.
* The new anchoring will be streamed back to the client, or modified on the server if desired.
*/
export interface ProcessAnchoringRequest {
/** Standard request header. */
header: RequestHeader | undefined;
params: ProcessAnchoringRequest_Params | undefined;
/** Initial guess at some number of waypoints and world objects and their anchorings. */
initialHint: AnchoringHint | undefined;
/**
* If true, the map currently uploaded to the server will have its anchoring modified.
* Otherwise, the user is expected to re-upload the anchoring.
*/
modifyAnchoringOnServer: boolean;
/**
* If true, the anchoring will be streamed back to the user after every iteration.
* This is useful for debug visualization.
*/
streamIntermediateResults: boolean;
}
/** Parameters for procesing an anchoring. */
export interface ProcessAnchoringRequest_Params {
optimizerParams: ProcessAnchoringRequest_Params_OptimizerParams | undefined;
measurementParams: ProcessAnchoringRequest_Params_MeasurementParams | undefined;
weights: ProcessAnchoringRequest_Params_Weights | undefined;
/**
* If true, the anchoring which already exists on the server will be used as the initial
* guess for the optimizer. Otherwise, a new anchoring will be generated for every waypoint
* which doesn't have a value passed in through initial_hint. If no hint is provided,
* and this value is false, every waypoint will be given a starting anchoring based on
* the oldest waypoint in the map.
*/
optimizeExistingAnchoring: boolean | undefined;
/**
* The optimizer will try to keep the orientation of waypoints consistent with gravity.
* If provided, this is the gravity direction expressed with respect to the seed. This
* will be interpreted as a unit vector. If not filled out, a default of (0, 0, -1) will be
* used.
*/
gravityEwrtSeed: Vec3 | undefined;
}
/** Parameters affecting the underlying optimizer. */
export interface ProcessAnchoringRequest_Params_OptimizerParams {
/** Maximum iterations of the optimizer to run. */
maxIters: number | undefined;
/** Maximum time the optimizer is allowed to run before giving up. */
maxTimeSeconds: number | undefined;
}
/** Parameters which affect the measurements the optimzier uses to process the anchoring. */
export interface ProcessAnchoringRequest_Params_MeasurementParams {
/**
* If true, waypoints which share the same kinematic odometry
* frame will be constrained to one another using it.
*/
useKinematicOdometry: boolean | undefined;
/**
* If true, waypoints which share the same visual odometry frame
* will be constrained to one another using it.
*/
useVisualOdometry: boolean | undefined;
/**
* If true, waypoints will be constrained so that the apparent pose of the
* robot w.r.t the waypoint at the time of recording is consistent with gravity.
*/
useGyroscopeMeasurements: boolean | undefined;
/**
* If true, edges which were created by topology processing via loop closures will
* be used as constraints.
*/
useLoopClosures: boolean | undefined;
/**
* If true, world object measurements will be used to constrain waypoints to one another
* when those waypoints co-observe the same world object.
*/
useWorldObjects: boolean | undefined;
}
/**
* Relative weights to use for each of the optimizer's terms. These can be any positive value.
* If set to zero, a reasonable default will be used. In general, the higher the weight, the more
* the optimizer will care about that particular measurement.
*/
export interface ProcessAnchoringRequest_Params_Weights {
kinematicOdometryWeight: number;
visualOdometryWeight: number;
worldObjectWeight: number;
hintWeight: number;
gyroscopeWeight: number;
loopClosureWeight: number;
}
/**
* Streamed response from the ProcessAnchoringRequest. These will be streamed until optimization is complete.
* New anchorings will be streamed as they become available.
*/
export interface ProcessAnchoringResponse {
header: ResponseHeader | undefined;
status: ProcessAnchoringResponse_Status;
/**
* Contains new anchorings for waypoint(s) processed by the server.
* These will be streamed back to the user as they become available.
*/
waypointResults: Anchor[];
/**
* Contains new anchorings for object(s) (e.g april tags) processed by the server.
* These will be streamed back to the user as they become available
*/
worldObjectResults: AnchoredWorldObject[];
/**
* If modify_anchoring_on_server was set to true in the request, then the anchoring currently on the server
* was modified using map processing. If this is set to false, then either an error occurred during
* processing, or modify_anchoring_on_server was set to false in the request.
* When anchoring_on_server_was_modified is set to false, the client is expected to upload the results
* back to the server to commit the changes.
*/
anchoringOnServerWasModified: boolean;
/** The current optimizer iteration that produced these data. */
iteration: number;
/** The current nonlinear optimization cost. */
cost: number;
/**
* If true, this is the result of the final iteration of optimization.
* This will always be true when stream_intermediate_results in the request is false.
*/
finalIteration: boolean;
/**
* On failure due to constraint violation, these hints were violated by the optimization.
* Try increasing the pose bounds on the constraints of these hints.
*/
violatedWaypointConstraints: WaypointAnchorHint[];
/**
* On failure due to constraint violation, these hints were violated by the optimization.
* Try increasing the pose bounds on the constraints of these hints.
*/
violatedObjectConstraints: WorldObjectAnchorHint[];
/**
* When there are missing waypoint snapshots, these are the IDs of the missing snapshots.
* Upload them to continue.
*/
missingSnapshotIds: string[];
/**
* When there are missing waypoints, these are the IDs of the missing waypoints. Upload them
* to continue.
*/
missingWaypointIds: string[];
/** Unorganized list of waypoints and object IDs which were invalid (missing from the map). */
invalidHints: string[];
}
export declare enum ProcessAnchoringResponse_Status {
/** STATUS_UNKNOWN - Programming error. */
STATUS_UNKNOWN = 0,
/** STATUS_OK - Success. */
STATUS_OK = 1,
/** STATUS_MISSING_WAYPOINT_SNAPSHOTS - Not all of the waypoint snapshots exist on the server. Upload them to continue. */
STATUS_MISSING_WAYPOINT_SNAPSHOTS = 2,
/** STATUS_INVALID_GRAPH - The graph is invalid topologically, for example containing missing waypoints referenced by edges. */
STATUS_INVALID_GRAPH = 3,
/** STATUS_OPTIMIZATION_FAILURE - The optimization failed due to local minima or an ill-conditioned problem definition. */
STATUS_OPTIMIZATION_FAILURE = 4,
/** STATUS_INVALID_PARAMS - The parameters passed to the optimizer do not make sense (e.g negative weights). */
STATUS_INVALID_PARAMS = 5,
/** STATUS_CONSTRAINT_VIOLATION - One or more anchors were moved outside of the desired constraints. */
STATUS_CONSTRAINT_VIOLATION = 6,
/** STATUS_MAX_ITERATIONS - The optimizer reached the maximum number of iterations before converging. */
STATUS_MAX_ITERATIONS = 7,
/** STATUS_MAX_TIME - The optimizer timed out before converging. */
STATUS_MAX_TIME = 8,
/** STATUS_INVALID_HINTS - One or more of the hints passed in to the optimizer are invalid (do not correspond to real waypoints or objects). */
STATUS_INVALID_HINTS = 9,
/** STATUS_MAP_MODIFIED_DURING_PROCESSING - Tried to write the anchoring after processing, but another client may have modified the map. Try again. */
STATUS_MAP_MODIFIED_DURING_PROCESSING = 10,
UNRECOGNIZED = -1
}
export declare function processAnchoringResponse_StatusFromJSON(object: any): ProcessAnchoringResponse_Status;
export declare function processAnchoringResponse_StatusToJSON(object: ProcessAnchoringResponse_Status): string;
export declare const ProcessTopologyRequest: {
encode(message: ProcessTopologyRequest, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ProcessTopologyRequest;
fromJSON(object: any): ProcessTopologyRequest;
toJSON(message: ProcessTopologyRequest): unknown;
fromPartial<I extends {
header?: {
requestTimestamp?: Date | undefined;
clientName?: string | undefined;
disableRpcLogging?: boolean | undefined;
} | undefined;
params?: {
doOdometryLoopClosure?: boolean | undefined;
odometryLoopClosureParams?: {
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} | undefined;
icpParams?: {
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} | undefined;
doFiducialLoopClosure?: boolean | undefined;
fiducialLoopClosureParams?: {
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} | undefined;
collisionCheckParams?: {
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} | undefined;
timeoutSeconds?: number | undefined;
} | undefined;
modifyMapOnServer?: boolean | undefined;
} & {
header?: ({
requestTimestamp?: Date | undefined;
clientName?: string | undefined;
disableRpcLogging?: boolean | undefined;
} & {
requestTimestamp?: Date | undefined;
clientName?: string | undefined;
disableRpcLogging?: boolean | undefined;
} & { [K in Exclude<keyof I["header"], keyof RequestHeader>]: never; }) | undefined;
params?: ({
doOdometryLoopClosure?: boolean | undefined;
odometryLoopClosureParams?: {
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} | undefined;
icpParams?: {
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} | undefined;
doFiducialLoopClosure?: boolean | undefined;
fiducialLoopClosureParams?: {
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} | undefined;
collisionCheckParams?: {
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} | undefined;
timeoutSeconds?: number | undefined;
} & {
doOdometryLoopClosure?: boolean | undefined;
odometryLoopClosureParams?: ({
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} & {
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} & { [K_1 in Exclude<keyof I["params"]["odometryLoopClosureParams"], keyof ProcessTopologyRequest_OdometryLoopClosureParams>]: never; }) | undefined;
icpParams?: ({
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} & {
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} & { [K_2 in Exclude<keyof I["params"]["icpParams"], keyof ProcessTopologyRequest_ICPParams>]: never; }) | undefined;
doFiducialLoopClosure?: boolean | undefined;
fiducialLoopClosureParams?: ({
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} & {
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} & { [K_3 in Exclude<keyof I["params"]["fiducialLoopClosureParams"], keyof ProcessTopologyRequest_FiducialLoopClosureParams>]: never; }) | undefined;
collisionCheckParams?: ({
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} & {
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} & { [K_4 in Exclude<keyof I["params"]["collisionCheckParams"], keyof ProcessTopologyRequest_CollisionCheckingParams>]: never; }) | undefined;
timeoutSeconds?: number | undefined;
} & { [K_5 in Exclude<keyof I["params"], keyof ProcessTopologyRequest_Params>]: never; }) | undefined;
modifyMapOnServer?: boolean | undefined;
} & { [K_6 in Exclude<keyof I, keyof ProcessTopologyRequest>]: never; }>(object: I): ProcessTopologyRequest;
};
export declare const ProcessTopologyRequest_ICPParams: {
encode(message: ProcessTopologyRequest_ICPParams, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ProcessTopologyRequest_ICPParams;
fromJSON(object: any): ProcessTopologyRequest_ICPParams;
toJSON(message: ProcessTopologyRequest_ICPParams): unknown;
fromPartial<I extends {
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} & {
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} & { [K in Exclude<keyof I, keyof ProcessTopologyRequest_ICPParams>]: never; }>(object: I): ProcessTopologyRequest_ICPParams;
};
export declare const ProcessTopologyRequest_OdometryLoopClosureParams: {
encode(message: ProcessTopologyRequest_OdometryLoopClosureParams, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ProcessTopologyRequest_OdometryLoopClosureParams;
fromJSON(object: any): ProcessTopologyRequest_OdometryLoopClosureParams;
toJSON(message: ProcessTopologyRequest_OdometryLoopClosureParams): unknown;
fromPartial<I extends {
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} & {
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} & { [K in Exclude<keyof I, keyof ProcessTopologyRequest_OdometryLoopClosureParams>]: never; }>(object: I): ProcessTopologyRequest_OdometryLoopClosureParams;
};
export declare const ProcessTopologyRequest_FiducialLoopClosureParams: {
encode(message: ProcessTopologyRequest_FiducialLoopClosureParams, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ProcessTopologyRequest_FiducialLoopClosureParams;
fromJSON(object: any): ProcessTopologyRequest_FiducialLoopClosureParams;
toJSON(message: ProcessTopologyRequest_FiducialLoopClosureParams): unknown;
fromPartial<I extends {
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} & {
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} & { [K in Exclude<keyof I, keyof ProcessTopologyRequest_FiducialLoopClosureParams>]: never; }>(object: I): ProcessTopologyRequest_FiducialLoopClosureParams;
};
export declare const ProcessTopologyRequest_CollisionCheckingParams: {
encode(message: ProcessTopologyRequest_CollisionCheckingParams, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ProcessTopologyRequest_CollisionCheckingParams;
fromJSON(object: any): ProcessTopologyRequest_CollisionCheckingParams;
toJSON(message: ProcessTopologyRequest_CollisionCheckingParams): unknown;
fromPartial<I extends {
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} & {
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} & { [K in Exclude<keyof I, keyof ProcessTopologyRequest_CollisionCheckingParams>]: never; }>(object: I): ProcessTopologyRequest_CollisionCheckingParams;
};
export declare const ProcessTopologyRequest_Params: {
encode(message: ProcessTopologyRequest_Params, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ProcessTopologyRequest_Params;
fromJSON(object: any): ProcessTopologyRequest_Params;
toJSON(message: ProcessTopologyRequest_Params): unknown;
fromPartial<I extends {
doOdometryLoopClosure?: boolean | undefined;
odometryLoopClosureParams?: {
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} | undefined;
icpParams?: {
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} | undefined;
doFiducialLoopClosure?: boolean | undefined;
fiducialLoopClosureParams?: {
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} | undefined;
collisionCheckParams?: {
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} | undefined;
timeoutSeconds?: number | undefined;
} & {
doOdometryLoopClosure?: boolean | undefined;
odometryLoopClosureParams?: ({
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} & {
maxLoopClosurePathLength?: number | undefined;
minLoopClosurePathLength?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
numExtraLoopClosureIterations?: number | undefined;
} & { [K in Exclude<keyof I["odometryLoopClosureParams"], keyof ProcessTopologyRequest_OdometryLoopClosureParams>]: never; }) | undefined;
icpParams?: ({
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} & {
icpIters?: number | undefined;
maxPointMatchDistance?: number | undefined;
} & { [K_1 in Exclude<keyof I["icpParams"], keyof ProcessTopologyRequest_ICPParams>]: never; }) | undefined;
doFiducialLoopClosure?: boolean | undefined;
fiducialLoopClosureParams?: ({
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} & {
minLoopClosurePathLength?: number | undefined;
maxLoopClosureEdgeLength?: number | undefined;
maxFiducialDistance?: number | undefined;
maxLoopClosureHeightChange?: number | undefined;
} & { [K_2 in Exclude<keyof I["fiducialLoopClosureParams"], keyof ProcessTopologyRequest_FiducialLoopClosureParams>]: never; }) | undefined;
collisionCheckParams?: ({
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} & {
checkEdgesForCollision?: boolean | undefined;
collisionCheckRobotRadius?: number | undefined;
collisionCheckHeightVariation?: number | undefined;
} & { [K_3 in Exclude<keyof I["collisionCheckParams"], keyof ProcessTopologyRequest_CollisionCheckingParams>]: never; }) | undefined;
timeoutSeconds?: number | undefined;
} & { [K_4 in Exclude<keyof I, keyof ProcessTopologyRequest_Params>]: never; }>(object: I): ProcessTopologyRequest_Params;
};
export declare const ProcessTopologyResponse: {
encode(message: ProcessTopologyResponse, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ProcessTopologyResponse;
fromJSON(object: any): ProcessTopologyResponse;
toJSON(message: ProcessTopologyResponse): unknown;
fromPartial<I extends {
header?: {
requestHeader?: {
requestTimestamp?: Date | undefined;
clientName?: string | undefined;
disableRpcLogging?: boolean | undefined;
} | undefined;
requestReceivedTimestamp?: Date | undefined;
responseTimestamp?: Date | undefined;
error?: {
code?: import("../header").CommonError_Code | undefined;
message?: string | undefined;
data?: {
typeUrl?: string | undefined;
value?: Uint8Array | undefined;
} | undefined;
} | undefined;
request?: {
typeUrl?: string | undefined;
value?: Uint8Array | undefined;
} | undefined;
} | undefined;
status?: ProcessTopologyResponse_Status | undefined;
newSubgraph?: {
waypoints?: {
id?: string | undefined;
snapshotId?: string | undefined;
waypointTformKo?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
annotations?: {
name?: string | undefined;
creationTime?: Date | undefined;
icpVariance?: {
matrix?: {
rows?: number | undefined;
cols?: number | undefined;
values?: number[] | undefined;
} | undefined;
yawVariance?: number | undefined;
covXx?: number | undefined;
covXy?: number | undefined;
covXz?: number | undefined;
covYx?: number | undefined;
covYy?: number | undefined;
covYz?: number | undefined;
covZx?: number | undefined;
covZy?: number | undefined;
covZz?: number | undefined;
} | undefined;
scanMatchRegion?: {
state?: import("./map").AnnotationState | undefined;
defaultRegion?: {} | undefined;
empty?: {} | undefined;
circle?: {
dist2d?: number | undefined;
} | undefined;
} | undefined;
waypointSource?: import("./map").Waypoint_WaypointSource | undefined;
} | undefined;
}[] | undefined;
edges?: {
id?: {
fromWaypoint?: string | undefined;
toWaypoint?: string | undefined;
} | undefined;
snapshotId?: string | undefined;
fromTformTo?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
annotations?: {
velLimit?: {
maxVel?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angular?: number | undefined;
} | undefined;
minVel?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angular?: number | undefined;
} | undefined;
} | undefined;
stairs?: {
state?: import("./map").AnnotationState | undefined;
straightStaircase?: {
fromKoTformStairs?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
tform?: {
frameTformStairs?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
frameName?: string | undefined;
} | undefined;
stairs?: {
rise?: number | undefined;
run?: number | undefined;
}[] | undefined;
bottomLanding?: {
stairsTformLandingCenter?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
landingExtentX?: number | undefined;
landingExtentY?: number | undefined;
} | undefined;
topLanding?: {
stairsTformLandingCenter?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
landingExtentX?: number | undefined;
landingExtentY?: number | undefined;
} | undefined;
} | undefined;
} | undefined;
directionConstraint?: import("./map").Edge_Annotations_DirectionConstraint | undefined;
requireAlignment?: boolean | undefined;
flatGround?: boolean | undefined;
groundMuHint?: number | undefined;
gratedFloor?: boolean | undefined;
overrideMobilityParams?: string[] | undefined;
mobilityParams?: {
velLimit?: {
maxVel?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angular?: number | undefined;
} | undefined;
minVel?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angular?: number | undefined;
} | undefined;
} | undefined;
bodyControl?: {
baseOffsetRtFootprint?: {
points?: {
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
velocity?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
angular?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
posInterpol