spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
447 lines • 18.9 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RaycastResponse = exports.RayIntersection = exports.RaycastRequest = exports.raycastResponse_StatusToJSON = exports.raycastResponse_StatusFromJSON = exports.RaycastResponse_Status = exports.rayIntersection_TypeToJSON = exports.rayIntersection_TypeFromJSON = exports.RayIntersection_Type = exports.protobufPackage = void 0;
/* eslint-disable */
const header_1 = require("./header");
const geometry_1 = require("./geometry");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
var RayIntersection_Type;
(function (RayIntersection_Type) {
/** TYPE_UNKNOWN - TYPE_UNKNOWN should not be used. */
RayIntersection_Type[RayIntersection_Type["TYPE_UNKNOWN"] = 0] = "TYPE_UNKNOWN";
/** TYPE_GROUND_PLANE - Intersected against estimated ground plane. */
RayIntersection_Type[RayIntersection_Type["TYPE_GROUND_PLANE"] = 1] = "TYPE_GROUND_PLANE";
/** TYPE_TERRAIN_MAP - Intersected against the terrain map. */
RayIntersection_Type[RayIntersection_Type["TYPE_TERRAIN_MAP"] = 2] = "TYPE_TERRAIN_MAP";
/** TYPE_VOXEL_MAP - Intersected against the full 3D voxel map. */
RayIntersection_Type[RayIntersection_Type["TYPE_VOXEL_MAP"] = 3] = "TYPE_VOXEL_MAP";
/** TYPE_HAND_DEPTH - Intersected against the hand depth data. */
RayIntersection_Type[RayIntersection_Type["TYPE_HAND_DEPTH"] = 4] = "TYPE_HAND_DEPTH";
RayIntersection_Type[RayIntersection_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(RayIntersection_Type = exports.RayIntersection_Type || (exports.RayIntersection_Type = {}));
function rayIntersection_TypeFromJSON(object) {
switch (object) {
case 0:
case "TYPE_UNKNOWN":
return RayIntersection_Type.TYPE_UNKNOWN;
case 1:
case "TYPE_GROUND_PLANE":
return RayIntersection_Type.TYPE_GROUND_PLANE;
case 2:
case "TYPE_TERRAIN_MAP":
return RayIntersection_Type.TYPE_TERRAIN_MAP;
case 3:
case "TYPE_VOXEL_MAP":
return RayIntersection_Type.TYPE_VOXEL_MAP;
case 4:
case "TYPE_HAND_DEPTH":
return RayIntersection_Type.TYPE_HAND_DEPTH;
case -1:
case "UNRECOGNIZED":
default:
return RayIntersection_Type.UNRECOGNIZED;
}
}
exports.rayIntersection_TypeFromJSON = rayIntersection_TypeFromJSON;
function rayIntersection_TypeToJSON(object) {
switch (object) {
case RayIntersection_Type.TYPE_UNKNOWN:
return "TYPE_UNKNOWN";
case RayIntersection_Type.TYPE_GROUND_PLANE:
return "TYPE_GROUND_PLANE";
case RayIntersection_Type.TYPE_TERRAIN_MAP:
return "TYPE_TERRAIN_MAP";
case RayIntersection_Type.TYPE_VOXEL_MAP:
return "TYPE_VOXEL_MAP";
case RayIntersection_Type.TYPE_HAND_DEPTH:
return "TYPE_HAND_DEPTH";
case RayIntersection_Type.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.rayIntersection_TypeToJSON = rayIntersection_TypeToJSON;
var RaycastResponse_Status;
(function (RaycastResponse_Status) {
/** STATUS_UNKNOWN - An unknown / unexpected error occurred. */
RaycastResponse_Status[RaycastResponse_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
/** STATUS_OK - Request was accepted. */
RaycastResponse_Status[RaycastResponse_Status["STATUS_OK"] = 1] = "STATUS_OK";
/** STATUS_INVALID_REQUEST - [Programming Error] Request was invalid / malformed in some way. */
RaycastResponse_Status[RaycastResponse_Status["STATUS_INVALID_REQUEST"] = 2] = "STATUS_INVALID_REQUEST";
/** STATUS_INVALID_INTERSECTION_TYPE - [Programming Error] Requested source not valid for current robot configuration. */
RaycastResponse_Status[RaycastResponse_Status["STATUS_INVALID_INTERSECTION_TYPE"] = 3] = "STATUS_INVALID_INTERSECTION_TYPE";
/** STATUS_UNKNOWN_FRAME - [Frame Error] The frame_name for a command was not a known frame. */
RaycastResponse_Status[RaycastResponse_Status["STATUS_UNKNOWN_FRAME"] = 4] = "STATUS_UNKNOWN_FRAME";
RaycastResponse_Status[RaycastResponse_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(RaycastResponse_Status = exports.RaycastResponse_Status || (exports.RaycastResponse_Status = {}));
function raycastResponse_StatusFromJSON(object) {
switch (object) {
case 0:
case "STATUS_UNKNOWN":
return RaycastResponse_Status.STATUS_UNKNOWN;
case 1:
case "STATUS_OK":
return RaycastResponse_Status.STATUS_OK;
case 2:
case "STATUS_INVALID_REQUEST":
return RaycastResponse_Status.STATUS_INVALID_REQUEST;
case 3:
case "STATUS_INVALID_INTERSECTION_TYPE":
return RaycastResponse_Status.STATUS_INVALID_INTERSECTION_TYPE;
case 4:
case "STATUS_UNKNOWN_FRAME":
return RaycastResponse_Status.STATUS_UNKNOWN_FRAME;
case -1:
case "UNRECOGNIZED":
default:
return RaycastResponse_Status.UNRECOGNIZED;
}
}
exports.raycastResponse_StatusFromJSON = raycastResponse_StatusFromJSON;
function raycastResponse_StatusToJSON(object) {
switch (object) {
case RaycastResponse_Status.STATUS_UNKNOWN:
return "STATUS_UNKNOWN";
case RaycastResponse_Status.STATUS_OK:
return "STATUS_OK";
case RaycastResponse_Status.STATUS_INVALID_REQUEST:
return "STATUS_INVALID_REQUEST";
case RaycastResponse_Status.STATUS_INVALID_INTERSECTION_TYPE:
return "STATUS_INVALID_INTERSECTION_TYPE";
case RaycastResponse_Status.STATUS_UNKNOWN_FRAME:
return "STATUS_UNKNOWN_FRAME";
case RaycastResponse_Status.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.raycastResponse_StatusToJSON = raycastResponse_StatusToJSON;
function createBaseRaycastRequest() {
return {
header: undefined,
rayFrameName: "",
ray: undefined,
minIntersectionDistance: 0,
intersectionTypes: [],
};
}
exports.RaycastRequest = {
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.rayFrameName !== "") {
writer.uint32(42).string(message.rayFrameName);
}
if (message.ray !== undefined) {
geometry_1.Ray.encode(message.ray, writer.uint32(18).fork()).ldelim();
}
if (message.minIntersectionDistance !== 0) {
writer.uint32(37).float(message.minIntersectionDistance);
}
writer.uint32(58).fork();
for (const v of message.intersectionTypes) {
writer.int32(v);
}
writer.ldelim();
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseRaycastRequest();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.header = header_1.RequestHeader.decode(reader, reader.uint32());
break;
case 5:
message.rayFrameName = reader.string();
break;
case 2:
message.ray = geometry_1.Ray.decode(reader, reader.uint32());
break;
case 4:
message.minIntersectionDistance = reader.float();
break;
case 7:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.intersectionTypes.push(reader.int32());
}
}
else {
message.intersectionTypes.push(reader.int32());
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
header: isSet(object.header)
? header_1.RequestHeader.fromJSON(object.header)
: undefined,
rayFrameName: isSet(object.rayFrameName)
? String(object.rayFrameName)
: "",
ray: isSet(object.ray) ? geometry_1.Ray.fromJSON(object.ray) : undefined,
minIntersectionDistance: isSet(object.minIntersectionDistance)
? Number(object.minIntersectionDistance)
: 0,
intersectionTypes: Array.isArray(object?.intersectionTypes)
? object.intersectionTypes.map((e) => rayIntersection_TypeFromJSON(e))
: [],
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.RequestHeader.toJSON(message.header)
: undefined);
message.rayFrameName !== undefined &&
(obj.rayFrameName = message.rayFrameName);
message.ray !== undefined &&
(obj.ray = message.ray ? geometry_1.Ray.toJSON(message.ray) : undefined);
message.minIntersectionDistance !== undefined &&
(obj.minIntersectionDistance = message.minIntersectionDistance);
if (message.intersectionTypes) {
obj.intersectionTypes = message.intersectionTypes.map((e) => rayIntersection_TypeToJSON(e));
}
else {
obj.intersectionTypes = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseRaycastRequest();
message.header =
object.header !== undefined && object.header !== null
? header_1.RequestHeader.fromPartial(object.header)
: undefined;
message.rayFrameName = object.rayFrameName ?? "";
message.ray =
object.ray !== undefined && object.ray !== null
? geometry_1.Ray.fromPartial(object.ray)
: undefined;
message.minIntersectionDistance = object.minIntersectionDistance ?? 0;
message.intersectionTypes = object.intersectionTypes?.map((e) => e) || [];
return message;
},
};
function createBaseRayIntersection() {
return { type: 0, hitPositionInHitFrame: undefined, distanceMeters: 0 };
}
exports.RayIntersection = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.type !== 0) {
writer.uint32(8).int32(message.type);
}
if (message.hitPositionInHitFrame !== undefined) {
geometry_1.Vec3.encode(message.hitPositionInHitFrame, writer.uint32(18).fork()).ldelim();
}
if (message.distanceMeters !== 0) {
writer.uint32(25).double(message.distanceMeters);
}
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 = createBaseRayIntersection();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.type = reader.int32();
break;
case 2:
message.hitPositionInHitFrame = geometry_1.Vec3.decode(reader, reader.uint32());
break;
case 3:
message.distanceMeters = reader.double();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
type: isSet(object.type) ? rayIntersection_TypeFromJSON(object.type) : 0,
hitPositionInHitFrame: isSet(object.hitPositionInHitFrame)
? geometry_1.Vec3.fromJSON(object.hitPositionInHitFrame)
: undefined,
distanceMeters: isSet(object.distanceMeters)
? Number(object.distanceMeters)
: 0,
};
},
toJSON(message) {
const obj = {};
message.type !== undefined &&
(obj.type = rayIntersection_TypeToJSON(message.type));
message.hitPositionInHitFrame !== undefined &&
(obj.hitPositionInHitFrame = message.hitPositionInHitFrame
? geometry_1.Vec3.toJSON(message.hitPositionInHitFrame)
: undefined);
message.distanceMeters !== undefined &&
(obj.distanceMeters = message.distanceMeters);
return obj;
},
fromPartial(object) {
const message = createBaseRayIntersection();
message.type = object.type ?? 0;
message.hitPositionInHitFrame =
object.hitPositionInHitFrame !== undefined &&
object.hitPositionInHitFrame !== null
? geometry_1.Vec3.fromPartial(object.hitPositionInHitFrame)
: undefined;
message.distanceMeters = object.distanceMeters ?? 0;
return message;
},
};
function createBaseRaycastResponse() {
return {
header: undefined,
status: 0,
message: "",
hitFrameName: "",
hits: [],
transformsSnapshot: undefined,
};
}
exports.RaycastResponse = {
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(40).int32(message.status);
}
if (message.message !== "") {
writer.uint32(50).string(message.message);
}
if (message.hitFrameName !== "") {
writer.uint32(26).string(message.hitFrameName);
}
for (const v of message.hits) {
exports.RayIntersection.encode(v, writer.uint32(18).fork()).ldelim();
}
if (message.transformsSnapshot !== undefined) {
geometry_1.FrameTreeSnapshot.encode(message.transformsSnapshot, 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 = createBaseRaycastResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.header = header_1.ResponseHeader.decode(reader, reader.uint32());
break;
case 5:
message.status = reader.int32();
break;
case 6:
message.message = reader.string();
break;
case 3:
message.hitFrameName = reader.string();
break;
case 2:
message.hits.push(exports.RayIntersection.decode(reader, reader.uint32()));
break;
case 4:
message.transformsSnapshot = geometry_1.FrameTreeSnapshot.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
header: isSet(object.header)
? header_1.ResponseHeader.fromJSON(object.header)
: undefined,
status: isSet(object.status)
? raycastResponse_StatusFromJSON(object.status)
: 0,
message: isSet(object.message) ? String(object.message) : "",
hitFrameName: isSet(object.hitFrameName)
? String(object.hitFrameName)
: "",
hits: Array.isArray(object?.hits)
? object.hits.map((e) => exports.RayIntersection.fromJSON(e))
: [],
transformsSnapshot: isSet(object.transformsSnapshot)
? geometry_1.FrameTreeSnapshot.fromJSON(object.transformsSnapshot)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.ResponseHeader.toJSON(message.header)
: undefined);
message.status !== undefined &&
(obj.status = raycastResponse_StatusToJSON(message.status));
message.message !== undefined && (obj.message = message.message);
message.hitFrameName !== undefined &&
(obj.hitFrameName = message.hitFrameName);
if (message.hits) {
obj.hits = message.hits.map((e) => e ? exports.RayIntersection.toJSON(e) : undefined);
}
else {
obj.hits = [];
}
message.transformsSnapshot !== undefined &&
(obj.transformsSnapshot = message.transformsSnapshot
? geometry_1.FrameTreeSnapshot.toJSON(message.transformsSnapshot)
: undefined);
return obj;
},
fromPartial(object) {
const message = createBaseRaycastResponse();
message.header =
object.header !== undefined && object.header !== null
? header_1.ResponseHeader.fromPartial(object.header)
: undefined;
message.status = object.status ?? 0;
message.message = object.message ?? "";
message.hitFrameName = object.hitFrameName ?? "";
message.hits =
object.hits?.map((e) => exports.RayIntersection.fromPartial(e)) || [];
message.transformsSnapshot =
object.transformsSnapshot !== undefined &&
object.transformsSnapshot !== null
? geometry_1.FrameTreeSnapshot.fromPartial(object.transformsSnapshot)
: undefined;
return message;
},
};
function isSet(value) {
return value !== null && value !== undefined;
}
//# sourceMappingURL=ray_cast.js.map