1#![allow(unknown_lints)]
6#![allow(clippy::all)]
7
8#![allow(unused_attributes)]
9#![cfg_attr(rustfmt, rustfmt::skip)]
10
11#![allow(box_pointers)]
12#![allow(dead_code)]
13#![allow(missing_docs)]
14#![allow(non_camel_case_types)]
15#![allow(non_snake_case)]
16#![allow(non_upper_case_globals)]
17#![allow(trivial_casts)]
18#![allow(unused_imports)]
19#![allow(unused_results)]
20#[derive(PartialEq,Clone,Default)]
27pub struct Point {
28 pub x: f32,
30 pub y: f32,
31 pub unknown_fields: ::protobuf::UnknownFields,
33 pub cached_size: ::protobuf::CachedSize,
34}
35
36impl<'a> ::std::default::Default for &'a Point {
37 fn default() -> &'a Point {
38 <Point as ::protobuf::Message>::default_instance()
39 }
40}
41
42impl Point {
43 pub fn new() -> Point {
44 ::std::default::Default::default()
45 }
46
47 pub fn get_x(&self) -> f32 {
51 self.x
52 }
53 pub fn clear_x(&mut self) {
54 self.x = 0.;
55 }
56
57 pub fn set_x(&mut self, v: f32) {
59 self.x = v;
60 }
61
62 pub fn get_y(&self) -> f32 {
66 self.y
67 }
68 pub fn clear_y(&mut self) {
69 self.y = 0.;
70 }
71
72 pub fn set_y(&mut self, v: f32) {
74 self.y = v;
75 }
76}
77
78impl ::protobuf::Message for Point {
79 fn is_initialized(&self) -> bool {
80 true
81 }
82
83 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
84 while !is.eof()? {
85 let (field_number, wire_type) = is.read_tag_unpack()?;
86 match field_number {
87 1 => {
88 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
89 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
90 }
91 let tmp = is.read_float()?;
92 self.x = tmp;
93 },
94 2 => {
95 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
96 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
97 }
98 let tmp = is.read_float()?;
99 self.y = tmp;
100 },
101 _ => {
102 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
103 },
104 };
105 }
106 ::std::result::Result::Ok(())
107 }
108
109 #[allow(unused_variables)]
111 fn compute_size(&self) -> u32 {
112 let mut my_size = 0;
113 if self.x != 0. {
114 my_size += 5;
115 }
116 if self.y != 0. {
117 my_size += 5;
118 }
119 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
120 self.cached_size.set(my_size);
121 my_size
122 }
123
124 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
125 if self.x != 0. {
126 os.write_float(1, self.x)?;
127 }
128 if self.y != 0. {
129 os.write_float(2, self.y)?;
130 }
131 os.write_unknown_fields(self.get_unknown_fields())?;
132 ::std::result::Result::Ok(())
133 }
134
135 fn get_cached_size(&self) -> u32 {
136 self.cached_size.get()
137 }
138
139 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
140 &self.unknown_fields
141 }
142
143 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
144 &mut self.unknown_fields
145 }
146
147 fn as_any(&self) -> &dyn (::std::any::Any) {
148 self as &dyn (::std::any::Any)
149 }
150 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
151 self as &mut dyn (::std::any::Any)
152 }
153 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
154 self
155 }
156
157 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
158 Self::descriptor_static()
159 }
160
161 fn new() -> Point {
162 Point::new()
163 }
164
165 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
166 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
167 descriptor.get(|| {
168 let mut fields = ::std::vec::Vec::new();
169 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
170 "x",
171 |m: &Point| { &m.x },
172 |m: &mut Point| { &mut m.x },
173 ));
174 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
175 "y",
176 |m: &Point| { &m.y },
177 |m: &mut Point| { &mut m.y },
178 ));
179 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Point>(
180 "Point",
181 fields,
182 file_descriptor_proto()
183 )
184 })
185 }
186
187 fn default_instance() -> &'static Point {
188 static instance: ::protobuf::rt::LazyV2<Point> = ::protobuf::rt::LazyV2::INIT;
189 instance.get(Point::new)
190 }
191}
192
193impl ::protobuf::Clear for Point {
194 fn clear(&mut self) {
195 self.x = 0.;
196 self.y = 0.;
197 self.unknown_fields.clear();
198 }
199}
200
201impl ::std::fmt::Debug for Point {
202 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
203 ::protobuf::text_format::fmt(self, f)
204 }
205}
206
207impl ::protobuf::reflect::ProtobufValue for Point {
208 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
209 ::protobuf::reflect::ReflectValueRef::Message(self)
210 }
211}
212
213#[derive(PartialEq,Clone,Default)]
214pub struct Size {
215 pub width: i32,
217 pub height: i32,
218 pub unknown_fields: ::protobuf::UnknownFields,
220 pub cached_size: ::protobuf::CachedSize,
221}
222
223impl<'a> ::std::default::Default for &'a Size {
224 fn default() -> &'a Size {
225 <Size as ::protobuf::Message>::default_instance()
226 }
227}
228
229impl Size {
230 pub fn new() -> Size {
231 ::std::default::Default::default()
232 }
233
234 pub fn get_width(&self) -> i32 {
238 self.width
239 }
240 pub fn clear_width(&mut self) {
241 self.width = 0;
242 }
243
244 pub fn set_width(&mut self, v: i32) {
246 self.width = v;
247 }
248
249 pub fn get_height(&self) -> i32 {
253 self.height
254 }
255 pub fn clear_height(&mut self) {
256 self.height = 0;
257 }
258
259 pub fn set_height(&mut self, v: i32) {
261 self.height = v;
262 }
263}
264
265impl ::protobuf::Message for Size {
266 fn is_initialized(&self) -> bool {
267 true
268 }
269
270 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
271 while !is.eof()? {
272 let (field_number, wire_type) = is.read_tag_unpack()?;
273 match field_number {
274 1 => {
275 if wire_type != ::protobuf::wire_format::WireTypeVarint {
276 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
277 }
278 let tmp = is.read_int32()?;
279 self.width = tmp;
280 },
281 2 => {
282 if wire_type != ::protobuf::wire_format::WireTypeVarint {
283 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
284 }
285 let tmp = is.read_int32()?;
286 self.height = tmp;
287 },
288 _ => {
289 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
290 },
291 };
292 }
293 ::std::result::Result::Ok(())
294 }
295
296 #[allow(unused_variables)]
298 fn compute_size(&self) -> u32 {
299 let mut my_size = 0;
300 if self.width != 0 {
301 my_size += ::protobuf::rt::value_size(1, self.width, ::protobuf::wire_format::WireTypeVarint);
302 }
303 if self.height != 0 {
304 my_size += ::protobuf::rt::value_size(2, self.height, ::protobuf::wire_format::WireTypeVarint);
305 }
306 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
307 self.cached_size.set(my_size);
308 my_size
309 }
310
311 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
312 if self.width != 0 {
313 os.write_int32(1, self.width)?;
314 }
315 if self.height != 0 {
316 os.write_int32(2, self.height)?;
317 }
318 os.write_unknown_fields(self.get_unknown_fields())?;
319 ::std::result::Result::Ok(())
320 }
321
322 fn get_cached_size(&self) -> u32 {
323 self.cached_size.get()
324 }
325
326 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
327 &self.unknown_fields
328 }
329
330 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
331 &mut self.unknown_fields
332 }
333
334 fn as_any(&self) -> &dyn (::std::any::Any) {
335 self as &dyn (::std::any::Any)
336 }
337 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
338 self as &mut dyn (::std::any::Any)
339 }
340 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
341 self
342 }
343
344 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
345 Self::descriptor_static()
346 }
347
348 fn new() -> Size {
349 Size::new()
350 }
351
352 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
353 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
354 descriptor.get(|| {
355 let mut fields = ::std::vec::Vec::new();
356 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
357 "width",
358 |m: &Size| { &m.width },
359 |m: &mut Size| { &mut m.width },
360 ));
361 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
362 "height",
363 |m: &Size| { &m.height },
364 |m: &mut Size| { &mut m.height },
365 ));
366 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Size>(
367 "Size",
368 fields,
369 file_descriptor_proto()
370 )
371 })
372 }
373
374 fn default_instance() -> &'static Size {
375 static instance: ::protobuf::rt::LazyV2<Size> = ::protobuf::rt::LazyV2::INIT;
376 instance.get(Size::new)
377 }
378}
379
380impl ::protobuf::Clear for Size {
381 fn clear(&mut self) {
382 self.width = 0;
383 self.height = 0;
384 self.unknown_fields.clear();
385 }
386}
387
388impl ::std::fmt::Debug for Size {
389 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
390 ::protobuf::text_format::fmt(self, f)
391 }
392}
393
394impl ::protobuf::reflect::ProtobufValue for Size {
395 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
396 ::protobuf::reflect::ReflectValueRef::Message(self)
397 }
398}
399
400#[derive(PartialEq,Clone,Default)]
401pub struct Rectangle {
402 pub x: f32,
404 pub y: f32,
405 pub width: f32,
406 pub height: f32,
407 pub unknown_fields: ::protobuf::UnknownFields,
409 pub cached_size: ::protobuf::CachedSize,
410}
411
412impl<'a> ::std::default::Default for &'a Rectangle {
413 fn default() -> &'a Rectangle {
414 <Rectangle as ::protobuf::Message>::default_instance()
415 }
416}
417
418impl Rectangle {
419 pub fn new() -> Rectangle {
420 ::std::default::Default::default()
421 }
422
423 pub fn get_x(&self) -> f32 {
427 self.x
428 }
429 pub fn clear_x(&mut self) {
430 self.x = 0.;
431 }
432
433 pub fn set_x(&mut self, v: f32) {
435 self.x = v;
436 }
437
438 pub fn get_y(&self) -> f32 {
442 self.y
443 }
444 pub fn clear_y(&mut self) {
445 self.y = 0.;
446 }
447
448 pub fn set_y(&mut self, v: f32) {
450 self.y = v;
451 }
452
453 pub fn get_width(&self) -> f32 {
457 self.width
458 }
459 pub fn clear_width(&mut self) {
460 self.width = 0.;
461 }
462
463 pub fn set_width(&mut self, v: f32) {
465 self.width = v;
466 }
467
468 pub fn get_height(&self) -> f32 {
472 self.height
473 }
474 pub fn clear_height(&mut self) {
475 self.height = 0.;
476 }
477
478 pub fn set_height(&mut self, v: f32) {
480 self.height = v;
481 }
482}
483
484impl ::protobuf::Message for Rectangle {
485 fn is_initialized(&self) -> bool {
486 true
487 }
488
489 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
490 while !is.eof()? {
491 let (field_number, wire_type) = is.read_tag_unpack()?;
492 match field_number {
493 1 => {
494 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
495 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
496 }
497 let tmp = is.read_float()?;
498 self.x = tmp;
499 },
500 2 => {
501 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
502 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
503 }
504 let tmp = is.read_float()?;
505 self.y = tmp;
506 },
507 3 => {
508 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
509 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
510 }
511 let tmp = is.read_float()?;
512 self.width = tmp;
513 },
514 4 => {
515 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
516 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
517 }
518 let tmp = is.read_float()?;
519 self.height = tmp;
520 },
521 _ => {
522 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
523 },
524 };
525 }
526 ::std::result::Result::Ok(())
527 }
528
529 #[allow(unused_variables)]
531 fn compute_size(&self) -> u32 {
532 let mut my_size = 0;
533 if self.x != 0. {
534 my_size += 5;
535 }
536 if self.y != 0. {
537 my_size += 5;
538 }
539 if self.width != 0. {
540 my_size += 5;
541 }
542 if self.height != 0. {
543 my_size += 5;
544 }
545 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
546 self.cached_size.set(my_size);
547 my_size
548 }
549
550 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
551 if self.x != 0. {
552 os.write_float(1, self.x)?;
553 }
554 if self.y != 0. {
555 os.write_float(2, self.y)?;
556 }
557 if self.width != 0. {
558 os.write_float(3, self.width)?;
559 }
560 if self.height != 0. {
561 os.write_float(4, self.height)?;
562 }
563 os.write_unknown_fields(self.get_unknown_fields())?;
564 ::std::result::Result::Ok(())
565 }
566
567 fn get_cached_size(&self) -> u32 {
568 self.cached_size.get()
569 }
570
571 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
572 &self.unknown_fields
573 }
574
575 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
576 &mut self.unknown_fields
577 }
578
579 fn as_any(&self) -> &dyn (::std::any::Any) {
580 self as &dyn (::std::any::Any)
581 }
582 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
583 self as &mut dyn (::std::any::Any)
584 }
585 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
586 self
587 }
588
589 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
590 Self::descriptor_static()
591 }
592
593 fn new() -> Rectangle {
594 Rectangle::new()
595 }
596
597 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
598 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
599 descriptor.get(|| {
600 let mut fields = ::std::vec::Vec::new();
601 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
602 "x",
603 |m: &Rectangle| { &m.x },
604 |m: &mut Rectangle| { &mut m.x },
605 ));
606 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
607 "y",
608 |m: &Rectangle| { &m.y },
609 |m: &mut Rectangle| { &mut m.y },
610 ));
611 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
612 "width",
613 |m: &Rectangle| { &m.width },
614 |m: &mut Rectangle| { &mut m.width },
615 ));
616 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
617 "height",
618 |m: &Rectangle| { &m.height },
619 |m: &mut Rectangle| { &mut m.height },
620 ));
621 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Rectangle>(
622 "Rectangle",
623 fields,
624 file_descriptor_proto()
625 )
626 })
627 }
628
629 fn default_instance() -> &'static Rectangle {
630 static instance: ::protobuf::rt::LazyV2<Rectangle> = ::protobuf::rt::LazyV2::INIT;
631 instance.get(Rectangle::new)
632 }
633}
634
635impl ::protobuf::Clear for Rectangle {
636 fn clear(&mut self) {
637 self.x = 0.;
638 self.y = 0.;
639 self.width = 0.;
640 self.height = 0.;
641 self.unknown_fields.clear();
642 }
643}
644
645impl ::std::fmt::Debug for Rectangle {
646 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
647 ::protobuf::text_format::fmt(self, f)
648 }
649}
650
651impl ::protobuf::reflect::ProtobufValue for Rectangle {
652 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
653 ::protobuf::reflect::ReflectValueRef::Message(self)
654 }
655}
656
657#[derive(PartialEq,Clone,Default)]
658pub struct VehicleRecognition {
659 pub field_type: ::std::string::String,
661 pub brand: ::std::string::String,
662 pub model: ::std::string::String,
663 pub year: i32,
664 pub tag: EnumVehicleRecognitionTag,
665 pub confidence: f32,
666 pub unknown_fields: ::protobuf::UnknownFields,
668 pub cached_size: ::protobuf::CachedSize,
669}
670
671impl<'a> ::std::default::Default for &'a VehicleRecognition {
672 fn default() -> &'a VehicleRecognition {
673 <VehicleRecognition as ::protobuf::Message>::default_instance()
674 }
675}
676
677impl VehicleRecognition {
678 pub fn new() -> VehicleRecognition {
679 ::std::default::Default::default()
680 }
681
682 pub fn get_field_type(&self) -> &str {
686 &self.field_type
687 }
688 pub fn clear_field_type(&mut self) {
689 self.field_type.clear();
690 }
691
692 pub fn set_field_type(&mut self, v: ::std::string::String) {
694 self.field_type = v;
695 }
696
697 pub fn mut_field_type(&mut self) -> &mut ::std::string::String {
700 &mut self.field_type
701 }
702
703 pub fn take_field_type(&mut self) -> ::std::string::String {
705 ::std::mem::replace(&mut self.field_type, ::std::string::String::new())
706 }
707
708 pub fn get_brand(&self) -> &str {
712 &self.brand
713 }
714 pub fn clear_brand(&mut self) {
715 self.brand.clear();
716 }
717
718 pub fn set_brand(&mut self, v: ::std::string::String) {
720 self.brand = v;
721 }
722
723 pub fn mut_brand(&mut self) -> &mut ::std::string::String {
726 &mut self.brand
727 }
728
729 pub fn take_brand(&mut self) -> ::std::string::String {
731 ::std::mem::replace(&mut self.brand, ::std::string::String::new())
732 }
733
734 pub fn get_model(&self) -> &str {
738 &self.model
739 }
740 pub fn clear_model(&mut self) {
741 self.model.clear();
742 }
743
744 pub fn set_model(&mut self, v: ::std::string::String) {
746 self.model = v;
747 }
748
749 pub fn mut_model(&mut self) -> &mut ::std::string::String {
752 &mut self.model
753 }
754
755 pub fn take_model(&mut self) -> ::std::string::String {
757 ::std::mem::replace(&mut self.model, ::std::string::String::new())
758 }
759
760 pub fn get_year(&self) -> i32 {
764 self.year
765 }
766 pub fn clear_year(&mut self) {
767 self.year = 0;
768 }
769
770 pub fn set_year(&mut self, v: i32) {
772 self.year = v;
773 }
774
775 pub fn get_tag(&self) -> EnumVehicleRecognitionTag {
779 self.tag
780 }
781 pub fn clear_tag(&mut self) {
782 self.tag = EnumVehicleRecognitionTag::VEHICLE_RECOGNITION_NOT_DEFINED;
783 }
784
785 pub fn set_tag(&mut self, v: EnumVehicleRecognitionTag) {
787 self.tag = v;
788 }
789
790 pub fn get_confidence(&self) -> f32 {
794 self.confidence
795 }
796 pub fn clear_confidence(&mut self) {
797 self.confidence = 0.;
798 }
799
800 pub fn set_confidence(&mut self, v: f32) {
802 self.confidence = v;
803 }
804}
805
806impl ::protobuf::Message for VehicleRecognition {
807 fn is_initialized(&self) -> bool {
808 true
809 }
810
811 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
812 while !is.eof()? {
813 let (field_number, wire_type) = is.read_tag_unpack()?;
814 match field_number {
815 1 => {
816 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_type)?;
817 },
818 2 => {
819 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.brand)?;
820 },
821 3 => {
822 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.model)?;
823 },
824 4 => {
825 if wire_type != ::protobuf::wire_format::WireTypeVarint {
826 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
827 }
828 let tmp = is.read_int32()?;
829 self.year = tmp;
830 },
831 5 => {
832 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.tag, 5, &mut self.unknown_fields)?
833 },
834 6 => {
835 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
836 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
837 }
838 let tmp = is.read_float()?;
839 self.confidence = tmp;
840 },
841 _ => {
842 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
843 },
844 };
845 }
846 ::std::result::Result::Ok(())
847 }
848
849 #[allow(unused_variables)]
851 fn compute_size(&self) -> u32 {
852 let mut my_size = 0;
853 if !self.field_type.is_empty() {
854 my_size += ::protobuf::rt::string_size(1, &self.field_type);
855 }
856 if !self.brand.is_empty() {
857 my_size += ::protobuf::rt::string_size(2, &self.brand);
858 }
859 if !self.model.is_empty() {
860 my_size += ::protobuf::rt::string_size(3, &self.model);
861 }
862 if self.year != 0 {
863 my_size += ::protobuf::rt::value_size(4, self.year, ::protobuf::wire_format::WireTypeVarint);
864 }
865 if self.tag != EnumVehicleRecognitionTag::VEHICLE_RECOGNITION_NOT_DEFINED {
866 my_size += ::protobuf::rt::enum_size(5, self.tag);
867 }
868 if self.confidence != 0. {
869 my_size += 5;
870 }
871 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
872 self.cached_size.set(my_size);
873 my_size
874 }
875
876 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
877 if !self.field_type.is_empty() {
878 os.write_string(1, &self.field_type)?;
879 }
880 if !self.brand.is_empty() {
881 os.write_string(2, &self.brand)?;
882 }
883 if !self.model.is_empty() {
884 os.write_string(3, &self.model)?;
885 }
886 if self.year != 0 {
887 os.write_int32(4, self.year)?;
888 }
889 if self.tag != EnumVehicleRecognitionTag::VEHICLE_RECOGNITION_NOT_DEFINED {
890 os.write_enum(5, ::protobuf::ProtobufEnum::value(&self.tag))?;
891 }
892 if self.confidence != 0. {
893 os.write_float(6, self.confidence)?;
894 }
895 os.write_unknown_fields(self.get_unknown_fields())?;
896 ::std::result::Result::Ok(())
897 }
898
899 fn get_cached_size(&self) -> u32 {
900 self.cached_size.get()
901 }
902
903 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
904 &self.unknown_fields
905 }
906
907 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
908 &mut self.unknown_fields
909 }
910
911 fn as_any(&self) -> &dyn (::std::any::Any) {
912 self as &dyn (::std::any::Any)
913 }
914 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
915 self as &mut dyn (::std::any::Any)
916 }
917 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
918 self
919 }
920
921 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
922 Self::descriptor_static()
923 }
924
925 fn new() -> VehicleRecognition {
926 VehicleRecognition::new()
927 }
928
929 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
930 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
931 descriptor.get(|| {
932 let mut fields = ::std::vec::Vec::new();
933 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
934 "type",
935 |m: &VehicleRecognition| { &m.field_type },
936 |m: &mut VehicleRecognition| { &mut m.field_type },
937 ));
938 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
939 "brand",
940 |m: &VehicleRecognition| { &m.brand },
941 |m: &mut VehicleRecognition| { &mut m.brand },
942 ));
943 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
944 "model",
945 |m: &VehicleRecognition| { &m.model },
946 |m: &mut VehicleRecognition| { &mut m.model },
947 ));
948 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
949 "year",
950 |m: &VehicleRecognition| { &m.year },
951 |m: &mut VehicleRecognition| { &mut m.year },
952 ));
953 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EnumVehicleRecognitionTag>>(
954 "tag",
955 |m: &VehicleRecognition| { &m.tag },
956 |m: &mut VehicleRecognition| { &mut m.tag },
957 ));
958 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
959 "confidence",
960 |m: &VehicleRecognition| { &m.confidence },
961 |m: &mut VehicleRecognition| { &mut m.confidence },
962 ));
963 ::protobuf::reflect::MessageDescriptor::new_pb_name::<VehicleRecognition>(
964 "VehicleRecognition",
965 fields,
966 file_descriptor_proto()
967 )
968 })
969 }
970
971 fn default_instance() -> &'static VehicleRecognition {
972 static instance: ::protobuf::rt::LazyV2<VehicleRecognition> = ::protobuf::rt::LazyV2::INIT;
973 instance.get(VehicleRecognition::new)
974 }
975}
976
977impl ::protobuf::Clear for VehicleRecognition {
978 fn clear(&mut self) {
979 self.field_type.clear();
980 self.brand.clear();
981 self.model.clear();
982 self.year = 0;
983 self.tag = EnumVehicleRecognitionTag::VEHICLE_RECOGNITION_NOT_DEFINED;
984 self.confidence = 0.;
985 self.unknown_fields.clear();
986 }
987}
988
989impl ::std::fmt::Debug for VehicleRecognition {
990 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
991 ::protobuf::text_format::fmt(self, f)
992 }
993}
994
995impl ::protobuf::reflect::ProtobufValue for VehicleRecognition {
996 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
997 ::protobuf::reflect::ReflectValueRef::Message(self)
998 }
999}
1000
1001#[derive(PartialEq,Clone,Default)]
1002pub struct FacialRecognition {
1003 pub tag: EnumFacialRecognitionTag,
1005 pub confidence: f32,
1006 pub age: i32,
1007 pub age_class: FacialRecognition_AgeClass,
1008 pub gender: FacialRecognition_Gender,
1009 pub emotion: FacialRecognition_Emotion,
1010 pub face_descriptor: ::std::vec::Vec<f32>,
1011 pub face_id: ::std::string::String,
1012 pub pose_yaw: f32,
1013 pub pose_roll: f32,
1014 pub pose_pitch: f32,
1015 pub is_looking: bool,
1016 pub basic_feature: ::protobuf::SingularPtrField<FacialRecognition_BasicFaceFeature>,
1017 pub is_face: bool,
1018 pub have_glass: bool,
1019 pub beard: bool,
1020 pub glasses: FacialRecognition_Glasses,
1021 pub unknown_fields: ::protobuf::UnknownFields,
1023 pub cached_size: ::protobuf::CachedSize,
1024}
1025
1026impl<'a> ::std::default::Default for &'a FacialRecognition {
1027 fn default() -> &'a FacialRecognition {
1028 <FacialRecognition as ::protobuf::Message>::default_instance()
1029 }
1030}
1031
1032impl FacialRecognition {
1033 pub fn new() -> FacialRecognition {
1034 ::std::default::Default::default()
1035 }
1036
1037 pub fn get_tag(&self) -> EnumFacialRecognitionTag {
1041 self.tag
1042 }
1043 pub fn clear_tag(&mut self) {
1044 self.tag = EnumFacialRecognitionTag::FACIAL_RECOGNITION_NOT_DEFINED;
1045 }
1046
1047 pub fn set_tag(&mut self, v: EnumFacialRecognitionTag) {
1049 self.tag = v;
1050 }
1051
1052 pub fn get_confidence(&self) -> f32 {
1056 self.confidence
1057 }
1058 pub fn clear_confidence(&mut self) {
1059 self.confidence = 0.;
1060 }
1061
1062 pub fn set_confidence(&mut self, v: f32) {
1064 self.confidence = v;
1065 }
1066
1067 pub fn get_age(&self) -> i32 {
1071 self.age
1072 }
1073 pub fn clear_age(&mut self) {
1074 self.age = 0;
1075 }
1076
1077 pub fn set_age(&mut self, v: i32) {
1079 self.age = v;
1080 }
1081
1082 pub fn get_age_class(&self) -> FacialRecognition_AgeClass {
1086 self.age_class
1087 }
1088 pub fn clear_age_class(&mut self) {
1089 self.age_class = FacialRecognition_AgeClass::AGE_CLASS_NOT_DEFINED;
1090 }
1091
1092 pub fn set_age_class(&mut self, v: FacialRecognition_AgeClass) {
1094 self.age_class = v;
1095 }
1096
1097 pub fn get_gender(&self) -> FacialRecognition_Gender {
1101 self.gender
1102 }
1103 pub fn clear_gender(&mut self) {
1104 self.gender = FacialRecognition_Gender::GENDER_NOT_DEFINED;
1105 }
1106
1107 pub fn set_gender(&mut self, v: FacialRecognition_Gender) {
1109 self.gender = v;
1110 }
1111
1112 pub fn get_emotion(&self) -> FacialRecognition_Emotion {
1116 self.emotion
1117 }
1118 pub fn clear_emotion(&mut self) {
1119 self.emotion = FacialRecognition_Emotion::EMOTION_NOT_DEFINED;
1120 }
1121
1122 pub fn set_emotion(&mut self, v: FacialRecognition_Emotion) {
1124 self.emotion = v;
1125 }
1126
1127 pub fn get_face_descriptor(&self) -> &[f32] {
1131 &self.face_descriptor
1132 }
1133 pub fn clear_face_descriptor(&mut self) {
1134 self.face_descriptor.clear();
1135 }
1136
1137 pub fn set_face_descriptor(&mut self, v: ::std::vec::Vec<f32>) {
1139 self.face_descriptor = v;
1140 }
1141
1142 pub fn mut_face_descriptor(&mut self) -> &mut ::std::vec::Vec<f32> {
1144 &mut self.face_descriptor
1145 }
1146
1147 pub fn take_face_descriptor(&mut self) -> ::std::vec::Vec<f32> {
1149 ::std::mem::replace(&mut self.face_descriptor, ::std::vec::Vec::new())
1150 }
1151
1152 pub fn get_face_id(&self) -> &str {
1156 &self.face_id
1157 }
1158 pub fn clear_face_id(&mut self) {
1159 self.face_id.clear();
1160 }
1161
1162 pub fn set_face_id(&mut self, v: ::std::string::String) {
1164 self.face_id = v;
1165 }
1166
1167 pub fn mut_face_id(&mut self) -> &mut ::std::string::String {
1170 &mut self.face_id
1171 }
1172
1173 pub fn take_face_id(&mut self) -> ::std::string::String {
1175 ::std::mem::replace(&mut self.face_id, ::std::string::String::new())
1176 }
1177
1178 pub fn get_pose_yaw(&self) -> f32 {
1182 self.pose_yaw
1183 }
1184 pub fn clear_pose_yaw(&mut self) {
1185 self.pose_yaw = 0.;
1186 }
1187
1188 pub fn set_pose_yaw(&mut self, v: f32) {
1190 self.pose_yaw = v;
1191 }
1192
1193 pub fn get_pose_roll(&self) -> f32 {
1197 self.pose_roll
1198 }
1199 pub fn clear_pose_roll(&mut self) {
1200 self.pose_roll = 0.;
1201 }
1202
1203 pub fn set_pose_roll(&mut self, v: f32) {
1205 self.pose_roll = v;
1206 }
1207
1208 pub fn get_pose_pitch(&self) -> f32 {
1212 self.pose_pitch
1213 }
1214 pub fn clear_pose_pitch(&mut self) {
1215 self.pose_pitch = 0.;
1216 }
1217
1218 pub fn set_pose_pitch(&mut self, v: f32) {
1220 self.pose_pitch = v;
1221 }
1222
1223 pub fn get_is_looking(&self) -> bool {
1227 self.is_looking
1228 }
1229 pub fn clear_is_looking(&mut self) {
1230 self.is_looking = false;
1231 }
1232
1233 pub fn set_is_looking(&mut self, v: bool) {
1235 self.is_looking = v;
1236 }
1237
1238 pub fn get_basic_feature(&self) -> &FacialRecognition_BasicFaceFeature {
1242 self.basic_feature.as_ref().unwrap_or_else(|| <FacialRecognition_BasicFaceFeature as ::protobuf::Message>::default_instance())
1243 }
1244 pub fn clear_basic_feature(&mut self) {
1245 self.basic_feature.clear();
1246 }
1247
1248 pub fn has_basic_feature(&self) -> bool {
1249 self.basic_feature.is_some()
1250 }
1251
1252 pub fn set_basic_feature(&mut self, v: FacialRecognition_BasicFaceFeature) {
1254 self.basic_feature = ::protobuf::SingularPtrField::some(v);
1255 }
1256
1257 pub fn mut_basic_feature(&mut self) -> &mut FacialRecognition_BasicFaceFeature {
1260 if self.basic_feature.is_none() {
1261 self.basic_feature.set_default();
1262 }
1263 self.basic_feature.as_mut().unwrap()
1264 }
1265
1266 pub fn take_basic_feature(&mut self) -> FacialRecognition_BasicFaceFeature {
1268 self.basic_feature.take().unwrap_or_else(|| FacialRecognition_BasicFaceFeature::new())
1269 }
1270
1271 pub fn get_is_face(&self) -> bool {
1275 self.is_face
1276 }
1277 pub fn clear_is_face(&mut self) {
1278 self.is_face = false;
1279 }
1280
1281 pub fn set_is_face(&mut self, v: bool) {
1283 self.is_face = v;
1284 }
1285
1286 pub fn get_have_glass(&self) -> bool {
1290 self.have_glass
1291 }
1292 pub fn clear_have_glass(&mut self) {
1293 self.have_glass = false;
1294 }
1295
1296 pub fn set_have_glass(&mut self, v: bool) {
1298 self.have_glass = v;
1299 }
1300
1301 pub fn get_beard(&self) -> bool {
1305 self.beard
1306 }
1307 pub fn clear_beard(&mut self) {
1308 self.beard = false;
1309 }
1310
1311 pub fn set_beard(&mut self, v: bool) {
1313 self.beard = v;
1314 }
1315
1316 pub fn get_glasses(&self) -> FacialRecognition_Glasses {
1320 self.glasses
1321 }
1322 pub fn clear_glasses(&mut self) {
1323 self.glasses = FacialRecognition_Glasses::GLASSES_NOT_DEFINED;
1324 }
1325
1326 pub fn set_glasses(&mut self, v: FacialRecognition_Glasses) {
1328 self.glasses = v;
1329 }
1330}
1331
1332impl ::protobuf::Message for FacialRecognition {
1333 fn is_initialized(&self) -> bool {
1334 for v in &self.basic_feature {
1335 if !v.is_initialized() {
1336 return false;
1337 }
1338 };
1339 true
1340 }
1341
1342 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1343 while !is.eof()? {
1344 let (field_number, wire_type) = is.read_tag_unpack()?;
1345 match field_number {
1346 1 => {
1347 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.tag, 1, &mut self.unknown_fields)?
1348 },
1349 2 => {
1350 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
1351 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1352 }
1353 let tmp = is.read_float()?;
1354 self.confidence = tmp;
1355 },
1356 3 => {
1357 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1358 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1359 }
1360 let tmp = is.read_int32()?;
1361 self.age = tmp;
1362 },
1363 13 => {
1364 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.age_class, 13, &mut self.unknown_fields)?
1365 },
1366 4 => {
1367 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.gender, 4, &mut self.unknown_fields)?
1368 },
1369 5 => {
1370 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.emotion, 5, &mut self.unknown_fields)?
1371 },
1372 6 => {
1373 ::protobuf::rt::read_repeated_float_into(wire_type, is, &mut self.face_descriptor)?;
1374 },
1375 7 => {
1376 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.face_id)?;
1377 },
1378 8 => {
1379 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
1380 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1381 }
1382 let tmp = is.read_float()?;
1383 self.pose_yaw = tmp;
1384 },
1385 9 => {
1386 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
1387 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1388 }
1389 let tmp = is.read_float()?;
1390 self.pose_roll = tmp;
1391 },
1392 10 => {
1393 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
1394 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1395 }
1396 let tmp = is.read_float()?;
1397 self.pose_pitch = tmp;
1398 },
1399 14 => {
1400 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1401 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1402 }
1403 let tmp = is.read_bool()?;
1404 self.is_looking = tmp;
1405 },
1406 11 => {
1407 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.basic_feature)?;
1408 },
1409 12 => {
1410 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1411 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1412 }
1413 let tmp = is.read_bool()?;
1414 self.is_face = tmp;
1415 },
1416 15 => {
1417 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1418 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1419 }
1420 let tmp = is.read_bool()?;
1421 self.have_glass = tmp;
1422 },
1423 16 => {
1424 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1425 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1426 }
1427 let tmp = is.read_bool()?;
1428 self.beard = tmp;
1429 },
1430 17 => {
1431 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.glasses, 17, &mut self.unknown_fields)?
1432 },
1433 _ => {
1434 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1435 },
1436 };
1437 }
1438 ::std::result::Result::Ok(())
1439 }
1440
1441 #[allow(unused_variables)]
1443 fn compute_size(&self) -> u32 {
1444 let mut my_size = 0;
1445 if self.tag != EnumFacialRecognitionTag::FACIAL_RECOGNITION_NOT_DEFINED {
1446 my_size += ::protobuf::rt::enum_size(1, self.tag);
1447 }
1448 if self.confidence != 0. {
1449 my_size += 5;
1450 }
1451 if self.age != 0 {
1452 my_size += ::protobuf::rt::value_size(3, self.age, ::protobuf::wire_format::WireTypeVarint);
1453 }
1454 if self.age_class != FacialRecognition_AgeClass::AGE_CLASS_NOT_DEFINED {
1455 my_size += ::protobuf::rt::enum_size(13, self.age_class);
1456 }
1457 if self.gender != FacialRecognition_Gender::GENDER_NOT_DEFINED {
1458 my_size += ::protobuf::rt::enum_size(4, self.gender);
1459 }
1460 if self.emotion != FacialRecognition_Emotion::EMOTION_NOT_DEFINED {
1461 my_size += ::protobuf::rt::enum_size(5, self.emotion);
1462 }
1463 if !self.face_descriptor.is_empty() {
1464 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size((self.face_descriptor.len() * 4) as u32) + (self.face_descriptor.len() * 4) as u32;
1465 }
1466 if !self.face_id.is_empty() {
1467 my_size += ::protobuf::rt::string_size(7, &self.face_id);
1468 }
1469 if self.pose_yaw != 0. {
1470 my_size += 5;
1471 }
1472 if self.pose_roll != 0. {
1473 my_size += 5;
1474 }
1475 if self.pose_pitch != 0. {
1476 my_size += 5;
1477 }
1478 if self.is_looking != false {
1479 my_size += 2;
1480 }
1481 if let Some(ref v) = self.basic_feature.as_ref() {
1482 let len = v.compute_size();
1483 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1484 }
1485 if self.is_face != false {
1486 my_size += 2;
1487 }
1488 if self.have_glass != false {
1489 my_size += 2;
1490 }
1491 if self.beard != false {
1492 my_size += 3;
1493 }
1494 if self.glasses != FacialRecognition_Glasses::GLASSES_NOT_DEFINED {
1495 my_size += ::protobuf::rt::enum_size(17, self.glasses);
1496 }
1497 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1498 self.cached_size.set(my_size);
1499 my_size
1500 }
1501
1502 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1503 if self.tag != EnumFacialRecognitionTag::FACIAL_RECOGNITION_NOT_DEFINED {
1504 os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.tag))?;
1505 }
1506 if self.confidence != 0. {
1507 os.write_float(2, self.confidence)?;
1508 }
1509 if self.age != 0 {
1510 os.write_int32(3, self.age)?;
1511 }
1512 if self.age_class != FacialRecognition_AgeClass::AGE_CLASS_NOT_DEFINED {
1513 os.write_enum(13, ::protobuf::ProtobufEnum::value(&self.age_class))?;
1514 }
1515 if self.gender != FacialRecognition_Gender::GENDER_NOT_DEFINED {
1516 os.write_enum(4, ::protobuf::ProtobufEnum::value(&self.gender))?;
1517 }
1518 if self.emotion != FacialRecognition_Emotion::EMOTION_NOT_DEFINED {
1519 os.write_enum(5, ::protobuf::ProtobufEnum::value(&self.emotion))?;
1520 }
1521 if !self.face_descriptor.is_empty() {
1522 os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1523 os.write_raw_varint32((self.face_descriptor.len() * 4) as u32)?;
1525 for v in &self.face_descriptor {
1526 os.write_float_no_tag(*v)?;
1527 };
1528 }
1529 if !self.face_id.is_empty() {
1530 os.write_string(7, &self.face_id)?;
1531 }
1532 if self.pose_yaw != 0. {
1533 os.write_float(8, self.pose_yaw)?;
1534 }
1535 if self.pose_roll != 0. {
1536 os.write_float(9, self.pose_roll)?;
1537 }
1538 if self.pose_pitch != 0. {
1539 os.write_float(10, self.pose_pitch)?;
1540 }
1541 if self.is_looking != false {
1542 os.write_bool(14, self.is_looking)?;
1543 }
1544 if let Some(ref v) = self.basic_feature.as_ref() {
1545 os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1546 os.write_raw_varint32(v.get_cached_size())?;
1547 v.write_to_with_cached_sizes(os)?;
1548 }
1549 if self.is_face != false {
1550 os.write_bool(12, self.is_face)?;
1551 }
1552 if self.have_glass != false {
1553 os.write_bool(15, self.have_glass)?;
1554 }
1555 if self.beard != false {
1556 os.write_bool(16, self.beard)?;
1557 }
1558 if self.glasses != FacialRecognition_Glasses::GLASSES_NOT_DEFINED {
1559 os.write_enum(17, ::protobuf::ProtobufEnum::value(&self.glasses))?;
1560 }
1561 os.write_unknown_fields(self.get_unknown_fields())?;
1562 ::std::result::Result::Ok(())
1563 }
1564
1565 fn get_cached_size(&self) -> u32 {
1566 self.cached_size.get()
1567 }
1568
1569 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1570 &self.unknown_fields
1571 }
1572
1573 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1574 &mut self.unknown_fields
1575 }
1576
1577 fn as_any(&self) -> &dyn (::std::any::Any) {
1578 self as &dyn (::std::any::Any)
1579 }
1580 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1581 self as &mut dyn (::std::any::Any)
1582 }
1583 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1584 self
1585 }
1586
1587 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1588 Self::descriptor_static()
1589 }
1590
1591 fn new() -> FacialRecognition {
1592 FacialRecognition::new()
1593 }
1594
1595 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1596 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1597 descriptor.get(|| {
1598 let mut fields = ::std::vec::Vec::new();
1599 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EnumFacialRecognitionTag>>(
1600 "tag",
1601 |m: &FacialRecognition| { &m.tag },
1602 |m: &mut FacialRecognition| { &mut m.tag },
1603 ));
1604 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
1605 "confidence",
1606 |m: &FacialRecognition| { &m.confidence },
1607 |m: &mut FacialRecognition| { &mut m.confidence },
1608 ));
1609 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
1610 "age",
1611 |m: &FacialRecognition| { &m.age },
1612 |m: &mut FacialRecognition| { &mut m.age },
1613 ));
1614 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FacialRecognition_AgeClass>>(
1615 "age_class",
1616 |m: &FacialRecognition| { &m.age_class },
1617 |m: &mut FacialRecognition| { &mut m.age_class },
1618 ));
1619 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FacialRecognition_Gender>>(
1620 "gender",
1621 |m: &FacialRecognition| { &m.gender },
1622 |m: &mut FacialRecognition| { &mut m.gender },
1623 ));
1624 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FacialRecognition_Emotion>>(
1625 "emotion",
1626 |m: &FacialRecognition| { &m.emotion },
1627 |m: &mut FacialRecognition| { &mut m.emotion },
1628 ));
1629 fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
1630 "face_descriptor",
1631 |m: &FacialRecognition| { &m.face_descriptor },
1632 |m: &mut FacialRecognition| { &mut m.face_descriptor },
1633 ));
1634 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1635 "face_id",
1636 |m: &FacialRecognition| { &m.face_id },
1637 |m: &mut FacialRecognition| { &mut m.face_id },
1638 ));
1639 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
1640 "pose_yaw",
1641 |m: &FacialRecognition| { &m.pose_yaw },
1642 |m: &mut FacialRecognition| { &mut m.pose_yaw },
1643 ));
1644 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
1645 "pose_roll",
1646 |m: &FacialRecognition| { &m.pose_roll },
1647 |m: &mut FacialRecognition| { &mut m.pose_roll },
1648 ));
1649 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
1650 "pose_pitch",
1651 |m: &FacialRecognition| { &m.pose_pitch },
1652 |m: &mut FacialRecognition| { &mut m.pose_pitch },
1653 ));
1654 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1655 "is_looking",
1656 |m: &FacialRecognition| { &m.is_looking },
1657 |m: &mut FacialRecognition| { &mut m.is_looking },
1658 ));
1659 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FacialRecognition_BasicFaceFeature>>(
1660 "basic_feature",
1661 |m: &FacialRecognition| { &m.basic_feature },
1662 |m: &mut FacialRecognition| { &mut m.basic_feature },
1663 ));
1664 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1665 "is_face",
1666 |m: &FacialRecognition| { &m.is_face },
1667 |m: &mut FacialRecognition| { &mut m.is_face },
1668 ));
1669 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1670 "have_glass",
1671 |m: &FacialRecognition| { &m.have_glass },
1672 |m: &mut FacialRecognition| { &mut m.have_glass },
1673 ));
1674 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1675 "beard",
1676 |m: &FacialRecognition| { &m.beard },
1677 |m: &mut FacialRecognition| { &mut m.beard },
1678 ));
1679 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FacialRecognition_Glasses>>(
1680 "glasses",
1681 |m: &FacialRecognition| { &m.glasses },
1682 |m: &mut FacialRecognition| { &mut m.glasses },
1683 ));
1684 ::protobuf::reflect::MessageDescriptor::new_pb_name::<FacialRecognition>(
1685 "FacialRecognition",
1686 fields,
1687 file_descriptor_proto()
1688 )
1689 })
1690 }
1691
1692 fn default_instance() -> &'static FacialRecognition {
1693 static instance: ::protobuf::rt::LazyV2<FacialRecognition> = ::protobuf::rt::LazyV2::INIT;
1694 instance.get(FacialRecognition::new)
1695 }
1696}
1697
1698impl ::protobuf::Clear for FacialRecognition {
1699 fn clear(&mut self) {
1700 self.tag = EnumFacialRecognitionTag::FACIAL_RECOGNITION_NOT_DEFINED;
1701 self.confidence = 0.;
1702 self.age = 0;
1703 self.age_class = FacialRecognition_AgeClass::AGE_CLASS_NOT_DEFINED;
1704 self.gender = FacialRecognition_Gender::GENDER_NOT_DEFINED;
1705 self.emotion = FacialRecognition_Emotion::EMOTION_NOT_DEFINED;
1706 self.face_descriptor.clear();
1707 self.face_id.clear();
1708 self.pose_yaw = 0.;
1709 self.pose_roll = 0.;
1710 self.pose_pitch = 0.;
1711 self.is_looking = false;
1712 self.basic_feature.clear();
1713 self.is_face = false;
1714 self.have_glass = false;
1715 self.beard = false;
1716 self.glasses = FacialRecognition_Glasses::GLASSES_NOT_DEFINED;
1717 self.unknown_fields.clear();
1718 }
1719}
1720
1721impl ::std::fmt::Debug for FacialRecognition {
1722 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1723 ::protobuf::text_format::fmt(self, f)
1724 }
1725}
1726
1727impl ::protobuf::reflect::ProtobufValue for FacialRecognition {
1728 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1729 ::protobuf::reflect::ReflectValueRef::Message(self)
1730 }
1731}
1732
1733#[derive(PartialEq,Clone,Default)]
1734pub struct FacialRecognition_BasicFaceFeature {
1735 pub mouth: ::protobuf::RepeatedField<Point>,
1737 pub left_eye: ::protobuf::RepeatedField<Point>,
1738 pub right_eye: ::protobuf::RepeatedField<Point>,
1739 pub nose: ::protobuf::RepeatedField<Point>,
1740 pub unknown_fields: ::protobuf::UnknownFields,
1742 pub cached_size: ::protobuf::CachedSize,
1743}
1744
1745impl<'a> ::std::default::Default for &'a FacialRecognition_BasicFaceFeature {
1746 fn default() -> &'a FacialRecognition_BasicFaceFeature {
1747 <FacialRecognition_BasicFaceFeature as ::protobuf::Message>::default_instance()
1748 }
1749}
1750
1751impl FacialRecognition_BasicFaceFeature {
1752 pub fn new() -> FacialRecognition_BasicFaceFeature {
1753 ::std::default::Default::default()
1754 }
1755
1756 pub fn get_mouth(&self) -> &[Point] {
1760 &self.mouth
1761 }
1762 pub fn clear_mouth(&mut self) {
1763 self.mouth.clear();
1764 }
1765
1766 pub fn set_mouth(&mut self, v: ::protobuf::RepeatedField<Point>) {
1768 self.mouth = v;
1769 }
1770
1771 pub fn mut_mouth(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
1773 &mut self.mouth
1774 }
1775
1776 pub fn take_mouth(&mut self) -> ::protobuf::RepeatedField<Point> {
1778 ::std::mem::replace(&mut self.mouth, ::protobuf::RepeatedField::new())
1779 }
1780
1781 pub fn get_left_eye(&self) -> &[Point] {
1785 &self.left_eye
1786 }
1787 pub fn clear_left_eye(&mut self) {
1788 self.left_eye.clear();
1789 }
1790
1791 pub fn set_left_eye(&mut self, v: ::protobuf::RepeatedField<Point>) {
1793 self.left_eye = v;
1794 }
1795
1796 pub fn mut_left_eye(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
1798 &mut self.left_eye
1799 }
1800
1801 pub fn take_left_eye(&mut self) -> ::protobuf::RepeatedField<Point> {
1803 ::std::mem::replace(&mut self.left_eye, ::protobuf::RepeatedField::new())
1804 }
1805
1806 pub fn get_right_eye(&self) -> &[Point] {
1810 &self.right_eye
1811 }
1812 pub fn clear_right_eye(&mut self) {
1813 self.right_eye.clear();
1814 }
1815
1816 pub fn set_right_eye(&mut self, v: ::protobuf::RepeatedField<Point>) {
1818 self.right_eye = v;
1819 }
1820
1821 pub fn mut_right_eye(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
1823 &mut self.right_eye
1824 }
1825
1826 pub fn take_right_eye(&mut self) -> ::protobuf::RepeatedField<Point> {
1828 ::std::mem::replace(&mut self.right_eye, ::protobuf::RepeatedField::new())
1829 }
1830
1831 pub fn get_nose(&self) -> &[Point] {
1835 &self.nose
1836 }
1837 pub fn clear_nose(&mut self) {
1838 self.nose.clear();
1839 }
1840
1841 pub fn set_nose(&mut self, v: ::protobuf::RepeatedField<Point>) {
1843 self.nose = v;
1844 }
1845
1846 pub fn mut_nose(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
1848 &mut self.nose
1849 }
1850
1851 pub fn take_nose(&mut self) -> ::protobuf::RepeatedField<Point> {
1853 ::std::mem::replace(&mut self.nose, ::protobuf::RepeatedField::new())
1854 }
1855}
1856
1857impl ::protobuf::Message for FacialRecognition_BasicFaceFeature {
1858 fn is_initialized(&self) -> bool {
1859 for v in &self.mouth {
1860 if !v.is_initialized() {
1861 return false;
1862 }
1863 };
1864 for v in &self.left_eye {
1865 if !v.is_initialized() {
1866 return false;
1867 }
1868 };
1869 for v in &self.right_eye {
1870 if !v.is_initialized() {
1871 return false;
1872 }
1873 };
1874 for v in &self.nose {
1875 if !v.is_initialized() {
1876 return false;
1877 }
1878 };
1879 true
1880 }
1881
1882 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1883 while !is.eof()? {
1884 let (field_number, wire_type) = is.read_tag_unpack()?;
1885 match field_number {
1886 1 => {
1887 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mouth)?;
1888 },
1889 2 => {
1890 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.left_eye)?;
1891 },
1892 3 => {
1893 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.right_eye)?;
1894 },
1895 4 => {
1896 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.nose)?;
1897 },
1898 _ => {
1899 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1900 },
1901 };
1902 }
1903 ::std::result::Result::Ok(())
1904 }
1905
1906 #[allow(unused_variables)]
1908 fn compute_size(&self) -> u32 {
1909 let mut my_size = 0;
1910 for value in &self.mouth {
1911 let len = value.compute_size();
1912 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1913 };
1914 for value in &self.left_eye {
1915 let len = value.compute_size();
1916 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1917 };
1918 for value in &self.right_eye {
1919 let len = value.compute_size();
1920 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1921 };
1922 for value in &self.nose {
1923 let len = value.compute_size();
1924 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1925 };
1926 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1927 self.cached_size.set(my_size);
1928 my_size
1929 }
1930
1931 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1932 for v in &self.mouth {
1933 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1934 os.write_raw_varint32(v.get_cached_size())?;
1935 v.write_to_with_cached_sizes(os)?;
1936 };
1937 for v in &self.left_eye {
1938 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1939 os.write_raw_varint32(v.get_cached_size())?;
1940 v.write_to_with_cached_sizes(os)?;
1941 };
1942 for v in &self.right_eye {
1943 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1944 os.write_raw_varint32(v.get_cached_size())?;
1945 v.write_to_with_cached_sizes(os)?;
1946 };
1947 for v in &self.nose {
1948 os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1949 os.write_raw_varint32(v.get_cached_size())?;
1950 v.write_to_with_cached_sizes(os)?;
1951 };
1952 os.write_unknown_fields(self.get_unknown_fields())?;
1953 ::std::result::Result::Ok(())
1954 }
1955
1956 fn get_cached_size(&self) -> u32 {
1957 self.cached_size.get()
1958 }
1959
1960 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1961 &self.unknown_fields
1962 }
1963
1964 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1965 &mut self.unknown_fields
1966 }
1967
1968 fn as_any(&self) -> &dyn (::std::any::Any) {
1969 self as &dyn (::std::any::Any)
1970 }
1971 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1972 self as &mut dyn (::std::any::Any)
1973 }
1974 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1975 self
1976 }
1977
1978 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1979 Self::descriptor_static()
1980 }
1981
1982 fn new() -> FacialRecognition_BasicFaceFeature {
1983 FacialRecognition_BasicFaceFeature::new()
1984 }
1985
1986 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1987 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1988 descriptor.get(|| {
1989 let mut fields = ::std::vec::Vec::new();
1990 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Point>>(
1991 "mouth",
1992 |m: &FacialRecognition_BasicFaceFeature| { &m.mouth },
1993 |m: &mut FacialRecognition_BasicFaceFeature| { &mut m.mouth },
1994 ));
1995 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Point>>(
1996 "left_eye",
1997 |m: &FacialRecognition_BasicFaceFeature| { &m.left_eye },
1998 |m: &mut FacialRecognition_BasicFaceFeature| { &mut m.left_eye },
1999 ));
2000 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Point>>(
2001 "right_eye",
2002 |m: &FacialRecognition_BasicFaceFeature| { &m.right_eye },
2003 |m: &mut FacialRecognition_BasicFaceFeature| { &mut m.right_eye },
2004 ));
2005 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Point>>(
2006 "nose",
2007 |m: &FacialRecognition_BasicFaceFeature| { &m.nose },
2008 |m: &mut FacialRecognition_BasicFaceFeature| { &mut m.nose },
2009 ));
2010 ::protobuf::reflect::MessageDescriptor::new_pb_name::<FacialRecognition_BasicFaceFeature>(
2011 "FacialRecognition.BasicFaceFeature",
2012 fields,
2013 file_descriptor_proto()
2014 )
2015 })
2016 }
2017
2018 fn default_instance() -> &'static FacialRecognition_BasicFaceFeature {
2019 static instance: ::protobuf::rt::LazyV2<FacialRecognition_BasicFaceFeature> = ::protobuf::rt::LazyV2::INIT;
2020 instance.get(FacialRecognition_BasicFaceFeature::new)
2021 }
2022}
2023
2024impl ::protobuf::Clear for FacialRecognition_BasicFaceFeature {
2025 fn clear(&mut self) {
2026 self.mouth.clear();
2027 self.left_eye.clear();
2028 self.right_eye.clear();
2029 self.nose.clear();
2030 self.unknown_fields.clear();
2031 }
2032}
2033
2034impl ::std::fmt::Debug for FacialRecognition_BasicFaceFeature {
2035 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2036 ::protobuf::text_format::fmt(self, f)
2037 }
2038}
2039
2040impl ::protobuf::reflect::ProtobufValue for FacialRecognition_BasicFaceFeature {
2041 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2042 ::protobuf::reflect::ReflectValueRef::Message(self)
2043 }
2044}
2045
2046#[derive(Clone,PartialEq,Eq,Debug,Hash)]
2047pub enum FacialRecognition_AgeClass {
2048 AGE_CLASS_NOT_DEFINED = 0,
2049 CHILDREN = 1,
2050 YOUNG_ADULT = 2,
2051 ADULT = 3,
2052 SENIOR = 4,
2053}
2054
2055impl ::protobuf::ProtobufEnum for FacialRecognition_AgeClass {
2056 fn value(&self) -> i32 {
2057 *self as i32
2058 }
2059
2060 fn from_i32(value: i32) -> ::std::option::Option<FacialRecognition_AgeClass> {
2061 match value {
2062 0 => ::std::option::Option::Some(FacialRecognition_AgeClass::AGE_CLASS_NOT_DEFINED),
2063 1 => ::std::option::Option::Some(FacialRecognition_AgeClass::CHILDREN),
2064 2 => ::std::option::Option::Some(FacialRecognition_AgeClass::YOUNG_ADULT),
2065 3 => ::std::option::Option::Some(FacialRecognition_AgeClass::ADULT),
2066 4 => ::std::option::Option::Some(FacialRecognition_AgeClass::SENIOR),
2067 _ => ::std::option::Option::None
2068 }
2069 }
2070
2071 fn values() -> &'static [Self] {
2072 static values: &'static [FacialRecognition_AgeClass] = &[
2073 FacialRecognition_AgeClass::AGE_CLASS_NOT_DEFINED,
2074 FacialRecognition_AgeClass::CHILDREN,
2075 FacialRecognition_AgeClass::YOUNG_ADULT,
2076 FacialRecognition_AgeClass::ADULT,
2077 FacialRecognition_AgeClass::SENIOR,
2078 ];
2079 values
2080 }
2081
2082 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
2083 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
2084 descriptor.get(|| {
2085 ::protobuf::reflect::EnumDescriptor::new_pb_name::<FacialRecognition_AgeClass>("FacialRecognition.AgeClass", file_descriptor_proto())
2086 })
2087 }
2088}
2089
2090impl ::std::marker::Copy for FacialRecognition_AgeClass {
2091}
2092
2093impl ::std::default::Default for FacialRecognition_AgeClass {
2094 fn default() -> Self {
2095 FacialRecognition_AgeClass::AGE_CLASS_NOT_DEFINED
2096 }
2097}
2098
2099impl ::protobuf::reflect::ProtobufValue for FacialRecognition_AgeClass {
2100 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2101 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
2102 }
2103}
2104
2105#[derive(Clone,PartialEq,Eq,Debug,Hash)]
2106pub enum FacialRecognition_Gender {
2107 GENDER_NOT_DEFINED = 0,
2108 MALE = 1,
2109 FEMALE = 2,
2110}
2111
2112impl ::protobuf::ProtobufEnum for FacialRecognition_Gender {
2113 fn value(&self) -> i32 {
2114 *self as i32
2115 }
2116
2117 fn from_i32(value: i32) -> ::std::option::Option<FacialRecognition_Gender> {
2118 match value {
2119 0 => ::std::option::Option::Some(FacialRecognition_Gender::GENDER_NOT_DEFINED),
2120 1 => ::std::option::Option::Some(FacialRecognition_Gender::MALE),
2121 2 => ::std::option::Option::Some(FacialRecognition_Gender::FEMALE),
2122 _ => ::std::option::Option::None
2123 }
2124 }
2125
2126 fn values() -> &'static [Self] {
2127 static values: &'static [FacialRecognition_Gender] = &[
2128 FacialRecognition_Gender::GENDER_NOT_DEFINED,
2129 FacialRecognition_Gender::MALE,
2130 FacialRecognition_Gender::FEMALE,
2131 ];
2132 values
2133 }
2134
2135 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
2136 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
2137 descriptor.get(|| {
2138 ::protobuf::reflect::EnumDescriptor::new_pb_name::<FacialRecognition_Gender>("FacialRecognition.Gender", file_descriptor_proto())
2139 })
2140 }
2141}
2142
2143impl ::std::marker::Copy for FacialRecognition_Gender {
2144}
2145
2146impl ::std::default::Default for FacialRecognition_Gender {
2147 fn default() -> Self {
2148 FacialRecognition_Gender::GENDER_NOT_DEFINED
2149 }
2150}
2151
2152impl ::protobuf::reflect::ProtobufValue for FacialRecognition_Gender {
2153 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2154 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
2155 }
2156}
2157
2158#[derive(Clone,PartialEq,Eq,Debug,Hash)]
2159pub enum FacialRecognition_Emotion {
2160 EMOTION_NOT_DEFINED = 0,
2161 ANGRY = 1,
2162 DISGUST = 2,
2163 CONFUSED = 3,
2164 HAPPY = 4,
2165 SAD = 5,
2166 SURPRISED = 6,
2167 CALM = 7,
2168 FEAR = 8,
2169 NEUTRAL = 9,
2170}
2171
2172impl ::protobuf::ProtobufEnum for FacialRecognition_Emotion {
2173 fn value(&self) -> i32 {
2174 *self as i32
2175 }
2176
2177 fn from_i32(value: i32) -> ::std::option::Option<FacialRecognition_Emotion> {
2178 match value {
2179 0 => ::std::option::Option::Some(FacialRecognition_Emotion::EMOTION_NOT_DEFINED),
2180 1 => ::std::option::Option::Some(FacialRecognition_Emotion::ANGRY),
2181 2 => ::std::option::Option::Some(FacialRecognition_Emotion::DISGUST),
2182 3 => ::std::option::Option::Some(FacialRecognition_Emotion::CONFUSED),
2183 4 => ::std::option::Option::Some(FacialRecognition_Emotion::HAPPY),
2184 5 => ::std::option::Option::Some(FacialRecognition_Emotion::SAD),
2185 6 => ::std::option::Option::Some(FacialRecognition_Emotion::SURPRISED),
2186 7 => ::std::option::Option::Some(FacialRecognition_Emotion::CALM),
2187 8 => ::std::option::Option::Some(FacialRecognition_Emotion::FEAR),
2188 9 => ::std::option::Option::Some(FacialRecognition_Emotion::NEUTRAL),
2189 _ => ::std::option::Option::None
2190 }
2191 }
2192
2193 fn values() -> &'static [Self] {
2194 static values: &'static [FacialRecognition_Emotion] = &[
2195 FacialRecognition_Emotion::EMOTION_NOT_DEFINED,
2196 FacialRecognition_Emotion::ANGRY,
2197 FacialRecognition_Emotion::DISGUST,
2198 FacialRecognition_Emotion::CONFUSED,
2199 FacialRecognition_Emotion::HAPPY,
2200 FacialRecognition_Emotion::SAD,
2201 FacialRecognition_Emotion::SURPRISED,
2202 FacialRecognition_Emotion::CALM,
2203 FacialRecognition_Emotion::FEAR,
2204 FacialRecognition_Emotion::NEUTRAL,
2205 ];
2206 values
2207 }
2208
2209 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
2210 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
2211 descriptor.get(|| {
2212 ::protobuf::reflect::EnumDescriptor::new_pb_name::<FacialRecognition_Emotion>("FacialRecognition.Emotion", file_descriptor_proto())
2213 })
2214 }
2215}
2216
2217impl ::std::marker::Copy for FacialRecognition_Emotion {
2218}
2219
2220impl ::std::default::Default for FacialRecognition_Emotion {
2221 fn default() -> Self {
2222 FacialRecognition_Emotion::EMOTION_NOT_DEFINED
2223 }
2224}
2225
2226impl ::protobuf::reflect::ProtobufValue for FacialRecognition_Emotion {
2227 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2228 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
2229 }
2230}
2231
2232#[derive(Clone,PartialEq,Eq,Debug,Hash)]
2233pub enum FacialRecognition_Glasses {
2234 GLASSES_NOT_DEFINED = 0,
2235 GLASSES = 1,
2236 NO_GLASSES = 2,
2237 SUN_GLASSES = 3,
2238}
2239
2240impl ::protobuf::ProtobufEnum for FacialRecognition_Glasses {
2241 fn value(&self) -> i32 {
2242 *self as i32
2243 }
2244
2245 fn from_i32(value: i32) -> ::std::option::Option<FacialRecognition_Glasses> {
2246 match value {
2247 0 => ::std::option::Option::Some(FacialRecognition_Glasses::GLASSES_NOT_DEFINED),
2248 1 => ::std::option::Option::Some(FacialRecognition_Glasses::GLASSES),
2249 2 => ::std::option::Option::Some(FacialRecognition_Glasses::NO_GLASSES),
2250 3 => ::std::option::Option::Some(FacialRecognition_Glasses::SUN_GLASSES),
2251 _ => ::std::option::Option::None
2252 }
2253 }
2254
2255 fn values() -> &'static [Self] {
2256 static values: &'static [FacialRecognition_Glasses] = &[
2257 FacialRecognition_Glasses::GLASSES_NOT_DEFINED,
2258 FacialRecognition_Glasses::GLASSES,
2259 FacialRecognition_Glasses::NO_GLASSES,
2260 FacialRecognition_Glasses::SUN_GLASSES,
2261 ];
2262 values
2263 }
2264
2265 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
2266 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
2267 descriptor.get(|| {
2268 ::protobuf::reflect::EnumDescriptor::new_pb_name::<FacialRecognition_Glasses>("FacialRecognition.Glasses", file_descriptor_proto())
2269 })
2270 }
2271}
2272
2273impl ::std::marker::Copy for FacialRecognition_Glasses {
2274}
2275
2276impl ::std::default::Default for FacialRecognition_Glasses {
2277 fn default() -> Self {
2278 FacialRecognition_Glasses::GLASSES_NOT_DEFINED
2279 }
2280}
2281
2282impl ::protobuf::reflect::ProtobufValue for FacialRecognition_Glasses {
2283 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2284 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
2285 }
2286}
2287
2288#[derive(PartialEq,Clone,Default)]
2289pub struct ZoneConfig {
2290 pub name: ::std::string::String,
2292 pub point_a: ::protobuf::SingularPtrField<Point>,
2293 pub point_b: ::protobuf::SingularPtrField<Point>,
2294 pub height: i32,
2295 pub real_height: f32,
2296 pub unknown_fields: ::protobuf::UnknownFields,
2298 pub cached_size: ::protobuf::CachedSize,
2299}
2300
2301impl<'a> ::std::default::Default for &'a ZoneConfig {
2302 fn default() -> &'a ZoneConfig {
2303 <ZoneConfig as ::protobuf::Message>::default_instance()
2304 }
2305}
2306
2307impl ZoneConfig {
2308 pub fn new() -> ZoneConfig {
2309 ::std::default::Default::default()
2310 }
2311
2312 pub fn get_name(&self) -> &str {
2316 &self.name
2317 }
2318 pub fn clear_name(&mut self) {
2319 self.name.clear();
2320 }
2321
2322 pub fn set_name(&mut self, v: ::std::string::String) {
2324 self.name = v;
2325 }
2326
2327 pub fn mut_name(&mut self) -> &mut ::std::string::String {
2330 &mut self.name
2331 }
2332
2333 pub fn take_name(&mut self) -> ::std::string::String {
2335 ::std::mem::replace(&mut self.name, ::std::string::String::new())
2336 }
2337
2338 pub fn get_point_a(&self) -> &Point {
2342 self.point_a.as_ref().unwrap_or_else(|| <Point as ::protobuf::Message>::default_instance())
2343 }
2344 pub fn clear_point_a(&mut self) {
2345 self.point_a.clear();
2346 }
2347
2348 pub fn has_point_a(&self) -> bool {
2349 self.point_a.is_some()
2350 }
2351
2352 pub fn set_point_a(&mut self, v: Point) {
2354 self.point_a = ::protobuf::SingularPtrField::some(v);
2355 }
2356
2357 pub fn mut_point_a(&mut self) -> &mut Point {
2360 if self.point_a.is_none() {
2361 self.point_a.set_default();
2362 }
2363 self.point_a.as_mut().unwrap()
2364 }
2365
2366 pub fn take_point_a(&mut self) -> Point {
2368 self.point_a.take().unwrap_or_else(|| Point::new())
2369 }
2370
2371 pub fn get_point_b(&self) -> &Point {
2375 self.point_b.as_ref().unwrap_or_else(|| <Point as ::protobuf::Message>::default_instance())
2376 }
2377 pub fn clear_point_b(&mut self) {
2378 self.point_b.clear();
2379 }
2380
2381 pub fn has_point_b(&self) -> bool {
2382 self.point_b.is_some()
2383 }
2384
2385 pub fn set_point_b(&mut self, v: Point) {
2387 self.point_b = ::protobuf::SingularPtrField::some(v);
2388 }
2389
2390 pub fn mut_point_b(&mut self) -> &mut Point {
2393 if self.point_b.is_none() {
2394 self.point_b.set_default();
2395 }
2396 self.point_b.as_mut().unwrap()
2397 }
2398
2399 pub fn take_point_b(&mut self) -> Point {
2401 self.point_b.take().unwrap_or_else(|| Point::new())
2402 }
2403
2404 pub fn get_height(&self) -> i32 {
2408 self.height
2409 }
2410 pub fn clear_height(&mut self) {
2411 self.height = 0;
2412 }
2413
2414 pub fn set_height(&mut self, v: i32) {
2416 self.height = v;
2417 }
2418
2419 pub fn get_real_height(&self) -> f32 {
2423 self.real_height
2424 }
2425 pub fn clear_real_height(&mut self) {
2426 self.real_height = 0.;
2427 }
2428
2429 pub fn set_real_height(&mut self, v: f32) {
2431 self.real_height = v;
2432 }
2433}
2434
2435impl ::protobuf::Message for ZoneConfig {
2436 fn is_initialized(&self) -> bool {
2437 for v in &self.point_a {
2438 if !v.is_initialized() {
2439 return false;
2440 }
2441 };
2442 for v in &self.point_b {
2443 if !v.is_initialized() {
2444 return false;
2445 }
2446 };
2447 true
2448 }
2449
2450 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2451 while !is.eof()? {
2452 let (field_number, wire_type) = is.read_tag_unpack()?;
2453 match field_number {
2454 1 => {
2455 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2456 },
2457 2 => {
2458 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.point_a)?;
2459 },
2460 3 => {
2461 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.point_b)?;
2462 },
2463 4 => {
2464 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2465 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2466 }
2467 let tmp = is.read_int32()?;
2468 self.height = tmp;
2469 },
2470 5 => {
2471 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
2472 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2473 }
2474 let tmp = is.read_float()?;
2475 self.real_height = tmp;
2476 },
2477 _ => {
2478 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2479 },
2480 };
2481 }
2482 ::std::result::Result::Ok(())
2483 }
2484
2485 #[allow(unused_variables)]
2487 fn compute_size(&self) -> u32 {
2488 let mut my_size = 0;
2489 if !self.name.is_empty() {
2490 my_size += ::protobuf::rt::string_size(1, &self.name);
2491 }
2492 if let Some(ref v) = self.point_a.as_ref() {
2493 let len = v.compute_size();
2494 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2495 }
2496 if let Some(ref v) = self.point_b.as_ref() {
2497 let len = v.compute_size();
2498 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2499 }
2500 if self.height != 0 {
2501 my_size += ::protobuf::rt::value_size(4, self.height, ::protobuf::wire_format::WireTypeVarint);
2502 }
2503 if self.real_height != 0. {
2504 my_size += 5;
2505 }
2506 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2507 self.cached_size.set(my_size);
2508 my_size
2509 }
2510
2511 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2512 if !self.name.is_empty() {
2513 os.write_string(1, &self.name)?;
2514 }
2515 if let Some(ref v) = self.point_a.as_ref() {
2516 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2517 os.write_raw_varint32(v.get_cached_size())?;
2518 v.write_to_with_cached_sizes(os)?;
2519 }
2520 if let Some(ref v) = self.point_b.as_ref() {
2521 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2522 os.write_raw_varint32(v.get_cached_size())?;
2523 v.write_to_with_cached_sizes(os)?;
2524 }
2525 if self.height != 0 {
2526 os.write_int32(4, self.height)?;
2527 }
2528 if self.real_height != 0. {
2529 os.write_float(5, self.real_height)?;
2530 }
2531 os.write_unknown_fields(self.get_unknown_fields())?;
2532 ::std::result::Result::Ok(())
2533 }
2534
2535 fn get_cached_size(&self) -> u32 {
2536 self.cached_size.get()
2537 }
2538
2539 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2540 &self.unknown_fields
2541 }
2542
2543 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2544 &mut self.unknown_fields
2545 }
2546
2547 fn as_any(&self) -> &dyn (::std::any::Any) {
2548 self as &dyn (::std::any::Any)
2549 }
2550 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2551 self as &mut dyn (::std::any::Any)
2552 }
2553 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2554 self
2555 }
2556
2557 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2558 Self::descriptor_static()
2559 }
2560
2561 fn new() -> ZoneConfig {
2562 ZoneConfig::new()
2563 }
2564
2565 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2566 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2567 descriptor.get(|| {
2568 let mut fields = ::std::vec::Vec::new();
2569 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2570 "name",
2571 |m: &ZoneConfig| { &m.name },
2572 |m: &mut ZoneConfig| { &mut m.name },
2573 ));
2574 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Point>>(
2575 "point_a",
2576 |m: &ZoneConfig| { &m.point_a },
2577 |m: &mut ZoneConfig| { &mut m.point_a },
2578 ));
2579 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Point>>(
2580 "point_b",
2581 |m: &ZoneConfig| { &m.point_b },
2582 |m: &mut ZoneConfig| { &mut m.point_b },
2583 ));
2584 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
2585 "height",
2586 |m: &ZoneConfig| { &m.height },
2587 |m: &mut ZoneConfig| { &mut m.height },
2588 ));
2589 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
2590 "real_height",
2591 |m: &ZoneConfig| { &m.real_height },
2592 |m: &mut ZoneConfig| { &mut m.real_height },
2593 ));
2594 ::protobuf::reflect::MessageDescriptor::new_pb_name::<ZoneConfig>(
2595 "ZoneConfig",
2596 fields,
2597 file_descriptor_proto()
2598 )
2599 })
2600 }
2601
2602 fn default_instance() -> &'static ZoneConfig {
2603 static instance: ::protobuf::rt::LazyV2<ZoneConfig> = ::protobuf::rt::LazyV2::INIT;
2604 instance.get(ZoneConfig::new)
2605 }
2606}
2607
2608impl ::protobuf::Clear for ZoneConfig {
2609 fn clear(&mut self) {
2610 self.name.clear();
2611 self.point_a.clear();
2612 self.point_b.clear();
2613 self.height = 0;
2614 self.real_height = 0.;
2615 self.unknown_fields.clear();
2616 }
2617}
2618
2619impl ::std::fmt::Debug for ZoneConfig {
2620 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2621 ::protobuf::text_format::fmt(self, f)
2622 }
2623}
2624
2625impl ::protobuf::reflect::ProtobufValue for ZoneConfig {
2626 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2627 ::protobuf::reflect::ReflectValueRef::Message(self)
2628 }
2629}
2630
2631#[derive(PartialEq,Clone,Default)]
2632pub struct AreaConfig {
2633 pub name: ::std::string::String,
2635 pub point: ::protobuf::RepeatedField<Point>,
2636 pub count_direction: ::protobuf::SingularPtrField<Point>,
2637 pub unknown_fields: ::protobuf::UnknownFields,
2639 pub cached_size: ::protobuf::CachedSize,
2640}
2641
2642impl<'a> ::std::default::Default for &'a AreaConfig {
2643 fn default() -> &'a AreaConfig {
2644 <AreaConfig as ::protobuf::Message>::default_instance()
2645 }
2646}
2647
2648impl AreaConfig {
2649 pub fn new() -> AreaConfig {
2650 ::std::default::Default::default()
2651 }
2652
2653 pub fn get_name(&self) -> &str {
2657 &self.name
2658 }
2659 pub fn clear_name(&mut self) {
2660 self.name.clear();
2661 }
2662
2663 pub fn set_name(&mut self, v: ::std::string::String) {
2665 self.name = v;
2666 }
2667
2668 pub fn mut_name(&mut self) -> &mut ::std::string::String {
2671 &mut self.name
2672 }
2673
2674 pub fn take_name(&mut self) -> ::std::string::String {
2676 ::std::mem::replace(&mut self.name, ::std::string::String::new())
2677 }
2678
2679 pub fn get_point(&self) -> &[Point] {
2683 &self.point
2684 }
2685 pub fn clear_point(&mut self) {
2686 self.point.clear();
2687 }
2688
2689 pub fn set_point(&mut self, v: ::protobuf::RepeatedField<Point>) {
2691 self.point = v;
2692 }
2693
2694 pub fn mut_point(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
2696 &mut self.point
2697 }
2698
2699 pub fn take_point(&mut self) -> ::protobuf::RepeatedField<Point> {
2701 ::std::mem::replace(&mut self.point, ::protobuf::RepeatedField::new())
2702 }
2703
2704 pub fn get_count_direction(&self) -> &Point {
2708 self.count_direction.as_ref().unwrap_or_else(|| <Point as ::protobuf::Message>::default_instance())
2709 }
2710 pub fn clear_count_direction(&mut self) {
2711 self.count_direction.clear();
2712 }
2713
2714 pub fn has_count_direction(&self) -> bool {
2715 self.count_direction.is_some()
2716 }
2717
2718 pub fn set_count_direction(&mut self, v: Point) {
2720 self.count_direction = ::protobuf::SingularPtrField::some(v);
2721 }
2722
2723 pub fn mut_count_direction(&mut self) -> &mut Point {
2726 if self.count_direction.is_none() {
2727 self.count_direction.set_default();
2728 }
2729 self.count_direction.as_mut().unwrap()
2730 }
2731
2732 pub fn take_count_direction(&mut self) -> Point {
2734 self.count_direction.take().unwrap_or_else(|| Point::new())
2735 }
2736}
2737
2738impl ::protobuf::Message for AreaConfig {
2739 fn is_initialized(&self) -> bool {
2740 for v in &self.point {
2741 if !v.is_initialized() {
2742 return false;
2743 }
2744 };
2745 for v in &self.count_direction {
2746 if !v.is_initialized() {
2747 return false;
2748 }
2749 };
2750 true
2751 }
2752
2753 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2754 while !is.eof()? {
2755 let (field_number, wire_type) = is.read_tag_unpack()?;
2756 match field_number {
2757 1 => {
2758 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2759 },
2760 2 => {
2761 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.point)?;
2762 },
2763 3 => {
2764 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.count_direction)?;
2765 },
2766 _ => {
2767 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2768 },
2769 };
2770 }
2771 ::std::result::Result::Ok(())
2772 }
2773
2774 #[allow(unused_variables)]
2776 fn compute_size(&self) -> u32 {
2777 let mut my_size = 0;
2778 if !self.name.is_empty() {
2779 my_size += ::protobuf::rt::string_size(1, &self.name);
2780 }
2781 for value in &self.point {
2782 let len = value.compute_size();
2783 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2784 };
2785 if let Some(ref v) = self.count_direction.as_ref() {
2786 let len = v.compute_size();
2787 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2788 }
2789 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2790 self.cached_size.set(my_size);
2791 my_size
2792 }
2793
2794 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2795 if !self.name.is_empty() {
2796 os.write_string(1, &self.name)?;
2797 }
2798 for v in &self.point {
2799 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2800 os.write_raw_varint32(v.get_cached_size())?;
2801 v.write_to_with_cached_sizes(os)?;
2802 };
2803 if let Some(ref v) = self.count_direction.as_ref() {
2804 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2805 os.write_raw_varint32(v.get_cached_size())?;
2806 v.write_to_with_cached_sizes(os)?;
2807 }
2808 os.write_unknown_fields(self.get_unknown_fields())?;
2809 ::std::result::Result::Ok(())
2810 }
2811
2812 fn get_cached_size(&self) -> u32 {
2813 self.cached_size.get()
2814 }
2815
2816 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2817 &self.unknown_fields
2818 }
2819
2820 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2821 &mut self.unknown_fields
2822 }
2823
2824 fn as_any(&self) -> &dyn (::std::any::Any) {
2825 self as &dyn (::std::any::Any)
2826 }
2827 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2828 self as &mut dyn (::std::any::Any)
2829 }
2830 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2831 self
2832 }
2833
2834 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2835 Self::descriptor_static()
2836 }
2837
2838 fn new() -> AreaConfig {
2839 AreaConfig::new()
2840 }
2841
2842 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2843 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2844 descriptor.get(|| {
2845 let mut fields = ::std::vec::Vec::new();
2846 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2847 "name",
2848 |m: &AreaConfig| { &m.name },
2849 |m: &mut AreaConfig| { &mut m.name },
2850 ));
2851 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Point>>(
2852 "point",
2853 |m: &AreaConfig| { &m.point },
2854 |m: &mut AreaConfig| { &mut m.point },
2855 ));
2856 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Point>>(
2857 "count_direction",
2858 |m: &AreaConfig| { &m.count_direction },
2859 |m: &mut AreaConfig| { &mut m.count_direction },
2860 ));
2861 ::protobuf::reflect::MessageDescriptor::new_pb_name::<AreaConfig>(
2862 "AreaConfig",
2863 fields,
2864 file_descriptor_proto()
2865 )
2866 })
2867 }
2868
2869 fn default_instance() -> &'static AreaConfig {
2870 static instance: ::protobuf::rt::LazyV2<AreaConfig> = ::protobuf::rt::LazyV2::INIT;
2871 instance.get(AreaConfig::new)
2872 }
2873}
2874
2875impl ::protobuf::Clear for AreaConfig {
2876 fn clear(&mut self) {
2877 self.name.clear();
2878 self.point.clear();
2879 self.count_direction.clear();
2880 self.unknown_fields.clear();
2881 }
2882}
2883
2884impl ::std::fmt::Debug for AreaConfig {
2885 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2886 ::protobuf::text_format::fmt(self, f)
2887 }
2888}
2889
2890impl ::protobuf::reflect::ProtobufValue for AreaConfig {
2891 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2892 ::protobuf::reflect::ReflectValueRef::Message(self)
2893 }
2894}
2895
2896#[derive(PartialEq,Clone,Default)]
2897pub struct AreaAndZoneConfig {
2898 pub area: ::protobuf::RepeatedField<AreaConfig>,
2900 pub zone: ::protobuf::RepeatedField<ZoneConfig>,
2901 pub region_of_interest: ::protobuf::RepeatedField<Rectangle>,
2902 pub unknown_fields: ::protobuf::UnknownFields,
2904 pub cached_size: ::protobuf::CachedSize,
2905}
2906
2907impl<'a> ::std::default::Default for &'a AreaAndZoneConfig {
2908 fn default() -> &'a AreaAndZoneConfig {
2909 <AreaAndZoneConfig as ::protobuf::Message>::default_instance()
2910 }
2911}
2912
2913impl AreaAndZoneConfig {
2914 pub fn new() -> AreaAndZoneConfig {
2915 ::std::default::Default::default()
2916 }
2917
2918 pub fn get_area(&self) -> &[AreaConfig] {
2922 &self.area
2923 }
2924 pub fn clear_area(&mut self) {
2925 self.area.clear();
2926 }
2927
2928 pub fn set_area(&mut self, v: ::protobuf::RepeatedField<AreaConfig>) {
2930 self.area = v;
2931 }
2932
2933 pub fn mut_area(&mut self) -> &mut ::protobuf::RepeatedField<AreaConfig> {
2935 &mut self.area
2936 }
2937
2938 pub fn take_area(&mut self) -> ::protobuf::RepeatedField<AreaConfig> {
2940 ::std::mem::replace(&mut self.area, ::protobuf::RepeatedField::new())
2941 }
2942
2943 pub fn get_zone(&self) -> &[ZoneConfig] {
2947 &self.zone
2948 }
2949 pub fn clear_zone(&mut self) {
2950 self.zone.clear();
2951 }
2952
2953 pub fn set_zone(&mut self, v: ::protobuf::RepeatedField<ZoneConfig>) {
2955 self.zone = v;
2956 }
2957
2958 pub fn mut_zone(&mut self) -> &mut ::protobuf::RepeatedField<ZoneConfig> {
2960 &mut self.zone
2961 }
2962
2963 pub fn take_zone(&mut self) -> ::protobuf::RepeatedField<ZoneConfig> {
2965 ::std::mem::replace(&mut self.zone, ::protobuf::RepeatedField::new())
2966 }
2967
2968 pub fn get_region_of_interest(&self) -> &[Rectangle] {
2972 &self.region_of_interest
2973 }
2974 pub fn clear_region_of_interest(&mut self) {
2975 self.region_of_interest.clear();
2976 }
2977
2978 pub fn set_region_of_interest(&mut self, v: ::protobuf::RepeatedField<Rectangle>) {
2980 self.region_of_interest = v;
2981 }
2982
2983 pub fn mut_region_of_interest(&mut self) -> &mut ::protobuf::RepeatedField<Rectangle> {
2985 &mut self.region_of_interest
2986 }
2987
2988 pub fn take_region_of_interest(&mut self) -> ::protobuf::RepeatedField<Rectangle> {
2990 ::std::mem::replace(&mut self.region_of_interest, ::protobuf::RepeatedField::new())
2991 }
2992}
2993
2994impl ::protobuf::Message for AreaAndZoneConfig {
2995 fn is_initialized(&self) -> bool {
2996 for v in &self.area {
2997 if !v.is_initialized() {
2998 return false;
2999 }
3000 };
3001 for v in &self.zone {
3002 if !v.is_initialized() {
3003 return false;
3004 }
3005 };
3006 for v in &self.region_of_interest {
3007 if !v.is_initialized() {
3008 return false;
3009 }
3010 };
3011 true
3012 }
3013
3014 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3015 while !is.eof()? {
3016 let (field_number, wire_type) = is.read_tag_unpack()?;
3017 match field_number {
3018 1 => {
3019 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.area)?;
3020 },
3021 2 => {
3022 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.zone)?;
3023 },
3024 3 => {
3025 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.region_of_interest)?;
3026 },
3027 _ => {
3028 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3029 },
3030 };
3031 }
3032 ::std::result::Result::Ok(())
3033 }
3034
3035 #[allow(unused_variables)]
3037 fn compute_size(&self) -> u32 {
3038 let mut my_size = 0;
3039 for value in &self.area {
3040 let len = value.compute_size();
3041 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
3042 };
3043 for value in &self.zone {
3044 let len = value.compute_size();
3045 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
3046 };
3047 for value in &self.region_of_interest {
3048 let len = value.compute_size();
3049 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
3050 };
3051 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3052 self.cached_size.set(my_size);
3053 my_size
3054 }
3055
3056 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3057 for v in &self.area {
3058 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
3059 os.write_raw_varint32(v.get_cached_size())?;
3060 v.write_to_with_cached_sizes(os)?;
3061 };
3062 for v in &self.zone {
3063 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
3064 os.write_raw_varint32(v.get_cached_size())?;
3065 v.write_to_with_cached_sizes(os)?;
3066 };
3067 for v in &self.region_of_interest {
3068 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
3069 os.write_raw_varint32(v.get_cached_size())?;
3070 v.write_to_with_cached_sizes(os)?;
3071 };
3072 os.write_unknown_fields(self.get_unknown_fields())?;
3073 ::std::result::Result::Ok(())
3074 }
3075
3076 fn get_cached_size(&self) -> u32 {
3077 self.cached_size.get()
3078 }
3079
3080 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3081 &self.unknown_fields
3082 }
3083
3084 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3085 &mut self.unknown_fields
3086 }
3087
3088 fn as_any(&self) -> &dyn (::std::any::Any) {
3089 self as &dyn (::std::any::Any)
3090 }
3091 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3092 self as &mut dyn (::std::any::Any)
3093 }
3094 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3095 self
3096 }
3097
3098 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3099 Self::descriptor_static()
3100 }
3101
3102 fn new() -> AreaAndZoneConfig {
3103 AreaAndZoneConfig::new()
3104 }
3105
3106 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3107 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
3108 descriptor.get(|| {
3109 let mut fields = ::std::vec::Vec::new();
3110 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AreaConfig>>(
3111 "area",
3112 |m: &AreaAndZoneConfig| { &m.area },
3113 |m: &mut AreaAndZoneConfig| { &mut m.area },
3114 ));
3115 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ZoneConfig>>(
3116 "zone",
3117 |m: &AreaAndZoneConfig| { &m.zone },
3118 |m: &mut AreaAndZoneConfig| { &mut m.zone },
3119 ));
3120 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Rectangle>>(
3121 "region_of_interest",
3122 |m: &AreaAndZoneConfig| { &m.region_of_interest },
3123 |m: &mut AreaAndZoneConfig| { &mut m.region_of_interest },
3124 ));
3125 ::protobuf::reflect::MessageDescriptor::new_pb_name::<AreaAndZoneConfig>(
3126 "AreaAndZoneConfig",
3127 fields,
3128 file_descriptor_proto()
3129 )
3130 })
3131 }
3132
3133 fn default_instance() -> &'static AreaAndZoneConfig {
3134 static instance: ::protobuf::rt::LazyV2<AreaAndZoneConfig> = ::protobuf::rt::LazyV2::INIT;
3135 instance.get(AreaAndZoneConfig::new)
3136 }
3137}
3138
3139impl ::protobuf::Clear for AreaAndZoneConfig {
3140 fn clear(&mut self) {
3141 self.area.clear();
3142 self.zone.clear();
3143 self.region_of_interest.clear();
3144 self.unknown_fields.clear();
3145 }
3146}
3147
3148impl ::std::fmt::Debug for AreaAndZoneConfig {
3149 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3150 ::protobuf::text_format::fmt(self, f)
3151 }
3152}
3153
3154impl ::protobuf::reflect::ProtobufValue for AreaAndZoneConfig {
3155 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
3156 ::protobuf::reflect::ReflectValueRef::Message(self)
3157 }
3158}
3159
3160#[derive(PartialEq,Clone,Default)]
3161pub struct VehicleConfig {
3162 pub camera_url: ::std::string::String,
3164 pub area_and_zone: ::protobuf::SingularPtrField<AreaAndZoneConfig>,
3165 pub unknown_fields: ::protobuf::UnknownFields,
3167 pub cached_size: ::protobuf::CachedSize,
3168}
3169
3170impl<'a> ::std::default::Default for &'a VehicleConfig {
3171 fn default() -> &'a VehicleConfig {
3172 <VehicleConfig as ::protobuf::Message>::default_instance()
3173 }
3174}
3175
3176impl VehicleConfig {
3177 pub fn new() -> VehicleConfig {
3178 ::std::default::Default::default()
3179 }
3180
3181 pub fn get_camera_url(&self) -> &str {
3185 &self.camera_url
3186 }
3187 pub fn clear_camera_url(&mut self) {
3188 self.camera_url.clear();
3189 }
3190
3191 pub fn set_camera_url(&mut self, v: ::std::string::String) {
3193 self.camera_url = v;
3194 }
3195
3196 pub fn mut_camera_url(&mut self) -> &mut ::std::string::String {
3199 &mut self.camera_url
3200 }
3201
3202 pub fn take_camera_url(&mut self) -> ::std::string::String {
3204 ::std::mem::replace(&mut self.camera_url, ::std::string::String::new())
3205 }
3206
3207 pub fn get_area_and_zone(&self) -> &AreaAndZoneConfig {
3211 self.area_and_zone.as_ref().unwrap_or_else(|| <AreaAndZoneConfig as ::protobuf::Message>::default_instance())
3212 }
3213 pub fn clear_area_and_zone(&mut self) {
3214 self.area_and_zone.clear();
3215 }
3216
3217 pub fn has_area_and_zone(&self) -> bool {
3218 self.area_and_zone.is_some()
3219 }
3220
3221 pub fn set_area_and_zone(&mut self, v: AreaAndZoneConfig) {
3223 self.area_and_zone = ::protobuf::SingularPtrField::some(v);
3224 }
3225
3226 pub fn mut_area_and_zone(&mut self) -> &mut AreaAndZoneConfig {
3229 if self.area_and_zone.is_none() {
3230 self.area_and_zone.set_default();
3231 }
3232 self.area_and_zone.as_mut().unwrap()
3233 }
3234
3235 pub fn take_area_and_zone(&mut self) -> AreaAndZoneConfig {
3237 self.area_and_zone.take().unwrap_or_else(|| AreaAndZoneConfig::new())
3238 }
3239}
3240
3241impl ::protobuf::Message for VehicleConfig {
3242 fn is_initialized(&self) -> bool {
3243 for v in &self.area_and_zone {
3244 if !v.is_initialized() {
3245 return false;
3246 }
3247 };
3248 true
3249 }
3250
3251 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3252 while !is.eof()? {
3253 let (field_number, wire_type) = is.read_tag_unpack()?;
3254 match field_number {
3255 1 => {
3256 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.camera_url)?;
3257 },
3258 2 => {
3259 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.area_and_zone)?;
3260 },
3261 _ => {
3262 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3263 },
3264 };
3265 }
3266 ::std::result::Result::Ok(())
3267 }
3268
3269 #[allow(unused_variables)]
3271 fn compute_size(&self) -> u32 {
3272 let mut my_size = 0;
3273 if !self.camera_url.is_empty() {
3274 my_size += ::protobuf::rt::string_size(1, &self.camera_url);
3275 }
3276 if let Some(ref v) = self.area_and_zone.as_ref() {
3277 let len = v.compute_size();
3278 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
3279 }
3280 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3281 self.cached_size.set(my_size);
3282 my_size
3283 }
3284
3285 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3286 if !self.camera_url.is_empty() {
3287 os.write_string(1, &self.camera_url)?;
3288 }
3289 if let Some(ref v) = self.area_and_zone.as_ref() {
3290 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
3291 os.write_raw_varint32(v.get_cached_size())?;
3292 v.write_to_with_cached_sizes(os)?;
3293 }
3294 os.write_unknown_fields(self.get_unknown_fields())?;
3295 ::std::result::Result::Ok(())
3296 }
3297
3298 fn get_cached_size(&self) -> u32 {
3299 self.cached_size.get()
3300 }
3301
3302 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3303 &self.unknown_fields
3304 }
3305
3306 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3307 &mut self.unknown_fields
3308 }
3309
3310 fn as_any(&self) -> &dyn (::std::any::Any) {
3311 self as &dyn (::std::any::Any)
3312 }
3313 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3314 self as &mut dyn (::std::any::Any)
3315 }
3316 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3317 self
3318 }
3319
3320 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3321 Self::descriptor_static()
3322 }
3323
3324 fn new() -> VehicleConfig {
3325 VehicleConfig::new()
3326 }
3327
3328 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3329 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
3330 descriptor.get(|| {
3331 let mut fields = ::std::vec::Vec::new();
3332 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3333 "camera_url",
3334 |m: &VehicleConfig| { &m.camera_url },
3335 |m: &mut VehicleConfig| { &mut m.camera_url },
3336 ));
3337 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AreaAndZoneConfig>>(
3338 "area_and_zone",
3339 |m: &VehicleConfig| { &m.area_and_zone },
3340 |m: &mut VehicleConfig| { &mut m.area_and_zone },
3341 ));
3342 ::protobuf::reflect::MessageDescriptor::new_pb_name::<VehicleConfig>(
3343 "VehicleConfig",
3344 fields,
3345 file_descriptor_proto()
3346 )
3347 })
3348 }
3349
3350 fn default_instance() -> &'static VehicleConfig {
3351 static instance: ::protobuf::rt::LazyV2<VehicleConfig> = ::protobuf::rt::LazyV2::INIT;
3352 instance.get(VehicleConfig::new)
3353 }
3354}
3355
3356impl ::protobuf::Clear for VehicleConfig {
3357 fn clear(&mut self) {
3358 self.camera_url.clear();
3359 self.area_and_zone.clear();
3360 self.unknown_fields.clear();
3361 }
3362}
3363
3364impl ::std::fmt::Debug for VehicleConfig {
3365 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3366 ::protobuf::text_format::fmt(self, f)
3367 }
3368}
3369
3370impl ::protobuf::reflect::ProtobufValue for VehicleConfig {
3371 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
3372 ::protobuf::reflect::ReflectValueRef::Message(self)
3373 }
3374}
3375
3376#[derive(PartialEq,Clone,Default)]
3377pub struct VisionEvent {
3378 pub tag: EventTag,
3380 pub tracking_id: u64,
3381 pub session_time: f32,
3382 pub dwell_time: f32,
3383 pub area_id: u64,
3384 pub zone_id: u64,
3385 pub zone_direction: ZoneDirection,
3386 pub speed: f32,
3387 pub timestamp: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
3388 pub area_name: ::std::string::String,
3389 pub zone_name: ::std::string::String,
3390 pub unknown_fields: ::protobuf::UnknownFields,
3392 pub cached_size: ::protobuf::CachedSize,
3393}
3394
3395impl<'a> ::std::default::Default for &'a VisionEvent {
3396 fn default() -> &'a VisionEvent {
3397 <VisionEvent as ::protobuf::Message>::default_instance()
3398 }
3399}
3400
3401impl VisionEvent {
3402 pub fn new() -> VisionEvent {
3403 ::std::default::Default::default()
3404 }
3405
3406 pub fn get_tag(&self) -> EventTag {
3410 self.tag
3411 }
3412 pub fn clear_tag(&mut self) {
3413 self.tag = EventTag::EVENT_NOT_DEFINED;
3414 }
3415
3416 pub fn set_tag(&mut self, v: EventTag) {
3418 self.tag = v;
3419 }
3420
3421 pub fn get_tracking_id(&self) -> u64 {
3425 self.tracking_id
3426 }
3427 pub fn clear_tracking_id(&mut self) {
3428 self.tracking_id = 0;
3429 }
3430
3431 pub fn set_tracking_id(&mut self, v: u64) {
3433 self.tracking_id = v;
3434 }
3435
3436 pub fn get_session_time(&self) -> f32 {
3440 self.session_time
3441 }
3442 pub fn clear_session_time(&mut self) {
3443 self.session_time = 0.;
3444 }
3445
3446 pub fn set_session_time(&mut self, v: f32) {
3448 self.session_time = v;
3449 }
3450
3451 pub fn get_dwell_time(&self) -> f32 {
3455 self.dwell_time
3456 }
3457 pub fn clear_dwell_time(&mut self) {
3458 self.dwell_time = 0.;
3459 }
3460
3461 pub fn set_dwell_time(&mut self, v: f32) {
3463 self.dwell_time = v;
3464 }
3465
3466 pub fn get_area_id(&self) -> u64 {
3470 self.area_id
3471 }
3472 pub fn clear_area_id(&mut self) {
3473 self.area_id = 0;
3474 }
3475
3476 pub fn set_area_id(&mut self, v: u64) {
3478 self.area_id = v;
3479 }
3480
3481 pub fn get_zone_id(&self) -> u64 {
3485 self.zone_id
3486 }
3487 pub fn clear_zone_id(&mut self) {
3488 self.zone_id = 0;
3489 }
3490
3491 pub fn set_zone_id(&mut self, v: u64) {
3493 self.zone_id = v;
3494 }
3495
3496 pub fn get_zone_direction(&self) -> ZoneDirection {
3500 self.zone_direction
3501 }
3502 pub fn clear_zone_direction(&mut self) {
3503 self.zone_direction = ZoneDirection::ZONE_DIRECTION_NOT_DEFINED;
3504 }
3505
3506 pub fn set_zone_direction(&mut self, v: ZoneDirection) {
3508 self.zone_direction = v;
3509 }
3510
3511 pub fn get_speed(&self) -> f32 {
3515 self.speed
3516 }
3517 pub fn clear_speed(&mut self) {
3518 self.speed = 0.;
3519 }
3520
3521 pub fn set_speed(&mut self, v: f32) {
3523 self.speed = v;
3524 }
3525
3526 pub fn get_timestamp(&self) -> &::protobuf::well_known_types::Timestamp {
3530 self.timestamp.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
3531 }
3532 pub fn clear_timestamp(&mut self) {
3533 self.timestamp.clear();
3534 }
3535
3536 pub fn has_timestamp(&self) -> bool {
3537 self.timestamp.is_some()
3538 }
3539
3540 pub fn set_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) {
3542 self.timestamp = ::protobuf::SingularPtrField::some(v);
3543 }
3544
3545 pub fn mut_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
3548 if self.timestamp.is_none() {
3549 self.timestamp.set_default();
3550 }
3551 self.timestamp.as_mut().unwrap()
3552 }
3553
3554 pub fn take_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp {
3556 self.timestamp.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
3557 }
3558
3559 pub fn get_area_name(&self) -> &str {
3563 &self.area_name
3564 }
3565 pub fn clear_area_name(&mut self) {
3566 self.area_name.clear();
3567 }
3568
3569 pub fn set_area_name(&mut self, v: ::std::string::String) {
3571 self.area_name = v;
3572 }
3573
3574 pub fn mut_area_name(&mut self) -> &mut ::std::string::String {
3577 &mut self.area_name
3578 }
3579
3580 pub fn take_area_name(&mut self) -> ::std::string::String {
3582 ::std::mem::replace(&mut self.area_name, ::std::string::String::new())
3583 }
3584
3585 pub fn get_zone_name(&self) -> &str {
3589 &self.zone_name
3590 }
3591 pub fn clear_zone_name(&mut self) {
3592 self.zone_name.clear();
3593 }
3594
3595 pub fn set_zone_name(&mut self, v: ::std::string::String) {
3597 self.zone_name = v;
3598 }
3599
3600 pub fn mut_zone_name(&mut self) -> &mut ::std::string::String {
3603 &mut self.zone_name
3604 }
3605
3606 pub fn take_zone_name(&mut self) -> ::std::string::String {
3608 ::std::mem::replace(&mut self.zone_name, ::std::string::String::new())
3609 }
3610}
3611
3612impl ::protobuf::Message for VisionEvent {
3613 fn is_initialized(&self) -> bool {
3614 for v in &self.timestamp {
3615 if !v.is_initialized() {
3616 return false;
3617 }
3618 };
3619 true
3620 }
3621
3622 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3623 while !is.eof()? {
3624 let (field_number, wire_type) = is.read_tag_unpack()?;
3625 match field_number {
3626 1 => {
3627 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.tag, 1, &mut self.unknown_fields)?
3628 },
3629 2 => {
3630 if wire_type != ::protobuf::wire_format::WireTypeVarint {
3631 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3632 }
3633 let tmp = is.read_uint64()?;
3634 self.tracking_id = tmp;
3635 },
3636 3 => {
3637 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
3638 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3639 }
3640 let tmp = is.read_float()?;
3641 self.session_time = tmp;
3642 },
3643 4 => {
3644 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
3645 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3646 }
3647 let tmp = is.read_float()?;
3648 self.dwell_time = tmp;
3649 },
3650 5 => {
3651 if wire_type != ::protobuf::wire_format::WireTypeVarint {
3652 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3653 }
3654 let tmp = is.read_uint64()?;
3655 self.area_id = tmp;
3656 },
3657 6 => {
3658 if wire_type != ::protobuf::wire_format::WireTypeVarint {
3659 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3660 }
3661 let tmp = is.read_uint64()?;
3662 self.zone_id = tmp;
3663 },
3664 7 => {
3665 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.zone_direction, 7, &mut self.unknown_fields)?
3666 },
3667 8 => {
3668 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
3669 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3670 }
3671 let tmp = is.read_float()?;
3672 self.speed = tmp;
3673 },
3674 9 => {
3675 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.timestamp)?;
3676 },
3677 10 => {
3678 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.area_name)?;
3679 },
3680 11 => {
3681 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.zone_name)?;
3682 },
3683 _ => {
3684 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3685 },
3686 };
3687 }
3688 ::std::result::Result::Ok(())
3689 }
3690
3691 #[allow(unused_variables)]
3693 fn compute_size(&self) -> u32 {
3694 let mut my_size = 0;
3695 if self.tag != EventTag::EVENT_NOT_DEFINED {
3696 my_size += ::protobuf::rt::enum_size(1, self.tag);
3697 }
3698 if self.tracking_id != 0 {
3699 my_size += ::protobuf::rt::value_size(2, self.tracking_id, ::protobuf::wire_format::WireTypeVarint);
3700 }
3701 if self.session_time != 0. {
3702 my_size += 5;
3703 }
3704 if self.dwell_time != 0. {
3705 my_size += 5;
3706 }
3707 if self.area_id != 0 {
3708 my_size += ::protobuf::rt::value_size(5, self.area_id, ::protobuf::wire_format::WireTypeVarint);
3709 }
3710 if self.zone_id != 0 {
3711 my_size += ::protobuf::rt::value_size(6, self.zone_id, ::protobuf::wire_format::WireTypeVarint);
3712 }
3713 if self.zone_direction != ZoneDirection::ZONE_DIRECTION_NOT_DEFINED {
3714 my_size += ::protobuf::rt::enum_size(7, self.zone_direction);
3715 }
3716 if self.speed != 0. {
3717 my_size += 5;
3718 }
3719 if let Some(ref v) = self.timestamp.as_ref() {
3720 let len = v.compute_size();
3721 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
3722 }
3723 if !self.area_name.is_empty() {
3724 my_size += ::protobuf::rt::string_size(10, &self.area_name);
3725 }
3726 if !self.zone_name.is_empty() {
3727 my_size += ::protobuf::rt::string_size(11, &self.zone_name);
3728 }
3729 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3730 self.cached_size.set(my_size);
3731 my_size
3732 }
3733
3734 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3735 if self.tag != EventTag::EVENT_NOT_DEFINED {
3736 os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.tag))?;
3737 }
3738 if self.tracking_id != 0 {
3739 os.write_uint64(2, self.tracking_id)?;
3740 }
3741 if self.session_time != 0. {
3742 os.write_float(3, self.session_time)?;
3743 }
3744 if self.dwell_time != 0. {
3745 os.write_float(4, self.dwell_time)?;
3746 }
3747 if self.area_id != 0 {
3748 os.write_uint64(5, self.area_id)?;
3749 }
3750 if self.zone_id != 0 {
3751 os.write_uint64(6, self.zone_id)?;
3752 }
3753 if self.zone_direction != ZoneDirection::ZONE_DIRECTION_NOT_DEFINED {
3754 os.write_enum(7, ::protobuf::ProtobufEnum::value(&self.zone_direction))?;
3755 }
3756 if self.speed != 0. {
3757 os.write_float(8, self.speed)?;
3758 }
3759 if let Some(ref v) = self.timestamp.as_ref() {
3760 os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
3761 os.write_raw_varint32(v.get_cached_size())?;
3762 v.write_to_with_cached_sizes(os)?;
3763 }
3764 if !self.area_name.is_empty() {
3765 os.write_string(10, &self.area_name)?;
3766 }
3767 if !self.zone_name.is_empty() {
3768 os.write_string(11, &self.zone_name)?;
3769 }
3770 os.write_unknown_fields(self.get_unknown_fields())?;
3771 ::std::result::Result::Ok(())
3772 }
3773
3774 fn get_cached_size(&self) -> u32 {
3775 self.cached_size.get()
3776 }
3777
3778 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3779 &self.unknown_fields
3780 }
3781
3782 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3783 &mut self.unknown_fields
3784 }
3785
3786 fn as_any(&self) -> &dyn (::std::any::Any) {
3787 self as &dyn (::std::any::Any)
3788 }
3789 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3790 self as &mut dyn (::std::any::Any)
3791 }
3792 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3793 self
3794 }
3795
3796 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3797 Self::descriptor_static()
3798 }
3799
3800 fn new() -> VisionEvent {
3801 VisionEvent::new()
3802 }
3803
3804 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3805 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
3806 descriptor.get(|| {
3807 let mut fields = ::std::vec::Vec::new();
3808 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EventTag>>(
3809 "tag",
3810 |m: &VisionEvent| { &m.tag },
3811 |m: &mut VisionEvent| { &mut m.tag },
3812 ));
3813 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
3814 "tracking_id",
3815 |m: &VisionEvent| { &m.tracking_id },
3816 |m: &mut VisionEvent| { &mut m.tracking_id },
3817 ));
3818 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
3819 "session_time",
3820 |m: &VisionEvent| { &m.session_time },
3821 |m: &mut VisionEvent| { &mut m.session_time },
3822 ));
3823 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
3824 "dwell_time",
3825 |m: &VisionEvent| { &m.dwell_time },
3826 |m: &mut VisionEvent| { &mut m.dwell_time },
3827 ));
3828 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
3829 "area_id",
3830 |m: &VisionEvent| { &m.area_id },
3831 |m: &mut VisionEvent| { &mut m.area_id },
3832 ));
3833 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
3834 "zone_id",
3835 |m: &VisionEvent| { &m.zone_id },
3836 |m: &mut VisionEvent| { &mut m.zone_id },
3837 ));
3838 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ZoneDirection>>(
3839 "zone_direction",
3840 |m: &VisionEvent| { &m.zone_direction },
3841 |m: &mut VisionEvent| { &mut m.zone_direction },
3842 ));
3843 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
3844 "speed",
3845 |m: &VisionEvent| { &m.speed },
3846 |m: &mut VisionEvent| { &mut m.speed },
3847 ));
3848 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
3849 "timestamp",
3850 |m: &VisionEvent| { &m.timestamp },
3851 |m: &mut VisionEvent| { &mut m.timestamp },
3852 ));
3853 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3854 "area_name",
3855 |m: &VisionEvent| { &m.area_name },
3856 |m: &mut VisionEvent| { &mut m.area_name },
3857 ));
3858 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3859 "zone_name",
3860 |m: &VisionEvent| { &m.zone_name },
3861 |m: &mut VisionEvent| { &mut m.zone_name },
3862 ));
3863 ::protobuf::reflect::MessageDescriptor::new_pb_name::<VisionEvent>(
3864 "VisionEvent",
3865 fields,
3866 file_descriptor_proto()
3867 )
3868 })
3869 }
3870
3871 fn default_instance() -> &'static VisionEvent {
3872 static instance: ::protobuf::rt::LazyV2<VisionEvent> = ::protobuf::rt::LazyV2::INIT;
3873 instance.get(VisionEvent::new)
3874 }
3875}
3876
3877impl ::protobuf::Clear for VisionEvent {
3878 fn clear(&mut self) {
3879 self.tag = EventTag::EVENT_NOT_DEFINED;
3880 self.tracking_id = 0;
3881 self.session_time = 0.;
3882 self.dwell_time = 0.;
3883 self.area_id = 0;
3884 self.zone_id = 0;
3885 self.zone_direction = ZoneDirection::ZONE_DIRECTION_NOT_DEFINED;
3886 self.speed = 0.;
3887 self.timestamp.clear();
3888 self.area_name.clear();
3889 self.zone_name.clear();
3890 self.unknown_fields.clear();
3891 }
3892}
3893
3894impl ::std::fmt::Debug for VisionEvent {
3895 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3896 ::protobuf::text_format::fmt(self, f)
3897 }
3898}
3899
3900impl ::protobuf::reflect::ProtobufValue for VisionEvent {
3901 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
3902 ::protobuf::reflect::ReflectValueRef::Message(self)
3903 }
3904}
3905
3906#[derive(PartialEq,Clone,Default)]
3907pub struct RectangularDetection {
3908 pub algorithm: EnumDetectionAlgorithm,
3910 pub location: ::protobuf::SingularPtrField<Rectangle>,
3911 pub tag: EnumDetectionTag,
3912 pub confidence: f32,
3913 pub facial_recognition: ::protobuf::RepeatedField<FacialRecognition>,
3914 pub vehicle_recognition: ::protobuf::RepeatedField<VehicleRecognition>,
3915 pub speed: f32,
3916 pub image: ::std::vec::Vec<u8>,
3917 pub image_small: ::std::vec::Vec<u8>,
3918 pub field_type: ::std::string::String,
3919 pub tracking_id: u64,
3920 pub uuid: ::std::string::String,
3921 pub unknown_fields: ::protobuf::UnknownFields,
3923 pub cached_size: ::protobuf::CachedSize,
3924}
3925
3926impl<'a> ::std::default::Default for &'a RectangularDetection {
3927 fn default() -> &'a RectangularDetection {
3928 <RectangularDetection as ::protobuf::Message>::default_instance()
3929 }
3930}
3931
3932impl RectangularDetection {
3933 pub fn new() -> RectangularDetection {
3934 ::std::default::Default::default()
3935 }
3936
3937 pub fn get_algorithm(&self) -> EnumDetectionAlgorithm {
3941 self.algorithm
3942 }
3943 pub fn clear_algorithm(&mut self) {
3944 self.algorithm = EnumDetectionAlgorithm::DETECTION_ALGORITHM_NOT_DEFINED;
3945 }
3946
3947 pub fn set_algorithm(&mut self, v: EnumDetectionAlgorithm) {
3949 self.algorithm = v;
3950 }
3951
3952 pub fn get_location(&self) -> &Rectangle {
3956 self.location.as_ref().unwrap_or_else(|| <Rectangle as ::protobuf::Message>::default_instance())
3957 }
3958 pub fn clear_location(&mut self) {
3959 self.location.clear();
3960 }
3961
3962 pub fn has_location(&self) -> bool {
3963 self.location.is_some()
3964 }
3965
3966 pub fn set_location(&mut self, v: Rectangle) {
3968 self.location = ::protobuf::SingularPtrField::some(v);
3969 }
3970
3971 pub fn mut_location(&mut self) -> &mut Rectangle {
3974 if self.location.is_none() {
3975 self.location.set_default();
3976 }
3977 self.location.as_mut().unwrap()
3978 }
3979
3980 pub fn take_location(&mut self) -> Rectangle {
3982 self.location.take().unwrap_or_else(|| Rectangle::new())
3983 }
3984
3985 pub fn get_tag(&self) -> EnumDetectionTag {
3989 self.tag
3990 }
3991 pub fn clear_tag(&mut self) {
3992 self.tag = EnumDetectionTag::DETECTION_NOT_DEFINED;
3993 }
3994
3995 pub fn set_tag(&mut self, v: EnumDetectionTag) {
3997 self.tag = v;
3998 }
3999
4000 pub fn get_confidence(&self) -> f32 {
4004 self.confidence
4005 }
4006 pub fn clear_confidence(&mut self) {
4007 self.confidence = 0.;
4008 }
4009
4010 pub fn set_confidence(&mut self, v: f32) {
4012 self.confidence = v;
4013 }
4014
4015 pub fn get_facial_recognition(&self) -> &[FacialRecognition] {
4019 &self.facial_recognition
4020 }
4021 pub fn clear_facial_recognition(&mut self) {
4022 self.facial_recognition.clear();
4023 }
4024
4025 pub fn set_facial_recognition(&mut self, v: ::protobuf::RepeatedField<FacialRecognition>) {
4027 self.facial_recognition = v;
4028 }
4029
4030 pub fn mut_facial_recognition(&mut self) -> &mut ::protobuf::RepeatedField<FacialRecognition> {
4032 &mut self.facial_recognition
4033 }
4034
4035 pub fn take_facial_recognition(&mut self) -> ::protobuf::RepeatedField<FacialRecognition> {
4037 ::std::mem::replace(&mut self.facial_recognition, ::protobuf::RepeatedField::new())
4038 }
4039
4040 pub fn get_vehicle_recognition(&self) -> &[VehicleRecognition] {
4044 &self.vehicle_recognition
4045 }
4046 pub fn clear_vehicle_recognition(&mut self) {
4047 self.vehicle_recognition.clear();
4048 }
4049
4050 pub fn set_vehicle_recognition(&mut self, v: ::protobuf::RepeatedField<VehicleRecognition>) {
4052 self.vehicle_recognition = v;
4053 }
4054
4055 pub fn mut_vehicle_recognition(&mut self) -> &mut ::protobuf::RepeatedField<VehicleRecognition> {
4057 &mut self.vehicle_recognition
4058 }
4059
4060 pub fn take_vehicle_recognition(&mut self) -> ::protobuf::RepeatedField<VehicleRecognition> {
4062 ::std::mem::replace(&mut self.vehicle_recognition, ::protobuf::RepeatedField::new())
4063 }
4064
4065 pub fn get_speed(&self) -> f32 {
4069 self.speed
4070 }
4071 pub fn clear_speed(&mut self) {
4072 self.speed = 0.;
4073 }
4074
4075 pub fn set_speed(&mut self, v: f32) {
4077 self.speed = v;
4078 }
4079
4080 pub fn get_image(&self) -> &[u8] {
4084 &self.image
4085 }
4086 pub fn clear_image(&mut self) {
4087 self.image.clear();
4088 }
4089
4090 pub fn set_image(&mut self, v: ::std::vec::Vec<u8>) {
4092 self.image = v;
4093 }
4094
4095 pub fn mut_image(&mut self) -> &mut ::std::vec::Vec<u8> {
4098 &mut self.image
4099 }
4100
4101 pub fn take_image(&mut self) -> ::std::vec::Vec<u8> {
4103 ::std::mem::replace(&mut self.image, ::std::vec::Vec::new())
4104 }
4105
4106 pub fn get_image_small(&self) -> &[u8] {
4110 &self.image_small
4111 }
4112 pub fn clear_image_small(&mut self) {
4113 self.image_small.clear();
4114 }
4115
4116 pub fn set_image_small(&mut self, v: ::std::vec::Vec<u8>) {
4118 self.image_small = v;
4119 }
4120
4121 pub fn mut_image_small(&mut self) -> &mut ::std::vec::Vec<u8> {
4124 &mut self.image_small
4125 }
4126
4127 pub fn take_image_small(&mut self) -> ::std::vec::Vec<u8> {
4129 ::std::mem::replace(&mut self.image_small, ::std::vec::Vec::new())
4130 }
4131
4132 pub fn get_field_type(&self) -> &str {
4136 &self.field_type
4137 }
4138 pub fn clear_field_type(&mut self) {
4139 self.field_type.clear();
4140 }
4141
4142 pub fn set_field_type(&mut self, v: ::std::string::String) {
4144 self.field_type = v;
4145 }
4146
4147 pub fn mut_field_type(&mut self) -> &mut ::std::string::String {
4150 &mut self.field_type
4151 }
4152
4153 pub fn take_field_type(&mut self) -> ::std::string::String {
4155 ::std::mem::replace(&mut self.field_type, ::std::string::String::new())
4156 }
4157
4158 pub fn get_tracking_id(&self) -> u64 {
4162 self.tracking_id
4163 }
4164 pub fn clear_tracking_id(&mut self) {
4165 self.tracking_id = 0;
4166 }
4167
4168 pub fn set_tracking_id(&mut self, v: u64) {
4170 self.tracking_id = v;
4171 }
4172
4173 pub fn get_uuid(&self) -> &str {
4177 &self.uuid
4178 }
4179 pub fn clear_uuid(&mut self) {
4180 self.uuid.clear();
4181 }
4182
4183 pub fn set_uuid(&mut self, v: ::std::string::String) {
4185 self.uuid = v;
4186 }
4187
4188 pub fn mut_uuid(&mut self) -> &mut ::std::string::String {
4191 &mut self.uuid
4192 }
4193
4194 pub fn take_uuid(&mut self) -> ::std::string::String {
4196 ::std::mem::replace(&mut self.uuid, ::std::string::String::new())
4197 }
4198}
4199
4200impl ::protobuf::Message for RectangularDetection {
4201 fn is_initialized(&self) -> bool {
4202 for v in &self.location {
4203 if !v.is_initialized() {
4204 return false;
4205 }
4206 };
4207 for v in &self.facial_recognition {
4208 if !v.is_initialized() {
4209 return false;
4210 }
4211 };
4212 for v in &self.vehicle_recognition {
4213 if !v.is_initialized() {
4214 return false;
4215 }
4216 };
4217 true
4218 }
4219
4220 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4221 while !is.eof()? {
4222 let (field_number, wire_type) = is.read_tag_unpack()?;
4223 match field_number {
4224 1 => {
4225 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.algorithm, 1, &mut self.unknown_fields)?
4226 },
4227 2 => {
4228 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.location)?;
4229 },
4230 3 => {
4231 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.tag, 3, &mut self.unknown_fields)?
4232 },
4233 4 => {
4234 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4235 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4236 }
4237 let tmp = is.read_float()?;
4238 self.confidence = tmp;
4239 },
4240 5 => {
4241 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.facial_recognition)?;
4242 },
4243 9 => {
4244 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.vehicle_recognition)?;
4245 },
4246 10 => {
4247 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4248 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4249 }
4250 let tmp = is.read_float()?;
4251 self.speed = tmp;
4252 },
4253 6 => {
4254 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.image)?;
4255 },
4256 7 => {
4257 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.image_small)?;
4258 },
4259 12 => {
4260 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_type)?;
4261 },
4262 8 => {
4263 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4264 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4265 }
4266 let tmp = is.read_uint64()?;
4267 self.tracking_id = tmp;
4268 },
4269 11 => {
4270 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.uuid)?;
4271 },
4272 _ => {
4273 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4274 },
4275 };
4276 }
4277 ::std::result::Result::Ok(())
4278 }
4279
4280 #[allow(unused_variables)]
4282 fn compute_size(&self) -> u32 {
4283 let mut my_size = 0;
4284 if self.algorithm != EnumDetectionAlgorithm::DETECTION_ALGORITHM_NOT_DEFINED {
4285 my_size += ::protobuf::rt::enum_size(1, self.algorithm);
4286 }
4287 if let Some(ref v) = self.location.as_ref() {
4288 let len = v.compute_size();
4289 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
4290 }
4291 if self.tag != EnumDetectionTag::DETECTION_NOT_DEFINED {
4292 my_size += ::protobuf::rt::enum_size(3, self.tag);
4293 }
4294 if self.confidence != 0. {
4295 my_size += 5;
4296 }
4297 for value in &self.facial_recognition {
4298 let len = value.compute_size();
4299 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
4300 };
4301 for value in &self.vehicle_recognition {
4302 let len = value.compute_size();
4303 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
4304 };
4305 if self.speed != 0. {
4306 my_size += 5;
4307 }
4308 if !self.image.is_empty() {
4309 my_size += ::protobuf::rt::bytes_size(6, &self.image);
4310 }
4311 if !self.image_small.is_empty() {
4312 my_size += ::protobuf::rt::bytes_size(7, &self.image_small);
4313 }
4314 if !self.field_type.is_empty() {
4315 my_size += ::protobuf::rt::string_size(12, &self.field_type);
4316 }
4317 if self.tracking_id != 0 {
4318 my_size += ::protobuf::rt::value_size(8, self.tracking_id, ::protobuf::wire_format::WireTypeVarint);
4319 }
4320 if !self.uuid.is_empty() {
4321 my_size += ::protobuf::rt::string_size(11, &self.uuid);
4322 }
4323 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4324 self.cached_size.set(my_size);
4325 my_size
4326 }
4327
4328 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4329 if self.algorithm != EnumDetectionAlgorithm::DETECTION_ALGORITHM_NOT_DEFINED {
4330 os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.algorithm))?;
4331 }
4332 if let Some(ref v) = self.location.as_ref() {
4333 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
4334 os.write_raw_varint32(v.get_cached_size())?;
4335 v.write_to_with_cached_sizes(os)?;
4336 }
4337 if self.tag != EnumDetectionTag::DETECTION_NOT_DEFINED {
4338 os.write_enum(3, ::protobuf::ProtobufEnum::value(&self.tag))?;
4339 }
4340 if self.confidence != 0. {
4341 os.write_float(4, self.confidence)?;
4342 }
4343 for v in &self.facial_recognition {
4344 os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
4345 os.write_raw_varint32(v.get_cached_size())?;
4346 v.write_to_with_cached_sizes(os)?;
4347 };
4348 for v in &self.vehicle_recognition {
4349 os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
4350 os.write_raw_varint32(v.get_cached_size())?;
4351 v.write_to_with_cached_sizes(os)?;
4352 };
4353 if self.speed != 0. {
4354 os.write_float(10, self.speed)?;
4355 }
4356 if !self.image.is_empty() {
4357 os.write_bytes(6, &self.image)?;
4358 }
4359 if !self.image_small.is_empty() {
4360 os.write_bytes(7, &self.image_small)?;
4361 }
4362 if !self.field_type.is_empty() {
4363 os.write_string(12, &self.field_type)?;
4364 }
4365 if self.tracking_id != 0 {
4366 os.write_uint64(8, self.tracking_id)?;
4367 }
4368 if !self.uuid.is_empty() {
4369 os.write_string(11, &self.uuid)?;
4370 }
4371 os.write_unknown_fields(self.get_unknown_fields())?;
4372 ::std::result::Result::Ok(())
4373 }
4374
4375 fn get_cached_size(&self) -> u32 {
4376 self.cached_size.get()
4377 }
4378
4379 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4380 &self.unknown_fields
4381 }
4382
4383 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4384 &mut self.unknown_fields
4385 }
4386
4387 fn as_any(&self) -> &dyn (::std::any::Any) {
4388 self as &dyn (::std::any::Any)
4389 }
4390 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4391 self as &mut dyn (::std::any::Any)
4392 }
4393 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4394 self
4395 }
4396
4397 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4398 Self::descriptor_static()
4399 }
4400
4401 fn new() -> RectangularDetection {
4402 RectangularDetection::new()
4403 }
4404
4405 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4406 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
4407 descriptor.get(|| {
4408 let mut fields = ::std::vec::Vec::new();
4409 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EnumDetectionAlgorithm>>(
4410 "algorithm",
4411 |m: &RectangularDetection| { &m.algorithm },
4412 |m: &mut RectangularDetection| { &mut m.algorithm },
4413 ));
4414 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Rectangle>>(
4415 "location",
4416 |m: &RectangularDetection| { &m.location },
4417 |m: &mut RectangularDetection| { &mut m.location },
4418 ));
4419 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EnumDetectionTag>>(
4420 "tag",
4421 |m: &RectangularDetection| { &m.tag },
4422 |m: &mut RectangularDetection| { &mut m.tag },
4423 ));
4424 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
4425 "confidence",
4426 |m: &RectangularDetection| { &m.confidence },
4427 |m: &mut RectangularDetection| { &mut m.confidence },
4428 ));
4429 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FacialRecognition>>(
4430 "facial_recognition",
4431 |m: &RectangularDetection| { &m.facial_recognition },
4432 |m: &mut RectangularDetection| { &mut m.facial_recognition },
4433 ));
4434 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<VehicleRecognition>>(
4435 "vehicle_recognition",
4436 |m: &RectangularDetection| { &m.vehicle_recognition },
4437 |m: &mut RectangularDetection| { &mut m.vehicle_recognition },
4438 ));
4439 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
4440 "speed",
4441 |m: &RectangularDetection| { &m.speed },
4442 |m: &mut RectangularDetection| { &mut m.speed },
4443 ));
4444 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
4445 "image",
4446 |m: &RectangularDetection| { &m.image },
4447 |m: &mut RectangularDetection| { &mut m.image },
4448 ));
4449 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
4450 "image_small",
4451 |m: &RectangularDetection| { &m.image_small },
4452 |m: &mut RectangularDetection| { &mut m.image_small },
4453 ));
4454 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
4455 "type",
4456 |m: &RectangularDetection| { &m.field_type },
4457 |m: &mut RectangularDetection| { &mut m.field_type },
4458 ));
4459 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
4460 "tracking_id",
4461 |m: &RectangularDetection| { &m.tracking_id },
4462 |m: &mut RectangularDetection| { &mut m.tracking_id },
4463 ));
4464 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
4465 "uuid",
4466 |m: &RectangularDetection| { &m.uuid },
4467 |m: &mut RectangularDetection| { &mut m.uuid },
4468 ));
4469 ::protobuf::reflect::MessageDescriptor::new_pb_name::<RectangularDetection>(
4470 "RectangularDetection",
4471 fields,
4472 file_descriptor_proto()
4473 )
4474 })
4475 }
4476
4477 fn default_instance() -> &'static RectangularDetection {
4478 static instance: ::protobuf::rt::LazyV2<RectangularDetection> = ::protobuf::rt::LazyV2::INIT;
4479 instance.get(RectangularDetection::new)
4480 }
4481}
4482
4483impl ::protobuf::Clear for RectangularDetection {
4484 fn clear(&mut self) {
4485 self.algorithm = EnumDetectionAlgorithm::DETECTION_ALGORITHM_NOT_DEFINED;
4486 self.location.clear();
4487 self.tag = EnumDetectionTag::DETECTION_NOT_DEFINED;
4488 self.confidence = 0.;
4489 self.facial_recognition.clear();
4490 self.vehicle_recognition.clear();
4491 self.speed = 0.;
4492 self.image.clear();
4493 self.image_small.clear();
4494 self.field_type.clear();
4495 self.tracking_id = 0;
4496 self.uuid.clear();
4497 self.unknown_fields.clear();
4498 }
4499}
4500
4501impl ::std::fmt::Debug for RectangularDetection {
4502 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4503 ::protobuf::text_format::fmt(self, f)
4504 }
4505}
4506
4507impl ::protobuf::reflect::ProtobufValue for RectangularDetection {
4508 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
4509 ::protobuf::reflect::ReflectValueRef::Message(self)
4510 }
4511}
4512
4513#[derive(PartialEq,Clone,Default)]
4514pub struct ImageList {
4515 pub image_data: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
4517 pub frames_per_second: i32,
4518 pub unknown_fields: ::protobuf::UnknownFields,
4520 pub cached_size: ::protobuf::CachedSize,
4521}
4522
4523impl<'a> ::std::default::Default for &'a ImageList {
4524 fn default() -> &'a ImageList {
4525 <ImageList as ::protobuf::Message>::default_instance()
4526 }
4527}
4528
4529impl ImageList {
4530 pub fn new() -> ImageList {
4531 ::std::default::Default::default()
4532 }
4533
4534 pub fn get_image_data(&self) -> &[::std::vec::Vec<u8>] {
4538 &self.image_data
4539 }
4540 pub fn clear_image_data(&mut self) {
4541 self.image_data.clear();
4542 }
4543
4544 pub fn set_image_data(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
4546 self.image_data = v;
4547 }
4548
4549 pub fn mut_image_data(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4551 &mut self.image_data
4552 }
4553
4554 pub fn take_image_data(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4556 ::std::mem::replace(&mut self.image_data, ::protobuf::RepeatedField::new())
4557 }
4558
4559 pub fn get_frames_per_second(&self) -> i32 {
4563 self.frames_per_second
4564 }
4565 pub fn clear_frames_per_second(&mut self) {
4566 self.frames_per_second = 0;
4567 }
4568
4569 pub fn set_frames_per_second(&mut self, v: i32) {
4571 self.frames_per_second = v;
4572 }
4573}
4574
4575impl ::protobuf::Message for ImageList {
4576 fn is_initialized(&self) -> bool {
4577 true
4578 }
4579
4580 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4581 while !is.eof()? {
4582 let (field_number, wire_type) = is.read_tag_unpack()?;
4583 match field_number {
4584 1 => {
4585 ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.image_data)?;
4586 },
4587 2 => {
4588 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4589 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4590 }
4591 let tmp = is.read_int32()?;
4592 self.frames_per_second = tmp;
4593 },
4594 _ => {
4595 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4596 },
4597 };
4598 }
4599 ::std::result::Result::Ok(())
4600 }
4601
4602 #[allow(unused_variables)]
4604 fn compute_size(&self) -> u32 {
4605 let mut my_size = 0;
4606 for value in &self.image_data {
4607 my_size += ::protobuf::rt::bytes_size(1, &value);
4608 };
4609 if self.frames_per_second != 0 {
4610 my_size += ::protobuf::rt::value_size(2, self.frames_per_second, ::protobuf::wire_format::WireTypeVarint);
4611 }
4612 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4613 self.cached_size.set(my_size);
4614 my_size
4615 }
4616
4617 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4618 for v in &self.image_data {
4619 os.write_bytes(1, &v)?;
4620 };
4621 if self.frames_per_second != 0 {
4622 os.write_int32(2, self.frames_per_second)?;
4623 }
4624 os.write_unknown_fields(self.get_unknown_fields())?;
4625 ::std::result::Result::Ok(())
4626 }
4627
4628 fn get_cached_size(&self) -> u32 {
4629 self.cached_size.get()
4630 }
4631
4632 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4633 &self.unknown_fields
4634 }
4635
4636 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4637 &mut self.unknown_fields
4638 }
4639
4640 fn as_any(&self) -> &dyn (::std::any::Any) {
4641 self as &dyn (::std::any::Any)
4642 }
4643 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4644 self as &mut dyn (::std::any::Any)
4645 }
4646 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4647 self
4648 }
4649
4650 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4651 Self::descriptor_static()
4652 }
4653
4654 fn new() -> ImageList {
4655 ImageList::new()
4656 }
4657
4658 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4659 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
4660 descriptor.get(|| {
4661 let mut fields = ::std::vec::Vec::new();
4662 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
4663 "image_data",
4664 |m: &ImageList| { &m.image_data },
4665 |m: &mut ImageList| { &mut m.image_data },
4666 ));
4667 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
4668 "frames_per_second",
4669 |m: &ImageList| { &m.frames_per_second },
4670 |m: &mut ImageList| { &mut m.frames_per_second },
4671 ));
4672 ::protobuf::reflect::MessageDescriptor::new_pb_name::<ImageList>(
4673 "ImageList",
4674 fields,
4675 file_descriptor_proto()
4676 )
4677 })
4678 }
4679
4680 fn default_instance() -> &'static ImageList {
4681 static instance: ::protobuf::rt::LazyV2<ImageList> = ::protobuf::rt::LazyV2::INIT;
4682 instance.get(ImageList::new)
4683 }
4684}
4685
4686impl ::protobuf::Clear for ImageList {
4687 fn clear(&mut self) {
4688 self.image_data.clear();
4689 self.frames_per_second = 0;
4690 self.unknown_fields.clear();
4691 }
4692}
4693
4694impl ::std::fmt::Debug for ImageList {
4695 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4696 ::protobuf::text_format::fmt(self, f)
4697 }
4698}
4699
4700impl ::protobuf::reflect::ProtobufValue for ImageList {
4701 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
4702 ::protobuf::reflect::ReflectValueRef::Message(self)
4703 }
4704}
4705
4706#[derive(PartialEq,Clone,Default)]
4707pub struct Video {
4708 pub video_data: ::std::vec::Vec<u8>,
4710 pub codec: EnumVideoCodec,
4711 pub tag: ::protobuf::RepeatedField<::std::string::String>,
4712 pub unknown_fields: ::protobuf::UnknownFields,
4714 pub cached_size: ::protobuf::CachedSize,
4715}
4716
4717impl<'a> ::std::default::Default for &'a Video {
4718 fn default() -> &'a Video {
4719 <Video as ::protobuf::Message>::default_instance()
4720 }
4721}
4722
4723impl Video {
4724 pub fn new() -> Video {
4725 ::std::default::Default::default()
4726 }
4727
4728 pub fn get_video_data(&self) -> &[u8] {
4732 &self.video_data
4733 }
4734 pub fn clear_video_data(&mut self) {
4735 self.video_data.clear();
4736 }
4737
4738 pub fn set_video_data(&mut self, v: ::std::vec::Vec<u8>) {
4740 self.video_data = v;
4741 }
4742
4743 pub fn mut_video_data(&mut self) -> &mut ::std::vec::Vec<u8> {
4746 &mut self.video_data
4747 }
4748
4749 pub fn take_video_data(&mut self) -> ::std::vec::Vec<u8> {
4751 ::std::mem::replace(&mut self.video_data, ::std::vec::Vec::new())
4752 }
4753
4754 pub fn get_codec(&self) -> EnumVideoCodec {
4758 self.codec
4759 }
4760 pub fn clear_codec(&mut self) {
4761 self.codec = EnumVideoCodec::VIDEO_CODEC_NOT_DEFINED;
4762 }
4763
4764 pub fn set_codec(&mut self, v: EnumVideoCodec) {
4766 self.codec = v;
4767 }
4768
4769 pub fn get_tag(&self) -> &[::std::string::String] {
4773 &self.tag
4774 }
4775 pub fn clear_tag(&mut self) {
4776 self.tag.clear();
4777 }
4778
4779 pub fn set_tag(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
4781 self.tag = v;
4782 }
4783
4784 pub fn mut_tag(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
4786 &mut self.tag
4787 }
4788
4789 pub fn take_tag(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
4791 ::std::mem::replace(&mut self.tag, ::protobuf::RepeatedField::new())
4792 }
4793}
4794
4795impl ::protobuf::Message for Video {
4796 fn is_initialized(&self) -> bool {
4797 true
4798 }
4799
4800 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4801 while !is.eof()? {
4802 let (field_number, wire_type) = is.read_tag_unpack()?;
4803 match field_number {
4804 1 => {
4805 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.video_data)?;
4806 },
4807 2 => {
4808 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.codec, 2, &mut self.unknown_fields)?
4809 },
4810 3 => {
4811 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tag)?;
4812 },
4813 _ => {
4814 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4815 },
4816 };
4817 }
4818 ::std::result::Result::Ok(())
4819 }
4820
4821 #[allow(unused_variables)]
4823 fn compute_size(&self) -> u32 {
4824 let mut my_size = 0;
4825 if !self.video_data.is_empty() {
4826 my_size += ::protobuf::rt::bytes_size(1, &self.video_data);
4827 }
4828 if self.codec != EnumVideoCodec::VIDEO_CODEC_NOT_DEFINED {
4829 my_size += ::protobuf::rt::enum_size(2, self.codec);
4830 }
4831 for value in &self.tag {
4832 my_size += ::protobuf::rt::string_size(3, &value);
4833 };
4834 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4835 self.cached_size.set(my_size);
4836 my_size
4837 }
4838
4839 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4840 if !self.video_data.is_empty() {
4841 os.write_bytes(1, &self.video_data)?;
4842 }
4843 if self.codec != EnumVideoCodec::VIDEO_CODEC_NOT_DEFINED {
4844 os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.codec))?;
4845 }
4846 for v in &self.tag {
4847 os.write_string(3, &v)?;
4848 };
4849 os.write_unknown_fields(self.get_unknown_fields())?;
4850 ::std::result::Result::Ok(())
4851 }
4852
4853 fn get_cached_size(&self) -> u32 {
4854 self.cached_size.get()
4855 }
4856
4857 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4858 &self.unknown_fields
4859 }
4860
4861 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4862 &mut self.unknown_fields
4863 }
4864
4865 fn as_any(&self) -> &dyn (::std::any::Any) {
4866 self as &dyn (::std::any::Any)
4867 }
4868 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4869 self as &mut dyn (::std::any::Any)
4870 }
4871 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4872 self
4873 }
4874
4875 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4876 Self::descriptor_static()
4877 }
4878
4879 fn new() -> Video {
4880 Video::new()
4881 }
4882
4883 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4884 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
4885 descriptor.get(|| {
4886 let mut fields = ::std::vec::Vec::new();
4887 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
4888 "video_data",
4889 |m: &Video| { &m.video_data },
4890 |m: &mut Video| { &mut m.video_data },
4891 ));
4892 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EnumVideoCodec>>(
4893 "codec",
4894 |m: &Video| { &m.codec },
4895 |m: &mut Video| { &mut m.codec },
4896 ));
4897 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
4898 "tag",
4899 |m: &Video| { &m.tag },
4900 |m: &mut Video| { &mut m.tag },
4901 ));
4902 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Video>(
4903 "Video",
4904 fields,
4905 file_descriptor_proto()
4906 )
4907 })
4908 }
4909
4910 fn default_instance() -> &'static Video {
4911 static instance: ::protobuf::rt::LazyV2<Video> = ::protobuf::rt::LazyV2::INIT;
4912 instance.get(Video::new)
4913 }
4914}
4915
4916impl ::protobuf::Clear for Video {
4917 fn clear(&mut self) {
4918 self.video_data.clear();
4919 self.codec = EnumVideoCodec::VIDEO_CODEC_NOT_DEFINED;
4920 self.tag.clear();
4921 self.unknown_fields.clear();
4922 }
4923}
4924
4925impl ::std::fmt::Debug for Video {
4926 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4927 ::protobuf::text_format::fmt(self, f)
4928 }
4929}
4930
4931impl ::protobuf::reflect::ProtobufValue for Video {
4932 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
4933 ::protobuf::reflect::ReflectValueRef::Message(self)
4934 }
4935}
4936
4937#[derive(PartialEq,Clone,Default)]
4938pub struct Image {
4939 pub image: ::std::vec::Vec<u8>,
4941 pub format: ImageFormat,
4942 pub size: ::protobuf::SingularPtrField<Size>,
4943 pub unknown_fields: ::protobuf::UnknownFields,
4945 pub cached_size: ::protobuf::CachedSize,
4946}
4947
4948impl<'a> ::std::default::Default for &'a Image {
4949 fn default() -> &'a Image {
4950 <Image as ::protobuf::Message>::default_instance()
4951 }
4952}
4953
4954impl Image {
4955 pub fn new() -> Image {
4956 ::std::default::Default::default()
4957 }
4958
4959 pub fn get_image(&self) -> &[u8] {
4963 &self.image
4964 }
4965 pub fn clear_image(&mut self) {
4966 self.image.clear();
4967 }
4968
4969 pub fn set_image(&mut self, v: ::std::vec::Vec<u8>) {
4971 self.image = v;
4972 }
4973
4974 pub fn mut_image(&mut self) -> &mut ::std::vec::Vec<u8> {
4977 &mut self.image
4978 }
4979
4980 pub fn take_image(&mut self) -> ::std::vec::Vec<u8> {
4982 ::std::mem::replace(&mut self.image, ::std::vec::Vec::new())
4983 }
4984
4985 pub fn get_format(&self) -> ImageFormat {
4989 self.format
4990 }
4991 pub fn clear_format(&mut self) {
4992 self.format = ImageFormat::IMAGE_FORMAT_NOT_DEFINED;
4993 }
4994
4995 pub fn set_format(&mut self, v: ImageFormat) {
4997 self.format = v;
4998 }
4999
5000 pub fn get_size(&self) -> &Size {
5004 self.size.as_ref().unwrap_or_else(|| <Size as ::protobuf::Message>::default_instance())
5005 }
5006 pub fn clear_size(&mut self) {
5007 self.size.clear();
5008 }
5009
5010 pub fn has_size(&self) -> bool {
5011 self.size.is_some()
5012 }
5013
5014 pub fn set_size(&mut self, v: Size) {
5016 self.size = ::protobuf::SingularPtrField::some(v);
5017 }
5018
5019 pub fn mut_size(&mut self) -> &mut Size {
5022 if self.size.is_none() {
5023 self.size.set_default();
5024 }
5025 self.size.as_mut().unwrap()
5026 }
5027
5028 pub fn take_size(&mut self) -> Size {
5030 self.size.take().unwrap_or_else(|| Size::new())
5031 }
5032}
5033
5034impl ::protobuf::Message for Image {
5035 fn is_initialized(&self) -> bool {
5036 for v in &self.size {
5037 if !v.is_initialized() {
5038 return false;
5039 }
5040 };
5041 true
5042 }
5043
5044 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5045 while !is.eof()? {
5046 let (field_number, wire_type) = is.read_tag_unpack()?;
5047 match field_number {
5048 1 => {
5049 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.image)?;
5050 },
5051 2 => {
5052 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.format, 2, &mut self.unknown_fields)?
5053 },
5054 3 => {
5055 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.size)?;
5056 },
5057 _ => {
5058 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5059 },
5060 };
5061 }
5062 ::std::result::Result::Ok(())
5063 }
5064
5065 #[allow(unused_variables)]
5067 fn compute_size(&self) -> u32 {
5068 let mut my_size = 0;
5069 if !self.image.is_empty() {
5070 my_size += ::protobuf::rt::bytes_size(1, &self.image);
5071 }
5072 if self.format != ImageFormat::IMAGE_FORMAT_NOT_DEFINED {
5073 my_size += ::protobuf::rt::enum_size(2, self.format);
5074 }
5075 if let Some(ref v) = self.size.as_ref() {
5076 let len = v.compute_size();
5077 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
5078 }
5079 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5080 self.cached_size.set(my_size);
5081 my_size
5082 }
5083
5084 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5085 if !self.image.is_empty() {
5086 os.write_bytes(1, &self.image)?;
5087 }
5088 if self.format != ImageFormat::IMAGE_FORMAT_NOT_DEFINED {
5089 os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.format))?;
5090 }
5091 if let Some(ref v) = self.size.as_ref() {
5092 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
5093 os.write_raw_varint32(v.get_cached_size())?;
5094 v.write_to_with_cached_sizes(os)?;
5095 }
5096 os.write_unknown_fields(self.get_unknown_fields())?;
5097 ::std::result::Result::Ok(())
5098 }
5099
5100 fn get_cached_size(&self) -> u32 {
5101 self.cached_size.get()
5102 }
5103
5104 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5105 &self.unknown_fields
5106 }
5107
5108 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5109 &mut self.unknown_fields
5110 }
5111
5112 fn as_any(&self) -> &dyn (::std::any::Any) {
5113 self as &dyn (::std::any::Any)
5114 }
5115 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5116 self as &mut dyn (::std::any::Any)
5117 }
5118 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5119 self
5120 }
5121
5122 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5123 Self::descriptor_static()
5124 }
5125
5126 fn new() -> Image {
5127 Image::new()
5128 }
5129
5130 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5131 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
5132 descriptor.get(|| {
5133 let mut fields = ::std::vec::Vec::new();
5134 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
5135 "image",
5136 |m: &Image| { &m.image },
5137 |m: &mut Image| { &mut m.image },
5138 ));
5139 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ImageFormat>>(
5140 "format",
5141 |m: &Image| { &m.format },
5142 |m: &mut Image| { &mut m.format },
5143 ));
5144 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Size>>(
5145 "size",
5146 |m: &Image| { &m.size },
5147 |m: &mut Image| { &mut m.size },
5148 ));
5149 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Image>(
5150 "Image",
5151 fields,
5152 file_descriptor_proto()
5153 )
5154 })
5155 }
5156
5157 fn default_instance() -> &'static Image {
5158 static instance: ::protobuf::rt::LazyV2<Image> = ::protobuf::rt::LazyV2::INIT;
5159 instance.get(Image::new)
5160 }
5161}
5162
5163impl ::protobuf::Clear for Image {
5164 fn clear(&mut self) {
5165 self.image.clear();
5166 self.format = ImageFormat::IMAGE_FORMAT_NOT_DEFINED;
5167 self.size.clear();
5168 self.unknown_fields.clear();
5169 }
5170}
5171
5172impl ::std::fmt::Debug for Image {
5173 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5174 ::protobuf::text_format::fmt(self, f)
5175 }
5176}
5177
5178impl ::protobuf::reflect::ProtobufValue for Image {
5179 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
5180 ::protobuf::reflect::ReflectValueRef::Message(self)
5181 }
5182}
5183
5184#[derive(PartialEq,Clone,Default)]
5185pub struct FrameData {
5186 pub id: u64,
5188 pub start_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
5189 pub end_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
5190 pub sections: ::std::collections::HashMap<::std::string::String, f32>,
5191 pub unknown_fields: ::protobuf::UnknownFields,
5193 pub cached_size: ::protobuf::CachedSize,
5194}
5195
5196impl<'a> ::std::default::Default for &'a FrameData {
5197 fn default() -> &'a FrameData {
5198 <FrameData as ::protobuf::Message>::default_instance()
5199 }
5200}
5201
5202impl FrameData {
5203 pub fn new() -> FrameData {
5204 ::std::default::Default::default()
5205 }
5206
5207 pub fn get_id(&self) -> u64 {
5211 self.id
5212 }
5213 pub fn clear_id(&mut self) {
5214 self.id = 0;
5215 }
5216
5217 pub fn set_id(&mut self, v: u64) {
5219 self.id = v;
5220 }
5221
5222 pub fn get_start_time(&self) -> &::protobuf::well_known_types::Timestamp {
5226 self.start_time.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
5227 }
5228 pub fn clear_start_time(&mut self) {
5229 self.start_time.clear();
5230 }
5231
5232 pub fn has_start_time(&self) -> bool {
5233 self.start_time.is_some()
5234 }
5235
5236 pub fn set_start_time(&mut self, v: ::protobuf::well_known_types::Timestamp) {
5238 self.start_time = ::protobuf::SingularPtrField::some(v);
5239 }
5240
5241 pub fn mut_start_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
5244 if self.start_time.is_none() {
5245 self.start_time.set_default();
5246 }
5247 self.start_time.as_mut().unwrap()
5248 }
5249
5250 pub fn take_start_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
5252 self.start_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
5253 }
5254
5255 pub fn get_end_time(&self) -> &::protobuf::well_known_types::Timestamp {
5259 self.end_time.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
5260 }
5261 pub fn clear_end_time(&mut self) {
5262 self.end_time.clear();
5263 }
5264
5265 pub fn has_end_time(&self) -> bool {
5266 self.end_time.is_some()
5267 }
5268
5269 pub fn set_end_time(&mut self, v: ::protobuf::well_known_types::Timestamp) {
5271 self.end_time = ::protobuf::SingularPtrField::some(v);
5272 }
5273
5274 pub fn mut_end_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
5277 if self.end_time.is_none() {
5278 self.end_time.set_default();
5279 }
5280 self.end_time.as_mut().unwrap()
5281 }
5282
5283 pub fn take_end_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
5285 self.end_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
5286 }
5287
5288 pub fn get_sections(&self) -> &::std::collections::HashMap<::std::string::String, f32> {
5292 &self.sections
5293 }
5294 pub fn clear_sections(&mut self) {
5295 self.sections.clear();
5296 }
5297
5298 pub fn set_sections(&mut self, v: ::std::collections::HashMap<::std::string::String, f32>) {
5300 self.sections = v;
5301 }
5302
5303 pub fn mut_sections(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, f32> {
5305 &mut self.sections
5306 }
5307
5308 pub fn take_sections(&mut self) -> ::std::collections::HashMap<::std::string::String, f32> {
5310 ::std::mem::replace(&mut self.sections, ::std::collections::HashMap::new())
5311 }
5312}
5313
5314impl ::protobuf::Message for FrameData {
5315 fn is_initialized(&self) -> bool {
5316 for v in &self.start_time {
5317 if !v.is_initialized() {
5318 return false;
5319 }
5320 };
5321 for v in &self.end_time {
5322 if !v.is_initialized() {
5323 return false;
5324 }
5325 };
5326 true
5327 }
5328
5329 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5330 while !is.eof()? {
5331 let (field_number, wire_type) = is.read_tag_unpack()?;
5332 match field_number {
5333 1 => {
5334 if wire_type != ::protobuf::wire_format::WireTypeVarint {
5335 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
5336 }
5337 let tmp = is.read_uint64()?;
5338 self.id = tmp;
5339 },
5340 2 => {
5341 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.start_time)?;
5342 },
5343 3 => {
5344 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.end_time)?;
5345 },
5346 4 => {
5347 ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeFloat>(wire_type, is, &mut self.sections)?;
5348 },
5349 _ => {
5350 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5351 },
5352 };
5353 }
5354 ::std::result::Result::Ok(())
5355 }
5356
5357 #[allow(unused_variables)]
5359 fn compute_size(&self) -> u32 {
5360 let mut my_size = 0;
5361 if self.id != 0 {
5362 my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
5363 }
5364 if let Some(ref v) = self.start_time.as_ref() {
5365 let len = v.compute_size();
5366 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
5367 }
5368 if let Some(ref v) = self.end_time.as_ref() {
5369 let len = v.compute_size();
5370 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
5371 }
5372 my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeFloat>(4, &self.sections);
5373 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5374 self.cached_size.set(my_size);
5375 my_size
5376 }
5377
5378 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5379 if self.id != 0 {
5380 os.write_uint64(1, self.id)?;
5381 }
5382 if let Some(ref v) = self.start_time.as_ref() {
5383 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
5384 os.write_raw_varint32(v.get_cached_size())?;
5385 v.write_to_with_cached_sizes(os)?;
5386 }
5387 if let Some(ref v) = self.end_time.as_ref() {
5388 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
5389 os.write_raw_varint32(v.get_cached_size())?;
5390 v.write_to_with_cached_sizes(os)?;
5391 }
5392 ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeFloat>(4, &self.sections, os)?;
5393 os.write_unknown_fields(self.get_unknown_fields())?;
5394 ::std::result::Result::Ok(())
5395 }
5396
5397 fn get_cached_size(&self) -> u32 {
5398 self.cached_size.get()
5399 }
5400
5401 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5402 &self.unknown_fields
5403 }
5404
5405 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5406 &mut self.unknown_fields
5407 }
5408
5409 fn as_any(&self) -> &dyn (::std::any::Any) {
5410 self as &dyn (::std::any::Any)
5411 }
5412 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5413 self as &mut dyn (::std::any::Any)
5414 }
5415 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5416 self
5417 }
5418
5419 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5420 Self::descriptor_static()
5421 }
5422
5423 fn new() -> FrameData {
5424 FrameData::new()
5425 }
5426
5427 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5428 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
5429 descriptor.get(|| {
5430 let mut fields = ::std::vec::Vec::new();
5431 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
5432 "id",
5433 |m: &FrameData| { &m.id },
5434 |m: &mut FrameData| { &mut m.id },
5435 ));
5436 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
5437 "start_time",
5438 |m: &FrameData| { &m.start_time },
5439 |m: &mut FrameData| { &mut m.start_time },
5440 ));
5441 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
5442 "end_time",
5443 |m: &FrameData| { &m.end_time },
5444 |m: &mut FrameData| { &mut m.end_time },
5445 ));
5446 fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeFloat>(
5447 "sections",
5448 |m: &FrameData| { &m.sections },
5449 |m: &mut FrameData| { &mut m.sections },
5450 ));
5451 ::protobuf::reflect::MessageDescriptor::new_pb_name::<FrameData>(
5452 "FrameData",
5453 fields,
5454 file_descriptor_proto()
5455 )
5456 })
5457 }
5458
5459 fn default_instance() -> &'static FrameData {
5460 static instance: ::protobuf::rt::LazyV2<FrameData> = ::protobuf::rt::LazyV2::INIT;
5461 instance.get(FrameData::new)
5462 }
5463}
5464
5465impl ::protobuf::Clear for FrameData {
5466 fn clear(&mut self) {
5467 self.id = 0;
5468 self.start_time.clear();
5469 self.end_time.clear();
5470 self.sections.clear();
5471 self.unknown_fields.clear();
5472 }
5473}
5474
5475impl ::std::fmt::Debug for FrameData {
5476 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5477 ::protobuf::text_format::fmt(self, f)
5478 }
5479}
5480
5481impl ::protobuf::reflect::ProtobufValue for FrameData {
5482 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
5483 ::protobuf::reflect::ReflectValueRef::Message(self)
5484 }
5485}
5486
5487#[derive(PartialEq,Clone,Default)]
5488pub struct FrameDataList {
5489 pub frames: ::protobuf::RepeatedField<FrameData>,
5491 pub unknown_fields: ::protobuf::UnknownFields,
5493 pub cached_size: ::protobuf::CachedSize,
5494}
5495
5496impl<'a> ::std::default::Default for &'a FrameDataList {
5497 fn default() -> &'a FrameDataList {
5498 <FrameDataList as ::protobuf::Message>::default_instance()
5499 }
5500}
5501
5502impl FrameDataList {
5503 pub fn new() -> FrameDataList {
5504 ::std::default::Default::default()
5505 }
5506
5507 pub fn get_frames(&self) -> &[FrameData] {
5511 &self.frames
5512 }
5513 pub fn clear_frames(&mut self) {
5514 self.frames.clear();
5515 }
5516
5517 pub fn set_frames(&mut self, v: ::protobuf::RepeatedField<FrameData>) {
5519 self.frames = v;
5520 }
5521
5522 pub fn mut_frames(&mut self) -> &mut ::protobuf::RepeatedField<FrameData> {
5524 &mut self.frames
5525 }
5526
5527 pub fn take_frames(&mut self) -> ::protobuf::RepeatedField<FrameData> {
5529 ::std::mem::replace(&mut self.frames, ::protobuf::RepeatedField::new())
5530 }
5531}
5532
5533impl ::protobuf::Message for FrameDataList {
5534 fn is_initialized(&self) -> bool {
5535 for v in &self.frames {
5536 if !v.is_initialized() {
5537 return false;
5538 }
5539 };
5540 true
5541 }
5542
5543 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5544 while !is.eof()? {
5545 let (field_number, wire_type) = is.read_tag_unpack()?;
5546 match field_number {
5547 1 => {
5548 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.frames)?;
5549 },
5550 _ => {
5551 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5552 },
5553 };
5554 }
5555 ::std::result::Result::Ok(())
5556 }
5557
5558 #[allow(unused_variables)]
5560 fn compute_size(&self) -> u32 {
5561 let mut my_size = 0;
5562 for value in &self.frames {
5563 let len = value.compute_size();
5564 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
5565 };
5566 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5567 self.cached_size.set(my_size);
5568 my_size
5569 }
5570
5571 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5572 for v in &self.frames {
5573 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
5574 os.write_raw_varint32(v.get_cached_size())?;
5575 v.write_to_with_cached_sizes(os)?;
5576 };
5577 os.write_unknown_fields(self.get_unknown_fields())?;
5578 ::std::result::Result::Ok(())
5579 }
5580
5581 fn get_cached_size(&self) -> u32 {
5582 self.cached_size.get()
5583 }
5584
5585 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5586 &self.unknown_fields
5587 }
5588
5589 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5590 &mut self.unknown_fields
5591 }
5592
5593 fn as_any(&self) -> &dyn (::std::any::Any) {
5594 self as &dyn (::std::any::Any)
5595 }
5596 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5597 self as &mut dyn (::std::any::Any)
5598 }
5599 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5600 self
5601 }
5602
5603 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5604 Self::descriptor_static()
5605 }
5606
5607 fn new() -> FrameDataList {
5608 FrameDataList::new()
5609 }
5610
5611 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5612 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
5613 descriptor.get(|| {
5614 let mut fields = ::std::vec::Vec::new();
5615 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FrameData>>(
5616 "frames",
5617 |m: &FrameDataList| { &m.frames },
5618 |m: &mut FrameDataList| { &mut m.frames },
5619 ));
5620 ::protobuf::reflect::MessageDescriptor::new_pb_name::<FrameDataList>(
5621 "FrameDataList",
5622 fields,
5623 file_descriptor_proto()
5624 )
5625 })
5626 }
5627
5628 fn default_instance() -> &'static FrameDataList {
5629 static instance: ::protobuf::rt::LazyV2<FrameDataList> = ::protobuf::rt::LazyV2::INIT;
5630 instance.get(FrameDataList::new)
5631 }
5632}
5633
5634impl ::protobuf::Clear for FrameDataList {
5635 fn clear(&mut self) {
5636 self.frames.clear();
5637 self.unknown_fields.clear();
5638 }
5639}
5640
5641impl ::std::fmt::Debug for FrameDataList {
5642 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5643 ::protobuf::text_format::fmt(self, f)
5644 }
5645}
5646
5647impl ::protobuf::reflect::ProtobufValue for FrameDataList {
5648 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
5649 ::protobuf::reflect::ReflectValueRef::Message(self)
5650 }
5651}
5652
5653#[derive(PartialEq,Clone,Default)]
5654pub struct VisionResult {
5655 pub rect_detection: ::protobuf::RepeatedField<RectangularDetection>,
5657 pub vision_event: ::protobuf::RepeatedField<VisionEvent>,
5658 pub result_image: ::protobuf::SingularPtrField<Image>,
5659 pub result_image_small: ::protobuf::SingularPtrField<Image>,
5660 pub image: ::std::vec::Vec<u8>,
5661 pub image_small: ::std::vec::Vec<u8>,
5662 pub uuid: ::std::string::String,
5663 pub frame_data: ::protobuf::SingularPtrField<FrameData>,
5664 pub moment_of_day: MomentOfDay,
5665 pub unknown_fields: ::protobuf::UnknownFields,
5667 pub cached_size: ::protobuf::CachedSize,
5668}
5669
5670impl<'a> ::std::default::Default for &'a VisionResult {
5671 fn default() -> &'a VisionResult {
5672 <VisionResult as ::protobuf::Message>::default_instance()
5673 }
5674}
5675
5676impl VisionResult {
5677 pub fn new() -> VisionResult {
5678 ::std::default::Default::default()
5679 }
5680
5681 pub fn get_rect_detection(&self) -> &[RectangularDetection] {
5685 &self.rect_detection
5686 }
5687 pub fn clear_rect_detection(&mut self) {
5688 self.rect_detection.clear();
5689 }
5690
5691 pub fn set_rect_detection(&mut self, v: ::protobuf::RepeatedField<RectangularDetection>) {
5693 self.rect_detection = v;
5694 }
5695
5696 pub fn mut_rect_detection(&mut self) -> &mut ::protobuf::RepeatedField<RectangularDetection> {
5698 &mut self.rect_detection
5699 }
5700
5701 pub fn take_rect_detection(&mut self) -> ::protobuf::RepeatedField<RectangularDetection> {
5703 ::std::mem::replace(&mut self.rect_detection, ::protobuf::RepeatedField::new())
5704 }
5705
5706 pub fn get_vision_event(&self) -> &[VisionEvent] {
5710 &self.vision_event
5711 }
5712 pub fn clear_vision_event(&mut self) {
5713 self.vision_event.clear();
5714 }
5715
5716 pub fn set_vision_event(&mut self, v: ::protobuf::RepeatedField<VisionEvent>) {
5718 self.vision_event = v;
5719 }
5720
5721 pub fn mut_vision_event(&mut self) -> &mut ::protobuf::RepeatedField<VisionEvent> {
5723 &mut self.vision_event
5724 }
5725
5726 pub fn take_vision_event(&mut self) -> ::protobuf::RepeatedField<VisionEvent> {
5728 ::std::mem::replace(&mut self.vision_event, ::protobuf::RepeatedField::new())
5729 }
5730
5731 pub fn get_result_image(&self) -> &Image {
5735 self.result_image.as_ref().unwrap_or_else(|| <Image as ::protobuf::Message>::default_instance())
5736 }
5737 pub fn clear_result_image(&mut self) {
5738 self.result_image.clear();
5739 }
5740
5741 pub fn has_result_image(&self) -> bool {
5742 self.result_image.is_some()
5743 }
5744
5745 pub fn set_result_image(&mut self, v: Image) {
5747 self.result_image = ::protobuf::SingularPtrField::some(v);
5748 }
5749
5750 pub fn mut_result_image(&mut self) -> &mut Image {
5753 if self.result_image.is_none() {
5754 self.result_image.set_default();
5755 }
5756 self.result_image.as_mut().unwrap()
5757 }
5758
5759 pub fn take_result_image(&mut self) -> Image {
5761 self.result_image.take().unwrap_or_else(|| Image::new())
5762 }
5763
5764 pub fn get_result_image_small(&self) -> &Image {
5768 self.result_image_small.as_ref().unwrap_or_else(|| <Image as ::protobuf::Message>::default_instance())
5769 }
5770 pub fn clear_result_image_small(&mut self) {
5771 self.result_image_small.clear();
5772 }
5773
5774 pub fn has_result_image_small(&self) -> bool {
5775 self.result_image_small.is_some()
5776 }
5777
5778 pub fn set_result_image_small(&mut self, v: Image) {
5780 self.result_image_small = ::protobuf::SingularPtrField::some(v);
5781 }
5782
5783 pub fn mut_result_image_small(&mut self) -> &mut Image {
5786 if self.result_image_small.is_none() {
5787 self.result_image_small.set_default();
5788 }
5789 self.result_image_small.as_mut().unwrap()
5790 }
5791
5792 pub fn take_result_image_small(&mut self) -> Image {
5794 self.result_image_small.take().unwrap_or_else(|| Image::new())
5795 }
5796
5797 pub fn get_image(&self) -> &[u8] {
5801 &self.image
5802 }
5803 pub fn clear_image(&mut self) {
5804 self.image.clear();
5805 }
5806
5807 pub fn set_image(&mut self, v: ::std::vec::Vec<u8>) {
5809 self.image = v;
5810 }
5811
5812 pub fn mut_image(&mut self) -> &mut ::std::vec::Vec<u8> {
5815 &mut self.image
5816 }
5817
5818 pub fn take_image(&mut self) -> ::std::vec::Vec<u8> {
5820 ::std::mem::replace(&mut self.image, ::std::vec::Vec::new())
5821 }
5822
5823 pub fn get_image_small(&self) -> &[u8] {
5827 &self.image_small
5828 }
5829 pub fn clear_image_small(&mut self) {
5830 self.image_small.clear();
5831 }
5832
5833 pub fn set_image_small(&mut self, v: ::std::vec::Vec<u8>) {
5835 self.image_small = v;
5836 }
5837
5838 pub fn mut_image_small(&mut self) -> &mut ::std::vec::Vec<u8> {
5841 &mut self.image_small
5842 }
5843
5844 pub fn take_image_small(&mut self) -> ::std::vec::Vec<u8> {
5846 ::std::mem::replace(&mut self.image_small, ::std::vec::Vec::new())
5847 }
5848
5849 pub fn get_uuid(&self) -> &str {
5853 &self.uuid
5854 }
5855 pub fn clear_uuid(&mut self) {
5856 self.uuid.clear();
5857 }
5858
5859 pub fn set_uuid(&mut self, v: ::std::string::String) {
5861 self.uuid = v;
5862 }
5863
5864 pub fn mut_uuid(&mut self) -> &mut ::std::string::String {
5867 &mut self.uuid
5868 }
5869
5870 pub fn take_uuid(&mut self) -> ::std::string::String {
5872 ::std::mem::replace(&mut self.uuid, ::std::string::String::new())
5873 }
5874
5875 pub fn get_frame_data(&self) -> &FrameData {
5879 self.frame_data.as_ref().unwrap_or_else(|| <FrameData as ::protobuf::Message>::default_instance())
5880 }
5881 pub fn clear_frame_data(&mut self) {
5882 self.frame_data.clear();
5883 }
5884
5885 pub fn has_frame_data(&self) -> bool {
5886 self.frame_data.is_some()
5887 }
5888
5889 pub fn set_frame_data(&mut self, v: FrameData) {
5891 self.frame_data = ::protobuf::SingularPtrField::some(v);
5892 }
5893
5894 pub fn mut_frame_data(&mut self) -> &mut FrameData {
5897 if self.frame_data.is_none() {
5898 self.frame_data.set_default();
5899 }
5900 self.frame_data.as_mut().unwrap()
5901 }
5902
5903 pub fn take_frame_data(&mut self) -> FrameData {
5905 self.frame_data.take().unwrap_or_else(|| FrameData::new())
5906 }
5907
5908 pub fn get_moment_of_day(&self) -> MomentOfDay {
5912 self.moment_of_day
5913 }
5914 pub fn clear_moment_of_day(&mut self) {
5915 self.moment_of_day = MomentOfDay::MOMENT_OF_DAY_NOT_DEFINED;
5916 }
5917
5918 pub fn set_moment_of_day(&mut self, v: MomentOfDay) {
5920 self.moment_of_day = v;
5921 }
5922}
5923
5924impl ::protobuf::Message for VisionResult {
5925 fn is_initialized(&self) -> bool {
5926 for v in &self.rect_detection {
5927 if !v.is_initialized() {
5928 return false;
5929 }
5930 };
5931 for v in &self.vision_event {
5932 if !v.is_initialized() {
5933 return false;
5934 }
5935 };
5936 for v in &self.result_image {
5937 if !v.is_initialized() {
5938 return false;
5939 }
5940 };
5941 for v in &self.result_image_small {
5942 if !v.is_initialized() {
5943 return false;
5944 }
5945 };
5946 for v in &self.frame_data {
5947 if !v.is_initialized() {
5948 return false;
5949 }
5950 };
5951 true
5952 }
5953
5954 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5955 while !is.eof()? {
5956 let (field_number, wire_type) = is.read_tag_unpack()?;
5957 match field_number {
5958 1 => {
5959 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rect_detection)?;
5960 },
5961 4 => {
5962 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.vision_event)?;
5963 },
5964 5 => {
5965 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.result_image)?;
5966 },
5967 6 => {
5968 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.result_image_small)?;
5969 },
5970 2 => {
5971 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.image)?;
5972 },
5973 3 => {
5974 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.image_small)?;
5975 },
5976 7 => {
5977 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.uuid)?;
5978 },
5979 8 => {
5980 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.frame_data)?;
5981 },
5982 9 => {
5983 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.moment_of_day, 9, &mut self.unknown_fields)?
5984 },
5985 _ => {
5986 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5987 },
5988 };
5989 }
5990 ::std::result::Result::Ok(())
5991 }
5992
5993 #[allow(unused_variables)]
5995 fn compute_size(&self) -> u32 {
5996 let mut my_size = 0;
5997 for value in &self.rect_detection {
5998 let len = value.compute_size();
5999 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
6000 };
6001 for value in &self.vision_event {
6002 let len = value.compute_size();
6003 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
6004 };
6005 if let Some(ref v) = self.result_image.as_ref() {
6006 let len = v.compute_size();
6007 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
6008 }
6009 if let Some(ref v) = self.result_image_small.as_ref() {
6010 let len = v.compute_size();
6011 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
6012 }
6013 if !self.image.is_empty() {
6014 my_size += ::protobuf::rt::bytes_size(2, &self.image);
6015 }
6016 if !self.image_small.is_empty() {
6017 my_size += ::protobuf::rt::bytes_size(3, &self.image_small);
6018 }
6019 if !self.uuid.is_empty() {
6020 my_size += ::protobuf::rt::string_size(7, &self.uuid);
6021 }
6022 if let Some(ref v) = self.frame_data.as_ref() {
6023 let len = v.compute_size();
6024 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
6025 }
6026 if self.moment_of_day != MomentOfDay::MOMENT_OF_DAY_NOT_DEFINED {
6027 my_size += ::protobuf::rt::enum_size(9, self.moment_of_day);
6028 }
6029 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
6030 self.cached_size.set(my_size);
6031 my_size
6032 }
6033
6034 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6035 for v in &self.rect_detection {
6036 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
6037 os.write_raw_varint32(v.get_cached_size())?;
6038 v.write_to_with_cached_sizes(os)?;
6039 };
6040 for v in &self.vision_event {
6041 os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
6042 os.write_raw_varint32(v.get_cached_size())?;
6043 v.write_to_with_cached_sizes(os)?;
6044 };
6045 if let Some(ref v) = self.result_image.as_ref() {
6046 os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
6047 os.write_raw_varint32(v.get_cached_size())?;
6048 v.write_to_with_cached_sizes(os)?;
6049 }
6050 if let Some(ref v) = self.result_image_small.as_ref() {
6051 os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
6052 os.write_raw_varint32(v.get_cached_size())?;
6053 v.write_to_with_cached_sizes(os)?;
6054 }
6055 if !self.image.is_empty() {
6056 os.write_bytes(2, &self.image)?;
6057 }
6058 if !self.image_small.is_empty() {
6059 os.write_bytes(3, &self.image_small)?;
6060 }
6061 if !self.uuid.is_empty() {
6062 os.write_string(7, &self.uuid)?;
6063 }
6064 if let Some(ref v) = self.frame_data.as_ref() {
6065 os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
6066 os.write_raw_varint32(v.get_cached_size())?;
6067 v.write_to_with_cached_sizes(os)?;
6068 }
6069 if self.moment_of_day != MomentOfDay::MOMENT_OF_DAY_NOT_DEFINED {
6070 os.write_enum(9, ::protobuf::ProtobufEnum::value(&self.moment_of_day))?;
6071 }
6072 os.write_unknown_fields(self.get_unknown_fields())?;
6073 ::std::result::Result::Ok(())
6074 }
6075
6076 fn get_cached_size(&self) -> u32 {
6077 self.cached_size.get()
6078 }
6079
6080 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
6081 &self.unknown_fields
6082 }
6083
6084 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
6085 &mut self.unknown_fields
6086 }
6087
6088 fn as_any(&self) -> &dyn (::std::any::Any) {
6089 self as &dyn (::std::any::Any)
6090 }
6091 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
6092 self as &mut dyn (::std::any::Any)
6093 }
6094 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
6095 self
6096 }
6097
6098 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
6099 Self::descriptor_static()
6100 }
6101
6102 fn new() -> VisionResult {
6103 VisionResult::new()
6104 }
6105
6106 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
6107 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
6108 descriptor.get(|| {
6109 let mut fields = ::std::vec::Vec::new();
6110 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RectangularDetection>>(
6111 "rect_detection",
6112 |m: &VisionResult| { &m.rect_detection },
6113 |m: &mut VisionResult| { &mut m.rect_detection },
6114 ));
6115 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<VisionEvent>>(
6116 "vision_event",
6117 |m: &VisionResult| { &m.vision_event },
6118 |m: &mut VisionResult| { &mut m.vision_event },
6119 ));
6120 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Image>>(
6121 "result_image",
6122 |m: &VisionResult| { &m.result_image },
6123 |m: &mut VisionResult| { &mut m.result_image },
6124 ));
6125 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Image>>(
6126 "result_image_small",
6127 |m: &VisionResult| { &m.result_image_small },
6128 |m: &mut VisionResult| { &mut m.result_image_small },
6129 ));
6130 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
6131 "image",
6132 |m: &VisionResult| { &m.image },
6133 |m: &mut VisionResult| { &mut m.image },
6134 ));
6135 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
6136 "image_small",
6137 |m: &VisionResult| { &m.image_small },
6138 |m: &mut VisionResult| { &mut m.image_small },
6139 ));
6140 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
6141 "uuid",
6142 |m: &VisionResult| { &m.uuid },
6143 |m: &mut VisionResult| { &mut m.uuid },
6144 ));
6145 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FrameData>>(
6146 "frame_data",
6147 |m: &VisionResult| { &m.frame_data },
6148 |m: &mut VisionResult| { &mut m.frame_data },
6149 ));
6150 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<MomentOfDay>>(
6151 "moment_of_day",
6152 |m: &VisionResult| { &m.moment_of_day },
6153 |m: &mut VisionResult| { &mut m.moment_of_day },
6154 ));
6155 ::protobuf::reflect::MessageDescriptor::new_pb_name::<VisionResult>(
6156 "VisionResult",
6157 fields,
6158 file_descriptor_proto()
6159 )
6160 })
6161 }
6162
6163 fn default_instance() -> &'static VisionResult {
6164 static instance: ::protobuf::rt::LazyV2<VisionResult> = ::protobuf::rt::LazyV2::INIT;
6165 instance.get(VisionResult::new)
6166 }
6167}
6168
6169impl ::protobuf::Clear for VisionResult {
6170 fn clear(&mut self) {
6171 self.rect_detection.clear();
6172 self.vision_event.clear();
6173 self.result_image.clear();
6174 self.result_image_small.clear();
6175 self.image.clear();
6176 self.image_small.clear();
6177 self.uuid.clear();
6178 self.frame_data.clear();
6179 self.moment_of_day = MomentOfDay::MOMENT_OF_DAY_NOT_DEFINED;
6180 self.unknown_fields.clear();
6181 }
6182}
6183
6184impl ::std::fmt::Debug for VisionResult {
6185 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6186 ::protobuf::text_format::fmt(self, f)
6187 }
6188}
6189
6190impl ::protobuf::reflect::ProtobufValue for VisionResult {
6191 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6192 ::protobuf::reflect::ReflectValueRef::Message(self)
6193 }
6194}
6195
6196#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6197pub enum EnumFacialRecognitionTag {
6198 FACIAL_RECOGNITION_NOT_DEFINED = 0,
6199 AGE = 1,
6200 EMOTION = 2,
6201 GENDER = 3,
6202 FACE_ID = 4,
6203 HEAD_POSE = 5,
6204 FACE_FEATURES = 6,
6205 FACE_DESCRIPTOR = 7,
6206 IS_FACE = 8,
6207 HAVE_GLASS = 9,
6208 BEARD = 10,
6209 TYPE_GLASS = 11,
6210}
6211
6212impl ::protobuf::ProtobufEnum for EnumFacialRecognitionTag {
6213 fn value(&self) -> i32 {
6214 *self as i32
6215 }
6216
6217 fn from_i32(value: i32) -> ::std::option::Option<EnumFacialRecognitionTag> {
6218 match value {
6219 0 => ::std::option::Option::Some(EnumFacialRecognitionTag::FACIAL_RECOGNITION_NOT_DEFINED),
6220 1 => ::std::option::Option::Some(EnumFacialRecognitionTag::AGE),
6221 2 => ::std::option::Option::Some(EnumFacialRecognitionTag::EMOTION),
6222 3 => ::std::option::Option::Some(EnumFacialRecognitionTag::GENDER),
6223 4 => ::std::option::Option::Some(EnumFacialRecognitionTag::FACE_ID),
6224 5 => ::std::option::Option::Some(EnumFacialRecognitionTag::HEAD_POSE),
6225 6 => ::std::option::Option::Some(EnumFacialRecognitionTag::FACE_FEATURES),
6226 7 => ::std::option::Option::Some(EnumFacialRecognitionTag::FACE_DESCRIPTOR),
6227 8 => ::std::option::Option::Some(EnumFacialRecognitionTag::IS_FACE),
6228 9 => ::std::option::Option::Some(EnumFacialRecognitionTag::HAVE_GLASS),
6229 10 => ::std::option::Option::Some(EnumFacialRecognitionTag::BEARD),
6230 11 => ::std::option::Option::Some(EnumFacialRecognitionTag::TYPE_GLASS),
6231 _ => ::std::option::Option::None
6232 }
6233 }
6234
6235 fn values() -> &'static [Self] {
6236 static values: &'static [EnumFacialRecognitionTag] = &[
6237 EnumFacialRecognitionTag::FACIAL_RECOGNITION_NOT_DEFINED,
6238 EnumFacialRecognitionTag::AGE,
6239 EnumFacialRecognitionTag::EMOTION,
6240 EnumFacialRecognitionTag::GENDER,
6241 EnumFacialRecognitionTag::FACE_ID,
6242 EnumFacialRecognitionTag::HEAD_POSE,
6243 EnumFacialRecognitionTag::FACE_FEATURES,
6244 EnumFacialRecognitionTag::FACE_DESCRIPTOR,
6245 EnumFacialRecognitionTag::IS_FACE,
6246 EnumFacialRecognitionTag::HAVE_GLASS,
6247 EnumFacialRecognitionTag::BEARD,
6248 EnumFacialRecognitionTag::TYPE_GLASS,
6249 ];
6250 values
6251 }
6252
6253 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6254 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6255 descriptor.get(|| {
6256 ::protobuf::reflect::EnumDescriptor::new_pb_name::<EnumFacialRecognitionTag>("EnumFacialRecognitionTag", file_descriptor_proto())
6257 })
6258 }
6259}
6260
6261impl ::std::marker::Copy for EnumFacialRecognitionTag {
6262}
6263
6264impl ::std::default::Default for EnumFacialRecognitionTag {
6265 fn default() -> Self {
6266 EnumFacialRecognitionTag::FACIAL_RECOGNITION_NOT_DEFINED
6267 }
6268}
6269
6270impl ::protobuf::reflect::ProtobufValue for EnumFacialRecognitionTag {
6271 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6272 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6273 }
6274}
6275
6276#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6277pub enum EnumVehicleRecognitionTag {
6278 VEHICLE_RECOGNITION_NOT_DEFINED = 0,
6279 FAMILY_CAR = 1,
6280}
6281
6282impl ::protobuf::ProtobufEnum for EnumVehicleRecognitionTag {
6283 fn value(&self) -> i32 {
6284 *self as i32
6285 }
6286
6287 fn from_i32(value: i32) -> ::std::option::Option<EnumVehicleRecognitionTag> {
6288 match value {
6289 0 => ::std::option::Option::Some(EnumVehicleRecognitionTag::VEHICLE_RECOGNITION_NOT_DEFINED),
6290 1 => ::std::option::Option::Some(EnumVehicleRecognitionTag::FAMILY_CAR),
6291 _ => ::std::option::Option::None
6292 }
6293 }
6294
6295 fn values() -> &'static [Self] {
6296 static values: &'static [EnumVehicleRecognitionTag] = &[
6297 EnumVehicleRecognitionTag::VEHICLE_RECOGNITION_NOT_DEFINED,
6298 EnumVehicleRecognitionTag::FAMILY_CAR,
6299 ];
6300 values
6301 }
6302
6303 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6304 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6305 descriptor.get(|| {
6306 ::protobuf::reflect::EnumDescriptor::new_pb_name::<EnumVehicleRecognitionTag>("EnumVehicleRecognitionTag", file_descriptor_proto())
6307 })
6308 }
6309}
6310
6311impl ::std::marker::Copy for EnumVehicleRecognitionTag {
6312}
6313
6314impl ::std::default::Default for EnumVehicleRecognitionTag {
6315 fn default() -> Self {
6316 EnumVehicleRecognitionTag::VEHICLE_RECOGNITION_NOT_DEFINED
6317 }
6318}
6319
6320impl ::protobuf::reflect::ProtobufValue for EnumVehicleRecognitionTag {
6321 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6322 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6323 }
6324}
6325
6326#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6327pub enum ZoneDirection {
6328 ZONE_DIRECTION_NOT_DEFINED = 0,
6329 FORWARD = 1,
6330 BACKWARD = 2,
6331}
6332
6333impl ::protobuf::ProtobufEnum for ZoneDirection {
6334 fn value(&self) -> i32 {
6335 *self as i32
6336 }
6337
6338 fn from_i32(value: i32) -> ::std::option::Option<ZoneDirection> {
6339 match value {
6340 0 => ::std::option::Option::Some(ZoneDirection::ZONE_DIRECTION_NOT_DEFINED),
6341 1 => ::std::option::Option::Some(ZoneDirection::FORWARD),
6342 2 => ::std::option::Option::Some(ZoneDirection::BACKWARD),
6343 _ => ::std::option::Option::None
6344 }
6345 }
6346
6347 fn values() -> &'static [Self] {
6348 static values: &'static [ZoneDirection] = &[
6349 ZoneDirection::ZONE_DIRECTION_NOT_DEFINED,
6350 ZoneDirection::FORWARD,
6351 ZoneDirection::BACKWARD,
6352 ];
6353 values
6354 }
6355
6356 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6357 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6358 descriptor.get(|| {
6359 ::protobuf::reflect::EnumDescriptor::new_pb_name::<ZoneDirection>("ZoneDirection", file_descriptor_proto())
6360 })
6361 }
6362}
6363
6364impl ::std::marker::Copy for ZoneDirection {
6365}
6366
6367impl ::std::default::Default for ZoneDirection {
6368 fn default() -> Self {
6369 ZoneDirection::ZONE_DIRECTION_NOT_DEFINED
6370 }
6371}
6372
6373impl ::protobuf::reflect::ProtobufValue for ZoneDirection {
6374 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6375 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6376 }
6377}
6378
6379#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6380pub enum EventTag {
6381 EVENT_NOT_DEFINED = 0,
6382 TRACKING_START = 1,
6383 TRACKING_END = 2,
6384 AREA_ENTER = 3,
6385 AREA_EXIT = 4,
6386 ZONE_ENTER = 5,
6387 ZONE_EXIT = 6,
6388}
6389
6390impl ::protobuf::ProtobufEnum for EventTag {
6391 fn value(&self) -> i32 {
6392 *self as i32
6393 }
6394
6395 fn from_i32(value: i32) -> ::std::option::Option<EventTag> {
6396 match value {
6397 0 => ::std::option::Option::Some(EventTag::EVENT_NOT_DEFINED),
6398 1 => ::std::option::Option::Some(EventTag::TRACKING_START),
6399 2 => ::std::option::Option::Some(EventTag::TRACKING_END),
6400 3 => ::std::option::Option::Some(EventTag::AREA_ENTER),
6401 4 => ::std::option::Option::Some(EventTag::AREA_EXIT),
6402 5 => ::std::option::Option::Some(EventTag::ZONE_ENTER),
6403 6 => ::std::option::Option::Some(EventTag::ZONE_EXIT),
6404 _ => ::std::option::Option::None
6405 }
6406 }
6407
6408 fn values() -> &'static [Self] {
6409 static values: &'static [EventTag] = &[
6410 EventTag::EVENT_NOT_DEFINED,
6411 EventTag::TRACKING_START,
6412 EventTag::TRACKING_END,
6413 EventTag::AREA_ENTER,
6414 EventTag::AREA_EXIT,
6415 EventTag::ZONE_ENTER,
6416 EventTag::ZONE_EXIT,
6417 ];
6418 values
6419 }
6420
6421 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6422 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6423 descriptor.get(|| {
6424 ::protobuf::reflect::EnumDescriptor::new_pb_name::<EventTag>("EventTag", file_descriptor_proto())
6425 })
6426 }
6427}
6428
6429impl ::std::marker::Copy for EventTag {
6430}
6431
6432impl ::std::default::Default for EventTag {
6433 fn default() -> Self {
6434 EventTag::EVENT_NOT_DEFINED
6435 }
6436}
6437
6438impl ::protobuf::reflect::ProtobufValue for EventTag {
6439 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6440 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6441 }
6442}
6443
6444#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6445pub enum EnumDetectionTag {
6446 DETECTION_NOT_DEFINED = 0,
6447 FACE = 1,
6448 HAND_THUMB = 2,
6449 HAND_PALM = 3,
6450 HAND_PINCH = 4,
6451 HAND_FIST = 5,
6452 PERSON = 6,
6453}
6454
6455impl ::protobuf::ProtobufEnum for EnumDetectionTag {
6456 fn value(&self) -> i32 {
6457 *self as i32
6458 }
6459
6460 fn from_i32(value: i32) -> ::std::option::Option<EnumDetectionTag> {
6461 match value {
6462 0 => ::std::option::Option::Some(EnumDetectionTag::DETECTION_NOT_DEFINED),
6463 1 => ::std::option::Option::Some(EnumDetectionTag::FACE),
6464 2 => ::std::option::Option::Some(EnumDetectionTag::HAND_THUMB),
6465 3 => ::std::option::Option::Some(EnumDetectionTag::HAND_PALM),
6466 4 => ::std::option::Option::Some(EnumDetectionTag::HAND_PINCH),
6467 5 => ::std::option::Option::Some(EnumDetectionTag::HAND_FIST),
6468 6 => ::std::option::Option::Some(EnumDetectionTag::PERSON),
6469 _ => ::std::option::Option::None
6470 }
6471 }
6472
6473 fn values() -> &'static [Self] {
6474 static values: &'static [EnumDetectionTag] = &[
6475 EnumDetectionTag::DETECTION_NOT_DEFINED,
6476 EnumDetectionTag::FACE,
6477 EnumDetectionTag::HAND_THUMB,
6478 EnumDetectionTag::HAND_PALM,
6479 EnumDetectionTag::HAND_PINCH,
6480 EnumDetectionTag::HAND_FIST,
6481 EnumDetectionTag::PERSON,
6482 ];
6483 values
6484 }
6485
6486 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6487 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6488 descriptor.get(|| {
6489 ::protobuf::reflect::EnumDescriptor::new_pb_name::<EnumDetectionTag>("EnumDetectionTag", file_descriptor_proto())
6490 })
6491 }
6492}
6493
6494impl ::std::marker::Copy for EnumDetectionTag {
6495}
6496
6497impl ::std::default::Default for EnumDetectionTag {
6498 fn default() -> Self {
6499 EnumDetectionTag::DETECTION_NOT_DEFINED
6500 }
6501}
6502
6503impl ::protobuf::reflect::ProtobufValue for EnumDetectionTag {
6504 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6505 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6506 }
6507}
6508
6509#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6510pub enum EnumDetectionAlgorithm {
6511 DETECTION_ALGORITHM_NOT_DEFINED = 0,
6512 DEFAULT = 1,
6513 FIRST_ALTERNATIVE = 2,
6514}
6515
6516impl ::protobuf::ProtobufEnum for EnumDetectionAlgorithm {
6517 fn value(&self) -> i32 {
6518 *self as i32
6519 }
6520
6521 fn from_i32(value: i32) -> ::std::option::Option<EnumDetectionAlgorithm> {
6522 match value {
6523 0 => ::std::option::Option::Some(EnumDetectionAlgorithm::DETECTION_ALGORITHM_NOT_DEFINED),
6524 1 => ::std::option::Option::Some(EnumDetectionAlgorithm::DEFAULT),
6525 2 => ::std::option::Option::Some(EnumDetectionAlgorithm::FIRST_ALTERNATIVE),
6526 _ => ::std::option::Option::None
6527 }
6528 }
6529
6530 fn values() -> &'static [Self] {
6531 static values: &'static [EnumDetectionAlgorithm] = &[
6532 EnumDetectionAlgorithm::DETECTION_ALGORITHM_NOT_DEFINED,
6533 EnumDetectionAlgorithm::DEFAULT,
6534 EnumDetectionAlgorithm::FIRST_ALTERNATIVE,
6535 ];
6536 values
6537 }
6538
6539 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6540 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6541 descriptor.get(|| {
6542 ::protobuf::reflect::EnumDescriptor::new_pb_name::<EnumDetectionAlgorithm>("EnumDetectionAlgorithm", file_descriptor_proto())
6543 })
6544 }
6545}
6546
6547impl ::std::marker::Copy for EnumDetectionAlgorithm {
6548}
6549
6550impl ::std::default::Default for EnumDetectionAlgorithm {
6551 fn default() -> Self {
6552 EnumDetectionAlgorithm::DETECTION_ALGORITHM_NOT_DEFINED
6553 }
6554}
6555
6556impl ::protobuf::reflect::ProtobufValue for EnumDetectionAlgorithm {
6557 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6558 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6559 }
6560}
6561
6562#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6563pub enum EnumVideoCodec {
6564 VIDEO_CODEC_NOT_DEFINED = 0,
6565 UNDEFINED_VIDEO_CODEC = 1,
6566 H264 = 2,
6567 MP4V = 3,
6568 RV24 = 4,
6569 VP8 = 5,
6570 VP9 = 6,
6571}
6572
6573impl ::protobuf::ProtobufEnum for EnumVideoCodec {
6574 fn value(&self) -> i32 {
6575 *self as i32
6576 }
6577
6578 fn from_i32(value: i32) -> ::std::option::Option<EnumVideoCodec> {
6579 match value {
6580 0 => ::std::option::Option::Some(EnumVideoCodec::VIDEO_CODEC_NOT_DEFINED),
6581 1 => ::std::option::Option::Some(EnumVideoCodec::UNDEFINED_VIDEO_CODEC),
6582 2 => ::std::option::Option::Some(EnumVideoCodec::H264),
6583 3 => ::std::option::Option::Some(EnumVideoCodec::MP4V),
6584 4 => ::std::option::Option::Some(EnumVideoCodec::RV24),
6585 5 => ::std::option::Option::Some(EnumVideoCodec::VP8),
6586 6 => ::std::option::Option::Some(EnumVideoCodec::VP9),
6587 _ => ::std::option::Option::None
6588 }
6589 }
6590
6591 fn values() -> &'static [Self] {
6592 static values: &'static [EnumVideoCodec] = &[
6593 EnumVideoCodec::VIDEO_CODEC_NOT_DEFINED,
6594 EnumVideoCodec::UNDEFINED_VIDEO_CODEC,
6595 EnumVideoCodec::H264,
6596 EnumVideoCodec::MP4V,
6597 EnumVideoCodec::RV24,
6598 EnumVideoCodec::VP8,
6599 EnumVideoCodec::VP9,
6600 ];
6601 values
6602 }
6603
6604 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6605 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6606 descriptor.get(|| {
6607 ::protobuf::reflect::EnumDescriptor::new_pb_name::<EnumVideoCodec>("EnumVideoCodec", file_descriptor_proto())
6608 })
6609 }
6610}
6611
6612impl ::std::marker::Copy for EnumVideoCodec {
6613}
6614
6615impl ::std::default::Default for EnumVideoCodec {
6616 fn default() -> Self {
6617 EnumVideoCodec::VIDEO_CODEC_NOT_DEFINED
6618 }
6619}
6620
6621impl ::protobuf::reflect::ProtobufValue for EnumVideoCodec {
6622 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6623 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6624 }
6625}
6626
6627#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6628pub enum ImageFormat {
6629 IMAGE_FORMAT_NOT_DEFINED = 0,
6630 UNSPECIFIED = 1,
6631 FORMAT_8URGB = 2,
6632 FORMAT_8UBGR = 3,
6633 FORMAT_8U = 4,
6634}
6635
6636impl ::protobuf::ProtobufEnum for ImageFormat {
6637 fn value(&self) -> i32 {
6638 *self as i32
6639 }
6640
6641 fn from_i32(value: i32) -> ::std::option::Option<ImageFormat> {
6642 match value {
6643 0 => ::std::option::Option::Some(ImageFormat::IMAGE_FORMAT_NOT_DEFINED),
6644 1 => ::std::option::Option::Some(ImageFormat::UNSPECIFIED),
6645 2 => ::std::option::Option::Some(ImageFormat::FORMAT_8URGB),
6646 3 => ::std::option::Option::Some(ImageFormat::FORMAT_8UBGR),
6647 4 => ::std::option::Option::Some(ImageFormat::FORMAT_8U),
6648 _ => ::std::option::Option::None
6649 }
6650 }
6651
6652 fn values() -> &'static [Self] {
6653 static values: &'static [ImageFormat] = &[
6654 ImageFormat::IMAGE_FORMAT_NOT_DEFINED,
6655 ImageFormat::UNSPECIFIED,
6656 ImageFormat::FORMAT_8URGB,
6657 ImageFormat::FORMAT_8UBGR,
6658 ImageFormat::FORMAT_8U,
6659 ];
6660 values
6661 }
6662
6663 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6664 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6665 descriptor.get(|| {
6666 ::protobuf::reflect::EnumDescriptor::new_pb_name::<ImageFormat>("ImageFormat", file_descriptor_proto())
6667 })
6668 }
6669}
6670
6671impl ::std::marker::Copy for ImageFormat {
6672}
6673
6674impl ::std::default::Default for ImageFormat {
6675 fn default() -> Self {
6676 ImageFormat::IMAGE_FORMAT_NOT_DEFINED
6677 }
6678}
6679
6680impl ::protobuf::reflect::ProtobufValue for ImageFormat {
6681 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6682 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6683 }
6684}
6685
6686#[derive(Clone,PartialEq,Eq,Debug,Hash)]
6687pub enum MomentOfDay {
6688 MOMENT_OF_DAY_NOT_DEFINED = 0,
6689 DAY = 1,
6690 NIGHT = 2,
6691}
6692
6693impl ::protobuf::ProtobufEnum for MomentOfDay {
6694 fn value(&self) -> i32 {
6695 *self as i32
6696 }
6697
6698 fn from_i32(value: i32) -> ::std::option::Option<MomentOfDay> {
6699 match value {
6700 0 => ::std::option::Option::Some(MomentOfDay::MOMENT_OF_DAY_NOT_DEFINED),
6701 1 => ::std::option::Option::Some(MomentOfDay::DAY),
6702 2 => ::std::option::Option::Some(MomentOfDay::NIGHT),
6703 _ => ::std::option::Option::None
6704 }
6705 }
6706
6707 fn values() -> &'static [Self] {
6708 static values: &'static [MomentOfDay] = &[
6709 MomentOfDay::MOMENT_OF_DAY_NOT_DEFINED,
6710 MomentOfDay::DAY,
6711 MomentOfDay::NIGHT,
6712 ];
6713 values
6714 }
6715
6716 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
6717 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
6718 descriptor.get(|| {
6719 ::protobuf::reflect::EnumDescriptor::new_pb_name::<MomentOfDay>("MomentOfDay", file_descriptor_proto())
6720 })
6721 }
6722}
6723
6724impl ::std::marker::Copy for MomentOfDay {
6725}
6726
6727impl ::std::default::Default for MomentOfDay {
6728 fn default() -> Self {
6729 MomentOfDay::MOMENT_OF_DAY_NOT_DEFINED
6730 }
6731}
6732
6733impl ::protobuf::reflect::ProtobufValue for MomentOfDay {
6734 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
6735 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
6736 }
6737}
6738
6739static file_descriptor_proto_data: &'static [u8] = b"\
6740 \n\x20matrix_io/vision/v1/vision.proto\x12\x13matrix_io.vision.v1\x1a\
6741 \x1fgoogle/protobuf/timestamp.proto\")\n\x05Point\x12\x0e\n\x01x\x18\x01\
6742 \x20\x01(\x02R\x01xB\0\x12\x0e\n\x01y\x18\x02\x20\x01(\x02R\x01yB\0:\0\"\
6743 :\n\x04Size\x12\x16\n\x05width\x18\x01\x20\x01(\x05R\x05widthB\0\x12\x18\
6744 \n\x06height\x18\x02\x20\x01(\x05R\x06heightB\0:\0\"_\n\tRectangle\x12\
6745 \x0e\n\x01x\x18\x01\x20\x01(\x02R\x01xB\0\x12\x0e\n\x01y\x18\x02\x20\x01\
6746 (\x02R\x01yB\0\x12\x16\n\x05width\x18\x03\x20\x01(\x02R\x05widthB\0\x12\
6747 \x18\n\x06height\x18\x04\x20\x01(\x02R\x06heightB\0:\0\"\xd8\x01\n\x12Ve\
6748 hicleRecognition\x12\x14\n\x04type\x18\x01\x20\x01(\tR\x04typeB\0\x12\
6749 \x16\n\x05brand\x18\x02\x20\x01(\tR\x05brandB\0\x12\x16\n\x05model\x18\
6750 \x03\x20\x01(\tR\x05modelB\0\x12\x14\n\x04year\x18\x04\x20\x01(\x05R\x04\
6751 yearB\0\x12B\n\x03tag\x18\x05\x20\x01(\x0e2..matrix_io.vision.v1.EnumVeh\
6752 icleRecognitionTagR\x03tagB\0\x12\x20\n\nconfidence\x18\x06\x20\x01(\x02\
6753 R\nconfidenceB\0:\0\"\xa8\x0b\n\x11FacialRecognition\x12A\n\x03tag\x18\
6754 \x01\x20\x01(\x0e2-.matrix_io.vision.v1.EnumFacialRecognitionTagR\x03tag\
6755 B\0\x12\x20\n\nconfidence\x18\x02\x20\x01(\x02R\nconfidenceB\0\x12\x12\n\
6756 \x03age\x18\x03\x20\x01(\x05R\x03ageB\0\x12N\n\tage_class\x18\r\x20\x01(\
6757 \x0e2/.matrix_io.vision.v1.FacialRecognition.AgeClassR\x08ageClassB\0\
6758 \x12G\n\x06gender\x18\x04\x20\x01(\x0e2-.matrix_io.vision.v1.FacialRecog\
6759 nition.GenderR\x06genderB\0\x12J\n\x07emotion\x18\x05\x20\x01(\x0e2..mat\
6760 rix_io.vision.v1.FacialRecognition.EmotionR\x07emotionB\0\x12+\n\x0fface\
6761 _descriptor\x18\x06\x20\x03(\x02R\x0efaceDescriptorB\x02\x10\x01\x12\x19\
6762 \n\x07face_id\x18\x07\x20\x01(\tR\x06faceIdB\0\x12\x1b\n\x08pose_yaw\x18\
6763 \x08\x20\x01(\x02R\x07poseYawB\0\x12\x1d\n\tpose_roll\x18\t\x20\x01(\x02\
6764 R\x08poseRollB\0\x12\x1f\n\npose_pitch\x18\n\x20\x01(\x02R\tposePitchB\0\
6765 \x12\x1f\n\nis_looking\x18\x0e\x20\x01(\x08R\tisLookingB\0\x12^\n\rbasic\
6766 _feature\x18\x0b\x20\x01(\x0b27.matrix_io.vision.v1.FacialRecognition.Ba\
6767 sicFaceFeatureR\x0cbasicFeatureB\0\x12\x19\n\x07is_face\x18\x0c\x20\x01(\
6768 \x08R\x06isFaceB\0\x12\x1f\n\nhave_glass\x18\x0f\x20\x01(\x08R\thaveGlas\
6769 sB\0\x12\x16\n\x05beard\x18\x10\x20\x01(\x08R\x05beardB\0\x12J\n\x07glas\
6770 ses\x18\x11\x20\x01(\x0e2..matrix_io.vision.v1.FacialRecognition.Glasses\
6771 R\x07glassesB\0\x1a\xee\x01\n\x10BasicFaceFeature\x122\n\x05mouth\x18\
6772 \x01\x20\x03(\x0b2\x1a.matrix_io.vision.v1.PointR\x05mouthB\0\x127\n\x08\
6773 left_eye\x18\x02\x20\x03(\x0b2\x1a.matrix_io.vision.v1.PointR\x07leftEye\
6774 B\0\x129\n\tright_eye\x18\x03\x20\x03(\x0b2\x1a.matrix_io.vision.v1.Poin\
6775 tR\x08rightEyeB\0\x120\n\x04nose\x18\x04\x20\x03(\x0b2\x1a.matrix_io.vis\
6776 ion.v1.PointR\x04noseB\0:\0\"]\n\x08AgeClass\x12\x19\n\x15AGE_CLASS_NOT_\
6777 DEFINED\x10\0\x12\x0c\n\x08CHILDREN\x10\x01\x12\x0f\n\x0bYOUNG_ADULT\x10\
6778 \x02\x12\t\n\x05ADULT\x10\x03\x12\n\n\x06SENIOR\x10\x04\x1a\0\"8\n\x06Ge\
6779 nder\x12\x16\n\x12GENDER_NOT_DEFINED\x10\0\x12\x08\n\x04MALE\x10\x01\x12\
6780 \n\n\x06FEMALE\x10\x02\x1a\0\"\x8e\x01\n\x07Emotion\x12\x17\n\x13EMOTION\
6781 _NOT_DEFINED\x10\0\x12\t\n\x05ANGRY\x10\x01\x12\x0b\n\x07DISGUST\x10\x02\
6782 \x12\x0c\n\x08CONFUSED\x10\x03\x12\t\n\x05HAPPY\x10\x04\x12\x07\n\x03SAD\
6783 \x10\x05\x12\r\n\tSURPRISED\x10\x06\x12\x08\n\x04CALM\x10\x07\x12\x08\n\
6784 \x04FEAR\x10\x08\x12\x0b\n\x07NEUTRAL\x10\t\x1a\0\"R\n\x07Glasses\x12\
6785 \x17\n\x13GLASSES_NOT_DEFINED\x10\0\x12\x0b\n\x07GLASSES\x10\x01\x12\x0e\
6786 \n\nNO_GLASSES\x10\x02\x12\x0f\n\x0bSUN_GLASSES\x10\x03\x1a\0:\0\"\xcf\
6787 \x01\n\nZoneConfig\x12\x14\n\x04name\x18\x01\x20\x01(\tR\x04nameB\0\x125\
6788 \n\x07point_a\x18\x02\x20\x01(\x0b2\x1a.matrix_io.vision.v1.PointR\x06po\
6789 intAB\0\x125\n\x07point_b\x18\x03\x20\x01(\x0b2\x1a.matrix_io.vision.v1.\
6790 PointR\x06pointBB\0\x12\x18\n\x06height\x18\x04\x20\x01(\x05R\x06heightB\
6791 \0\x12!\n\x0breal_height\x18\x05\x20\x01(\x02R\nrealHeightB\0:\0\"\x9f\
6792 \x01\n\nAreaConfig\x12\x14\n\x04name\x18\x01\x20\x01(\tR\x04nameB\0\x122\
6793 \n\x05point\x18\x02\x20\x03(\x0b2\x1a.matrix_io.vision.v1.PointR\x05poin\
6794 tB\0\x12E\n\x0fcount_direction\x18\x03\x20\x01(\x0b2\x1a.matrix_io.visio\
6795 n.v1.PointR\x0ecountDirectionB\0:\0\"\xd3\x01\n\x11AreaAndZoneConfig\x12\
6796 5\n\x04area\x18\x01\x20\x03(\x0b2\x1f.matrix_io.vision.v1.AreaConfigR\
6797 \x04areaB\0\x125\n\x04zone\x18\x02\x20\x03(\x0b2\x1f.matrix_io.vision.v1\
6798 .ZoneConfigR\x04zoneB\0\x12N\n\x12region_of_interest\x18\x03\x20\x03(\
6799 \x0b2\x1e.matrix_io.vision.v1.RectangleR\x10regionOfInterestB\0:\0\"\x80\
6800 \x01\n\rVehicleConfig\x12\x1f\n\ncamera_url\x18\x01\x20\x01(\tR\tcameraU\
6801 rlB\0\x12L\n\rarea_and_zone\x18\x02\x20\x01(\x0b2&.matrix_io.vision.v1.A\
6802 reaAndZoneConfigR\x0bareaAndZoneB\0:\0\"\xc0\x03\n\x0bVisionEvent\x121\n\
6803 \x03tag\x18\x01\x20\x01(\x0e2\x1d.matrix_io.vision.v1.EventTagR\x03tagB\
6804 \0\x12!\n\x0btracking_id\x18\x02\x20\x01(\x04R\ntrackingIdB\0\x12#\n\x0c\
6805 session_time\x18\x03\x20\x01(\x02R\x0bsessionTimeB\0\x12\x1f\n\ndwell_ti\
6806 me\x18\x04\x20\x01(\x02R\tdwellTimeB\0\x12\x19\n\x07area_id\x18\x05\x20\
6807 \x01(\x04R\x06areaIdB\0\x12\x19\n\x07zone_id\x18\x06\x20\x01(\x04R\x06zo\
6808 neIdB\0\x12K\n\x0ezone_direction\x18\x07\x20\x01(\x0e2\".matrix_io.visio\
6809 n.v1.ZoneDirectionR\rzoneDirectionB\0\x12\x16\n\x05speed\x18\x08\x20\x01\
6810 (\x02R\x05speedB\0\x12:\n\ttimestamp\x18\t\x20\x01(\x0b2\x1a.google.prot\
6811 obuf.TimestampR\ttimestampB\0\x12\x1d\n\tarea_name\x18\n\x20\x01(\tR\x08\
6812 areaNameB\0\x12\x1d\n\tzone_name\x18\x0b\x20\x01(\tR\x08zoneNameB\0:\0\"\
6813 \xd7\x04\n\x14RectangularDetection\x12K\n\talgorithm\x18\x01\x20\x01(\
6814 \x0e2+.matrix_io.vision.v1.EnumDetectionAlgorithmR\talgorithmB\0\x12<\n\
6815 \x08location\x18\x02\x20\x01(\x0b2\x1e.matrix_io.vision.v1.RectangleR\
6816 \x08locationB\0\x129\n\x03tag\x18\x03\x20\x01(\x0e2%.matrix_io.vision.v1\
6817 .EnumDetectionTagR\x03tagB\0\x12\x20\n\nconfidence\x18\x04\x20\x01(\x02R\
6818 \nconfidenceB\0\x12W\n\x12facial_recognition\x18\x05\x20\x03(\x0b2&.matr\
6819 ix_io.vision.v1.FacialRecognitionR\x11facialRecognitionB\0\x12Z\n\x13veh\
6820 icle_recognition\x18\t\x20\x03(\x0b2'.matrix_io.vision.v1.VehicleRecogni\
6821 tionR\x12vehicleRecognitionB\0\x12\x16\n\x05speed\x18\n\x20\x01(\x02R\
6822 \x05speedB\0\x12\x16\n\x05image\x18\x06\x20\x01(\x0cR\x05imageB\0\x12!\n\
6823 \x0bimage_small\x18\x07\x20\x01(\x0cR\nimageSmallB\0\x12\x14\n\x04type\
6824 \x18\x0c\x20\x01(\tR\x04typeB\0\x12!\n\x0btracking_id\x18\x08\x20\x01(\
6825 \x04R\ntrackingIdB\0\x12\x14\n\x04uuid\x18\x0b\x20\x01(\tR\x04uuidB\0:\0\
6826 \"\\\n\tImageList\x12\x1f\n\nimage_data\x18\x01\x20\x03(\x0cR\timageData\
6827 B\0\x12,\n\x11frames_per_second\x18\x02\x20\x01(\x05R\x0fframesPerSecond\
6828 B\0:\0\"{\n\x05Video\x12\x1f\n\nvideo_data\x18\x01\x20\x01(\x0cR\tvideoD\
6829 ataB\0\x12;\n\x05codec\x18\x02\x20\x01(\x0e2#.matrix_io.vision.v1.EnumVi\
6830 deoCodecR\x05codecB\0\x12\x12\n\x03tag\x18\x03\x20\x03(\tR\x03tagB\0:\0\
6831 \"\x8e\x01\n\x05Image\x12\x16\n\x05image\x18\x01\x20\x01(\x0cR\x05imageB\
6832 \0\x12:\n\x06format\x18\x02\x20\x01(\x0e2\x20.matrix_io.vision.v1.ImageF\
6833 ormatR\x06formatB\0\x12/\n\x04size\x18\x03\x20\x01(\x0b2\x19.matrix_io.v\
6834 ision.v1.SizeR\x04sizeB\0:\0\"\xa2\x02\n\tFrameData\x12\x10\n\x02id\x18\
6835 \x01\x20\x01(\x04R\x02idB\0\x12;\n\nstart_time\x18\x02\x20\x01(\x0b2\x1a\
6836 .google.protobuf.TimestampR\tstartTimeB\0\x127\n\x08end_time\x18\x03\x20\
6837 \x01(\x0b2\x1a.google.protobuf.TimestampR\x07endTimeB\0\x12N\n\x08sectio\
6838 ns\x18\x04\x20\x03(\x0b20.matrix_io.vision.v1.FrameData.sections_MapEntr\
6839 yR\x08sectionsB\0\x1a;\n\x11sections_MapEntry\x12\x0e\n\x03key\x18\x01(\
6840 \tR\x03key\x12\x12\n\x05value\x18\x02(\x02R\x05value:\x028\x01:\0\"K\n\r\
6841 FrameDataList\x128\n\x06frames\x18\x01\x20\x03(\x0b2\x1e.matrix_io.visio\
6842 n.v1.FrameDataR\x06framesB\0:\0\"\x92\x04\n\x0cVisionResult\x12R\n\x0ere\
6843 ct_detection\x18\x01\x20\x03(\x0b2).matrix_io.vision.v1.RectangularDetec\
6844 tionR\rrectDetectionB\0\x12E\n\x0cvision_event\x18\x04\x20\x03(\x0b2\x20\
6845 .matrix_io.vision.v1.VisionEventR\x0bvisionEventB\0\x12?\n\x0cresult_ima\
6846 ge\x18\x05\x20\x01(\x0b2\x1a.matrix_io.vision.v1.ImageR\x0bresultImageB\
6847 \0\x12J\n\x12result_image_small\x18\x06\x20\x01(\x0b2\x1a.matrix_io.visi\
6848 on.v1.ImageR\x10resultImageSmallB\0\x12\x16\n\x05image\x18\x02\x20\x01(\
6849 \x0cR\x05imageB\0\x12!\n\x0bimage_small\x18\x03\x20\x01(\x0cR\nimageSmal\
6850 lB\0\x12\x14\n\x04uuid\x18\x07\x20\x01(\tR\x04uuidB\0\x12?\n\nframe_data\
6851 \x18\x08\x20\x01(\x0b2\x1e.matrix_io.vision.v1.FrameDataR\tframeDataB\0\
6852 \x12F\n\rmoment_of_day\x18\t\x20\x01(\x0e2\x20.matrix_io.vision.v1.Momen\
6853 tOfDayR\x0bmomentOfDayB\0:\0*\xde\x01\n\x18EnumFacialRecognitionTag\x12\
6854 \"\n\x1eFACIAL_RECOGNITION_NOT_DEFINED\x10\0\x12\x07\n\x03AGE\x10\x01\
6855 \x12\x0b\n\x07EMOTION\x10\x02\x12\n\n\x06GENDER\x10\x03\x12\x0b\n\x07FAC\
6856 E_ID\x10\x04\x12\r\n\tHEAD_POSE\x10\x05\x12\x11\n\rFACE_FEATURES\x10\x06\
6857 \x12\x13\n\x0fFACE_DESCRIPTOR\x10\x07\x12\x0b\n\x07IS_FACE\x10\x08\x12\
6858 \x0e\n\nHAVE_GLASS\x10\t\x12\t\n\x05BEARD\x10\n\x12\x0e\n\nTYPE_GLASS\
6859 \x10\x0b\x1a\0*R\n\x19EnumVehicleRecognitionTag\x12#\n\x1fVEHICLE_RECOGN\
6860 ITION_NOT_DEFINED\x10\0\x12\x0e\n\nFAMILY_CAR\x10\x01\x1a\0*L\n\rZoneDir\
6861 ection\x12\x1e\n\x1aZONE_DIRECTION_NOT_DEFINED\x10\0\x12\x0b\n\x07FORWAR\
6862 D\x10\x01\x12\x0c\n\x08BACKWARD\x10\x02\x1a\0*\x87\x01\n\x08EventTag\x12\
6863 \x15\n\x11EVENT_NOT_DEFINED\x10\0\x12\x12\n\x0eTRACKING_START\x10\x01\
6864 \x12\x10\n\x0cTRACKING_END\x10\x02\x12\x0e\n\nAREA_ENTER\x10\x03\x12\r\n\
6865 \tAREA_EXIT\x10\x04\x12\x0e\n\nZONE_ENTER\x10\x05\x12\r\n\tZONE_EXIT\x10\
6866 \x06\x1a\0*\x83\x01\n\x10EnumDetectionTag\x12\x19\n\x15DETECTION_NOT_DEF\
6867 INED\x10\0\x12\x08\n\x04FACE\x10\x01\x12\x0e\n\nHAND_THUMB\x10\x02\x12\r\
6868 \n\tHAND_PALM\x10\x03\x12\x0e\n\nHAND_PINCH\x10\x04\x12\r\n\tHAND_FIST\
6869 \x10\x05\x12\n\n\x06PERSON\x10\x06\x1a\0*c\n\x16EnumDetectionAlgorithm\
6870 \x12#\n\x1fDETECTION_ALGORITHM_NOT_DEFINED\x10\0\x12\x0b\n\x07DEFAULT\
6871 \x10\x01\x12\x15\n\x11FIRST_ALTERNATIVE\x10\x02\x1a\0*z\n\x0eEnumVideoCo\
6872 dec\x12\x1b\n\x17VIDEO_CODEC_NOT_DEFINED\x10\0\x12\x19\n\x15UNDEFINED_VI\
6873 DEO_CODEC\x10\x01\x12\x08\n\x04H264\x10\x02\x12\x08\n\x04MP4V\x10\x03\
6874 \x12\x08\n\x04RV24\x10\x04\x12\x07\n\x03VP8\x10\x05\x12\x07\n\x03VP9\x10\
6875 \x06\x1a\0*q\n\x0bImageFormat\x12\x1c\n\x18IMAGE_FORMAT_NOT_DEFINED\x10\
6876 \0\x12\x0f\n\x0bUNSPECIFIED\x10\x01\x12\x10\n\x0cFORMAT_8URGB\x10\x02\
6877 \x12\x10\n\x0cFORMAT_8UBGR\x10\x03\x12\r\n\tFORMAT_8U\x10\x04\x1a\0*B\n\
6878 \x0bMomentOfDay\x12\x1d\n\x19MOMENT_OF_DAY_NOT_DEFINED\x10\0\x12\x07\n\
6879 \x03DAY\x10\x01\x12\t\n\x05NIGHT\x10\x02\x1a\0B\0b\x06proto3\
6880";
6881
6882static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
6883
6884fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
6885 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
6886}
6887
6888pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
6889 file_descriptor_proto_lazy.get(|| {
6890 parse_descriptor_proto()
6891 })
6892}