matrix_protos_rust/protos/
vision.rs

1// This file is generated by rust-protobuf 2.25.1. Do not edit
2// @generated
3
4// https://github.com/rust-lang/rust-clippy/issues/702
5#![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//! Generated file from `matrix_io/vision/v1/vision.proto`
21
22/// Generated files are compatible only with the same version
23/// of protobuf runtime.
24// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_1;
25
26#[derive(PartialEq,Clone,Default)]
27pub struct Point {
28    // message fields
29    pub x: f32,
30    pub y: f32,
31    // special fields
32    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    // float x = 1;
48
49
50    pub fn get_x(&self) -> f32 {
51        self.x
52    }
53    pub fn clear_x(&mut self) {
54        self.x = 0.;
55    }
56
57    // Param is passed by value, moved
58    pub fn set_x(&mut self, v: f32) {
59        self.x = v;
60    }
61
62    // float y = 2;
63
64
65    pub fn get_y(&self) -> f32 {
66        self.y
67    }
68    pub fn clear_y(&mut self) {
69        self.y = 0.;
70    }
71
72    // Param is passed by value, moved
73    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    // Compute sizes of nested messages
110    #[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    // message fields
216    pub width: i32,
217    pub height: i32,
218    // special fields
219    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    // int32 width = 1;
235
236
237    pub fn get_width(&self) -> i32 {
238        self.width
239    }
240    pub fn clear_width(&mut self) {
241        self.width = 0;
242    }
243
244    // Param is passed by value, moved
245    pub fn set_width(&mut self, v: i32) {
246        self.width = v;
247    }
248
249    // int32 height = 2;
250
251
252    pub fn get_height(&self) -> i32 {
253        self.height
254    }
255    pub fn clear_height(&mut self) {
256        self.height = 0;
257    }
258
259    // Param is passed by value, moved
260    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    // Compute sizes of nested messages
297    #[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    // message fields
403    pub x: f32,
404    pub y: f32,
405    pub width: f32,
406    pub height: f32,
407    // special fields
408    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    // float x = 1;
424
425
426    pub fn get_x(&self) -> f32 {
427        self.x
428    }
429    pub fn clear_x(&mut self) {
430        self.x = 0.;
431    }
432
433    // Param is passed by value, moved
434    pub fn set_x(&mut self, v: f32) {
435        self.x = v;
436    }
437
438    // float y = 2;
439
440
441    pub fn get_y(&self) -> f32 {
442        self.y
443    }
444    pub fn clear_y(&mut self) {
445        self.y = 0.;
446    }
447
448    // Param is passed by value, moved
449    pub fn set_y(&mut self, v: f32) {
450        self.y = v;
451    }
452
453    // float width = 3;
454
455
456    pub fn get_width(&self) -> f32 {
457        self.width
458    }
459    pub fn clear_width(&mut self) {
460        self.width = 0.;
461    }
462
463    // Param is passed by value, moved
464    pub fn set_width(&mut self, v: f32) {
465        self.width = v;
466    }
467
468    // float height = 4;
469
470
471    pub fn get_height(&self) -> f32 {
472        self.height
473    }
474    pub fn clear_height(&mut self) {
475        self.height = 0.;
476    }
477
478    // Param is passed by value, moved
479    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    // Compute sizes of nested messages
530    #[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    // message fields
660    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    // special fields
667    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    // string type = 1;
683
684
685    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    // Param is passed by value, moved
693    pub fn set_field_type(&mut self, v: ::std::string::String) {
694        self.field_type = v;
695    }
696
697    // Mutable pointer to the field.
698    // If field is not initialized, it is initialized with default value first.
699    pub fn mut_field_type(&mut self) -> &mut ::std::string::String {
700        &mut self.field_type
701    }
702
703    // Take field
704    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    // string brand = 2;
709
710
711    pub fn get_brand(&self) -> &str {
712        &self.brand
713    }
714    pub fn clear_brand(&mut self) {
715        self.brand.clear();
716    }
717
718    // Param is passed by value, moved
719    pub fn set_brand(&mut self, v: ::std::string::String) {
720        self.brand = v;
721    }
722
723    // Mutable pointer to the field.
724    // If field is not initialized, it is initialized with default value first.
725    pub fn mut_brand(&mut self) -> &mut ::std::string::String {
726        &mut self.brand
727    }
728
729    // Take field
730    pub fn take_brand(&mut self) -> ::std::string::String {
731        ::std::mem::replace(&mut self.brand, ::std::string::String::new())
732    }
733
734    // string model = 3;
735
736
737    pub fn get_model(&self) -> &str {
738        &self.model
739    }
740    pub fn clear_model(&mut self) {
741        self.model.clear();
742    }
743
744    // Param is passed by value, moved
745    pub fn set_model(&mut self, v: ::std::string::String) {
746        self.model = v;
747    }
748
749    // Mutable pointer to the field.
750    // If field is not initialized, it is initialized with default value first.
751    pub fn mut_model(&mut self) -> &mut ::std::string::String {
752        &mut self.model
753    }
754
755    // Take field
756    pub fn take_model(&mut self) -> ::std::string::String {
757        ::std::mem::replace(&mut self.model, ::std::string::String::new())
758    }
759
760    // int32 year = 4;
761
762
763    pub fn get_year(&self) -> i32 {
764        self.year
765    }
766    pub fn clear_year(&mut self) {
767        self.year = 0;
768    }
769
770    // Param is passed by value, moved
771    pub fn set_year(&mut self, v: i32) {
772        self.year = v;
773    }
774
775    // .matrix_io.vision.v1.EnumVehicleRecognitionTag tag = 5;
776
777
778    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    // Param is passed by value, moved
786    pub fn set_tag(&mut self, v: EnumVehicleRecognitionTag) {
787        self.tag = v;
788    }
789
790    // float confidence = 6;
791
792
793    pub fn get_confidence(&self) -> f32 {
794        self.confidence
795    }
796    pub fn clear_confidence(&mut self) {
797        self.confidence = 0.;
798    }
799
800    // Param is passed by value, moved
801    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    // Compute sizes of nested messages
850    #[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    // message fields
1004    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    // special fields
1022    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    // .matrix_io.vision.v1.EnumFacialRecognitionTag tag = 1;
1038
1039
1040    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    // Param is passed by value, moved
1048    pub fn set_tag(&mut self, v: EnumFacialRecognitionTag) {
1049        self.tag = v;
1050    }
1051
1052    // float confidence = 2;
1053
1054
1055    pub fn get_confidence(&self) -> f32 {
1056        self.confidence
1057    }
1058    pub fn clear_confidence(&mut self) {
1059        self.confidence = 0.;
1060    }
1061
1062    // Param is passed by value, moved
1063    pub fn set_confidence(&mut self, v: f32) {
1064        self.confidence = v;
1065    }
1066
1067    // int32 age = 3;
1068
1069
1070    pub fn get_age(&self) -> i32 {
1071        self.age
1072    }
1073    pub fn clear_age(&mut self) {
1074        self.age = 0;
1075    }
1076
1077    // Param is passed by value, moved
1078    pub fn set_age(&mut self, v: i32) {
1079        self.age = v;
1080    }
1081
1082    // .matrix_io.vision.v1.FacialRecognition.AgeClass age_class = 13;
1083
1084
1085    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    // Param is passed by value, moved
1093    pub fn set_age_class(&mut self, v: FacialRecognition_AgeClass) {
1094        self.age_class = v;
1095    }
1096
1097    // .matrix_io.vision.v1.FacialRecognition.Gender gender = 4;
1098
1099
1100    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    // Param is passed by value, moved
1108    pub fn set_gender(&mut self, v: FacialRecognition_Gender) {
1109        self.gender = v;
1110    }
1111
1112    // .matrix_io.vision.v1.FacialRecognition.Emotion emotion = 5;
1113
1114
1115    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    // Param is passed by value, moved
1123    pub fn set_emotion(&mut self, v: FacialRecognition_Emotion) {
1124        self.emotion = v;
1125    }
1126
1127    // repeated float face_descriptor = 6;
1128
1129
1130    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    // Param is passed by value, moved
1138    pub fn set_face_descriptor(&mut self, v: ::std::vec::Vec<f32>) {
1139        self.face_descriptor = v;
1140    }
1141
1142    // Mutable pointer to the field.
1143    pub fn mut_face_descriptor(&mut self) -> &mut ::std::vec::Vec<f32> {
1144        &mut self.face_descriptor
1145    }
1146
1147    // Take field
1148    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    // string face_id = 7;
1153
1154
1155    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    // Param is passed by value, moved
1163    pub fn set_face_id(&mut self, v: ::std::string::String) {
1164        self.face_id = v;
1165    }
1166
1167    // Mutable pointer to the field.
1168    // If field is not initialized, it is initialized with default value first.
1169    pub fn mut_face_id(&mut self) -> &mut ::std::string::String {
1170        &mut self.face_id
1171    }
1172
1173    // Take field
1174    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    // float pose_yaw = 8;
1179
1180
1181    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    // Param is passed by value, moved
1189    pub fn set_pose_yaw(&mut self, v: f32) {
1190        self.pose_yaw = v;
1191    }
1192
1193    // float pose_roll = 9;
1194
1195
1196    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    // Param is passed by value, moved
1204    pub fn set_pose_roll(&mut self, v: f32) {
1205        self.pose_roll = v;
1206    }
1207
1208    // float pose_pitch = 10;
1209
1210
1211    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    // Param is passed by value, moved
1219    pub fn set_pose_pitch(&mut self, v: f32) {
1220        self.pose_pitch = v;
1221    }
1222
1223    // bool is_looking = 14;
1224
1225
1226    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    // Param is passed by value, moved
1234    pub fn set_is_looking(&mut self, v: bool) {
1235        self.is_looking = v;
1236    }
1237
1238    // .matrix_io.vision.v1.FacialRecognition.BasicFaceFeature basic_feature = 11;
1239
1240
1241    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    // Param is passed by value, moved
1253    pub fn set_basic_feature(&mut self, v: FacialRecognition_BasicFaceFeature) {
1254        self.basic_feature = ::protobuf::SingularPtrField::some(v);
1255    }
1256
1257    // Mutable pointer to the field.
1258    // If field is not initialized, it is initialized with default value first.
1259    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    // Take field
1267    pub fn take_basic_feature(&mut self) -> FacialRecognition_BasicFaceFeature {
1268        self.basic_feature.take().unwrap_or_else(|| FacialRecognition_BasicFaceFeature::new())
1269    }
1270
1271    // bool is_face = 12;
1272
1273
1274    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    // Param is passed by value, moved
1282    pub fn set_is_face(&mut self, v: bool) {
1283        self.is_face = v;
1284    }
1285
1286    // bool have_glass = 15;
1287
1288
1289    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    // Param is passed by value, moved
1297    pub fn set_have_glass(&mut self, v: bool) {
1298        self.have_glass = v;
1299    }
1300
1301    // bool beard = 16;
1302
1303
1304    pub fn get_beard(&self) -> bool {
1305        self.beard
1306    }
1307    pub fn clear_beard(&mut self) {
1308        self.beard = false;
1309    }
1310
1311    // Param is passed by value, moved
1312    pub fn set_beard(&mut self, v: bool) {
1313        self.beard = v;
1314    }
1315
1316    // .matrix_io.vision.v1.FacialRecognition.Glasses glasses = 17;
1317
1318
1319    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    // Param is passed by value, moved
1327    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    // Compute sizes of nested messages
1442    #[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            // TODO: Data size is computed again, it should be cached
1524            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    // message fields
1736    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    // special fields
1741    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    // repeated .matrix_io.vision.v1.Point mouth = 1;
1757
1758
1759    pub fn get_mouth(&self) -> &[Point] {
1760        &self.mouth
1761    }
1762    pub fn clear_mouth(&mut self) {
1763        self.mouth.clear();
1764    }
1765
1766    // Param is passed by value, moved
1767    pub fn set_mouth(&mut self, v: ::protobuf::RepeatedField<Point>) {
1768        self.mouth = v;
1769    }
1770
1771    // Mutable pointer to the field.
1772    pub fn mut_mouth(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
1773        &mut self.mouth
1774    }
1775
1776    // Take field
1777    pub fn take_mouth(&mut self) -> ::protobuf::RepeatedField<Point> {
1778        ::std::mem::replace(&mut self.mouth, ::protobuf::RepeatedField::new())
1779    }
1780
1781    // repeated .matrix_io.vision.v1.Point left_eye = 2;
1782
1783
1784    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    // Param is passed by value, moved
1792    pub fn set_left_eye(&mut self, v: ::protobuf::RepeatedField<Point>) {
1793        self.left_eye = v;
1794    }
1795
1796    // Mutable pointer to the field.
1797    pub fn mut_left_eye(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
1798        &mut self.left_eye
1799    }
1800
1801    // Take field
1802    pub fn take_left_eye(&mut self) -> ::protobuf::RepeatedField<Point> {
1803        ::std::mem::replace(&mut self.left_eye, ::protobuf::RepeatedField::new())
1804    }
1805
1806    // repeated .matrix_io.vision.v1.Point right_eye = 3;
1807
1808
1809    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    // Param is passed by value, moved
1817    pub fn set_right_eye(&mut self, v: ::protobuf::RepeatedField<Point>) {
1818        self.right_eye = v;
1819    }
1820
1821    // Mutable pointer to the field.
1822    pub fn mut_right_eye(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
1823        &mut self.right_eye
1824    }
1825
1826    // Take field
1827    pub fn take_right_eye(&mut self) -> ::protobuf::RepeatedField<Point> {
1828        ::std::mem::replace(&mut self.right_eye, ::protobuf::RepeatedField::new())
1829    }
1830
1831    // repeated .matrix_io.vision.v1.Point nose = 4;
1832
1833
1834    pub fn get_nose(&self) -> &[Point] {
1835        &self.nose
1836    }
1837    pub fn clear_nose(&mut self) {
1838        self.nose.clear();
1839    }
1840
1841    // Param is passed by value, moved
1842    pub fn set_nose(&mut self, v: ::protobuf::RepeatedField<Point>) {
1843        self.nose = v;
1844    }
1845
1846    // Mutable pointer to the field.
1847    pub fn mut_nose(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
1848        &mut self.nose
1849    }
1850
1851    // Take field
1852    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    // Compute sizes of nested messages
1907    #[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    // message fields
2291    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    // special fields
2297    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    // string name = 1;
2313
2314
2315    pub fn get_name(&self) -> &str {
2316        &self.name
2317    }
2318    pub fn clear_name(&mut self) {
2319        self.name.clear();
2320    }
2321
2322    // Param is passed by value, moved
2323    pub fn set_name(&mut self, v: ::std::string::String) {
2324        self.name = v;
2325    }
2326
2327    // Mutable pointer to the field.
2328    // If field is not initialized, it is initialized with default value first.
2329    pub fn mut_name(&mut self) -> &mut ::std::string::String {
2330        &mut self.name
2331    }
2332
2333    // Take field
2334    pub fn take_name(&mut self) -> ::std::string::String {
2335        ::std::mem::replace(&mut self.name, ::std::string::String::new())
2336    }
2337
2338    // .matrix_io.vision.v1.Point point_a = 2;
2339
2340
2341    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    // Param is passed by value, moved
2353    pub fn set_point_a(&mut self, v: Point) {
2354        self.point_a = ::protobuf::SingularPtrField::some(v);
2355    }
2356
2357    // Mutable pointer to the field.
2358    // If field is not initialized, it is initialized with default value first.
2359    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    // Take field
2367    pub fn take_point_a(&mut self) -> Point {
2368        self.point_a.take().unwrap_or_else(|| Point::new())
2369    }
2370
2371    // .matrix_io.vision.v1.Point point_b = 3;
2372
2373
2374    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    // Param is passed by value, moved
2386    pub fn set_point_b(&mut self, v: Point) {
2387        self.point_b = ::protobuf::SingularPtrField::some(v);
2388    }
2389
2390    // Mutable pointer to the field.
2391    // If field is not initialized, it is initialized with default value first.
2392    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    // Take field
2400    pub fn take_point_b(&mut self) -> Point {
2401        self.point_b.take().unwrap_or_else(|| Point::new())
2402    }
2403
2404    // int32 height = 4;
2405
2406
2407    pub fn get_height(&self) -> i32 {
2408        self.height
2409    }
2410    pub fn clear_height(&mut self) {
2411        self.height = 0;
2412    }
2413
2414    // Param is passed by value, moved
2415    pub fn set_height(&mut self, v: i32) {
2416        self.height = v;
2417    }
2418
2419    // float real_height = 5;
2420
2421
2422    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    // Param is passed by value, moved
2430    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    // Compute sizes of nested messages
2486    #[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    // message fields
2634    pub name: ::std::string::String,
2635    pub point: ::protobuf::RepeatedField<Point>,
2636    pub count_direction: ::protobuf::SingularPtrField<Point>,
2637    // special fields
2638    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    // string name = 1;
2654
2655
2656    pub fn get_name(&self) -> &str {
2657        &self.name
2658    }
2659    pub fn clear_name(&mut self) {
2660        self.name.clear();
2661    }
2662
2663    // Param is passed by value, moved
2664    pub fn set_name(&mut self, v: ::std::string::String) {
2665        self.name = v;
2666    }
2667
2668    // Mutable pointer to the field.
2669    // If field is not initialized, it is initialized with default value first.
2670    pub fn mut_name(&mut self) -> &mut ::std::string::String {
2671        &mut self.name
2672    }
2673
2674    // Take field
2675    pub fn take_name(&mut self) -> ::std::string::String {
2676        ::std::mem::replace(&mut self.name, ::std::string::String::new())
2677    }
2678
2679    // repeated .matrix_io.vision.v1.Point point = 2;
2680
2681
2682    pub fn get_point(&self) -> &[Point] {
2683        &self.point
2684    }
2685    pub fn clear_point(&mut self) {
2686        self.point.clear();
2687    }
2688
2689    // Param is passed by value, moved
2690    pub fn set_point(&mut self, v: ::protobuf::RepeatedField<Point>) {
2691        self.point = v;
2692    }
2693
2694    // Mutable pointer to the field.
2695    pub fn mut_point(&mut self) -> &mut ::protobuf::RepeatedField<Point> {
2696        &mut self.point
2697    }
2698
2699    // Take field
2700    pub fn take_point(&mut self) -> ::protobuf::RepeatedField<Point> {
2701        ::std::mem::replace(&mut self.point, ::protobuf::RepeatedField::new())
2702    }
2703
2704    // .matrix_io.vision.v1.Point count_direction = 3;
2705
2706
2707    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    // Param is passed by value, moved
2719    pub fn set_count_direction(&mut self, v: Point) {
2720        self.count_direction = ::protobuf::SingularPtrField::some(v);
2721    }
2722
2723    // Mutable pointer to the field.
2724    // If field is not initialized, it is initialized with default value first.
2725    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    // Take field
2733    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    // Compute sizes of nested messages
2775    #[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    // message fields
2899    pub area: ::protobuf::RepeatedField<AreaConfig>,
2900    pub zone: ::protobuf::RepeatedField<ZoneConfig>,
2901    pub region_of_interest: ::protobuf::RepeatedField<Rectangle>,
2902    // special fields
2903    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    // repeated .matrix_io.vision.v1.AreaConfig area = 1;
2919
2920
2921    pub fn get_area(&self) -> &[AreaConfig] {
2922        &self.area
2923    }
2924    pub fn clear_area(&mut self) {
2925        self.area.clear();
2926    }
2927
2928    // Param is passed by value, moved
2929    pub fn set_area(&mut self, v: ::protobuf::RepeatedField<AreaConfig>) {
2930        self.area = v;
2931    }
2932
2933    // Mutable pointer to the field.
2934    pub fn mut_area(&mut self) -> &mut ::protobuf::RepeatedField<AreaConfig> {
2935        &mut self.area
2936    }
2937
2938    // Take field
2939    pub fn take_area(&mut self) -> ::protobuf::RepeatedField<AreaConfig> {
2940        ::std::mem::replace(&mut self.area, ::protobuf::RepeatedField::new())
2941    }
2942
2943    // repeated .matrix_io.vision.v1.ZoneConfig zone = 2;
2944
2945
2946    pub fn get_zone(&self) -> &[ZoneConfig] {
2947        &self.zone
2948    }
2949    pub fn clear_zone(&mut self) {
2950        self.zone.clear();
2951    }
2952
2953    // Param is passed by value, moved
2954    pub fn set_zone(&mut self, v: ::protobuf::RepeatedField<ZoneConfig>) {
2955        self.zone = v;
2956    }
2957
2958    // Mutable pointer to the field.
2959    pub fn mut_zone(&mut self) -> &mut ::protobuf::RepeatedField<ZoneConfig> {
2960        &mut self.zone
2961    }
2962
2963    // Take field
2964    pub fn take_zone(&mut self) -> ::protobuf::RepeatedField<ZoneConfig> {
2965        ::std::mem::replace(&mut self.zone, ::protobuf::RepeatedField::new())
2966    }
2967
2968    // repeated .matrix_io.vision.v1.Rectangle region_of_interest = 3;
2969
2970
2971    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    // Param is passed by value, moved
2979    pub fn set_region_of_interest(&mut self, v: ::protobuf::RepeatedField<Rectangle>) {
2980        self.region_of_interest = v;
2981    }
2982
2983    // Mutable pointer to the field.
2984    pub fn mut_region_of_interest(&mut self) -> &mut ::protobuf::RepeatedField<Rectangle> {
2985        &mut self.region_of_interest
2986    }
2987
2988    // Take field
2989    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    // Compute sizes of nested messages
3036    #[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    // message fields
3163    pub camera_url: ::std::string::String,
3164    pub area_and_zone: ::protobuf::SingularPtrField<AreaAndZoneConfig>,
3165    // special fields
3166    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    // string camera_url = 1;
3182
3183
3184    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    // Param is passed by value, moved
3192    pub fn set_camera_url(&mut self, v: ::std::string::String) {
3193        self.camera_url = v;
3194    }
3195
3196    // Mutable pointer to the field.
3197    // If field is not initialized, it is initialized with default value first.
3198    pub fn mut_camera_url(&mut self) -> &mut ::std::string::String {
3199        &mut self.camera_url
3200    }
3201
3202    // Take field
3203    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    // .matrix_io.vision.v1.AreaAndZoneConfig area_and_zone = 2;
3208
3209
3210    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    // Param is passed by value, moved
3222    pub fn set_area_and_zone(&mut self, v: AreaAndZoneConfig) {
3223        self.area_and_zone = ::protobuf::SingularPtrField::some(v);
3224    }
3225
3226    // Mutable pointer to the field.
3227    // If field is not initialized, it is initialized with default value first.
3228    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    // Take field
3236    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    // Compute sizes of nested messages
3270    #[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    // message fields
3379    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    // special fields
3391    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    // .matrix_io.vision.v1.EventTag tag = 1;
3407
3408
3409    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    // Param is passed by value, moved
3417    pub fn set_tag(&mut self, v: EventTag) {
3418        self.tag = v;
3419    }
3420
3421    // uint64 tracking_id = 2;
3422
3423
3424    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    // Param is passed by value, moved
3432    pub fn set_tracking_id(&mut self, v: u64) {
3433        self.tracking_id = v;
3434    }
3435
3436    // float session_time = 3;
3437
3438
3439    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    // Param is passed by value, moved
3447    pub fn set_session_time(&mut self, v: f32) {
3448        self.session_time = v;
3449    }
3450
3451    // float dwell_time = 4;
3452
3453
3454    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    // Param is passed by value, moved
3462    pub fn set_dwell_time(&mut self, v: f32) {
3463        self.dwell_time = v;
3464    }
3465
3466    // uint64 area_id = 5;
3467
3468
3469    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    // Param is passed by value, moved
3477    pub fn set_area_id(&mut self, v: u64) {
3478        self.area_id = v;
3479    }
3480
3481    // uint64 zone_id = 6;
3482
3483
3484    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    // Param is passed by value, moved
3492    pub fn set_zone_id(&mut self, v: u64) {
3493        self.zone_id = v;
3494    }
3495
3496    // .matrix_io.vision.v1.ZoneDirection zone_direction = 7;
3497
3498
3499    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    // Param is passed by value, moved
3507    pub fn set_zone_direction(&mut self, v: ZoneDirection) {
3508        self.zone_direction = v;
3509    }
3510
3511    // float speed = 8;
3512
3513
3514    pub fn get_speed(&self) -> f32 {
3515        self.speed
3516    }
3517    pub fn clear_speed(&mut self) {
3518        self.speed = 0.;
3519    }
3520
3521    // Param is passed by value, moved
3522    pub fn set_speed(&mut self, v: f32) {
3523        self.speed = v;
3524    }
3525
3526    // .google.protobuf.Timestamp timestamp = 9;
3527
3528
3529    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    // Param is passed by value, moved
3541    pub fn set_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) {
3542        self.timestamp = ::protobuf::SingularPtrField::some(v);
3543    }
3544
3545    // Mutable pointer to the field.
3546    // If field is not initialized, it is initialized with default value first.
3547    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    // Take field
3555    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    // string area_name = 10;
3560
3561
3562    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    // Param is passed by value, moved
3570    pub fn set_area_name(&mut self, v: ::std::string::String) {
3571        self.area_name = v;
3572    }
3573
3574    // Mutable pointer to the field.
3575    // If field is not initialized, it is initialized with default value first.
3576    pub fn mut_area_name(&mut self) -> &mut ::std::string::String {
3577        &mut self.area_name
3578    }
3579
3580    // Take field
3581    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    // string zone_name = 11;
3586
3587
3588    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    // Param is passed by value, moved
3596    pub fn set_zone_name(&mut self, v: ::std::string::String) {
3597        self.zone_name = v;
3598    }
3599
3600    // Mutable pointer to the field.
3601    // If field is not initialized, it is initialized with default value first.
3602    pub fn mut_zone_name(&mut self) -> &mut ::std::string::String {
3603        &mut self.zone_name
3604    }
3605
3606    // Take field
3607    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    // Compute sizes of nested messages
3692    #[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    // message fields
3909    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    // special fields
3922    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    // .matrix_io.vision.v1.EnumDetectionAlgorithm algorithm = 1;
3938
3939
3940    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    // Param is passed by value, moved
3948    pub fn set_algorithm(&mut self, v: EnumDetectionAlgorithm) {
3949        self.algorithm = v;
3950    }
3951
3952    // .matrix_io.vision.v1.Rectangle location = 2;
3953
3954
3955    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    // Param is passed by value, moved
3967    pub fn set_location(&mut self, v: Rectangle) {
3968        self.location = ::protobuf::SingularPtrField::some(v);
3969    }
3970
3971    // Mutable pointer to the field.
3972    // If field is not initialized, it is initialized with default value first.
3973    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    // Take field
3981    pub fn take_location(&mut self) -> Rectangle {
3982        self.location.take().unwrap_or_else(|| Rectangle::new())
3983    }
3984
3985    // .matrix_io.vision.v1.EnumDetectionTag tag = 3;
3986
3987
3988    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    // Param is passed by value, moved
3996    pub fn set_tag(&mut self, v: EnumDetectionTag) {
3997        self.tag = v;
3998    }
3999
4000    // float confidence = 4;
4001
4002
4003    pub fn get_confidence(&self) -> f32 {
4004        self.confidence
4005    }
4006    pub fn clear_confidence(&mut self) {
4007        self.confidence = 0.;
4008    }
4009
4010    // Param is passed by value, moved
4011    pub fn set_confidence(&mut self, v: f32) {
4012        self.confidence = v;
4013    }
4014
4015    // repeated .matrix_io.vision.v1.FacialRecognition facial_recognition = 5;
4016
4017
4018    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    // Param is passed by value, moved
4026    pub fn set_facial_recognition(&mut self, v: ::protobuf::RepeatedField<FacialRecognition>) {
4027        self.facial_recognition = v;
4028    }
4029
4030    // Mutable pointer to the field.
4031    pub fn mut_facial_recognition(&mut self) -> &mut ::protobuf::RepeatedField<FacialRecognition> {
4032        &mut self.facial_recognition
4033    }
4034
4035    // Take field
4036    pub fn take_facial_recognition(&mut self) -> ::protobuf::RepeatedField<FacialRecognition> {
4037        ::std::mem::replace(&mut self.facial_recognition, ::protobuf::RepeatedField::new())
4038    }
4039
4040    // repeated .matrix_io.vision.v1.VehicleRecognition vehicle_recognition = 9;
4041
4042
4043    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    // Param is passed by value, moved
4051    pub fn set_vehicle_recognition(&mut self, v: ::protobuf::RepeatedField<VehicleRecognition>) {
4052        self.vehicle_recognition = v;
4053    }
4054
4055    // Mutable pointer to the field.
4056    pub fn mut_vehicle_recognition(&mut self) -> &mut ::protobuf::RepeatedField<VehicleRecognition> {
4057        &mut self.vehicle_recognition
4058    }
4059
4060    // Take field
4061    pub fn take_vehicle_recognition(&mut self) -> ::protobuf::RepeatedField<VehicleRecognition> {
4062        ::std::mem::replace(&mut self.vehicle_recognition, ::protobuf::RepeatedField::new())
4063    }
4064
4065    // float speed = 10;
4066
4067
4068    pub fn get_speed(&self) -> f32 {
4069        self.speed
4070    }
4071    pub fn clear_speed(&mut self) {
4072        self.speed = 0.;
4073    }
4074
4075    // Param is passed by value, moved
4076    pub fn set_speed(&mut self, v: f32) {
4077        self.speed = v;
4078    }
4079
4080    // bytes image = 6;
4081
4082
4083    pub fn get_image(&self) -> &[u8] {
4084        &self.image
4085    }
4086    pub fn clear_image(&mut self) {
4087        self.image.clear();
4088    }
4089
4090    // Param is passed by value, moved
4091    pub fn set_image(&mut self, v: ::std::vec::Vec<u8>) {
4092        self.image = v;
4093    }
4094
4095    // Mutable pointer to the field.
4096    // If field is not initialized, it is initialized with default value first.
4097    pub fn mut_image(&mut self) -> &mut ::std::vec::Vec<u8> {
4098        &mut self.image
4099    }
4100
4101    // Take field
4102    pub fn take_image(&mut self) -> ::std::vec::Vec<u8> {
4103        ::std::mem::replace(&mut self.image, ::std::vec::Vec::new())
4104    }
4105
4106    // bytes image_small = 7;
4107
4108
4109    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    // Param is passed by value, moved
4117    pub fn set_image_small(&mut self, v: ::std::vec::Vec<u8>) {
4118        self.image_small = v;
4119    }
4120
4121    // Mutable pointer to the field.
4122    // If field is not initialized, it is initialized with default value first.
4123    pub fn mut_image_small(&mut self) -> &mut ::std::vec::Vec<u8> {
4124        &mut self.image_small
4125    }
4126
4127    // Take field
4128    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    // string type = 12;
4133
4134
4135    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    // Param is passed by value, moved
4143    pub fn set_field_type(&mut self, v: ::std::string::String) {
4144        self.field_type = v;
4145    }
4146
4147    // Mutable pointer to the field.
4148    // If field is not initialized, it is initialized with default value first.
4149    pub fn mut_field_type(&mut self) -> &mut ::std::string::String {
4150        &mut self.field_type
4151    }
4152
4153    // Take field
4154    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    // uint64 tracking_id = 8;
4159
4160
4161    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    // Param is passed by value, moved
4169    pub fn set_tracking_id(&mut self, v: u64) {
4170        self.tracking_id = v;
4171    }
4172
4173    // string uuid = 11;
4174
4175
4176    pub fn get_uuid(&self) -> &str {
4177        &self.uuid
4178    }
4179    pub fn clear_uuid(&mut self) {
4180        self.uuid.clear();
4181    }
4182
4183    // Param is passed by value, moved
4184    pub fn set_uuid(&mut self, v: ::std::string::String) {
4185        self.uuid = v;
4186    }
4187
4188    // Mutable pointer to the field.
4189    // If field is not initialized, it is initialized with default value first.
4190    pub fn mut_uuid(&mut self) -> &mut ::std::string::String {
4191        &mut self.uuid
4192    }
4193
4194    // Take field
4195    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    // Compute sizes of nested messages
4281    #[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    // message fields
4516    pub image_data: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
4517    pub frames_per_second: i32,
4518    // special fields
4519    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    // repeated bytes image_data = 1;
4535
4536
4537    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    // Param is passed by value, moved
4545    pub fn set_image_data(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
4546        self.image_data = v;
4547    }
4548
4549    // Mutable pointer to the field.
4550    pub fn mut_image_data(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4551        &mut self.image_data
4552    }
4553
4554    // Take field
4555    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    // int32 frames_per_second = 2;
4560
4561
4562    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    // Param is passed by value, moved
4570    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    // Compute sizes of nested messages
4603    #[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    // message fields
4709    pub video_data: ::std::vec::Vec<u8>,
4710    pub codec: EnumVideoCodec,
4711    pub tag: ::protobuf::RepeatedField<::std::string::String>,
4712    // special fields
4713    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    // bytes video_data = 1;
4729
4730
4731    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    // Param is passed by value, moved
4739    pub fn set_video_data(&mut self, v: ::std::vec::Vec<u8>) {
4740        self.video_data = v;
4741    }
4742
4743    // Mutable pointer to the field.
4744    // If field is not initialized, it is initialized with default value first.
4745    pub fn mut_video_data(&mut self) -> &mut ::std::vec::Vec<u8> {
4746        &mut self.video_data
4747    }
4748
4749    // Take field
4750    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    // .matrix_io.vision.v1.EnumVideoCodec codec = 2;
4755
4756
4757    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    // Param is passed by value, moved
4765    pub fn set_codec(&mut self, v: EnumVideoCodec) {
4766        self.codec = v;
4767    }
4768
4769    // repeated string tag = 3;
4770
4771
4772    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    // Param is passed by value, moved
4780    pub fn set_tag(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
4781        self.tag = v;
4782    }
4783
4784    // Mutable pointer to the field.
4785    pub fn mut_tag(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
4786        &mut self.tag
4787    }
4788
4789    // Take field
4790    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    // Compute sizes of nested messages
4822    #[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    // message fields
4940    pub image: ::std::vec::Vec<u8>,
4941    pub format: ImageFormat,
4942    pub size: ::protobuf::SingularPtrField<Size>,
4943    // special fields
4944    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    // bytes image = 1;
4960
4961
4962    pub fn get_image(&self) -> &[u8] {
4963        &self.image
4964    }
4965    pub fn clear_image(&mut self) {
4966        self.image.clear();
4967    }
4968
4969    // Param is passed by value, moved
4970    pub fn set_image(&mut self, v: ::std::vec::Vec<u8>) {
4971        self.image = v;
4972    }
4973
4974    // Mutable pointer to the field.
4975    // If field is not initialized, it is initialized with default value first.
4976    pub fn mut_image(&mut self) -> &mut ::std::vec::Vec<u8> {
4977        &mut self.image
4978    }
4979
4980    // Take field
4981    pub fn take_image(&mut self) -> ::std::vec::Vec<u8> {
4982        ::std::mem::replace(&mut self.image, ::std::vec::Vec::new())
4983    }
4984
4985    // .matrix_io.vision.v1.ImageFormat format = 2;
4986
4987
4988    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    // Param is passed by value, moved
4996    pub fn set_format(&mut self, v: ImageFormat) {
4997        self.format = v;
4998    }
4999
5000    // .matrix_io.vision.v1.Size size = 3;
5001
5002
5003    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    // Param is passed by value, moved
5015    pub fn set_size(&mut self, v: Size) {
5016        self.size = ::protobuf::SingularPtrField::some(v);
5017    }
5018
5019    // Mutable pointer to the field.
5020    // If field is not initialized, it is initialized with default value first.
5021    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    // Take field
5029    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    // Compute sizes of nested messages
5066    #[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    // message fields
5187    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    // special fields
5192    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    // uint64 id = 1;
5208
5209
5210    pub fn get_id(&self) -> u64 {
5211        self.id
5212    }
5213    pub fn clear_id(&mut self) {
5214        self.id = 0;
5215    }
5216
5217    // Param is passed by value, moved
5218    pub fn set_id(&mut self, v: u64) {
5219        self.id = v;
5220    }
5221
5222    // .google.protobuf.Timestamp start_time = 2;
5223
5224
5225    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    // Param is passed by value, moved
5237    pub fn set_start_time(&mut self, v: ::protobuf::well_known_types::Timestamp) {
5238        self.start_time = ::protobuf::SingularPtrField::some(v);
5239    }
5240
5241    // Mutable pointer to the field.
5242    // If field is not initialized, it is initialized with default value first.
5243    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    // Take field
5251    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    // .google.protobuf.Timestamp end_time = 3;
5256
5257
5258    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    // Param is passed by value, moved
5270    pub fn set_end_time(&mut self, v: ::protobuf::well_known_types::Timestamp) {
5271        self.end_time = ::protobuf::SingularPtrField::some(v);
5272    }
5273
5274    // Mutable pointer to the field.
5275    // If field is not initialized, it is initialized with default value first.
5276    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    // Take field
5284    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    // repeated .matrix_io.vision.v1.FrameData.sections_MapEntry sections = 4;
5289
5290
5291    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    // Param is passed by value, moved
5299    pub fn set_sections(&mut self, v: ::std::collections::HashMap<::std::string::String, f32>) {
5300        self.sections = v;
5301    }
5302
5303    // Mutable pointer to the field.
5304    pub fn mut_sections(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, f32> {
5305        &mut self.sections
5306    }
5307
5308    // Take field
5309    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    // Compute sizes of nested messages
5358    #[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    // message fields
5490    pub frames: ::protobuf::RepeatedField<FrameData>,
5491    // special fields
5492    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    // repeated .matrix_io.vision.v1.FrameData frames = 1;
5508
5509
5510    pub fn get_frames(&self) -> &[FrameData] {
5511        &self.frames
5512    }
5513    pub fn clear_frames(&mut self) {
5514        self.frames.clear();
5515    }
5516
5517    // Param is passed by value, moved
5518    pub fn set_frames(&mut self, v: ::protobuf::RepeatedField<FrameData>) {
5519        self.frames = v;
5520    }
5521
5522    // Mutable pointer to the field.
5523    pub fn mut_frames(&mut self) -> &mut ::protobuf::RepeatedField<FrameData> {
5524        &mut self.frames
5525    }
5526
5527    // Take field
5528    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    // Compute sizes of nested messages
5559    #[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    // message fields
5656    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    // special fields
5666    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    // repeated .matrix_io.vision.v1.RectangularDetection rect_detection = 1;
5682
5683
5684    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    // Param is passed by value, moved
5692    pub fn set_rect_detection(&mut self, v: ::protobuf::RepeatedField<RectangularDetection>) {
5693        self.rect_detection = v;
5694    }
5695
5696    // Mutable pointer to the field.
5697    pub fn mut_rect_detection(&mut self) -> &mut ::protobuf::RepeatedField<RectangularDetection> {
5698        &mut self.rect_detection
5699    }
5700
5701    // Take field
5702    pub fn take_rect_detection(&mut self) -> ::protobuf::RepeatedField<RectangularDetection> {
5703        ::std::mem::replace(&mut self.rect_detection, ::protobuf::RepeatedField::new())
5704    }
5705
5706    // repeated .matrix_io.vision.v1.VisionEvent vision_event = 4;
5707
5708
5709    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    // Param is passed by value, moved
5717    pub fn set_vision_event(&mut self, v: ::protobuf::RepeatedField<VisionEvent>) {
5718        self.vision_event = v;
5719    }
5720
5721    // Mutable pointer to the field.
5722    pub fn mut_vision_event(&mut self) -> &mut ::protobuf::RepeatedField<VisionEvent> {
5723        &mut self.vision_event
5724    }
5725
5726    // Take field
5727    pub fn take_vision_event(&mut self) -> ::protobuf::RepeatedField<VisionEvent> {
5728        ::std::mem::replace(&mut self.vision_event, ::protobuf::RepeatedField::new())
5729    }
5730
5731    // .matrix_io.vision.v1.Image result_image = 5;
5732
5733
5734    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    // Param is passed by value, moved
5746    pub fn set_result_image(&mut self, v: Image) {
5747        self.result_image = ::protobuf::SingularPtrField::some(v);
5748    }
5749
5750    // Mutable pointer to the field.
5751    // If field is not initialized, it is initialized with default value first.
5752    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    // Take field
5760    pub fn take_result_image(&mut self) -> Image {
5761        self.result_image.take().unwrap_or_else(|| Image::new())
5762    }
5763
5764    // .matrix_io.vision.v1.Image result_image_small = 6;
5765
5766
5767    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    // Param is passed by value, moved
5779    pub fn set_result_image_small(&mut self, v: Image) {
5780        self.result_image_small = ::protobuf::SingularPtrField::some(v);
5781    }
5782
5783    // Mutable pointer to the field.
5784    // If field is not initialized, it is initialized with default value first.
5785    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    // Take field
5793    pub fn take_result_image_small(&mut self) -> Image {
5794        self.result_image_small.take().unwrap_or_else(|| Image::new())
5795    }
5796
5797    // bytes image = 2;
5798
5799
5800    pub fn get_image(&self) -> &[u8] {
5801        &self.image
5802    }
5803    pub fn clear_image(&mut self) {
5804        self.image.clear();
5805    }
5806
5807    // Param is passed by value, moved
5808    pub fn set_image(&mut self, v: ::std::vec::Vec<u8>) {
5809        self.image = v;
5810    }
5811
5812    // Mutable pointer to the field.
5813    // If field is not initialized, it is initialized with default value first.
5814    pub fn mut_image(&mut self) -> &mut ::std::vec::Vec<u8> {
5815        &mut self.image
5816    }
5817
5818    // Take field
5819    pub fn take_image(&mut self) -> ::std::vec::Vec<u8> {
5820        ::std::mem::replace(&mut self.image, ::std::vec::Vec::new())
5821    }
5822
5823    // bytes image_small = 3;
5824
5825
5826    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    // Param is passed by value, moved
5834    pub fn set_image_small(&mut self, v: ::std::vec::Vec<u8>) {
5835        self.image_small = v;
5836    }
5837
5838    // Mutable pointer to the field.
5839    // If field is not initialized, it is initialized with default value first.
5840    pub fn mut_image_small(&mut self) -> &mut ::std::vec::Vec<u8> {
5841        &mut self.image_small
5842    }
5843
5844    // Take field
5845    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    // string uuid = 7;
5850
5851
5852    pub fn get_uuid(&self) -> &str {
5853        &self.uuid
5854    }
5855    pub fn clear_uuid(&mut self) {
5856        self.uuid.clear();
5857    }
5858
5859    // Param is passed by value, moved
5860    pub fn set_uuid(&mut self, v: ::std::string::String) {
5861        self.uuid = v;
5862    }
5863
5864    // Mutable pointer to the field.
5865    // If field is not initialized, it is initialized with default value first.
5866    pub fn mut_uuid(&mut self) -> &mut ::std::string::String {
5867        &mut self.uuid
5868    }
5869
5870    // Take field
5871    pub fn take_uuid(&mut self) -> ::std::string::String {
5872        ::std::mem::replace(&mut self.uuid, ::std::string::String::new())
5873    }
5874
5875    // .matrix_io.vision.v1.FrameData frame_data = 8;
5876
5877
5878    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    // Param is passed by value, moved
5890    pub fn set_frame_data(&mut self, v: FrameData) {
5891        self.frame_data = ::protobuf::SingularPtrField::some(v);
5892    }
5893
5894    // Mutable pointer to the field.
5895    // If field is not initialized, it is initialized with default value first.
5896    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    // Take field
5904    pub fn take_frame_data(&mut self) -> FrameData {
5905        self.frame_data.take().unwrap_or_else(|| FrameData::new())
5906    }
5907
5908    // .matrix_io.vision.v1.MomentOfDay moment_of_day = 9;
5909
5910
5911    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    // Param is passed by value, moved
5919    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    // Compute sizes of nested messages
5994    #[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}