text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: constraint_set.proto
  
  #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
  #include "constraint_set.pb.h"
  
  #include <algorithm>
  
  #include <google/protobuf/stubs/common.h>
  #include <google/protobuf/stubs/once.h>
  #include <google/protobuf/io/coded_stream.h>
  #include <google/protobuf/wire_format_lite_inl.h>
  #include <google/protobuf/descriptor.h>
  #include <google/protobuf/generated_message_reflection.h>
  #include <google/protobuf/reflection_ops.h>
  #include <google/protobuf/wire_format.h>
  // @@protoc_insertion_point(includes)
  
  namespace roborts_detection {
  
  namespace {
  
  const ::google::protobuf::Descriptor* Threshold_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    Threshold_reflection_ = NULL;
  const ::google::protobuf::Descriptor* ArmorSize_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    ArmorSize_reflection_ = NULL;
  const ::google::protobuf::Descriptor* SignalRecognization_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    SignalRecognization_reflection_ = NULL;
  const ::google::protobuf::Descriptor* ConstraintSetConfig_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    ConstraintSetConfig_reflection_ = NULL;
  const ::google::protobuf::EnumDescriptor* EnemyColor_descriptor_ = NULL;
  
  }  // namespace
  
  
  void protobuf_AssignDesc_constraint_5fset_2eproto() {
    protobuf_AddDesc_constraint_5fset_2eproto();
    const ::google::protobuf::FileDescriptor* file =
      ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
        "constraint_set.proto");
    GOOGLE_CHECK(file != NULL);
    Threshold_descriptor_ = file->message_type(0);
    static const int Threshold_offsets_[23] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_threshold_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, blue_threshold_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, red_threshold_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_min_area_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_max_area_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_min_angle_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_max_angle_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_min_angle_diff_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_max_angle_diff_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_min_aspect_ratio_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_max_aspect_ratio_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_max_width_diff_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, light_max_height_diff_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_min_area_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_max_area_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_min_angle_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_max_angle_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_light_angle_diff_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_min_ratio_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_max_ratio_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_min_aspect_ratio_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, armor_max_aspect_ratio_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, filter_armor_area_),
    };
    Threshold_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        Threshold_descriptor_,
        Threshold::default_instance_,
        Threshold_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Threshold, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(Threshold));
    ArmorSize_descriptor_ = file->message_type(1);
    static const int ArmorSize_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArmorSize, width_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArmorSize, height_),
    };
    ArmorSize_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        ArmorSize_descriptor_,
        ArmorSize::default_instance_,
        ArmorSize_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArmorSize, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArmorSize, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(ArmorSize));
    SignalRecognization_descriptor_ = file->message_type(2);
    static const int SignalRecognization_offsets_[3] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignalRecognization, max_wait_fps_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignalRecognization, min_pulse_angle_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignalRecognization, min_num_),
    };
    SignalRecognization_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        SignalRecognization_descriptor_,
        SignalRecognization::default_instance_,
        SignalRecognization_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignalRecognization, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignalRecognization, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(SignalRecognization));
    ConstraintSetConfig_descriptor_ = file->message_type(3);
    static const int ConstraintSetConfig_offsets_[7] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, enable_debug_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, enable_neon_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, using_hsv_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, threshold_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, armor_size_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, enemy_color_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, signal_recognization_),
    };
    ConstraintSetConfig_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        ConstraintSetConfig_descriptor_,
        ConstraintSetConfig::default_instance_,
        ConstraintSetConfig_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConstraintSetConfig, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(ConstraintSetConfig));
    EnemyColor_descriptor_ = file->enum_type(0);
  }
  
  namespace {
  
  GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
  inline void protobuf_AssignDescriptorsOnce() {
    ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                   &protobuf_AssignDesc_constraint_5fset_2eproto);
  }
  
  void protobuf_RegisterTypes(const ::std::string&) {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      Threshold_descriptor_, &Threshold::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ArmorSize_descriptor_, &ArmorSize::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      SignalRecognization_descriptor_, &SignalRecognization::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ConstraintSetConfig_descriptor_, &ConstraintSetConfig::default_instance());
  }
  
  }  // namespace
  
  void protobuf_ShutdownFile_constraint_5fset_2eproto() {
    delete Threshold::default_instance_;
    delete Threshold_reflection_;
    delete ArmorSize::default_instance_;
    delete ArmorSize_reflection_;
    delete SignalRecognization::default_instance_;
    delete SignalRecognization_reflection_;
    delete ConstraintSetConfig::default_instance_;
    delete ConstraintSetConfig_reflection_;
  }
  
  void protobuf_AddDesc_constraint_5fset_2eproto() {
    static bool already_here = false;
    if (already_here) return;
    already_here = true;
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      "\n\024constraint_set.proto\022\021roborts_detectio"
      "n\"\375\004\n\tThreshold\022\027\n\017light_threshold\030\001 \002(\002"
      "\022\026\n\016blue_threshold\030\002 \002(\002\022\025\n\rred_threshol"
      "d\030\003 \002(\002\022\026\n\016light_min_area\030\004 \002(\002\022\026\n\016light"
      "_max_area\030\005 \002(\002\022\027\n\017light_min_angle\030\006 \002(\002"
      "\022\027\n\017light_max_angle\030\007 \002(\002\022\034\n\024light_min_a"
      "ngle_diff\030\010 \002(\002\022\034\n\024light_max_angle_diff\030"
      "\t \002(\002\022\036\n\026light_min_aspect_ratio\030\n \002(\002\022\036\n"
      "\026light_max_aspect_ratio\030\013 \002(\002\022\034\n\024light_m"
      "ax_width_diff\030\014 \002(\002\022\035\n\025light_max_height_"
      "diff\030\r \002(\002\022\026\n\016armor_min_area\030\016 \002(\002\022\026\n\016ar"
      "mor_max_area\030\017 \002(\002\022\027\n\017armor_min_angle\030\020 "
      "\002(\002\022\027\n\017armor_max_angle\030\021 \002(\002\022\036\n\026armor_li"
      "ght_angle_diff\030\022 \002(\002\022\027\n\017armor_min_ratio\030"
      "\023 \002(\002\022\027\n\017armor_max_ratio\030\024 \002(\002\022\036\n\026armor_"
      "min_aspect_ratio\030\025 \002(\002\022\036\n\026armor_max_aspe"
      "ct_ratio\030\026 \002(\002\022\031\n\021filter_armor_area\030\027 \002("
      "\002\"*\n\tArmorSize\022\r\n\005width\030\001 \002(\002\022\016\n\006height\030"
      "\002 \002(\002\"U\n\023SignalRecognization\022\024\n\014max_wait"
      "_fps\030\001 \002(\r\022\027\n\017min_pulse_angle\030\002 \002(\002\022\017\n\007m"
      "in_num\030\003 \002(\r\"\260\002\n\023ConstraintSetConfig\022\024\n\014"
      "enable_debug\030\001 \002(\010\022\023\n\013enable_neon\030\002 \002(\010\022"
      "\021\n\tusing_hsv\030\003 \002(\010\022/\n\tthreshold\030\004 \002(\0132\034."
      "roborts_detection.Threshold\0220\n\narmor_siz"
      "e\030\005 \002(\0132\034.roborts_detection.ArmorSize\0222\n"
      "\013enemy_color\030\006 \002(\0162\035.roborts_detection.E"
      "nemyColor\022D\n\024signal_recognization\030\007 \002(\0132"
      "&.roborts_detection.SignalRecognization*"
      "\037\n\nEnemyColor\022\010\n\004BLUE\020\000\022\007\n\003RED\020\001", 1152);
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
      "constraint_set.proto", &protobuf_RegisterTypes);
    Threshold::default_instance_ = new Threshold();
    ArmorSize::default_instance_ = new ArmorSize();
    SignalRecognization::default_instance_ = new SignalRecognization();
    ConstraintSetConfig::default_instance_ = new ConstraintSetConfig();
    Threshold::default_instance_->InitAsDefaultInstance();
    ArmorSize::default_instance_->InitAsDefaultInstance();
    SignalRecognization::default_instance_->InitAsDefaultInstance();
    ConstraintSetConfig::default_instance_->InitAsDefaultInstance();
    ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_constraint_5fset_2eproto);
  }
  
  // Force AddDescriptors() to be called at static initialization time.
  struct StaticDescriptorInitializer_constraint_5fset_2eproto {
    StaticDescriptorInitializer_constraint_5fset_2eproto() {
      protobuf_AddDesc_constraint_5fset_2eproto();
    }
  } static_descriptor_initializer_constraint_5fset_2eproto_;
  const ::google::protobuf::EnumDescriptor* EnemyColor_descriptor() {
    protobuf_AssignDescriptorsOnce();
    return EnemyColor_descriptor_;
  }
  bool EnemyColor_IsValid(int value) {
    switch(value) {
      case 0:
      case 1:
        return true;
      default:
        return false;
    }
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int Threshold::kLightThresholdFieldNumber;
  const int Threshold::kBlueThresholdFieldNumber;
  const int Threshold::kRedThresholdFieldNumber;
  const int Threshold::kLightMinAreaFieldNumber;
  const int Threshold::kLightMaxAreaFieldNumber;
  const int Threshold::kLightMinAngleFieldNumber;
  const int Threshold::kLightMaxAngleFieldNumber;
  const int Threshold::kLightMinAngleDiffFieldNumber;
  const int Threshold::kLightMaxAngleDiffFieldNumber;
  const int Threshold::kLightMinAspectRatioFieldNumber;
  const int Threshold::kLightMaxAspectRatioFieldNumber;
  const int Threshold::kLightMaxWidthDiffFieldNumber;
  const int Threshold::kLightMaxHeightDiffFieldNumber;
  const int Threshold::kArmorMinAreaFieldNumber;
  const int Threshold::kArmorMaxAreaFieldNumber;
  const int Threshold::kArmorMinAngleFieldNumber;
  const int Threshold::kArmorMaxAngleFieldNumber;
  const int Threshold::kArmorLightAngleDiffFieldNumber;
  const int Threshold::kArmorMinRatioFieldNumber;
  const int Threshold::kArmorMaxRatioFieldNumber;
  const int Threshold::kArmorMinAspectRatioFieldNumber;
  const int Threshold::kArmorMaxAspectRatioFieldNumber;
  const int Threshold::kFilterArmorAreaFieldNumber;
  #endif  // !_MSC_VER
  
  Threshold::Threshold()
    : ::google::protobuf::Message() {
    SharedCtor();
    // @@protoc_insertion_point(constructor:roborts_detection.Threshold)
  }
  
  void Threshold::InitAsDefaultInstance() {
  }
  
  Threshold::Threshold(const Threshold& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:roborts_detection.Threshold)
  }
  
  void Threshold::SharedCtor() {
    _cached_size_ = 0;
    light_threshold_ = 0;
    blue_threshold_ = 0;
    red_threshold_ = 0;
    light_min_area_ = 0;
    light_max_area_ = 0;
    light_min_angle_ = 0;
    light_max_angle_ = 0;
    light_min_angle_diff_ = 0;
    light_max_angle_diff_ = 0;
    light_min_aspect_ratio_ = 0;
    light_max_aspect_ratio_ = 0;
    light_max_width_diff_ = 0;
    light_max_height_diff_ = 0;
    armor_min_area_ = 0;
    armor_max_area_ = 0;
    armor_min_angle_ = 0;
    armor_max_angle_ = 0;
    armor_light_angle_diff_ = 0;
    armor_min_ratio_ = 0;
    armor_max_ratio_ = 0;
    armor_min_aspect_ratio_ = 0;
    armor_max_aspect_ratio_ = 0;
    filter_armor_area_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  Threshold::~Threshold() {
    // @@protoc_insertion_point(destructor:roborts_detection.Threshold)
    SharedDtor();
  }
  
  void Threshold::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void Threshold::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* Threshold::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return Threshold_descriptor_;
  }
  
  const Threshold& Threshold::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_constraint_5fset_2eproto();
    return *default_instance_;
  }
  
  Threshold* Threshold::default_instance_ = NULL;
  
  Threshold* Threshold::New() const {
    return new Threshold;
  }
  
  void Threshold::Clear() {
  #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
    &reinterpret_cast<Threshold*>(16)->f) - \
     reinterpret_cast<char*>(16))
  
  #define ZR_(first, last) do {                              \
      size_t f = OFFSET_OF_FIELD_(first);                    \
      size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
      ::memset(&first, 0, n);                                \
    } while (0)
  
    if (_has_bits_[0 / 32] & 255) {
      ZR_(light_threshold_, light_min_angle_diff_);
    }
    if (_has_bits_[8 / 32] & 65280) {
      ZR_(light_max_angle_diff_, armor_min_angle_);
    }
    if (_has_bits_[16 / 32] & 8323072) {
      ZR_(armor_max_angle_, filter_armor_area_);
    }
  
  #undef OFFSET_OF_FIELD_
  #undef ZR_
  
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool Threshold::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:roborts_detection.Threshold)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // required float light_threshold = 1;
        case 1: {
          if (tag == 13) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_threshold_)));
            set_has_light_threshold();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(21)) goto parse_blue_threshold;
          break;
        }
  
        // required float blue_threshold = 2;
        case 2: {
          if (tag == 21) {
           parse_blue_threshold:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &blue_threshold_)));
            set_has_blue_threshold();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(29)) goto parse_red_threshold;
          break;
        }
  
        // required float red_threshold = 3;
        case 3: {
          if (tag == 29) {
           parse_red_threshold:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &red_threshold_)));
            set_has_red_threshold();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(37)) goto parse_light_min_area;
          break;
        }
  
        // required float light_min_area = 4;
        case 4: {
          if (tag == 37) {
           parse_light_min_area:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_min_area_)));
            set_has_light_min_area();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(45)) goto parse_light_max_area;
          break;
        }
  
        // required float light_max_area = 5;
        case 5: {
          if (tag == 45) {
           parse_light_max_area:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_max_area_)));
            set_has_light_max_area();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(53)) goto parse_light_min_angle;
          break;
        }
  
        // required float light_min_angle = 6;
        case 6: {
          if (tag == 53) {
           parse_light_min_angle:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_min_angle_)));
            set_has_light_min_angle();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(61)) goto parse_light_max_angle;
          break;
        }
  
        // required float light_max_angle = 7;
        case 7: {
          if (tag == 61) {
           parse_light_max_angle:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_max_angle_)));
            set_has_light_max_angle();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(69)) goto parse_light_min_angle_diff;
          break;
        }
  
        // required float light_min_angle_diff = 8;
        case 8: {
          if (tag == 69) {
           parse_light_min_angle_diff:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_min_angle_diff_)));
            set_has_light_min_angle_diff();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(77)) goto parse_light_max_angle_diff;
          break;
        }
  
        // required float light_max_angle_diff = 9;
        case 9: {
          if (tag == 77) {
           parse_light_max_angle_diff:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_max_angle_diff_)));
            set_has_light_max_angle_diff();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(85)) goto parse_light_min_aspect_ratio;
          break;
        }
  
        // required float light_min_aspect_ratio = 10;
        case 10: {
          if (tag == 85) {
           parse_light_min_aspect_ratio:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_min_aspect_ratio_)));
            set_has_light_min_aspect_ratio();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(93)) goto parse_light_max_aspect_ratio;
          break;
        }
  
        // required float light_max_aspect_ratio = 11;
        case 11: {
          if (tag == 93) {
           parse_light_max_aspect_ratio:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_max_aspect_ratio_)));
            set_has_light_max_aspect_ratio();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(101)) goto parse_light_max_width_diff;
          break;
        }
  
        // required float light_max_width_diff = 12;
        case 12: {
          if (tag == 101) {
           parse_light_max_width_diff:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_max_width_diff_)));
            set_has_light_max_width_diff();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(109)) goto parse_light_max_height_diff;
          break;
        }
  
        // required float light_max_height_diff = 13;
        case 13: {
          if (tag == 109) {
           parse_light_max_height_diff:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &light_max_height_diff_)));
            set_has_light_max_height_diff();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(117)) goto parse_armor_min_area;
          break;
        }
  
        // required float armor_min_area = 14;
        case 14: {
          if (tag == 117) {
           parse_armor_min_area:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_min_area_)));
            set_has_armor_min_area();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(125)) goto parse_armor_max_area;
          break;
        }
  
        // required float armor_max_area = 15;
        case 15: {
          if (tag == 125) {
           parse_armor_max_area:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_max_area_)));
            set_has_armor_max_area();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(133)) goto parse_armor_min_angle;
          break;
        }
  
        // required float armor_min_angle = 16;
        case 16: {
          if (tag == 133) {
           parse_armor_min_angle:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_min_angle_)));
            set_has_armor_min_angle();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(141)) goto parse_armor_max_angle;
          break;
        }
  
        // required float armor_max_angle = 17;
        case 17: {
          if (tag == 141) {
           parse_armor_max_angle:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_max_angle_)));
            set_has_armor_max_angle();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(149)) goto parse_armor_light_angle_diff;
          break;
        }
  
        // required float armor_light_angle_diff = 18;
        case 18: {
          if (tag == 149) {
           parse_armor_light_angle_diff:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_light_angle_diff_)));
            set_has_armor_light_angle_diff();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(157)) goto parse_armor_min_ratio;
          break;
        }
  
        // required float armor_min_ratio = 19;
        case 19: {
          if (tag == 157) {
           parse_armor_min_ratio:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_min_ratio_)));
            set_has_armor_min_ratio();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(165)) goto parse_armor_max_ratio;
          break;
        }
  
        // required float armor_max_ratio = 20;
        case 20: {
          if (tag == 165) {
           parse_armor_max_ratio:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_max_ratio_)));
            set_has_armor_max_ratio();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(173)) goto parse_armor_min_aspect_ratio;
          break;
        }
  
        // required float armor_min_aspect_ratio = 21;
        case 21: {
          if (tag == 173) {
           parse_armor_min_aspect_ratio:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_min_aspect_ratio_)));
            set_has_armor_min_aspect_ratio();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(181)) goto parse_armor_max_aspect_ratio;
          break;
        }
  
        // required float armor_max_aspect_ratio = 22;
        case 22: {
          if (tag == 181) {
           parse_armor_max_aspect_ratio:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &armor_max_aspect_ratio_)));
            set_has_armor_max_aspect_ratio();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(189)) goto parse_filter_armor_area;
          break;
        }
  
        // required float filter_armor_area = 23;
        case 23: {
          if (tag == 189) {
           parse_filter_armor_area:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &filter_armor_area_)));
            set_has_filter_armor_area();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:roborts_detection.Threshold)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:roborts_detection.Threshold)
    return false;
  #undef DO_
  }
  
  void Threshold::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:roborts_detection.Threshold)
    // required float light_threshold = 1;
    if (has_light_threshold()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->light_threshold(), output);
    }
  
    // required float blue_threshold = 2;
    if (has_blue_threshold()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->blue_threshold(), output);
    }
  
    // required float red_threshold = 3;
    if (has_red_threshold()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->red_threshold(), output);
    }
  
    // required float light_min_area = 4;
    if (has_light_min_area()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->light_min_area(), output);
    }
  
    // required float light_max_area = 5;
    if (has_light_max_area()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->light_max_area(), output);
    }
  
    // required float light_min_angle = 6;
    if (has_light_min_angle()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->light_min_angle(), output);
    }
  
    // required float light_max_angle = 7;
    if (has_light_max_angle()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->light_max_angle(), output);
    }
  
    // required float light_min_angle_diff = 8;
    if (has_light_min_angle_diff()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->light_min_angle_diff(), output);
    }
  
    // required float light_max_angle_diff = 9;
    if (has_light_max_angle_diff()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->light_max_angle_diff(), output);
    }
  
    // required float light_min_aspect_ratio = 10;
    if (has_light_min_aspect_ratio()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->light_min_aspect_ratio(), output);
    }
  
    // required float light_max_aspect_ratio = 11;
    if (has_light_max_aspect_ratio()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->light_max_aspect_ratio(), output);
    }
  
    // required float light_max_width_diff = 12;
    if (has_light_max_width_diff()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->light_max_width_diff(), output);
    }
  
    // required float light_max_height_diff = 13;
    if (has_light_max_height_diff()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->light_max_height_diff(), output);
    }
  
    // required float armor_min_area = 14;
    if (has_armor_min_area()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(14, this->armor_min_area(), output);
    }
  
    // required float armor_max_area = 15;
    if (has_armor_max_area()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(15, this->armor_max_area(), output);
    }
  
    // required float armor_min_angle = 16;
    if (has_armor_min_angle()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(16, this->armor_min_angle(), output);
    }
  
    // required float armor_max_angle = 17;
    if (has_armor_max_angle()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(17, this->armor_max_angle(), output);
    }
  
    // required float armor_light_angle_diff = 18;
    if (has_armor_light_angle_diff()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(18, this->armor_light_angle_diff(), output);
    }
  
    // required float armor_min_ratio = 19;
    if (has_armor_min_ratio()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(19, this->armor_min_ratio(), output);
    }
  
    // required float armor_max_ratio = 20;
    if (has_armor_max_ratio()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(20, this->armor_max_ratio(), output);
    }
  
    // required float armor_min_aspect_ratio = 21;
    if (has_armor_min_aspect_ratio()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(21, this->armor_min_aspect_ratio(), output);
    }
  
    // required float armor_max_aspect_ratio = 22;
    if (has_armor_max_aspect_ratio()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(22, this->armor_max_aspect_ratio(), output);
    }
  
    // required float filter_armor_area = 23;
    if (has_filter_armor_area()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(23, this->filter_armor_area(), output);
    }
  
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
    // @@protoc_insertion_point(serialize_end:roborts_detection.Threshold)
  }
  
  ::google::protobuf::uint8* Threshold::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // @@protoc_insertion_point(serialize_to_array_start:roborts_detection.Threshold)
    // required float light_threshold = 1;
    if (has_light_threshold()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->light_threshold(), target);
    }
  
    // required float blue_threshold = 2;
    if (has_blue_threshold()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->blue_threshold(), target);
    }
  
    // required float red_threshold = 3;
    if (has_red_threshold()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->red_threshold(), target);
    }
  
    // required float light_min_area = 4;
    if (has_light_min_area()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->light_min_area(), target);
    }
  
    // required float light_max_area = 5;
    if (has_light_max_area()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->light_max_area(), target);
    }
  
    // required float light_min_angle = 6;
    if (has_light_min_angle()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->light_min_angle(), target);
    }
  
    // required float light_max_angle = 7;
    if (has_light_max_angle()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->light_max_angle(), target);
    }
  
    // required float light_min_angle_diff = 8;
    if (has_light_min_angle_diff()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->light_min_angle_diff(), target);
    }
  
    // required float light_max_angle_diff = 9;
    if (has_light_max_angle_diff()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->light_max_angle_diff(), target);
    }
  
    // required float light_min_aspect_ratio = 10;
    if (has_light_min_aspect_ratio()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(10, this->light_min_aspect_ratio(), target);
    }
  
    // required float light_max_aspect_ratio = 11;
    if (has_light_max_aspect_ratio()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->light_max_aspect_ratio(), target);
    }
  
    // required float light_max_width_diff = 12;
    if (has_light_max_width_diff()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->light_max_width_diff(), target);
    }
  
    // required float light_max_height_diff = 13;
    if (has_light_max_height_diff()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->light_max_height_diff(), target);
    }
  
    // required float armor_min_area = 14;
    if (has_armor_min_area()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(14, this->armor_min_area(), target);
    }
  
    // required float armor_max_area = 15;
    if (has_armor_max_area()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(15, this->armor_max_area(), target);
    }
  
    // required float armor_min_angle = 16;
    if (has_armor_min_angle()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(16, this->armor_min_angle(), target);
    }
  
    // required float armor_max_angle = 17;
    if (has_armor_max_angle()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(17, this->armor_max_angle(), target);
    }
  
    // required float armor_light_angle_diff = 18;
    if (has_armor_light_angle_diff()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(18, this->armor_light_angle_diff(), target);
    }
  
    // required float armor_min_ratio = 19;
    if (has_armor_min_ratio()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(19, this->armor_min_ratio(), target);
    }
  
    // required float armor_max_ratio = 20;
    if (has_armor_max_ratio()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(20, this->armor_max_ratio(), target);
    }
  
    // required float armor_min_aspect_ratio = 21;
    if (has_armor_min_aspect_ratio()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(21, this->armor_min_aspect_ratio(), target);
    }
  
    // required float armor_max_aspect_ratio = 22;
    if (has_armor_max_aspect_ratio()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(22, this->armor_max_aspect_ratio(), target);
    }
  
    // required float filter_armor_area = 23;
    if (has_filter_armor_area()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(23, this->filter_armor_area(), target);
    }
  
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    // @@protoc_insertion_point(serialize_to_array_end:roborts_detection.Threshold)
    return target;
  }
  
  int Threshold::ByteSize() const {
    int total_size = 0;
  
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // required float light_threshold = 1;
      if (has_light_threshold()) {
        total_size += 1 + 4;
      }
  
      // required float blue_threshold = 2;
      if (has_blue_threshold()) {
        total_size += 1 + 4;
      }
  
      // required float red_threshold = 3;
      if (has_red_threshold()) {
        total_size += 1 + 4;
      }
  
      // required float light_min_area = 4;
      if (has_light_min_area()) {
        total_size += 1 + 4;
      }
  
      // required float light_max_area = 5;
      if (has_light_max_area()) {
        total_size += 1 + 4;
      }
  
      // required float light_min_angle = 6;
      if (has_light_min_angle()) {
        total_size += 1 + 4;
      }
  
      // required float light_max_angle = 7;
      if (has_light_max_angle()) {
        total_size += 1 + 4;
      }
  
      // required float light_min_angle_diff = 8;
      if (has_light_min_angle_diff()) {
        total_size += 1 + 4;
      }
  
    }
    if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
      // required float light_max_angle_diff = 9;
      if (has_light_max_angle_diff()) {
        total_size += 1 + 4;
      }
  
      // required float light_min_aspect_ratio = 10;
      if (has_light_min_aspect_ratio()) {
        total_size += 1 + 4;
      }
  
      // required float light_max_aspect_ratio = 11;
      if (has_light_max_aspect_ratio()) {
        total_size += 1 + 4;
      }
  
      // required float light_max_width_diff = 12;
      if (has_light_max_width_diff()) {
        total_size += 1 + 4;
      }
  
      // required float light_max_height_diff = 13;
      if (has_light_max_height_diff()) {
        total_size += 1 + 4;
      }
  
      // required float armor_min_area = 14;
      if (has_armor_min_area()) {
        total_size += 1 + 4;
      }
  
      // required float armor_max_area = 15;
      if (has_armor_max_area()) {
        total_size += 1 + 4;
      }
  
      // required float armor_min_angle = 16;
      if (has_armor_min_angle()) {
        total_size += 2 + 4;
      }
  
    }
    if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
      // required float armor_max_angle = 17;
      if (has_armor_max_angle()) {
        total_size += 2 + 4;
      }
  
      // required float armor_light_angle_diff = 18;
      if (has_armor_light_angle_diff()) {
        total_size += 2 + 4;
      }
  
      // required float armor_min_ratio = 19;
      if (has_armor_min_ratio()) {
        total_size += 2 + 4;
      }
  
      // required float armor_max_ratio = 20;
      if (has_armor_max_ratio()) {
        total_size += 2 + 4;
      }
  
      // required float armor_min_aspect_ratio = 21;
      if (has_armor_min_aspect_ratio()) {
        total_size += 2 + 4;
      }
  
      // required float armor_max_aspect_ratio = 22;
      if (has_armor_max_aspect_ratio()) {
        total_size += 2 + 4;
      }
  
      // required float filter_armor_area = 23;
      if (has_filter_armor_area()) {
        total_size += 2 + 4;
      }
  
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void Threshold::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const Threshold* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const Threshold*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void Threshold::MergeFrom(const Threshold& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from.has_light_threshold()) {
        set_light_threshold(from.light_threshold());
      }
      if (from.has_blue_threshold()) {
        set_blue_threshold(from.blue_threshold());
      }
      if (from.has_red_threshold()) {
        set_red_threshold(from.red_threshold());
      }
      if (from.has_light_min_area()) {
        set_light_min_area(from.light_min_area());
      }
      if (from.has_light_max_area()) {
        set_light_max_area(from.light_max_area());
      }
      if (from.has_light_min_angle()) {
        set_light_min_angle(from.light_min_angle());
      }
      if (from.has_light_max_angle()) {
        set_light_max_angle(from.light_max_angle());
      }
      if (from.has_light_min_angle_diff()) {
        set_light_min_angle_diff(from.light_min_angle_diff());
      }
    }
    if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
      if (from.has_light_max_angle_diff()) {
        set_light_max_angle_diff(from.light_max_angle_diff());
      }
      if (from.has_light_min_aspect_ratio()) {
        set_light_min_aspect_ratio(from.light_min_aspect_ratio());
      }
      if (from.has_light_max_aspect_ratio()) {
        set_light_max_aspect_ratio(from.light_max_aspect_ratio());
      }
      if (from.has_light_max_width_diff()) {
        set_light_max_width_diff(from.light_max_width_diff());
      }
      if (from.has_light_max_height_diff()) {
        set_light_max_height_diff(from.light_max_height_diff());
      }
      if (from.has_armor_min_area()) {
        set_armor_min_area(from.armor_min_area());
      }
      if (from.has_armor_max_area()) {
        set_armor_max_area(from.armor_max_area());
      }
      if (from.has_armor_min_angle()) {
        set_armor_min_angle(from.armor_min_angle());
      }
    }
    if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
      if (from.has_armor_max_angle()) {
        set_armor_max_angle(from.armor_max_angle());
      }
      if (from.has_armor_light_angle_diff()) {
        set_armor_light_angle_diff(from.armor_light_angle_diff());
      }
      if (from.has_armor_min_ratio()) {
        set_armor_min_ratio(from.armor_min_ratio());
      }
      if (from.has_armor_max_ratio()) {
        set_armor_max_ratio(from.armor_max_ratio());
      }
      if (from.has_armor_min_aspect_ratio()) {
        set_armor_min_aspect_ratio(from.armor_min_aspect_ratio());
      }
      if (from.has_armor_max_aspect_ratio()) {
        set_armor_max_aspect_ratio(from.armor_max_aspect_ratio());
      }
      if (from.has_filter_armor_area()) {
        set_filter_armor_area(from.filter_armor_area());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void Threshold::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void Threshold::CopyFrom(const Threshold& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool Threshold::IsInitialized() const {
    if ((_has_bits_[0] & 0x007fffff) != 0x007fffff) return false;
  
    return true;
  }
  
  void Threshold::Swap(Threshold* other) {
    if (other != this) {
      std::swap(light_threshold_, other->light_threshold_);
      std::swap(blue_threshold_, other->blue_threshold_);
      std::swap(red_threshold_, other->red_threshold_);
      std::swap(light_min_area_, other->light_min_area_);
      std::swap(light_max_area_, other->light_max_area_);
      std::swap(light_min_angle_, other->light_min_angle_);
      std::swap(light_max_angle_, other->light_max_angle_);
      std::swap(light_min_angle_diff_, other->light_min_angle_diff_);
      std::swap(light_max_angle_diff_, other->light_max_angle_diff_);
      std::swap(light_min_aspect_ratio_, other->light_min_aspect_ratio_);
      std::swap(light_max_aspect_ratio_, other->light_max_aspect_ratio_);
      std::swap(light_max_width_diff_, other->light_max_width_diff_);
      std::swap(light_max_height_diff_, other->light_max_height_diff_);
      std::swap(armor_min_area_, other->armor_min_area_);
      std::swap(armor_max_area_, other->armor_max_area_);
      std::swap(armor_min_angle_, other->armor_min_angle_);
      std::swap(armor_max_angle_, other->armor_max_angle_);
      std::swap(armor_light_angle_diff_, other->armor_light_angle_diff_);
      std::swap(armor_min_ratio_, other->armor_min_ratio_);
      std::swap(armor_max_ratio_, other->armor_max_ratio_);
      std::swap(armor_min_aspect_ratio_, other->armor_min_aspect_ratio_);
      std::swap(armor_max_aspect_ratio_, other->armor_max_aspect_ratio_);
      std::swap(filter_armor_area_, other->filter_armor_area_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata Threshold::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = Threshold_descriptor_;
    metadata.reflection = Threshold_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int ArmorSize::kWidthFieldNumber;
  const int ArmorSize::kHeightFieldNumber;
  #endif  // !_MSC_VER
  
  ArmorSize::ArmorSize()
    : ::google::protobuf::Message() {
    SharedCtor();
    // @@protoc_insertion_point(constructor:roborts_detection.ArmorSize)
  }
  
  void ArmorSize::InitAsDefaultInstance() {
  }
  
  ArmorSize::ArmorSize(const ArmorSize& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:roborts_detection.ArmorSize)
  }
  
  void ArmorSize::SharedCtor() {
    _cached_size_ = 0;
    width_ = 0;
    height_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  ArmorSize::~ArmorSize() {
    // @@protoc_insertion_point(destructor:roborts_detection.ArmorSize)
    SharedDtor();
  }
  
  void ArmorSize::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void ArmorSize::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* ArmorSize::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return ArmorSize_descriptor_;
  }
  
  const ArmorSize& ArmorSize::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_constraint_5fset_2eproto();
    return *default_instance_;
  }
  
  ArmorSize* ArmorSize::default_instance_ = NULL;
  
  ArmorSize* ArmorSize::New() const {
    return new ArmorSize;
  }
  
  void ArmorSize::Clear() {
  #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
    &reinterpret_cast<ArmorSize*>(16)->f) - \
     reinterpret_cast<char*>(16))
  
  #define ZR_(first, last) do {                              \
      size_t f = OFFSET_OF_FIELD_(first);                    \
      size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
      ::memset(&first, 0, n);                                \
    } while (0)
  
    ZR_(width_, height_);
  
  #undef OFFSET_OF_FIELD_
  #undef ZR_
  
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool ArmorSize::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:roborts_detection.ArmorSize)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // required float width = 1;
        case 1: {
          if (tag == 13) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &width_)));
            set_has_width();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(21)) goto parse_height;
          break;
        }
  
        // required float height = 2;
        case 2: {
          if (tag == 21) {
           parse_height:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &height_)));
            set_has_height();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:roborts_detection.ArmorSize)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:roborts_detection.ArmorSize)
    return false;
  #undef DO_
  }
  
  void ArmorSize::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:roborts_detection.ArmorSize)
    // required float width = 1;
    if (has_width()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->width(), output);
    }
  
    // required float height = 2;
    if (has_height()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->height(), output);
    }
  
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
    // @@protoc_insertion_point(serialize_end:roborts_detection.ArmorSize)
  }
  
  ::google::protobuf::uint8* ArmorSize::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // @@protoc_insertion_point(serialize_to_array_start:roborts_detection.ArmorSize)
    // required float width = 1;
    if (has_width()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->width(), target);
    }
  
    // required float height = 2;
    if (has_height()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->height(), target);
    }
  
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    // @@protoc_insertion_point(serialize_to_array_end:roborts_detection.ArmorSize)
    return target;
  }
  
  int ArmorSize::ByteSize() const {
    int total_size = 0;
  
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // required float width = 1;
      if (has_width()) {
        total_size += 1 + 4;
      }
  
      // required float height = 2;
      if (has_height()) {
        total_size += 1 + 4;
      }
  
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void ArmorSize::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const ArmorSize* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const ArmorSize*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void ArmorSize::MergeFrom(const ArmorSize& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from.has_width()) {
        set_width(from.width());
      }
      if (from.has_height()) {
        set_height(from.height());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void ArmorSize::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void ArmorSize::CopyFrom(const ArmorSize& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool ArmorSize::IsInitialized() const {
    if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
  
    return true;
  }
  
  void ArmorSize::Swap(ArmorSize* other) {
    if (other != this) {
      std::swap(width_, other->width_);
      std::swap(height_, other->height_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata ArmorSize::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = ArmorSize_descriptor_;
    metadata.reflection = ArmorSize_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int SignalRecognization::kMaxWaitFpsFieldNumber;
  const int SignalRecognization::kMinPulseAngleFieldNumber;
  const int SignalRecognization::kMinNumFieldNumber;
  #endif  // !_MSC_VER
  
  SignalRecognization::SignalRecognization()
    : ::google::protobuf::Message() {
    SharedCtor();
    // @@protoc_insertion_point(constructor:roborts_detection.SignalRecognization)
  }
  
  void SignalRecognization::InitAsDefaultInstance() {
  }
  
  SignalRecognization::SignalRecognization(const SignalRecognization& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:roborts_detection.SignalRecognization)
  }
  
  void SignalRecognization::SharedCtor() {
    _cached_size_ = 0;
    max_wait_fps_ = 0u;
    min_pulse_angle_ = 0;
    min_num_ = 0u;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  SignalRecognization::~SignalRecognization() {
    // @@protoc_insertion_point(destructor:roborts_detection.SignalRecognization)
    SharedDtor();
  }
  
  void SignalRecognization::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void SignalRecognization::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* SignalRecognization::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return SignalRecognization_descriptor_;
  }
  
  const SignalRecognization& SignalRecognization::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_constraint_5fset_2eproto();
    return *default_instance_;
  }
  
  SignalRecognization* SignalRecognization::default_instance_ = NULL;
  
  SignalRecognization* SignalRecognization::New() const {
    return new SignalRecognization;
  }
  
  void SignalRecognization::Clear() {
  #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
    &reinterpret_cast<SignalRecognization*>(16)->f) - \
     reinterpret_cast<char*>(16))
  
  #define ZR_(first, last) do {                              \
      size_t f = OFFSET_OF_FIELD_(first);                    \
      size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
      ::memset(&first, 0, n);                                \
    } while (0)
  
    ZR_(max_wait_fps_, min_num_);
  
  #undef OFFSET_OF_FIELD_
  #undef ZR_
  
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool SignalRecognization::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:roborts_detection.SignalRecognization)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // required uint32 max_wait_fps = 1;
        case 1: {
          if (tag == 8) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &max_wait_fps_)));
            set_has_max_wait_fps();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(21)) goto parse_min_pulse_angle;
          break;
        }
  
        // required float min_pulse_angle = 2;
        case 2: {
          if (tag == 21) {
           parse_min_pulse_angle:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &min_pulse_angle_)));
            set_has_min_pulse_angle();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(24)) goto parse_min_num;
          break;
        }
  
        // required uint32 min_num = 3;
        case 3: {
          if (tag == 24) {
           parse_min_num:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &min_num_)));
            set_has_min_num();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:roborts_detection.SignalRecognization)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:roborts_detection.SignalRecognization)
    return false;
  #undef DO_
  }
  
  void SignalRecognization::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:roborts_detection.SignalRecognization)
    // required uint32 max_wait_fps = 1;
    if (has_max_wait_fps()) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->max_wait_fps(), output);
    }
  
    // required float min_pulse_angle = 2;
    if (has_min_pulse_angle()) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->min_pulse_angle(), output);
    }
  
    // required uint32 min_num = 3;
    if (has_min_num()) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->min_num(), output);
    }
  
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
    // @@protoc_insertion_point(serialize_end:roborts_detection.SignalRecognization)
  }
  
  ::google::protobuf::uint8* SignalRecognization::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // @@protoc_insertion_point(serialize_to_array_start:roborts_detection.SignalRecognization)
    // required uint32 max_wait_fps = 1;
    if (has_max_wait_fps()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->max_wait_fps(), target);
    }
  
    // required float min_pulse_angle = 2;
    if (has_min_pulse_angle()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->min_pulse_angle(), target);
    }
  
    // required uint32 min_num = 3;
    if (has_min_num()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->min_num(), target);
    }
  
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    // @@protoc_insertion_point(serialize_to_array_end:roborts_detection.SignalRecognization)
    return target;
  }
  
  int SignalRecognization::ByteSize() const {
    int total_size = 0;
  
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // required uint32 max_wait_fps = 1;
      if (has_max_wait_fps()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->max_wait_fps());
      }
  
      // required float min_pulse_angle = 2;
      if (has_min_pulse_angle()) {
        total_size += 1 + 4;
      }
  
      // required uint32 min_num = 3;
      if (has_min_num()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->min_num());
      }
  
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void SignalRecognization::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const SignalRecognization* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const SignalRecognization*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void SignalRecognization::MergeFrom(const SignalRecognization& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from.has_max_wait_fps()) {
        set_max_wait_fps(from.max_wait_fps());
      }
      if (from.has_min_pulse_angle()) {
        set_min_pulse_angle(from.min_pulse_angle());
      }
      if (from.has_min_num()) {
        set_min_num(from.min_num());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void SignalRecognization::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void SignalRecognization::CopyFrom(const SignalRecognization& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool SignalRecognization::IsInitialized() const {
    if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
  
    return true;
  }
  
  void SignalRecognization::Swap(SignalRecognization* other) {
    if (other != this) {
      std::swap(max_wait_fps_, other->max_wait_fps_);
      std::swap(min_pulse_angle_, other->min_pulse_angle_);
      std::swap(min_num_, other->min_num_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata SignalRecognization::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = SignalRecognization_descriptor_;
    metadata.reflection = SignalRecognization_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int ConstraintSetConfig::kEnableDebugFieldNumber;
  const int ConstraintSetConfig::kEnableNeonFieldNumber;
  const int ConstraintSetConfig::kUsingHsvFieldNumber;
  const int ConstraintSetConfig::kThresholdFieldNumber;
  const int ConstraintSetConfig::kArmorSizeFieldNumber;
  const int ConstraintSetConfig::kEnemyColorFieldNumber;
  const int ConstraintSetConfig::kSignalRecognizationFieldNumber;
  #endif  // !_MSC_VER
  
  ConstraintSetConfig::ConstraintSetConfig()
    : ::google::protobuf::Message() {
    SharedCtor();
    // @@protoc_insertion_point(constructor:roborts_detection.ConstraintSetConfig)
  }
  
  void ConstraintSetConfig::InitAsDefaultInstance() {
    threshold_ = const_cast< ::roborts_detection::Threshold*>(&::roborts_detection::Threshold::default_instance());
    armor_size_ = const_cast< ::roborts_detection::ArmorSize*>(&::roborts_detection::ArmorSize::default_instance());
    signal_recognization_ = const_cast< ::roborts_detection::SignalRecognization*>(&::roborts_detection::SignalRecognization::default_instance());
  }
  
  ConstraintSetConfig::ConstraintSetConfig(const ConstraintSetConfig& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:roborts_detection.ConstraintSetConfig)
  }
  
  void ConstraintSetConfig::SharedCtor() {
    _cached_size_ = 0;
    enable_debug_ = false;
    enable_neon_ = false;
    using_hsv_ = false;
    threshold_ = NULL;
    armor_size_ = NULL;
    enemy_color_ = 0;
    signal_recognization_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  ConstraintSetConfig::~ConstraintSetConfig() {
    // @@protoc_insertion_point(destructor:roborts_detection.ConstraintSetConfig)
    SharedDtor();
  }
  
  void ConstraintSetConfig::SharedDtor() {
    if (this != default_instance_) {
      delete threshold_;
      delete armor_size_;
      delete signal_recognization_;
    }
  }
  
  void ConstraintSetConfig::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* ConstraintSetConfig::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return ConstraintSetConfig_descriptor_;
  }
  
  const ConstraintSetConfig& ConstraintSetConfig::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_constraint_5fset_2eproto();
    return *default_instance_;
  }
  
  ConstraintSetConfig* ConstraintSetConfig::default_instance_ = NULL;
  
  ConstraintSetConfig* ConstraintSetConfig::New() const {
    return new ConstraintSetConfig;
  }
  
  void ConstraintSetConfig::Clear() {
  #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
    &reinterpret_cast<ConstraintSetConfig*>(16)->f) - \
     reinterpret_cast<char*>(16))
  
  #define ZR_(first, last) do {                              \
      size_t f = OFFSET_OF_FIELD_(first);                    \
      size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
      ::memset(&first, 0, n);                                \
    } while (0)
  
    if (_has_bits_[0 / 32] & 127) {
      ZR_(enable_debug_, enemy_color_);
      if (has_threshold()) {
        if (threshold_ != NULL) threshold_->::roborts_detection::Threshold::Clear();
      }
      if (has_armor_size()) {
        if (armor_size_ != NULL) armor_size_->::roborts_detection::ArmorSize::Clear();
      }
      if (has_signal_recognization()) {
        if (signal_recognization_ != NULL) signal_recognization_->::roborts_detection::SignalRecognization::Clear();
      }
    }
  
  #undef OFFSET_OF_FIELD_
  #undef ZR_
  
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool ConstraintSetConfig::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:roborts_detection.ConstraintSetConfig)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // required bool enable_debug = 1;
        case 1: {
          if (tag == 8) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                   input, &enable_debug_)));
            set_has_enable_debug();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(16)) goto parse_enable_neon;
          break;
        }
  
        // required bool enable_neon = 2;
        case 2: {
          if (tag == 16) {
           parse_enable_neon:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                   input, &enable_neon_)));
            set_has_enable_neon();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(24)) goto parse_using_hsv;
          break;
        }
  
        // required bool using_hsv = 3;
        case 3: {
          if (tag == 24) {
           parse_using_hsv:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                   input, &using_hsv_)));
            set_has_using_hsv();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(34)) goto parse_threshold;
          break;
        }
  
        // required .roborts_detection.Threshold threshold = 4;
        case 4: {
          if (tag == 34) {
           parse_threshold:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_threshold()));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(42)) goto parse_armor_size;
          break;
        }
  
        // required .roborts_detection.ArmorSize armor_size = 5;
        case 5: {
          if (tag == 42) {
           parse_armor_size:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_armor_size()));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(48)) goto parse_enemy_color;
          break;
        }
  
        // required .roborts_detection.EnemyColor enemy_color = 6;
        case 6: {
          if (tag == 48) {
           parse_enemy_color:
            int value;
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                   input, &value)));
            if (::roborts_detection::EnemyColor_IsValid(value)) {
              set_enemy_color(static_cast< ::roborts_detection::EnemyColor >(value));
            } else {
              mutable_unknown_fields()->AddVarint(6, value);
            }
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(58)) goto parse_signal_recognization;
          break;
        }
  
        // required .roborts_detection.SignalRecognization signal_recognization = 7;
        case 7: {
          if (tag == 58) {
           parse_signal_recognization:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_signal_recognization()));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:roborts_detection.ConstraintSetConfig)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:roborts_detection.ConstraintSetConfig)
    return false;
  #undef DO_
  }
  
  void ConstraintSetConfig::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:roborts_detection.ConstraintSetConfig)
    // required bool enable_debug = 1;
    if (has_enable_debug()) {
      ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enable_debug(), output);
    }
  
    // required bool enable_neon = 2;
    if (has_enable_neon()) {
      ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->enable_neon(), output);
    }
  
    // required bool using_hsv = 3;
    if (has_using_hsv()) {
      ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->using_hsv(), output);
    }
  
    // required .roborts_detection.Threshold threshold = 4;
    if (has_threshold()) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        4, this->threshold(), output);
    }
  
    // required .roborts_detection.ArmorSize armor_size = 5;
    if (has_armor_size()) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        5, this->armor_size(), output);
    }
  
    // required .roborts_detection.EnemyColor enemy_color = 6;
    if (has_enemy_color()) {
      ::google::protobuf::internal::WireFormatLite::WriteEnum(
        6, this->enemy_color(), output);
    }
  
    // required .roborts_detection.SignalRecognization signal_recognization = 7;
    if (has_signal_recognization()) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        7, this->signal_recognization(), output);
    }
  
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
    // @@protoc_insertion_point(serialize_end:roborts_detection.ConstraintSetConfig)
  }
  
  ::google::protobuf::uint8* ConstraintSetConfig::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // @@protoc_insertion_point(serialize_to_array_start:roborts_detection.ConstraintSetConfig)
    // required bool enable_debug = 1;
    if (has_enable_debug()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->enable_debug(), target);
    }
  
    // required bool enable_neon = 2;
    if (has_enable_neon()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->enable_neon(), target);
    }
  
    // required bool using_hsv = 3;
    if (has_using_hsv()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->using_hsv(), target);
    }
  
    // required .roborts_detection.Threshold threshold = 4;
    if (has_threshold()) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          4, this->threshold(), target);
    }
  
    // required .roborts_detection.ArmorSize armor_size = 5;
    if (has_armor_size()) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          5, this->armor_size(), target);
    }
  
    // required .roborts_detection.EnemyColor enemy_color = 6;
    if (has_enemy_color()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
        6, this->enemy_color(), target);
    }
  
    // required .roborts_detection.SignalRecognization signal_recognization = 7;
    if (has_signal_recognization()) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          7, this->signal_recognization(), target);
    }
  
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    // @@protoc_insertion_point(serialize_to_array_end:roborts_detection.ConstraintSetConfig)
    return target;
  }
  
  int ConstraintSetConfig::ByteSize() const {
    int total_size = 0;
  
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // required bool enable_debug = 1;
      if (has_enable_debug()) {
        total_size += 1 + 1;
      }
  
      // required bool enable_neon = 2;
      if (has_enable_neon()) {
        total_size += 1 + 1;
      }
  
      // required bool using_hsv = 3;
      if (has_using_hsv()) {
        total_size += 1 + 1;
      }
  
      // required .roborts_detection.Threshold threshold = 4;
      if (has_threshold()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->threshold());
      }
  
      // required .roborts_detection.ArmorSize armor_size = 5;
      if (has_armor_size()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->armor_size());
      }
  
      // required .roborts_detection.EnemyColor enemy_color = 6;
      if (has_enemy_color()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::EnumSize(this->enemy_color());
      }
  
      // required .roborts_detection.SignalRecognization signal_recognization = 7;
      if (has_signal_recognization()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->signal_recognization());
      }
  
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void ConstraintSetConfig::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const ConstraintSetConfig* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const ConstraintSetConfig*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void ConstraintSetConfig::MergeFrom(const ConstraintSetConfig& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from.has_enable_debug()) {
        set_enable_debug(from.enable_debug());
      }
      if (from.has_enable_neon()) {
        set_enable_neon(from.enable_neon());
      }
      if (from.has_using_hsv()) {
        set_using_hsv(from.using_hsv());
      }
      if (from.has_threshold()) {
        mutable_threshold()->::roborts_detection::Threshold::MergeFrom(from.threshold());
      }
      if (from.has_armor_size()) {
        mutable_armor_size()->::roborts_detection::ArmorSize::MergeFrom(from.armor_size());
      }
      if (from.has_enemy_color()) {
        set_enemy_color(from.enemy_color());
      }
      if (from.has_signal_recognization()) {
        mutable_signal_recognization()->::roborts_detection::SignalRecognization::MergeFrom(from.signal_recognization());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void ConstraintSetConfig::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void ConstraintSetConfig::CopyFrom(const ConstraintSetConfig& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool ConstraintSetConfig::IsInitialized() const {
    if ((_has_bits_[0] & 0x0000007f) != 0x0000007f) return false;
  
    if (has_threshold()) {
      if (!this->threshold().IsInitialized()) return false;
    }
    if (has_armor_size()) {
      if (!this->armor_size().IsInitialized()) return false;
    }
    if (has_signal_recognization()) {
      if (!this->signal_recognization().IsInitialized()) return false;
    }
    return true;
  }
  
  void ConstraintSetConfig::Swap(ConstraintSetConfig* other) {
    if (other != this) {
      std::swap(enable_debug_, other->enable_debug_);
      std::swap(enable_neon_, other->enable_neon_);
      std::swap(using_hsv_, other->using_hsv_);
      std::swap(threshold_, other->threshold_);
      std::swap(armor_size_, other->armor_size_);
      std::swap(enemy_color_, other->enemy_color_);
      std::swap(signal_recognization_, other->signal_recognization_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata ConstraintSetConfig::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = ConstraintSetConfig_descriptor_;
    metadata.reflection = ConstraintSetConfig_reflection_;
    return metadata;
  }
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace roborts_detection
  
  // @@protoc_insertion_point(global_scope)
  