From cfdbfd73e6aac2f78fd6532ec52c702ef96f1659 Mon Sep 17 00:00:00 2001 From: Ivan Malison Date: Fri, 24 May 2024 14:28:41 -0600 Subject: [PATCH] Restructure protobuf/add annotations --- rbproto/python/shot_pb2.py | 28 +- rbproto/python/shot_pb2.pyi | 74 +++-- rbproto/shot.proto | 49 +++- rbproto/ts/shot.ts | 529 ++++++++++++++++++++++++++++++------ 4 files changed, 552 insertions(+), 128 deletions(-) diff --git a/rbproto/python/shot_pb2.py b/rbproto/python/shot_pb2.py index e6861d7..f57571f 100644 --- a/rbproto/python/shot_pb2.py +++ b/rbproto/python/shot_pb2.py @@ -13,19 +13,29 @@ _sym_db = _symbol_database.Default() -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nshot.proto\x12\x0fserialized_shot\",\n\x05Point\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\x12\r\n\x05\x63ount\x18\x03 \x01(\x05\"i\n\x04Path\x12\x13\n\x0bstart_frame\x18\x01 \x01(\x05\x12\x11\n\tend_frame\x18\x02 \x01(\x05\x12\x11\n\tis_static\x18\x03 \x01(\x08\x12&\n\x06points\x18\x04 \x03(\x0b\x32\x16.serialized_shot.Point\"J\n\tBallPaths\x12\x17\n\x0f\x62\x61ll_identifier\x18\x01 \x01(\x05\x12$\n\x05paths\x18\x02 \x03(\x0b\x32\x15.serialized_shot.Path\"^\n\x04Shot\x12\x13\n\x0bstart_frame\x18\x01 \x01(\x05\x12\x11\n\tend_frame\x18\x02 \x01(\x05\x12.\n\nball_paths\x18\x03 \x03(\x0b\x32\x1a.serialized_shot.BallPathsb\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nshot.proto\x12\x0fserialized_shot\"?\n\x03\x42ox\x12\x0c\n\x04left\x18\x01 \x01(\x02\x12\x0b\n\x03top\x18\x02 \x01(\x02\x12\r\n\x05width\x18\x03 \x01(\x02\x12\x0e\n\x06height\x18\x04 \x01(\x02\"\x1d\n\x05Point\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\"\x7f\n\rBallDetection\x12.\n\x0eplane_position\x18\x01 \x01(\x0b\x32\x16.serialized_shot.Point\x12(\n\nannotation\x18\x02 \x01(\x0b\x32\x14.serialized_shot.Box\x12\x14\n\x0cinterpolated\x18\x03 \x01(\x08\"T\n\x10RLEBallDetection\x12\x31\n\tdetection\x18\x01 \x01(\x0b\x32\x1e.serialized_shot.BallDetection\x12\r\n\x05\x63ount\x18\x02 \x01(\r\"L\n\x13RLEDetectionHistory\x12\x35\n\ndetections\x18\x01 \x03(\x0b\x32!.serialized_shot.RLEBallDetection\"F\n\x10\x44\x65tectionHistory\x12\x32\n\ndetections\x18\x01 \x03(\x0b\x32\x1e.serialized_shot.BallDetection\"\xcd\x01\n\x04Path\x12\x13\n\x0bstart_frame\x18\x01 \x01(\r\x12\x11\n\tend_frame\x18\x02 \x01(\r\x12\x34\n\ndetections\x18\x03 \x01(\x0b\x32\x1e.serialized_shot.BallDetectionH\x00\x12;\n\x0erle_detections\x18\x04 \x01(\x0b\x32!.serialized_shot.RLEBallDetectionH\x00\x12\x15\n\x0bnot_present\x18\x05 \x01(\x08H\x00\x42\x13\n\x11\x64\x65tection_history\"R\n\x11IdentifierHistory\x12\x17\n\x0f\x62\x61ll_identifier\x18\x01 \x01(\r\x12$\n\x05paths\x18\x02 \x03(\x0b\x32\x15.serialized_shot.Path\"H\n\x04Shot\x12@\n\x14identifier_histories\x18\x03 \x03(\x0b\x32\".serialized_shot.IdentifierHistoryb\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'shot_pb2', _globals) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None - _globals['_POINT']._serialized_start=31 - _globals['_POINT']._serialized_end=75 - _globals['_PATH']._serialized_start=77 - _globals['_PATH']._serialized_end=182 - _globals['_BALLPATHS']._serialized_start=184 - _globals['_BALLPATHS']._serialized_end=258 - _globals['_SHOT']._serialized_start=260 - _globals['_SHOT']._serialized_end=354 + _globals['_BOX']._serialized_start=31 + _globals['_BOX']._serialized_end=94 + _globals['_POINT']._serialized_start=96 + _globals['_POINT']._serialized_end=125 + _globals['_BALLDETECTION']._serialized_start=127 + _globals['_BALLDETECTION']._serialized_end=254 + _globals['_RLEBALLDETECTION']._serialized_start=256 + _globals['_RLEBALLDETECTION']._serialized_end=340 + _globals['_RLEDETECTIONHISTORY']._serialized_start=342 + _globals['_RLEDETECTIONHISTORY']._serialized_end=418 + _globals['_DETECTIONHISTORY']._serialized_start=420 + _globals['_DETECTIONHISTORY']._serialized_end=490 + _globals['_PATH']._serialized_start=493 + _globals['_PATH']._serialized_end=698 + _globals['_IDENTIFIERHISTORY']._serialized_start=700 + _globals['_IDENTIFIERHISTORY']._serialized_end=782 + _globals['_SHOT']._serialized_start=784 + _globals['_SHOT']._serialized_end=856 # @@protoc_insertion_point(module_scope) diff --git a/rbproto/python/shot_pb2.pyi b/rbproto/python/shot_pb2.pyi index 71354b1..49e4d7b 100644 --- a/rbproto/python/shot_pb2.pyi +++ b/rbproto/python/shot_pb2.pyi @@ -5,29 +5,71 @@ from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Map DESCRIPTOR: _descriptor.FileDescriptor +class Box(_message.Message): + __slots__ = ["left", "top", "width", "height"] + LEFT_FIELD_NUMBER: _ClassVar[int] + TOP_FIELD_NUMBER: _ClassVar[int] + WIDTH_FIELD_NUMBER: _ClassVar[int] + HEIGHT_FIELD_NUMBER: _ClassVar[int] + left: float + top: float + width: float + height: float + def __init__(self, left: _Optional[float] = ..., top: _Optional[float] = ..., width: _Optional[float] = ..., height: _Optional[float] = ...) -> None: ... + class Point(_message.Message): - __slots__ = ["x", "y", "count"] + __slots__ = ["x", "y"] X_FIELD_NUMBER: _ClassVar[int] Y_FIELD_NUMBER: _ClassVar[int] - COUNT_FIELD_NUMBER: _ClassVar[int] x: float y: float + def __init__(self, x: _Optional[float] = ..., y: _Optional[float] = ...) -> None: ... + +class BallDetection(_message.Message): + __slots__ = ["plane_position", "annotation", "interpolated"] + PLANE_POSITION_FIELD_NUMBER: _ClassVar[int] + ANNOTATION_FIELD_NUMBER: _ClassVar[int] + INTERPOLATED_FIELD_NUMBER: _ClassVar[int] + plane_position: Point + annotation: Box + interpolated: bool + def __init__(self, plane_position: _Optional[_Union[Point, _Mapping]] = ..., annotation: _Optional[_Union[Box, _Mapping]] = ..., interpolated: bool = ...) -> None: ... + +class RLEBallDetection(_message.Message): + __slots__ = ["detection", "count"] + DETECTION_FIELD_NUMBER: _ClassVar[int] + COUNT_FIELD_NUMBER: _ClassVar[int] + detection: BallDetection count: int - def __init__(self, x: _Optional[float] = ..., y: _Optional[float] = ..., count: _Optional[int] = ...) -> None: ... + def __init__(self, detection: _Optional[_Union[BallDetection, _Mapping]] = ..., count: _Optional[int] = ...) -> None: ... + +class RLEDetectionHistory(_message.Message): + __slots__ = ["detections"] + DETECTIONS_FIELD_NUMBER: _ClassVar[int] + detections: _containers.RepeatedCompositeFieldContainer[RLEBallDetection] + def __init__(self, detections: _Optional[_Iterable[_Union[RLEBallDetection, _Mapping]]] = ...) -> None: ... + +class DetectionHistory(_message.Message): + __slots__ = ["detections"] + DETECTIONS_FIELD_NUMBER: _ClassVar[int] + detections: _containers.RepeatedCompositeFieldContainer[BallDetection] + def __init__(self, detections: _Optional[_Iterable[_Union[BallDetection, _Mapping]]] = ...) -> None: ... class Path(_message.Message): - __slots__ = ["start_frame", "end_frame", "is_static", "points"] + __slots__ = ["start_frame", "end_frame", "detections", "rle_detections", "not_present"] START_FRAME_FIELD_NUMBER: _ClassVar[int] END_FRAME_FIELD_NUMBER: _ClassVar[int] - IS_STATIC_FIELD_NUMBER: _ClassVar[int] - POINTS_FIELD_NUMBER: _ClassVar[int] + DETECTIONS_FIELD_NUMBER: _ClassVar[int] + RLE_DETECTIONS_FIELD_NUMBER: _ClassVar[int] + NOT_PRESENT_FIELD_NUMBER: _ClassVar[int] start_frame: int end_frame: int - is_static: bool - points: _containers.RepeatedCompositeFieldContainer[Point] - def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., is_static: bool = ..., points: _Optional[_Iterable[_Union[Point, _Mapping]]] = ...) -> None: ... + detections: BallDetection + rle_detections: RLEBallDetection + not_present: bool + def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., detections: _Optional[_Union[BallDetection, _Mapping]] = ..., rle_detections: _Optional[_Union[RLEBallDetection, _Mapping]] = ..., not_present: bool = ...) -> None: ... -class BallPaths(_message.Message): +class IdentifierHistory(_message.Message): __slots__ = ["ball_identifier", "paths"] BALL_IDENTIFIER_FIELD_NUMBER: _ClassVar[int] PATHS_FIELD_NUMBER: _ClassVar[int] @@ -36,11 +78,7 @@ class BallPaths(_message.Message): def __init__(self, ball_identifier: _Optional[int] = ..., paths: _Optional[_Iterable[_Union[Path, _Mapping]]] = ...) -> None: ... class Shot(_message.Message): - __slots__ = ["start_frame", "end_frame", "ball_paths"] - START_FRAME_FIELD_NUMBER: _ClassVar[int] - END_FRAME_FIELD_NUMBER: _ClassVar[int] - BALL_PATHS_FIELD_NUMBER: _ClassVar[int] - start_frame: int - end_frame: int - ball_paths: _containers.RepeatedCompositeFieldContainer[BallPaths] - def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., ball_paths: _Optional[_Iterable[_Union[BallPaths, _Mapping]]] = ...) -> None: ... + __slots__ = ["identifier_histories"] + IDENTIFIER_HISTORIES_FIELD_NUMBER: _ClassVar[int] + identifier_histories: _containers.RepeatedCompositeFieldContainer[IdentifierHistory] + def __init__(self, identifier_histories: _Optional[_Iterable[_Union[IdentifierHistory, _Mapping]]] = ...) -> None: ... diff --git a/rbproto/shot.proto b/rbproto/shot.proto index 49933e3..61c7770 100644 --- a/rbproto/shot.proto +++ b/rbproto/shot.proto @@ -2,26 +2,53 @@ syntax = "proto3"; package serialized_shot; +message Box { + float left = 1; + float top = 2; + float width = 3; + float height = 4; +} + message Point { float x = 1; float y = 2; - int32 count = 3; +} + +message BallDetection { + Point plane_position = 1; + Box annotation = 2; + bool interpolated = 3; +} + +message RLEBallDetection { + BallDetection detection = 1; + uint32 count = 2; +} + +message RLEDetectionHistory { + repeated RLEBallDetection detections = 1; +} + +message DetectionHistory { + repeated BallDetection detections = 1; } message Path { - int32 start_frame = 1; - int32 end_frame = 2; - bool is_static = 3; - repeated Point points = 4; + uint32 start_frame = 1; + uint32 end_frame = 2; + oneof detection_history { + BallDetection detections = 3; + RLEBallDetection rle_detections = 4; + bool not_present = 5; + } + bool is_static = 6; } -message BallPaths { - int32 ball_identifier = 1; +message IdentifierHistory { + uint32 ball_identifier = 1; repeated Path paths = 2; } message Shot { - int32 start_frame = 1; - int32 end_frame = 2; - repeated BallPaths ball_paths = 3; -} \ No newline at end of file + repeated IdentifierHistory identifier_histories = 3; +} diff --git a/rbproto/ts/shot.ts b/rbproto/ts/shot.ts index fcb9b2a..cef6ab2 100644 --- a/rbproto/ts/shot.ts +++ b/rbproto/ts/shot.ts @@ -1,7 +1,95 @@ +export interface Box { + left?: number; + top?: number; + width?: number; + height?: number; +} + +export function encodeBox(message: Box): Uint8Array { + let bb = popByteBuffer(); + _encodeBox(message, bb); + return toUint8Array(bb); +} + +function _encodeBox(message: Box, bb: ByteBuffer): void { + // optional float left = 1; + let $left = message.left; + if ($left !== undefined) { + writeVarint32(bb, 13); + writeFloat(bb, $left); + } + + // optional float top = 2; + let $top = message.top; + if ($top !== undefined) { + writeVarint32(bb, 21); + writeFloat(bb, $top); + } + + // optional float width = 3; + let $width = message.width; + if ($width !== undefined) { + writeVarint32(bb, 29); + writeFloat(bb, $width); + } + + // optional float height = 4; + let $height = message.height; + if ($height !== undefined) { + writeVarint32(bb, 37); + writeFloat(bb, $height); + } +} + +export function decodeBox(binary: Uint8Array): Box { + return _decodeBox(wrapByteBuffer(binary)); +} + +function _decodeBox(bb: ByteBuffer): Box { + let message: Box = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // optional float left = 1; + case 1: { + message.left = readFloat(bb); + break; + } + + // optional float top = 2; + case 2: { + message.top = readFloat(bb); + break; + } + + // optional float width = 3; + case 3: { + message.width = readFloat(bb); + break; + } + + // optional float height = 4; + case 4: { + message.height = readFloat(bb); + break; + } + + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + export interface Point { x?: number; y?: number; - count?: number; } export function encodePoint(message: Point): Uint8Array { @@ -24,13 +112,6 @@ function _encodePoint(message: Point, bb: ByteBuffer): void { writeVarint32(bb, 21); writeFloat(bb, $y); } - - // optional int32 count = 3; - let $count = message.count; - if ($count !== undefined) { - writeVarint32(bb, 24); - writeVarint64(bb, intToLong($count)); - } } export function decodePoint(binary: Uint8Array): Point { @@ -59,9 +140,282 @@ function _decodePoint(bb: ByteBuffer): Point { break; } - // optional int32 count = 3; + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + +export interface BallDetection { + plane_position?: Point; + annotation?: Box; + interpolated?: boolean; +} + +export function encodeBallDetection(message: BallDetection): Uint8Array { + let bb = popByteBuffer(); + _encodeBallDetection(message, bb); + return toUint8Array(bb); +} + +function _encodeBallDetection(message: BallDetection, bb: ByteBuffer): void { + // optional Point plane_position = 1; + let $plane_position = message.plane_position; + if ($plane_position !== undefined) { + writeVarint32(bb, 10); + let nested = popByteBuffer(); + _encodePoint($plane_position, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + + // optional Box annotation = 2; + let $annotation = message.annotation; + if ($annotation !== undefined) { + writeVarint32(bb, 18); + let nested = popByteBuffer(); + _encodeBox($annotation, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + + // optional bool interpolated = 3; + let $interpolated = message.interpolated; + if ($interpolated !== undefined) { + writeVarint32(bb, 24); + writeByte(bb, $interpolated ? 1 : 0); + } +} + +export function decodeBallDetection(binary: Uint8Array): BallDetection { + return _decodeBallDetection(wrapByteBuffer(binary)); +} + +function _decodeBallDetection(bb: ByteBuffer): BallDetection { + let message: BallDetection = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // optional Point plane_position = 1; + case 1: { + let limit = pushTemporaryLength(bb); + message.plane_position = _decodePoint(bb); + bb.limit = limit; + break; + } + + // optional Box annotation = 2; + case 2: { + let limit = pushTemporaryLength(bb); + message.annotation = _decodeBox(bb); + bb.limit = limit; + break; + } + + // optional bool interpolated = 3; case 3: { - message.count = readVarint32(bb); + message.interpolated = !!readByte(bb); + break; + } + + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + +export interface RLEBallDetection { + detection?: BallDetection; + count?: number; +} + +export function encodeRLEBallDetection(message: RLEBallDetection): Uint8Array { + let bb = popByteBuffer(); + _encodeRLEBallDetection(message, bb); + return toUint8Array(bb); +} + +function _encodeRLEBallDetection( + message: RLEBallDetection, + bb: ByteBuffer, +): void { + // optional BallDetection detection = 1; + let $detection = message.detection; + if ($detection !== undefined) { + writeVarint32(bb, 10); + let nested = popByteBuffer(); + _encodeBallDetection($detection, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + + // optional uint32 count = 2; + let $count = message.count; + if ($count !== undefined) { + writeVarint32(bb, 16); + writeVarint32(bb, $count); + } +} + +export function decodeRLEBallDetection(binary: Uint8Array): RLEBallDetection { + return _decodeRLEBallDetection(wrapByteBuffer(binary)); +} + +function _decodeRLEBallDetection(bb: ByteBuffer): RLEBallDetection { + let message: RLEBallDetection = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // optional BallDetection detection = 1; + case 1: { + let limit = pushTemporaryLength(bb); + message.detection = _decodeBallDetection(bb); + bb.limit = limit; + break; + } + + // optional uint32 count = 2; + case 2: { + message.count = readVarint32(bb) >>> 0; + break; + } + + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + +export interface RLEDetectionHistory { + detections?: RLEBallDetection[]; +} + +export function encodeRLEDetectionHistory( + message: RLEDetectionHistory, +): Uint8Array { + let bb = popByteBuffer(); + _encodeRLEDetectionHistory(message, bb); + return toUint8Array(bb); +} + +function _encodeRLEDetectionHistory( + message: RLEDetectionHistory, + bb: ByteBuffer, +): void { + // repeated RLEBallDetection detections = 1; + let array$detections = message.detections; + if (array$detections !== undefined) { + for (let value of array$detections) { + writeVarint32(bb, 10); + let nested = popByteBuffer(); + _encodeRLEBallDetection(value, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + } +} + +export function decodeRLEDetectionHistory( + binary: Uint8Array, +): RLEDetectionHistory { + return _decodeRLEDetectionHistory(wrapByteBuffer(binary)); +} + +function _decodeRLEDetectionHistory(bb: ByteBuffer): RLEDetectionHistory { + let message: RLEDetectionHistory = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // repeated RLEBallDetection detections = 1; + case 1: { + let limit = pushTemporaryLength(bb); + let values = message.detections || (message.detections = []); + values.push(_decodeRLEBallDetection(bb)); + bb.limit = limit; + break; + } + + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + +export interface DetectionHistory { + detections?: BallDetection[]; +} + +export function encodeDetectionHistory(message: DetectionHistory): Uint8Array { + let bb = popByteBuffer(); + _encodeDetectionHistory(message, bb); + return toUint8Array(bb); +} + +function _encodeDetectionHistory( + message: DetectionHistory, + bb: ByteBuffer, +): void { + // repeated BallDetection detections = 1; + let array$detections = message.detections; + if (array$detections !== undefined) { + for (let value of array$detections) { + writeVarint32(bb, 10); + let nested = popByteBuffer(); + _encodeBallDetection(value, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + } +} + +export function decodeDetectionHistory(binary: Uint8Array): DetectionHistory { + return _decodeDetectionHistory(wrapByteBuffer(binary)); +} + +function _decodeDetectionHistory(bb: ByteBuffer): DetectionHistory { + let message: DetectionHistory = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // repeated BallDetection detections = 1; + case 1: { + let limit = pushTemporaryLength(bb); + let values = message.detections || (message.detections = []); + values.push(_decodeBallDetection(bb)); + bb.limit = limit; break; } @@ -76,8 +430,9 @@ function _decodePoint(bb: ByteBuffer): Point { export interface Path { start_frame?: number; end_frame?: number; - is_static?: boolean; - points?: Point[]; + detections?: BallDetection; + rle_detections?: RLEBallDetection; + not_present?: boolean; } export function encodePath(message: Path): Uint8Array { @@ -87,38 +442,47 @@ export function encodePath(message: Path): Uint8Array { } function _encodePath(message: Path, bb: ByteBuffer): void { - // optional int32 start_frame = 1; + // optional uint32 start_frame = 1; let $start_frame = message.start_frame; if ($start_frame !== undefined) { writeVarint32(bb, 8); - writeVarint64(bb, intToLong($start_frame)); + writeVarint32(bb, $start_frame); } - // optional int32 end_frame = 2; + // optional uint32 end_frame = 2; let $end_frame = message.end_frame; if ($end_frame !== undefined) { writeVarint32(bb, 16); - writeVarint64(bb, intToLong($end_frame)); + writeVarint32(bb, $end_frame); } - // optional bool is_static = 3; - let $is_static = message.is_static; - if ($is_static !== undefined) { - writeVarint32(bb, 24); - writeByte(bb, $is_static ? 1 : 0); + // optional BallDetection detections = 3; + let $detections = message.detections; + if ($detections !== undefined) { + writeVarint32(bb, 26); + let nested = popByteBuffer(); + _encodeBallDetection($detections, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); } - // repeated Point points = 4; - let array$points = message.points; - if (array$points !== undefined) { - for (let value of array$points) { - writeVarint32(bb, 34); - let nested = popByteBuffer(); - _encodePoint(value, nested); - writeVarint32(bb, nested.limit); - writeByteBuffer(bb, nested); - pushByteBuffer(nested); - } + // optional RLEBallDetection rle_detections = 4; + let $rle_detections = message.rle_detections; + if ($rle_detections !== undefined) { + writeVarint32(bb, 34); + let nested = popByteBuffer(); + _encodeRLEBallDetection($rle_detections, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + + // optional bool not_present = 5; + let $not_present = message.not_present; + if ($not_present !== undefined) { + writeVarint32(bb, 40); + writeByte(bb, $not_present ? 1 : 0); } } @@ -136,33 +500,40 @@ function _decodePath(bb: ByteBuffer): Path { case 0: break end_of_message; - // optional int32 start_frame = 1; + // optional uint32 start_frame = 1; case 1: { - message.start_frame = readVarint32(bb); + message.start_frame = readVarint32(bb) >>> 0; break; } - // optional int32 end_frame = 2; + // optional uint32 end_frame = 2; case 2: { - message.end_frame = readVarint32(bb); + message.end_frame = readVarint32(bb) >>> 0; break; } - // optional bool is_static = 3; + // optional BallDetection detections = 3; case 3: { - message.is_static = !!readByte(bb); + let limit = pushTemporaryLength(bb); + message.detections = _decodeBallDetection(bb); + bb.limit = limit; break; } - // repeated Point points = 4; + // optional RLEBallDetection rle_detections = 4; case 4: { let limit = pushTemporaryLength(bb); - let values = message.points || (message.points = []); - values.push(_decodePoint(bb)); + message.rle_detections = _decodeRLEBallDetection(bb); bb.limit = limit; break; } + // optional bool not_present = 5; + case 5: { + message.not_present = !!readByte(bb); + break; + } + default: skipUnknownField(bb, tag & 7); } @@ -171,23 +542,28 @@ function _decodePath(bb: ByteBuffer): Path { return message; } -export interface BallPaths { +export interface IdentifierHistory { ball_identifier?: number; paths?: Path[]; } -export function encodeBallPaths(message: BallPaths): Uint8Array { +export function encodeIdentifierHistory( + message: IdentifierHistory, +): Uint8Array { let bb = popByteBuffer(); - _encodeBallPaths(message, bb); + _encodeIdentifierHistory(message, bb); return toUint8Array(bb); } -function _encodeBallPaths(message: BallPaths, bb: ByteBuffer): void { - // optional int32 ball_identifier = 1; +function _encodeIdentifierHistory( + message: IdentifierHistory, + bb: ByteBuffer, +): void { + // optional uint32 ball_identifier = 1; let $ball_identifier = message.ball_identifier; if ($ball_identifier !== undefined) { writeVarint32(bb, 8); - writeVarint64(bb, intToLong($ball_identifier)); + writeVarint32(bb, $ball_identifier); } // repeated Path paths = 2; @@ -204,12 +580,12 @@ function _encodeBallPaths(message: BallPaths, bb: ByteBuffer): void { } } -export function decodeBallPaths(binary: Uint8Array): BallPaths { - return _decodeBallPaths(wrapByteBuffer(binary)); +export function decodeIdentifierHistory(binary: Uint8Array): IdentifierHistory { + return _decodeIdentifierHistory(wrapByteBuffer(binary)); } -function _decodeBallPaths(bb: ByteBuffer): BallPaths { - let message: BallPaths = {} as any; +function _decodeIdentifierHistory(bb: ByteBuffer): IdentifierHistory { + let message: IdentifierHistory = {} as any; end_of_message: while (!isAtEnd(bb)) { let tag = readVarint32(bb); @@ -218,9 +594,9 @@ function _decodeBallPaths(bb: ByteBuffer): BallPaths { case 0: break end_of_message; - // optional int32 ball_identifier = 1; + // optional uint32 ball_identifier = 1; case 1: { - message.ball_identifier = readVarint32(bb); + message.ball_identifier = readVarint32(bb) >>> 0; break; } @@ -242,9 +618,7 @@ function _decodeBallPaths(bb: ByteBuffer): BallPaths { } export interface Shot { - start_frame?: number; - end_frame?: number; - ball_paths?: BallPaths[]; + identifier_histories?: IdentifierHistory[]; } export function encodeShot(message: Shot): Uint8Array { @@ -254,27 +628,13 @@ export function encodeShot(message: Shot): Uint8Array { } function _encodeShot(message: Shot, bb: ByteBuffer): void { - // optional int32 start_frame = 1; - let $start_frame = message.start_frame; - if ($start_frame !== undefined) { - writeVarint32(bb, 8); - writeVarint64(bb, intToLong($start_frame)); - } - - // optional int32 end_frame = 2; - let $end_frame = message.end_frame; - if ($end_frame !== undefined) { - writeVarint32(bb, 16); - writeVarint64(bb, intToLong($end_frame)); - } - - // repeated BallPaths ball_paths = 3; - let array$ball_paths = message.ball_paths; - if (array$ball_paths !== undefined) { - for (let value of array$ball_paths) { + // repeated IdentifierHistory identifier_histories = 3; + let array$identifier_histories = message.identifier_histories; + if (array$identifier_histories !== undefined) { + for (let value of array$identifier_histories) { writeVarint32(bb, 26); let nested = popByteBuffer(); - _encodeBallPaths(value, nested); + _encodeIdentifierHistory(value, nested); writeVarint32(bb, nested.limit); writeByteBuffer(bb, nested); pushByteBuffer(nested); @@ -296,23 +656,12 @@ function _decodeShot(bb: ByteBuffer): Shot { case 0: break end_of_message; - // optional int32 start_frame = 1; - case 1: { - message.start_frame = readVarint32(bb); - break; - } - - // optional int32 end_frame = 2; - case 2: { - message.end_frame = readVarint32(bb); - break; - } - - // repeated BallPaths ball_paths = 3; + // repeated IdentifierHistory identifier_histories = 3; case 3: { let limit = pushTemporaryLength(bb); - let values = message.ball_paths || (message.ball_paths = []); - values.push(_decodeBallPaths(bb)); + let values = + message.identifier_histories || (message.identifier_histories = []); + values.push(_decodeIdentifierHistory(bb)); bb.limit = limit; break; }