spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
412 lines • 15.5 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.KeypointMatches = exports.Match = exports.KeypointSet = exports.Keypoint = exports.keypointSet_KeypointTypeToJSON = exports.keypointSet_KeypointTypeFromJSON = exports.KeypointSet_KeypointType = exports.protobufPackage = void 0;
/* eslint-disable */
const geometry_1 = require("./geometry");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
var KeypointSet_KeypointType;
(function (KeypointSet_KeypointType) {
KeypointSet_KeypointType[KeypointSet_KeypointType["KEYPOINT_UNKNOWN"] = 0] = "KEYPOINT_UNKNOWN";
/**
* KEYPOINT_SIMPLE - Keypoints that consist only of image coordinates. Simple keypoints do not have
* descriptors.
*/
KeypointSet_KeypointType[KeypointSet_KeypointType["KEYPOINT_SIMPLE"] = 1] = "KEYPOINT_SIMPLE";
/**
* KEYPOINT_ORB - Keypoints detected by the ORB feature extraction algorithm (Oriented FAST and Rotated
* BRIEF.)
*/
KeypointSet_KeypointType[KeypointSet_KeypointType["KEYPOINT_ORB"] = 2] = "KEYPOINT_ORB";
KeypointSet_KeypointType[KeypointSet_KeypointType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(KeypointSet_KeypointType = exports.KeypointSet_KeypointType || (exports.KeypointSet_KeypointType = {}));
function keypointSet_KeypointTypeFromJSON(object) {
switch (object) {
case 0:
case "KEYPOINT_UNKNOWN":
return KeypointSet_KeypointType.KEYPOINT_UNKNOWN;
case 1:
case "KEYPOINT_SIMPLE":
return KeypointSet_KeypointType.KEYPOINT_SIMPLE;
case 2:
case "KEYPOINT_ORB":
return KeypointSet_KeypointType.KEYPOINT_ORB;
case -1:
case "UNRECOGNIZED":
default:
return KeypointSet_KeypointType.UNRECOGNIZED;
}
}
exports.keypointSet_KeypointTypeFromJSON = keypointSet_KeypointTypeFromJSON;
function keypointSet_KeypointTypeToJSON(object) {
switch (object) {
case KeypointSet_KeypointType.KEYPOINT_UNKNOWN:
return "KEYPOINT_UNKNOWN";
case KeypointSet_KeypointType.KEYPOINT_SIMPLE:
return "KEYPOINT_SIMPLE";
case KeypointSet_KeypointType.KEYPOINT_ORB:
return "KEYPOINT_ORB";
case KeypointSet_KeypointType.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.keypointSet_KeypointTypeToJSON = keypointSet_KeypointTypeToJSON;
function createBaseKeypoint() {
return {
coordinates: undefined,
binaryDescriptor: new Uint8Array(),
score: 0,
size: 0,
angle: 0,
};
}
exports.Keypoint = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.coordinates !== undefined) {
geometry_1.Vec2.encode(message.coordinates, writer.uint32(18).fork()).ldelim();
}
if (message.binaryDescriptor.length !== 0) {
writer.uint32(26).bytes(message.binaryDescriptor);
}
if (message.score !== 0) {
writer.uint32(37).float(message.score);
}
if (message.size !== 0) {
writer.uint32(45).float(message.size);
}
if (message.angle !== 0) {
writer.uint32(53).float(message.angle);
}
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 = createBaseKeypoint();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 2:
message.coordinates = geometry_1.Vec2.decode(reader, reader.uint32());
break;
case 3:
message.binaryDescriptor = reader.bytes();
break;
case 4:
message.score = reader.float();
break;
case 5:
message.size = reader.float();
break;
case 6:
message.angle = reader.float();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
coordinates: isSet(object.coordinates)
? geometry_1.Vec2.fromJSON(object.coordinates)
: undefined,
binaryDescriptor: isSet(object.binaryDescriptor)
? bytesFromBase64(object.binaryDescriptor)
: new Uint8Array(),
score: isSet(object.score) ? Number(object.score) : 0,
size: isSet(object.size) ? Number(object.size) : 0,
angle: isSet(object.angle) ? Number(object.angle) : 0,
};
},
toJSON(message) {
const obj = {};
message.coordinates !== undefined &&
(obj.coordinates = message.coordinates
? geometry_1.Vec2.toJSON(message.coordinates)
: undefined);
message.binaryDescriptor !== undefined &&
(obj.binaryDescriptor = base64FromBytes(message.binaryDescriptor !== undefined
? message.binaryDescriptor
: new Uint8Array()));
message.score !== undefined && (obj.score = message.score);
message.size !== undefined && (obj.size = message.size);
message.angle !== undefined && (obj.angle = message.angle);
return obj;
},
fromPartial(object) {
const message = createBaseKeypoint();
message.coordinates =
object.coordinates !== undefined && object.coordinates !== null
? geometry_1.Vec2.fromPartial(object.coordinates)
: undefined;
message.binaryDescriptor = object.binaryDescriptor ?? new Uint8Array();
message.score = object.score ?? 0;
message.size = object.size ?? 0;
message.angle = object.angle ?? 0;
return message;
},
};
function createBaseKeypointSet() {
return { keypoints: [], type: 0 };
}
exports.KeypointSet = {
encode(message, writer = minimal_1.default.Writer.create()) {
for (const v of message.keypoints) {
exports.Keypoint.encode(v, writer.uint32(18).fork()).ldelim();
}
if (message.type !== 0) {
writer.uint32(24).int32(message.type);
}
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 = createBaseKeypointSet();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 2:
message.keypoints.push(exports.Keypoint.decode(reader, reader.uint32()));
break;
case 3:
message.type = reader.int32();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
keypoints: Array.isArray(object?.keypoints)
? object.keypoints.map((e) => exports.Keypoint.fromJSON(e))
: [],
type: isSet(object.type)
? keypointSet_KeypointTypeFromJSON(object.type)
: 0,
};
},
toJSON(message) {
const obj = {};
if (message.keypoints) {
obj.keypoints = message.keypoints.map((e) => e ? exports.Keypoint.toJSON(e) : undefined);
}
else {
obj.keypoints = [];
}
message.type !== undefined &&
(obj.type = keypointSet_KeypointTypeToJSON(message.type));
return obj;
},
fromPartial(object) {
const message = createBaseKeypointSet();
message.keypoints =
object.keypoints?.map((e) => exports.Keypoint.fromPartial(e)) || [];
message.type = object.type ?? 0;
return message;
},
};
function createBaseMatch() {
return { referenceIndex: 0, liveIndex: 0, distance: 0 };
}
exports.Match = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.referenceIndex !== 0) {
writer.uint32(16).int32(message.referenceIndex);
}
if (message.liveIndex !== 0) {
writer.uint32(24).int32(message.liveIndex);
}
if (message.distance !== 0) {
writer.uint32(37).float(message.distance);
}
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 = createBaseMatch();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 2:
message.referenceIndex = reader.int32();
break;
case 3:
message.liveIndex = reader.int32();
break;
case 4:
message.distance = reader.float();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
referenceIndex: isSet(object.referenceIndex)
? Number(object.referenceIndex)
: 0,
liveIndex: isSet(object.liveIndex) ? Number(object.liveIndex) : 0,
distance: isSet(object.distance) ? Number(object.distance) : 0,
};
},
toJSON(message) {
const obj = {};
message.referenceIndex !== undefined &&
(obj.referenceIndex = Math.round(message.referenceIndex));
message.liveIndex !== undefined &&
(obj.liveIndex = Math.round(message.liveIndex));
message.distance !== undefined && (obj.distance = message.distance);
return obj;
},
fromPartial(object) {
const message = createBaseMatch();
message.referenceIndex = object.referenceIndex ?? 0;
message.liveIndex = object.liveIndex ?? 0;
message.distance = object.distance ?? 0;
return message;
},
};
function createBaseKeypointMatches() {
return {
referenceKeypoints: undefined,
liveKeypoints: undefined,
matches: [],
};
}
exports.KeypointMatches = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.referenceKeypoints !== undefined) {
exports.KeypointSet.encode(message.referenceKeypoints, writer.uint32(18).fork()).ldelim();
}
if (message.liveKeypoints !== undefined) {
exports.KeypointSet.encode(message.liveKeypoints, writer.uint32(26).fork()).ldelim();
}
for (const v of message.matches) {
exports.Match.encode(v, 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 = createBaseKeypointMatches();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 2:
message.referenceKeypoints = exports.KeypointSet.decode(reader, reader.uint32());
break;
case 3:
message.liveKeypoints = exports.KeypointSet.decode(reader, reader.uint32());
break;
case 4:
message.matches.push(exports.Match.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
referenceKeypoints: isSet(object.referenceKeypoints)
? exports.KeypointSet.fromJSON(object.referenceKeypoints)
: undefined,
liveKeypoints: isSet(object.liveKeypoints)
? exports.KeypointSet.fromJSON(object.liveKeypoints)
: undefined,
matches: Array.isArray(object?.matches)
? object.matches.map((e) => exports.Match.fromJSON(e))
: [],
};
},
toJSON(message) {
const obj = {};
message.referenceKeypoints !== undefined &&
(obj.referenceKeypoints = message.referenceKeypoints
? exports.KeypointSet.toJSON(message.referenceKeypoints)
: undefined);
message.liveKeypoints !== undefined &&
(obj.liveKeypoints = message.liveKeypoints
? exports.KeypointSet.toJSON(message.liveKeypoints)
: undefined);
if (message.matches) {
obj.matches = message.matches.map((e) => e ? exports.Match.toJSON(e) : undefined);
}
else {
obj.matches = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseKeypointMatches();
message.referenceKeypoints =
object.referenceKeypoints !== undefined &&
object.referenceKeypoints !== null
? exports.KeypointSet.fromPartial(object.referenceKeypoints)
: undefined;
message.liveKeypoints =
object.liveKeypoints !== undefined && object.liveKeypoints !== null
? exports.KeypointSet.fromPartial(object.liveKeypoints)
: undefined;
message.matches = object.matches?.map((e) => exports.Match.fromPartial(e)) || [];
return message;
},
};
var globalThis = (() => {
if (typeof globalThis !== "undefined")
return globalThis;
if (typeof self !== "undefined")
return self;
if (typeof window !== "undefined")
return window;
if (typeof global !== "undefined")
return global;
throw "Unable to locate global object";
})();
function bytesFromBase64(b64) {
if (globalThis.Buffer) {
return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
}
else {
const bin = globalThis.atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
}
function base64FromBytes(arr) {
if (globalThis.Buffer) {
return globalThis.Buffer.from(arr).toString("base64");
}
else {
const bin = [];
arr.forEach((byte) => {
bin.push(String.fromCharCode(byte));
});
return globalThis.btoa(bin.join(""));
}
}
function isSet(value) {
return value !== null && value !== undefined;
}
//# sourceMappingURL=sparse_features.js.map