// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: object_detection/protos/preprocessor.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2fpreprocessor_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2fpreprocessor_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021005 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_bases.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_object_5fdetection_2fprotos_2fpreprocessor_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
namespace object_detection {
namespace protos {
class AutoAugmentImage;
struct AutoAugmentImageDefaultTypeInternal;
extern AutoAugmentImageDefaultTypeInternal _AutoAugmentImage_default_instance_;
class ConvertClassLogitsToSoftmax;
struct ConvertClassLogitsToSoftmaxDefaultTypeInternal;
extern ConvertClassLogitsToSoftmaxDefaultTypeInternal _ConvertClassLogitsToSoftmax_default_instance_;
class DropLabelProbabilistically;
struct DropLabelProbabilisticallyDefaultTypeInternal;
extern DropLabelProbabilisticallyDefaultTypeInternal _DropLabelProbabilistically_default_instance_;
class NormalizeImage;
struct NormalizeImageDefaultTypeInternal;
extern NormalizeImageDefaultTypeInternal _NormalizeImage_default_instance_;
class PreprocessingStep;
struct PreprocessingStepDefaultTypeInternal;
extern PreprocessingStepDefaultTypeInternal _PreprocessingStep_default_instance_;
class RGBtoGray;
struct RGBtoGrayDefaultTypeInternal;
extern RGBtoGrayDefaultTypeInternal _RGBtoGray_default_instance_;
class RandomAbsolutePadImage;
struct RandomAbsolutePadImageDefaultTypeInternal;
extern RandomAbsolutePadImageDefaultTypeInternal _RandomAbsolutePadImage_default_instance_;
class RandomAdjustBrightness;
struct RandomAdjustBrightnessDefaultTypeInternal;
extern RandomAdjustBrightnessDefaultTypeInternal _RandomAdjustBrightness_default_instance_;
class RandomAdjustContrast;
struct RandomAdjustContrastDefaultTypeInternal;
extern RandomAdjustContrastDefaultTypeInternal _RandomAdjustContrast_default_instance_;
class RandomAdjustHue;
struct RandomAdjustHueDefaultTypeInternal;
extern RandomAdjustHueDefaultTypeInternal _RandomAdjustHue_default_instance_;
class RandomAdjustSaturation;
struct RandomAdjustSaturationDefaultTypeInternal;
extern RandomAdjustSaturationDefaultTypeInternal _RandomAdjustSaturation_default_instance_;
class RandomBlackPatches;
struct RandomBlackPatchesDefaultTypeInternal;
extern RandomBlackPatchesDefaultTypeInternal _RandomBlackPatches_default_instance_;
class RandomCropImage;
struct RandomCropImageDefaultTypeInternal;
extern RandomCropImageDefaultTypeInternal _RandomCropImage_default_instance_;
class RandomCropPadImage;
struct RandomCropPadImageDefaultTypeInternal;
extern RandomCropPadImageDefaultTypeInternal _RandomCropPadImage_default_instance_;
class RandomCropToAspectRatio;
struct RandomCropToAspectRatioDefaultTypeInternal;
extern RandomCropToAspectRatioDefaultTypeInternal _RandomCropToAspectRatio_default_instance_;
class RandomDistortColor;
struct RandomDistortColorDefaultTypeInternal;
extern RandomDistortColorDefaultTypeInternal _RandomDistortColor_default_instance_;
class RandomHorizontalFlip;
struct RandomHorizontalFlipDefaultTypeInternal;
extern RandomHorizontalFlipDefaultTypeInternal _RandomHorizontalFlip_default_instance_;
class RandomImageScale;
struct RandomImageScaleDefaultTypeInternal;
extern RandomImageScaleDefaultTypeInternal _RandomImageScale_default_instance_;
class RandomJitterBoxes;
struct RandomJitterBoxesDefaultTypeInternal;
extern RandomJitterBoxesDefaultTypeInternal _RandomJitterBoxes_default_instance_;
class RandomPadImage;
struct RandomPadImageDefaultTypeInternal;
extern RandomPadImageDefaultTypeInternal _RandomPadImage_default_instance_;
class RandomPixelValueScale;
struct RandomPixelValueScaleDefaultTypeInternal;
extern RandomPixelValueScaleDefaultTypeInternal _RandomPixelValueScale_default_instance_;
class RandomRGBtoGray;
struct RandomRGBtoGrayDefaultTypeInternal;
extern RandomRGBtoGrayDefaultTypeInternal _RandomRGBtoGray_default_instance_;
class RandomResizeMethod;
struct RandomResizeMethodDefaultTypeInternal;
extern RandomResizeMethodDefaultTypeInternal _RandomResizeMethod_default_instance_;
class RandomRotation90;
struct RandomRotation90DefaultTypeInternal;
extern RandomRotation90DefaultTypeInternal _RandomRotation90_default_instance_;
class RandomSelfConcatImage;
struct RandomSelfConcatImageDefaultTypeInternal;
extern RandomSelfConcatImageDefaultTypeInternal _RandomSelfConcatImage_default_instance_;
class RandomVerticalFlip;
struct RandomVerticalFlipDefaultTypeInternal;
extern RandomVerticalFlipDefaultTypeInternal _RandomVerticalFlip_default_instance_;
class RemapLabels;
struct RemapLabelsDefaultTypeInternal;
extern RemapLabelsDefaultTypeInternal _RemapLabels_default_instance_;
class ResizeImage;
struct ResizeImageDefaultTypeInternal;
extern ResizeImageDefaultTypeInternal _ResizeImage_default_instance_;
class SSDRandomCrop;
struct SSDRandomCropDefaultTypeInternal;
extern SSDRandomCropDefaultTypeInternal _SSDRandomCrop_default_instance_;
class SSDRandomCropFixedAspectRatio;
struct SSDRandomCropFixedAspectRatioDefaultTypeInternal;
extern SSDRandomCropFixedAspectRatioDefaultTypeInternal _SSDRandomCropFixedAspectRatio_default_instance_;
class SSDRandomCropFixedAspectRatioOperation;
struct SSDRandomCropFixedAspectRatioOperationDefaultTypeInternal;
extern SSDRandomCropFixedAspectRatioOperationDefaultTypeInternal _SSDRandomCropFixedAspectRatioOperation_default_instance_;
class SSDRandomCropOperation;
struct SSDRandomCropOperationDefaultTypeInternal;
extern SSDRandomCropOperationDefaultTypeInternal _SSDRandomCropOperation_default_instance_;
class SSDRandomCropPad;
struct SSDRandomCropPadDefaultTypeInternal;
extern SSDRandomCropPadDefaultTypeInternal _SSDRandomCropPad_default_instance_;
class SSDRandomCropPadFixedAspectRatio;
struct SSDRandomCropPadFixedAspectRatioDefaultTypeInternal;
extern SSDRandomCropPadFixedAspectRatioDefaultTypeInternal _SSDRandomCropPadFixedAspectRatio_default_instance_;
class SSDRandomCropPadFixedAspectRatioOperation;
struct SSDRandomCropPadFixedAspectRatioOperationDefaultTypeInternal;
extern SSDRandomCropPadFixedAspectRatioOperationDefaultTypeInternal _SSDRandomCropPadFixedAspectRatioOperation_default_instance_;
class SSDRandomCropPadOperation;
struct SSDRandomCropPadOperationDefaultTypeInternal;
extern SSDRandomCropPadOperationDefaultTypeInternal _SSDRandomCropPadOperation_default_instance_;
class ScaleBoxesToPixelCoordinates;
struct ScaleBoxesToPixelCoordinatesDefaultTypeInternal;
extern ScaleBoxesToPixelCoordinatesDefaultTypeInternal _ScaleBoxesToPixelCoordinates_default_instance_;
class SubtractChannelMean;
struct SubtractChannelMeanDefaultTypeInternal;
extern SubtractChannelMeanDefaultTypeInternal _SubtractChannelMean_default_instance_;
}  // namespace protos
}  // namespace object_detection
PROTOBUF_NAMESPACE_OPEN
template<> ::object_detection::protos::AutoAugmentImage* Arena::CreateMaybeMessage<::object_detection::protos::AutoAugmentImage>(Arena*);
template<> ::object_detection::protos::ConvertClassLogitsToSoftmax* Arena::CreateMaybeMessage<::object_detection::protos::ConvertClassLogitsToSoftmax>(Arena*);
template<> ::object_detection::protos::DropLabelProbabilistically* Arena::CreateMaybeMessage<::object_detection::protos::DropLabelProbabilistically>(Arena*);
template<> ::object_detection::protos::NormalizeImage* Arena::CreateMaybeMessage<::object_detection::protos::NormalizeImage>(Arena*);
template<> ::object_detection::protos::PreprocessingStep* Arena::CreateMaybeMessage<::object_detection::protos::PreprocessingStep>(Arena*);
template<> ::object_detection::protos::RGBtoGray* Arena::CreateMaybeMessage<::object_detection::protos::RGBtoGray>(Arena*);
template<> ::object_detection::protos::RandomAbsolutePadImage* Arena::CreateMaybeMessage<::object_detection::protos::RandomAbsolutePadImage>(Arena*);
template<> ::object_detection::protos::RandomAdjustBrightness* Arena::CreateMaybeMessage<::object_detection::protos::RandomAdjustBrightness>(Arena*);
template<> ::object_detection::protos::RandomAdjustContrast* Arena::CreateMaybeMessage<::object_detection::protos::RandomAdjustContrast>(Arena*);
template<> ::object_detection::protos::RandomAdjustHue* Arena::CreateMaybeMessage<::object_detection::protos::RandomAdjustHue>(Arena*);
template<> ::object_detection::protos::RandomAdjustSaturation* Arena::CreateMaybeMessage<::object_detection::protos::RandomAdjustSaturation>(Arena*);
template<> ::object_detection::protos::RandomBlackPatches* Arena::CreateMaybeMessage<::object_detection::protos::RandomBlackPatches>(Arena*);
template<> ::object_detection::protos::RandomCropImage* Arena::CreateMaybeMessage<::object_detection::protos::RandomCropImage>(Arena*);
template<> ::object_detection::protos::RandomCropPadImage* Arena::CreateMaybeMessage<::object_detection::protos::RandomCropPadImage>(Arena*);
template<> ::object_detection::protos::RandomCropToAspectRatio* Arena::CreateMaybeMessage<::object_detection::protos::RandomCropToAspectRatio>(Arena*);
template<> ::object_detection::protos::RandomDistortColor* Arena::CreateMaybeMessage<::object_detection::protos::RandomDistortColor>(Arena*);
template<> ::object_detection::protos::RandomHorizontalFlip* Arena::CreateMaybeMessage<::object_detection::protos::RandomHorizontalFlip>(Arena*);
template<> ::object_detection::protos::RandomImageScale* Arena::CreateMaybeMessage<::object_detection::protos::RandomImageScale>(Arena*);
template<> ::object_detection::protos::RandomJitterBoxes* Arena::CreateMaybeMessage<::object_detection::protos::RandomJitterBoxes>(Arena*);
template<> ::object_detection::protos::RandomPadImage* Arena::CreateMaybeMessage<::object_detection::protos::RandomPadImage>(Arena*);
template<> ::object_detection::protos::RandomPixelValueScale* Arena::CreateMaybeMessage<::object_detection::protos::RandomPixelValueScale>(Arena*);
template<> ::object_detection::protos::RandomRGBtoGray* Arena::CreateMaybeMessage<::object_detection::protos::RandomRGBtoGray>(Arena*);
template<> ::object_detection::protos::RandomResizeMethod* Arena::CreateMaybeMessage<::object_detection::protos::RandomResizeMethod>(Arena*);
template<> ::object_detection::protos::RandomRotation90* Arena::CreateMaybeMessage<::object_detection::protos::RandomRotation90>(Arena*);
template<> ::object_detection::protos::RandomSelfConcatImage* Arena::CreateMaybeMessage<::object_detection::protos::RandomSelfConcatImage>(Arena*);
template<> ::object_detection::protos::RandomVerticalFlip* Arena::CreateMaybeMessage<::object_detection::protos::RandomVerticalFlip>(Arena*);
template<> ::object_detection::protos::RemapLabels* Arena::CreateMaybeMessage<::object_detection::protos::RemapLabels>(Arena*);
template<> ::object_detection::protos::ResizeImage* Arena::CreateMaybeMessage<::object_detection::protos::ResizeImage>(Arena*);
template<> ::object_detection::protos::SSDRandomCrop* Arena::CreateMaybeMessage<::object_detection::protos::SSDRandomCrop>(Arena*);
template<> ::object_detection::protos::SSDRandomCropFixedAspectRatio* Arena::CreateMaybeMessage<::object_detection::protos::SSDRandomCropFixedAspectRatio>(Arena*);
template<> ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation* Arena::CreateMaybeMessage<::object_detection::protos::SSDRandomCropFixedAspectRatioOperation>(Arena*);
template<> ::object_detection::protos::SSDRandomCropOperation* Arena::CreateMaybeMessage<::object_detection::protos::SSDRandomCropOperation>(Arena*);
template<> ::object_detection::protos::SSDRandomCropPad* Arena::CreateMaybeMessage<::object_detection::protos::SSDRandomCropPad>(Arena*);
template<> ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* Arena::CreateMaybeMessage<::object_detection::protos::SSDRandomCropPadFixedAspectRatio>(Arena*);
template<> ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation* Arena::CreateMaybeMessage<::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation>(Arena*);
template<> ::object_detection::protos::SSDRandomCropPadOperation* Arena::CreateMaybeMessage<::object_detection::protos::SSDRandomCropPadOperation>(Arena*);
template<> ::object_detection::protos::ScaleBoxesToPixelCoordinates* Arena::CreateMaybeMessage<::object_detection::protos::ScaleBoxesToPixelCoordinates>(Arena*);
template<> ::object_detection::protos::SubtractChannelMean* Arena::CreateMaybeMessage<::object_detection::protos::SubtractChannelMean>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace object_detection {
namespace protos {

enum ResizeImage_Method : int {
  ResizeImage_Method_AREA = 1,
  ResizeImage_Method_BICUBIC = 2,
  ResizeImage_Method_BILINEAR = 3,
  ResizeImage_Method_NEAREST_NEIGHBOR = 4
};
bool ResizeImage_Method_IsValid(int value);
constexpr ResizeImage_Method ResizeImage_Method_Method_MIN = ResizeImage_Method_AREA;
constexpr ResizeImage_Method ResizeImage_Method_Method_MAX = ResizeImage_Method_NEAREST_NEIGHBOR;
constexpr int ResizeImage_Method_Method_ARRAYSIZE = ResizeImage_Method_Method_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResizeImage_Method_descriptor();
template<typename T>
inline const std::string& ResizeImage_Method_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ResizeImage_Method>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ResizeImage_Method_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ResizeImage_Method_descriptor(), enum_t_value);
}
inline bool ResizeImage_Method_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResizeImage_Method* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ResizeImage_Method>(
    ResizeImage_Method_descriptor(), name, value);
}
// ===================================================================

class PreprocessingStep final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.PreprocessingStep) */ {
 public:
  inline PreprocessingStep() : PreprocessingStep(nullptr) {}
  ~PreprocessingStep() override;
  explicit PROTOBUF_CONSTEXPR PreprocessingStep(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PreprocessingStep(const PreprocessingStep& from);
  PreprocessingStep(PreprocessingStep&& from) noexcept
    : PreprocessingStep() {
    *this = ::std::move(from);
  }

  inline PreprocessingStep& operator=(const PreprocessingStep& from) {
    CopyFrom(from);
    return *this;
  }
  inline PreprocessingStep& operator=(PreprocessingStep&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PreprocessingStep& default_instance() {
    return *internal_default_instance();
  }
  enum PreprocessingStepCase {
    kNormalizeImage = 1,
    kRandomHorizontalFlip = 2,
    kRandomPixelValueScale = 3,
    kRandomImageScale = 4,
    kRandomRgbToGray = 5,
    kRandomAdjustBrightness = 6,
    kRandomAdjustContrast = 7,
    kRandomAdjustHue = 8,
    kRandomAdjustSaturation = 9,
    kRandomDistortColor = 10,
    kRandomJitterBoxes = 11,
    kRandomCropImage = 12,
    kRandomPadImage = 13,
    kRandomCropPadImage = 14,
    kRandomCropToAspectRatio = 15,
    kRandomBlackPatches = 16,
    kRandomResizeMethod = 17,
    kScaleBoxesToPixelCoordinates = 18,
    kResizeImage = 19,
    kSubtractChannelMean = 20,
    kSsdRandomCrop = 21,
    kSsdRandomCropPad = 22,
    kSsdRandomCropFixedAspectRatio = 23,
    kSsdRandomCropPadFixedAspectRatio = 24,
    kRandomVerticalFlip = 25,
    kRandomRotation90 = 26,
    kRgbToGray = 27,
    kConvertClassLogitsToSoftmax = 28,
    kRandomAbsolutePadImage = 29,
    kRandomSelfConcatImage = 30,
    kAutoaugmentImage = 31,
    kDropLabelProbabilistically = 32,
    kRemapLabels = 33,
    PREPROCESSING_STEP_NOT_SET = 0,
  };

  static inline const PreprocessingStep* internal_default_instance() {
    return reinterpret_cast<const PreprocessingStep*>(
               &_PreprocessingStep_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(PreprocessingStep& a, PreprocessingStep& b) {
    a.Swap(&b);
  }
  inline void Swap(PreprocessingStep* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PreprocessingStep* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PreprocessingStep* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PreprocessingStep>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PreprocessingStep& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PreprocessingStep& from) {
    PreprocessingStep::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PreprocessingStep* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.PreprocessingStep";
  }
  protected:
  explicit PreprocessingStep(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNormalizeImageFieldNumber = 1,
    kRandomHorizontalFlipFieldNumber = 2,
    kRandomPixelValueScaleFieldNumber = 3,
    kRandomImageScaleFieldNumber = 4,
    kRandomRgbToGrayFieldNumber = 5,
    kRandomAdjustBrightnessFieldNumber = 6,
    kRandomAdjustContrastFieldNumber = 7,
    kRandomAdjustHueFieldNumber = 8,
    kRandomAdjustSaturationFieldNumber = 9,
    kRandomDistortColorFieldNumber = 10,
    kRandomJitterBoxesFieldNumber = 11,
    kRandomCropImageFieldNumber = 12,
    kRandomPadImageFieldNumber = 13,
    kRandomCropPadImageFieldNumber = 14,
    kRandomCropToAspectRatioFieldNumber = 15,
    kRandomBlackPatchesFieldNumber = 16,
    kRandomResizeMethodFieldNumber = 17,
    kScaleBoxesToPixelCoordinatesFieldNumber = 18,
    kResizeImageFieldNumber = 19,
    kSubtractChannelMeanFieldNumber = 20,
    kSsdRandomCropFieldNumber = 21,
    kSsdRandomCropPadFieldNumber = 22,
    kSsdRandomCropFixedAspectRatioFieldNumber = 23,
    kSsdRandomCropPadFixedAspectRatioFieldNumber = 24,
    kRandomVerticalFlipFieldNumber = 25,
    kRandomRotation90FieldNumber = 26,
    kRgbToGrayFieldNumber = 27,
    kConvertClassLogitsToSoftmaxFieldNumber = 28,
    kRandomAbsolutePadImageFieldNumber = 29,
    kRandomSelfConcatImageFieldNumber = 30,
    kAutoaugmentImageFieldNumber = 31,
    kDropLabelProbabilisticallyFieldNumber = 32,
    kRemapLabelsFieldNumber = 33,
  };
  // .object_detection.protos.NormalizeImage normalize_image = 1;
  bool has_normalize_image() const;
  private:
  bool _internal_has_normalize_image() const;
  public:
  void clear_normalize_image();
  const ::object_detection::protos::NormalizeImage& normalize_image() const;
  PROTOBUF_NODISCARD ::object_detection::protos::NormalizeImage* release_normalize_image();
  ::object_detection::protos::NormalizeImage* mutable_normalize_image();
  void set_allocated_normalize_image(::object_detection::protos::NormalizeImage* normalize_image);
  private:
  const ::object_detection::protos::NormalizeImage& _internal_normalize_image() const;
  ::object_detection::protos::NormalizeImage* _internal_mutable_normalize_image();
  public:
  void unsafe_arena_set_allocated_normalize_image(
      ::object_detection::protos::NormalizeImage* normalize_image);
  ::object_detection::protos::NormalizeImage* unsafe_arena_release_normalize_image();

  // .object_detection.protos.RandomHorizontalFlip random_horizontal_flip = 2;
  bool has_random_horizontal_flip() const;
  private:
  bool _internal_has_random_horizontal_flip() const;
  public:
  void clear_random_horizontal_flip();
  const ::object_detection::protos::RandomHorizontalFlip& random_horizontal_flip() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomHorizontalFlip* release_random_horizontal_flip();
  ::object_detection::protos::RandomHorizontalFlip* mutable_random_horizontal_flip();
  void set_allocated_random_horizontal_flip(::object_detection::protos::RandomHorizontalFlip* random_horizontal_flip);
  private:
  const ::object_detection::protos::RandomHorizontalFlip& _internal_random_horizontal_flip() const;
  ::object_detection::protos::RandomHorizontalFlip* _internal_mutable_random_horizontal_flip();
  public:
  void unsafe_arena_set_allocated_random_horizontal_flip(
      ::object_detection::protos::RandomHorizontalFlip* random_horizontal_flip);
  ::object_detection::protos::RandomHorizontalFlip* unsafe_arena_release_random_horizontal_flip();

  // .object_detection.protos.RandomPixelValueScale random_pixel_value_scale = 3;
  bool has_random_pixel_value_scale() const;
  private:
  bool _internal_has_random_pixel_value_scale() const;
  public:
  void clear_random_pixel_value_scale();
  const ::object_detection::protos::RandomPixelValueScale& random_pixel_value_scale() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomPixelValueScale* release_random_pixel_value_scale();
  ::object_detection::protos::RandomPixelValueScale* mutable_random_pixel_value_scale();
  void set_allocated_random_pixel_value_scale(::object_detection::protos::RandomPixelValueScale* random_pixel_value_scale);
  private:
  const ::object_detection::protos::RandomPixelValueScale& _internal_random_pixel_value_scale() const;
  ::object_detection::protos::RandomPixelValueScale* _internal_mutable_random_pixel_value_scale();
  public:
  void unsafe_arena_set_allocated_random_pixel_value_scale(
      ::object_detection::protos::RandomPixelValueScale* random_pixel_value_scale);
  ::object_detection::protos::RandomPixelValueScale* unsafe_arena_release_random_pixel_value_scale();

  // .object_detection.protos.RandomImageScale random_image_scale = 4;
  bool has_random_image_scale() const;
  private:
  bool _internal_has_random_image_scale() const;
  public:
  void clear_random_image_scale();
  const ::object_detection::protos::RandomImageScale& random_image_scale() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomImageScale* release_random_image_scale();
  ::object_detection::protos::RandomImageScale* mutable_random_image_scale();
  void set_allocated_random_image_scale(::object_detection::protos::RandomImageScale* random_image_scale);
  private:
  const ::object_detection::protos::RandomImageScale& _internal_random_image_scale() const;
  ::object_detection::protos::RandomImageScale* _internal_mutable_random_image_scale();
  public:
  void unsafe_arena_set_allocated_random_image_scale(
      ::object_detection::protos::RandomImageScale* random_image_scale);
  ::object_detection::protos::RandomImageScale* unsafe_arena_release_random_image_scale();

  // .object_detection.protos.RandomRGBtoGray random_rgb_to_gray = 5;
  bool has_random_rgb_to_gray() const;
  private:
  bool _internal_has_random_rgb_to_gray() const;
  public:
  void clear_random_rgb_to_gray();
  const ::object_detection::protos::RandomRGBtoGray& random_rgb_to_gray() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomRGBtoGray* release_random_rgb_to_gray();
  ::object_detection::protos::RandomRGBtoGray* mutable_random_rgb_to_gray();
  void set_allocated_random_rgb_to_gray(::object_detection::protos::RandomRGBtoGray* random_rgb_to_gray);
  private:
  const ::object_detection::protos::RandomRGBtoGray& _internal_random_rgb_to_gray() const;
  ::object_detection::protos::RandomRGBtoGray* _internal_mutable_random_rgb_to_gray();
  public:
  void unsafe_arena_set_allocated_random_rgb_to_gray(
      ::object_detection::protos::RandomRGBtoGray* random_rgb_to_gray);
  ::object_detection::protos::RandomRGBtoGray* unsafe_arena_release_random_rgb_to_gray();

  // .object_detection.protos.RandomAdjustBrightness random_adjust_brightness = 6;
  bool has_random_adjust_brightness() const;
  private:
  bool _internal_has_random_adjust_brightness() const;
  public:
  void clear_random_adjust_brightness();
  const ::object_detection::protos::RandomAdjustBrightness& random_adjust_brightness() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomAdjustBrightness* release_random_adjust_brightness();
  ::object_detection::protos::RandomAdjustBrightness* mutable_random_adjust_brightness();
  void set_allocated_random_adjust_brightness(::object_detection::protos::RandomAdjustBrightness* random_adjust_brightness);
  private:
  const ::object_detection::protos::RandomAdjustBrightness& _internal_random_adjust_brightness() const;
  ::object_detection::protos::RandomAdjustBrightness* _internal_mutable_random_adjust_brightness();
  public:
  void unsafe_arena_set_allocated_random_adjust_brightness(
      ::object_detection::protos::RandomAdjustBrightness* random_adjust_brightness);
  ::object_detection::protos::RandomAdjustBrightness* unsafe_arena_release_random_adjust_brightness();

  // .object_detection.protos.RandomAdjustContrast random_adjust_contrast = 7;
  bool has_random_adjust_contrast() const;
  private:
  bool _internal_has_random_adjust_contrast() const;
  public:
  void clear_random_adjust_contrast();
  const ::object_detection::protos::RandomAdjustContrast& random_adjust_contrast() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomAdjustContrast* release_random_adjust_contrast();
  ::object_detection::protos::RandomAdjustContrast* mutable_random_adjust_contrast();
  void set_allocated_random_adjust_contrast(::object_detection::protos::RandomAdjustContrast* random_adjust_contrast);
  private:
  const ::object_detection::protos::RandomAdjustContrast& _internal_random_adjust_contrast() const;
  ::object_detection::protos::RandomAdjustContrast* _internal_mutable_random_adjust_contrast();
  public:
  void unsafe_arena_set_allocated_random_adjust_contrast(
      ::object_detection::protos::RandomAdjustContrast* random_adjust_contrast);
  ::object_detection::protos::RandomAdjustContrast* unsafe_arena_release_random_adjust_contrast();

  // .object_detection.protos.RandomAdjustHue random_adjust_hue = 8;
  bool has_random_adjust_hue() const;
  private:
  bool _internal_has_random_adjust_hue() const;
  public:
  void clear_random_adjust_hue();
  const ::object_detection::protos::RandomAdjustHue& random_adjust_hue() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomAdjustHue* release_random_adjust_hue();
  ::object_detection::protos::RandomAdjustHue* mutable_random_adjust_hue();
  void set_allocated_random_adjust_hue(::object_detection::protos::RandomAdjustHue* random_adjust_hue);
  private:
  const ::object_detection::protos::RandomAdjustHue& _internal_random_adjust_hue() const;
  ::object_detection::protos::RandomAdjustHue* _internal_mutable_random_adjust_hue();
  public:
  void unsafe_arena_set_allocated_random_adjust_hue(
      ::object_detection::protos::RandomAdjustHue* random_adjust_hue);
  ::object_detection::protos::RandomAdjustHue* unsafe_arena_release_random_adjust_hue();

  // .object_detection.protos.RandomAdjustSaturation random_adjust_saturation = 9;
  bool has_random_adjust_saturation() const;
  private:
  bool _internal_has_random_adjust_saturation() const;
  public:
  void clear_random_adjust_saturation();
  const ::object_detection::protos::RandomAdjustSaturation& random_adjust_saturation() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomAdjustSaturation* release_random_adjust_saturation();
  ::object_detection::protos::RandomAdjustSaturation* mutable_random_adjust_saturation();
  void set_allocated_random_adjust_saturation(::object_detection::protos::RandomAdjustSaturation* random_adjust_saturation);
  private:
  const ::object_detection::protos::RandomAdjustSaturation& _internal_random_adjust_saturation() const;
  ::object_detection::protos::RandomAdjustSaturation* _internal_mutable_random_adjust_saturation();
  public:
  void unsafe_arena_set_allocated_random_adjust_saturation(
      ::object_detection::protos::RandomAdjustSaturation* random_adjust_saturation);
  ::object_detection::protos::RandomAdjustSaturation* unsafe_arena_release_random_adjust_saturation();

  // .object_detection.protos.RandomDistortColor random_distort_color = 10;
  bool has_random_distort_color() const;
  private:
  bool _internal_has_random_distort_color() const;
  public:
  void clear_random_distort_color();
  const ::object_detection::protos::RandomDistortColor& random_distort_color() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomDistortColor* release_random_distort_color();
  ::object_detection::protos::RandomDistortColor* mutable_random_distort_color();
  void set_allocated_random_distort_color(::object_detection::protos::RandomDistortColor* random_distort_color);
  private:
  const ::object_detection::protos::RandomDistortColor& _internal_random_distort_color() const;
  ::object_detection::protos::RandomDistortColor* _internal_mutable_random_distort_color();
  public:
  void unsafe_arena_set_allocated_random_distort_color(
      ::object_detection::protos::RandomDistortColor* random_distort_color);
  ::object_detection::protos::RandomDistortColor* unsafe_arena_release_random_distort_color();

  // .object_detection.protos.RandomJitterBoxes random_jitter_boxes = 11;
  bool has_random_jitter_boxes() const;
  private:
  bool _internal_has_random_jitter_boxes() const;
  public:
  void clear_random_jitter_boxes();
  const ::object_detection::protos::RandomJitterBoxes& random_jitter_boxes() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomJitterBoxes* release_random_jitter_boxes();
  ::object_detection::protos::RandomJitterBoxes* mutable_random_jitter_boxes();
  void set_allocated_random_jitter_boxes(::object_detection::protos::RandomJitterBoxes* random_jitter_boxes);
  private:
  const ::object_detection::protos::RandomJitterBoxes& _internal_random_jitter_boxes() const;
  ::object_detection::protos::RandomJitterBoxes* _internal_mutable_random_jitter_boxes();
  public:
  void unsafe_arena_set_allocated_random_jitter_boxes(
      ::object_detection::protos::RandomJitterBoxes* random_jitter_boxes);
  ::object_detection::protos::RandomJitterBoxes* unsafe_arena_release_random_jitter_boxes();

  // .object_detection.protos.RandomCropImage random_crop_image = 12;
  bool has_random_crop_image() const;
  private:
  bool _internal_has_random_crop_image() const;
  public:
  void clear_random_crop_image();
  const ::object_detection::protos::RandomCropImage& random_crop_image() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomCropImage* release_random_crop_image();
  ::object_detection::protos::RandomCropImage* mutable_random_crop_image();
  void set_allocated_random_crop_image(::object_detection::protos::RandomCropImage* random_crop_image);
  private:
  const ::object_detection::protos::RandomCropImage& _internal_random_crop_image() const;
  ::object_detection::protos::RandomCropImage* _internal_mutable_random_crop_image();
  public:
  void unsafe_arena_set_allocated_random_crop_image(
      ::object_detection::protos::RandomCropImage* random_crop_image);
  ::object_detection::protos::RandomCropImage* unsafe_arena_release_random_crop_image();

  // .object_detection.protos.RandomPadImage random_pad_image = 13;
  bool has_random_pad_image() const;
  private:
  bool _internal_has_random_pad_image() const;
  public:
  void clear_random_pad_image();
  const ::object_detection::protos::RandomPadImage& random_pad_image() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomPadImage* release_random_pad_image();
  ::object_detection::protos::RandomPadImage* mutable_random_pad_image();
  void set_allocated_random_pad_image(::object_detection::protos::RandomPadImage* random_pad_image);
  private:
  const ::object_detection::protos::RandomPadImage& _internal_random_pad_image() const;
  ::object_detection::protos::RandomPadImage* _internal_mutable_random_pad_image();
  public:
  void unsafe_arena_set_allocated_random_pad_image(
      ::object_detection::protos::RandomPadImage* random_pad_image);
  ::object_detection::protos::RandomPadImage* unsafe_arena_release_random_pad_image();

  // .object_detection.protos.RandomCropPadImage random_crop_pad_image = 14;
  bool has_random_crop_pad_image() const;
  private:
  bool _internal_has_random_crop_pad_image() const;
  public:
  void clear_random_crop_pad_image();
  const ::object_detection::protos::RandomCropPadImage& random_crop_pad_image() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomCropPadImage* release_random_crop_pad_image();
  ::object_detection::protos::RandomCropPadImage* mutable_random_crop_pad_image();
  void set_allocated_random_crop_pad_image(::object_detection::protos::RandomCropPadImage* random_crop_pad_image);
  private:
  const ::object_detection::protos::RandomCropPadImage& _internal_random_crop_pad_image() const;
  ::object_detection::protos::RandomCropPadImage* _internal_mutable_random_crop_pad_image();
  public:
  void unsafe_arena_set_allocated_random_crop_pad_image(
      ::object_detection::protos::RandomCropPadImage* random_crop_pad_image);
  ::object_detection::protos::RandomCropPadImage* unsafe_arena_release_random_crop_pad_image();

  // .object_detection.protos.RandomCropToAspectRatio random_crop_to_aspect_ratio = 15;
  bool has_random_crop_to_aspect_ratio() const;
  private:
  bool _internal_has_random_crop_to_aspect_ratio() const;
  public:
  void clear_random_crop_to_aspect_ratio();
  const ::object_detection::protos::RandomCropToAspectRatio& random_crop_to_aspect_ratio() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomCropToAspectRatio* release_random_crop_to_aspect_ratio();
  ::object_detection::protos::RandomCropToAspectRatio* mutable_random_crop_to_aspect_ratio();
  void set_allocated_random_crop_to_aspect_ratio(::object_detection::protos::RandomCropToAspectRatio* random_crop_to_aspect_ratio);
  private:
  const ::object_detection::protos::RandomCropToAspectRatio& _internal_random_crop_to_aspect_ratio() const;
  ::object_detection::protos::RandomCropToAspectRatio* _internal_mutable_random_crop_to_aspect_ratio();
  public:
  void unsafe_arena_set_allocated_random_crop_to_aspect_ratio(
      ::object_detection::protos::RandomCropToAspectRatio* random_crop_to_aspect_ratio);
  ::object_detection::protos::RandomCropToAspectRatio* unsafe_arena_release_random_crop_to_aspect_ratio();

  // .object_detection.protos.RandomBlackPatches random_black_patches = 16;
  bool has_random_black_patches() const;
  private:
  bool _internal_has_random_black_patches() const;
  public:
  void clear_random_black_patches();
  const ::object_detection::protos::RandomBlackPatches& random_black_patches() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomBlackPatches* release_random_black_patches();
  ::object_detection::protos::RandomBlackPatches* mutable_random_black_patches();
  void set_allocated_random_black_patches(::object_detection::protos::RandomBlackPatches* random_black_patches);
  private:
  const ::object_detection::protos::RandomBlackPatches& _internal_random_black_patches() const;
  ::object_detection::protos::RandomBlackPatches* _internal_mutable_random_black_patches();
  public:
  void unsafe_arena_set_allocated_random_black_patches(
      ::object_detection::protos::RandomBlackPatches* random_black_patches);
  ::object_detection::protos::RandomBlackPatches* unsafe_arena_release_random_black_patches();

  // .object_detection.protos.RandomResizeMethod random_resize_method = 17;
  bool has_random_resize_method() const;
  private:
  bool _internal_has_random_resize_method() const;
  public:
  void clear_random_resize_method();
  const ::object_detection::protos::RandomResizeMethod& random_resize_method() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomResizeMethod* release_random_resize_method();
  ::object_detection::protos::RandomResizeMethod* mutable_random_resize_method();
  void set_allocated_random_resize_method(::object_detection::protos::RandomResizeMethod* random_resize_method);
  private:
  const ::object_detection::protos::RandomResizeMethod& _internal_random_resize_method() const;
  ::object_detection::protos::RandomResizeMethod* _internal_mutable_random_resize_method();
  public:
  void unsafe_arena_set_allocated_random_resize_method(
      ::object_detection::protos::RandomResizeMethod* random_resize_method);
  ::object_detection::protos::RandomResizeMethod* unsafe_arena_release_random_resize_method();

  // .object_detection.protos.ScaleBoxesToPixelCoordinates scale_boxes_to_pixel_coordinates = 18;
  bool has_scale_boxes_to_pixel_coordinates() const;
  private:
  bool _internal_has_scale_boxes_to_pixel_coordinates() const;
  public:
  void clear_scale_boxes_to_pixel_coordinates();
  const ::object_detection::protos::ScaleBoxesToPixelCoordinates& scale_boxes_to_pixel_coordinates() const;
  PROTOBUF_NODISCARD ::object_detection::protos::ScaleBoxesToPixelCoordinates* release_scale_boxes_to_pixel_coordinates();
  ::object_detection::protos::ScaleBoxesToPixelCoordinates* mutable_scale_boxes_to_pixel_coordinates();
  void set_allocated_scale_boxes_to_pixel_coordinates(::object_detection::protos::ScaleBoxesToPixelCoordinates* scale_boxes_to_pixel_coordinates);
  private:
  const ::object_detection::protos::ScaleBoxesToPixelCoordinates& _internal_scale_boxes_to_pixel_coordinates() const;
  ::object_detection::protos::ScaleBoxesToPixelCoordinates* _internal_mutable_scale_boxes_to_pixel_coordinates();
  public:
  void unsafe_arena_set_allocated_scale_boxes_to_pixel_coordinates(
      ::object_detection::protos::ScaleBoxesToPixelCoordinates* scale_boxes_to_pixel_coordinates);
  ::object_detection::protos::ScaleBoxesToPixelCoordinates* unsafe_arena_release_scale_boxes_to_pixel_coordinates();

  // .object_detection.protos.ResizeImage resize_image = 19;
  bool has_resize_image() const;
  private:
  bool _internal_has_resize_image() const;
  public:
  void clear_resize_image();
  const ::object_detection::protos::ResizeImage& resize_image() const;
  PROTOBUF_NODISCARD ::object_detection::protos::ResizeImage* release_resize_image();
  ::object_detection::protos::ResizeImage* mutable_resize_image();
  void set_allocated_resize_image(::object_detection::protos::ResizeImage* resize_image);
  private:
  const ::object_detection::protos::ResizeImage& _internal_resize_image() const;
  ::object_detection::protos::ResizeImage* _internal_mutable_resize_image();
  public:
  void unsafe_arena_set_allocated_resize_image(
      ::object_detection::protos::ResizeImage* resize_image);
  ::object_detection::protos::ResizeImage* unsafe_arena_release_resize_image();

  // .object_detection.protos.SubtractChannelMean subtract_channel_mean = 20;
  bool has_subtract_channel_mean() const;
  private:
  bool _internal_has_subtract_channel_mean() const;
  public:
  void clear_subtract_channel_mean();
  const ::object_detection::protos::SubtractChannelMean& subtract_channel_mean() const;
  PROTOBUF_NODISCARD ::object_detection::protos::SubtractChannelMean* release_subtract_channel_mean();
  ::object_detection::protos::SubtractChannelMean* mutable_subtract_channel_mean();
  void set_allocated_subtract_channel_mean(::object_detection::protos::SubtractChannelMean* subtract_channel_mean);
  private:
  const ::object_detection::protos::SubtractChannelMean& _internal_subtract_channel_mean() const;
  ::object_detection::protos::SubtractChannelMean* _internal_mutable_subtract_channel_mean();
  public:
  void unsafe_arena_set_allocated_subtract_channel_mean(
      ::object_detection::protos::SubtractChannelMean* subtract_channel_mean);
  ::object_detection::protos::SubtractChannelMean* unsafe_arena_release_subtract_channel_mean();

  // .object_detection.protos.SSDRandomCrop ssd_random_crop = 21;
  bool has_ssd_random_crop() const;
  private:
  bool _internal_has_ssd_random_crop() const;
  public:
  void clear_ssd_random_crop();
  const ::object_detection::protos::SSDRandomCrop& ssd_random_crop() const;
  PROTOBUF_NODISCARD ::object_detection::protos::SSDRandomCrop* release_ssd_random_crop();
  ::object_detection::protos::SSDRandomCrop* mutable_ssd_random_crop();
  void set_allocated_ssd_random_crop(::object_detection::protos::SSDRandomCrop* ssd_random_crop);
  private:
  const ::object_detection::protos::SSDRandomCrop& _internal_ssd_random_crop() const;
  ::object_detection::protos::SSDRandomCrop* _internal_mutable_ssd_random_crop();
  public:
  void unsafe_arena_set_allocated_ssd_random_crop(
      ::object_detection::protos::SSDRandomCrop* ssd_random_crop);
  ::object_detection::protos::SSDRandomCrop* unsafe_arena_release_ssd_random_crop();

  // .object_detection.protos.SSDRandomCropPad ssd_random_crop_pad = 22;
  bool has_ssd_random_crop_pad() const;
  private:
  bool _internal_has_ssd_random_crop_pad() const;
  public:
  void clear_ssd_random_crop_pad();
  const ::object_detection::protos::SSDRandomCropPad& ssd_random_crop_pad() const;
  PROTOBUF_NODISCARD ::object_detection::protos::SSDRandomCropPad* release_ssd_random_crop_pad();
  ::object_detection::protos::SSDRandomCropPad* mutable_ssd_random_crop_pad();
  void set_allocated_ssd_random_crop_pad(::object_detection::protos::SSDRandomCropPad* ssd_random_crop_pad);
  private:
  const ::object_detection::protos::SSDRandomCropPad& _internal_ssd_random_crop_pad() const;
  ::object_detection::protos::SSDRandomCropPad* _internal_mutable_ssd_random_crop_pad();
  public:
  void unsafe_arena_set_allocated_ssd_random_crop_pad(
      ::object_detection::protos::SSDRandomCropPad* ssd_random_crop_pad);
  ::object_detection::protos::SSDRandomCropPad* unsafe_arena_release_ssd_random_crop_pad();

  // .object_detection.protos.SSDRandomCropFixedAspectRatio ssd_random_crop_fixed_aspect_ratio = 23;
  bool has_ssd_random_crop_fixed_aspect_ratio() const;
  private:
  bool _internal_has_ssd_random_crop_fixed_aspect_ratio() const;
  public:
  void clear_ssd_random_crop_fixed_aspect_ratio();
  const ::object_detection::protos::SSDRandomCropFixedAspectRatio& ssd_random_crop_fixed_aspect_ratio() const;
  PROTOBUF_NODISCARD ::object_detection::protos::SSDRandomCropFixedAspectRatio* release_ssd_random_crop_fixed_aspect_ratio();
  ::object_detection::protos::SSDRandomCropFixedAspectRatio* mutable_ssd_random_crop_fixed_aspect_ratio();
  void set_allocated_ssd_random_crop_fixed_aspect_ratio(::object_detection::protos::SSDRandomCropFixedAspectRatio* ssd_random_crop_fixed_aspect_ratio);
  private:
  const ::object_detection::protos::SSDRandomCropFixedAspectRatio& _internal_ssd_random_crop_fixed_aspect_ratio() const;
  ::object_detection::protos::SSDRandomCropFixedAspectRatio* _internal_mutable_ssd_random_crop_fixed_aspect_ratio();
  public:
  void unsafe_arena_set_allocated_ssd_random_crop_fixed_aspect_ratio(
      ::object_detection::protos::SSDRandomCropFixedAspectRatio* ssd_random_crop_fixed_aspect_ratio);
  ::object_detection::protos::SSDRandomCropFixedAspectRatio* unsafe_arena_release_ssd_random_crop_fixed_aspect_ratio();

  // .object_detection.protos.SSDRandomCropPadFixedAspectRatio ssd_random_crop_pad_fixed_aspect_ratio = 24;
  bool has_ssd_random_crop_pad_fixed_aspect_ratio() const;
  private:
  bool _internal_has_ssd_random_crop_pad_fixed_aspect_ratio() const;
  public:
  void clear_ssd_random_crop_pad_fixed_aspect_ratio();
  const ::object_detection::protos::SSDRandomCropPadFixedAspectRatio& ssd_random_crop_pad_fixed_aspect_ratio() const;
  PROTOBUF_NODISCARD ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* release_ssd_random_crop_pad_fixed_aspect_ratio();
  ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* mutable_ssd_random_crop_pad_fixed_aspect_ratio();
  void set_allocated_ssd_random_crop_pad_fixed_aspect_ratio(::object_detection::protos::SSDRandomCropPadFixedAspectRatio* ssd_random_crop_pad_fixed_aspect_ratio);
  private:
  const ::object_detection::protos::SSDRandomCropPadFixedAspectRatio& _internal_ssd_random_crop_pad_fixed_aspect_ratio() const;
  ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* _internal_mutable_ssd_random_crop_pad_fixed_aspect_ratio();
  public:
  void unsafe_arena_set_allocated_ssd_random_crop_pad_fixed_aspect_ratio(
      ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* ssd_random_crop_pad_fixed_aspect_ratio);
  ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* unsafe_arena_release_ssd_random_crop_pad_fixed_aspect_ratio();

  // .object_detection.protos.RandomVerticalFlip random_vertical_flip = 25;
  bool has_random_vertical_flip() const;
  private:
  bool _internal_has_random_vertical_flip() const;
  public:
  void clear_random_vertical_flip();
  const ::object_detection::protos::RandomVerticalFlip& random_vertical_flip() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomVerticalFlip* release_random_vertical_flip();
  ::object_detection::protos::RandomVerticalFlip* mutable_random_vertical_flip();
  void set_allocated_random_vertical_flip(::object_detection::protos::RandomVerticalFlip* random_vertical_flip);
  private:
  const ::object_detection::protos::RandomVerticalFlip& _internal_random_vertical_flip() const;
  ::object_detection::protos::RandomVerticalFlip* _internal_mutable_random_vertical_flip();
  public:
  void unsafe_arena_set_allocated_random_vertical_flip(
      ::object_detection::protos::RandomVerticalFlip* random_vertical_flip);
  ::object_detection::protos::RandomVerticalFlip* unsafe_arena_release_random_vertical_flip();

  // .object_detection.protos.RandomRotation90 random_rotation90 = 26;
  bool has_random_rotation90() const;
  private:
  bool _internal_has_random_rotation90() const;
  public:
  void clear_random_rotation90();
  const ::object_detection::protos::RandomRotation90& random_rotation90() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomRotation90* release_random_rotation90();
  ::object_detection::protos::RandomRotation90* mutable_random_rotation90();
  void set_allocated_random_rotation90(::object_detection::protos::RandomRotation90* random_rotation90);
  private:
  const ::object_detection::protos::RandomRotation90& _internal_random_rotation90() const;
  ::object_detection::protos::RandomRotation90* _internal_mutable_random_rotation90();
  public:
  void unsafe_arena_set_allocated_random_rotation90(
      ::object_detection::protos::RandomRotation90* random_rotation90);
  ::object_detection::protos::RandomRotation90* unsafe_arena_release_random_rotation90();

  // .object_detection.protos.RGBtoGray rgb_to_gray = 27;
  bool has_rgb_to_gray() const;
  private:
  bool _internal_has_rgb_to_gray() const;
  public:
  void clear_rgb_to_gray();
  const ::object_detection::protos::RGBtoGray& rgb_to_gray() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RGBtoGray* release_rgb_to_gray();
  ::object_detection::protos::RGBtoGray* mutable_rgb_to_gray();
  void set_allocated_rgb_to_gray(::object_detection::protos::RGBtoGray* rgb_to_gray);
  private:
  const ::object_detection::protos::RGBtoGray& _internal_rgb_to_gray() const;
  ::object_detection::protos::RGBtoGray* _internal_mutable_rgb_to_gray();
  public:
  void unsafe_arena_set_allocated_rgb_to_gray(
      ::object_detection::protos::RGBtoGray* rgb_to_gray);
  ::object_detection::protos::RGBtoGray* unsafe_arena_release_rgb_to_gray();

  // .object_detection.protos.ConvertClassLogitsToSoftmax convert_class_logits_to_softmax = 28;
  bool has_convert_class_logits_to_softmax() const;
  private:
  bool _internal_has_convert_class_logits_to_softmax() const;
  public:
  void clear_convert_class_logits_to_softmax();
  const ::object_detection::protos::ConvertClassLogitsToSoftmax& convert_class_logits_to_softmax() const;
  PROTOBUF_NODISCARD ::object_detection::protos::ConvertClassLogitsToSoftmax* release_convert_class_logits_to_softmax();
  ::object_detection::protos::ConvertClassLogitsToSoftmax* mutable_convert_class_logits_to_softmax();
  void set_allocated_convert_class_logits_to_softmax(::object_detection::protos::ConvertClassLogitsToSoftmax* convert_class_logits_to_softmax);
  private:
  const ::object_detection::protos::ConvertClassLogitsToSoftmax& _internal_convert_class_logits_to_softmax() const;
  ::object_detection::protos::ConvertClassLogitsToSoftmax* _internal_mutable_convert_class_logits_to_softmax();
  public:
  void unsafe_arena_set_allocated_convert_class_logits_to_softmax(
      ::object_detection::protos::ConvertClassLogitsToSoftmax* convert_class_logits_to_softmax);
  ::object_detection::protos::ConvertClassLogitsToSoftmax* unsafe_arena_release_convert_class_logits_to_softmax();

  // .object_detection.protos.RandomAbsolutePadImage random_absolute_pad_image = 29;
  bool has_random_absolute_pad_image() const;
  private:
  bool _internal_has_random_absolute_pad_image() const;
  public:
  void clear_random_absolute_pad_image();
  const ::object_detection::protos::RandomAbsolutePadImage& random_absolute_pad_image() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomAbsolutePadImage* release_random_absolute_pad_image();
  ::object_detection::protos::RandomAbsolutePadImage* mutable_random_absolute_pad_image();
  void set_allocated_random_absolute_pad_image(::object_detection::protos::RandomAbsolutePadImage* random_absolute_pad_image);
  private:
  const ::object_detection::protos::RandomAbsolutePadImage& _internal_random_absolute_pad_image() const;
  ::object_detection::protos::RandomAbsolutePadImage* _internal_mutable_random_absolute_pad_image();
  public:
  void unsafe_arena_set_allocated_random_absolute_pad_image(
      ::object_detection::protos::RandomAbsolutePadImage* random_absolute_pad_image);
  ::object_detection::protos::RandomAbsolutePadImage* unsafe_arena_release_random_absolute_pad_image();

  // .object_detection.protos.RandomSelfConcatImage random_self_concat_image = 30;
  bool has_random_self_concat_image() const;
  private:
  bool _internal_has_random_self_concat_image() const;
  public:
  void clear_random_self_concat_image();
  const ::object_detection::protos::RandomSelfConcatImage& random_self_concat_image() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RandomSelfConcatImage* release_random_self_concat_image();
  ::object_detection::protos::RandomSelfConcatImage* mutable_random_self_concat_image();
  void set_allocated_random_self_concat_image(::object_detection::protos::RandomSelfConcatImage* random_self_concat_image);
  private:
  const ::object_detection::protos::RandomSelfConcatImage& _internal_random_self_concat_image() const;
  ::object_detection::protos::RandomSelfConcatImage* _internal_mutable_random_self_concat_image();
  public:
  void unsafe_arena_set_allocated_random_self_concat_image(
      ::object_detection::protos::RandomSelfConcatImage* random_self_concat_image);
  ::object_detection::protos::RandomSelfConcatImage* unsafe_arena_release_random_self_concat_image();

  // .object_detection.protos.AutoAugmentImage autoaugment_image = 31;
  bool has_autoaugment_image() const;
  private:
  bool _internal_has_autoaugment_image() const;
  public:
  void clear_autoaugment_image();
  const ::object_detection::protos::AutoAugmentImage& autoaugment_image() const;
  PROTOBUF_NODISCARD ::object_detection::protos::AutoAugmentImage* release_autoaugment_image();
  ::object_detection::protos::AutoAugmentImage* mutable_autoaugment_image();
  void set_allocated_autoaugment_image(::object_detection::protos::AutoAugmentImage* autoaugment_image);
  private:
  const ::object_detection::protos::AutoAugmentImage& _internal_autoaugment_image() const;
  ::object_detection::protos::AutoAugmentImage* _internal_mutable_autoaugment_image();
  public:
  void unsafe_arena_set_allocated_autoaugment_image(
      ::object_detection::protos::AutoAugmentImage* autoaugment_image);
  ::object_detection::protos::AutoAugmentImage* unsafe_arena_release_autoaugment_image();

  // .object_detection.protos.DropLabelProbabilistically drop_label_probabilistically = 32;
  bool has_drop_label_probabilistically() const;
  private:
  bool _internal_has_drop_label_probabilistically() const;
  public:
  void clear_drop_label_probabilistically();
  const ::object_detection::protos::DropLabelProbabilistically& drop_label_probabilistically() const;
  PROTOBUF_NODISCARD ::object_detection::protos::DropLabelProbabilistically* release_drop_label_probabilistically();
  ::object_detection::protos::DropLabelProbabilistically* mutable_drop_label_probabilistically();
  void set_allocated_drop_label_probabilistically(::object_detection::protos::DropLabelProbabilistically* drop_label_probabilistically);
  private:
  const ::object_detection::protos::DropLabelProbabilistically& _internal_drop_label_probabilistically() const;
  ::object_detection::protos::DropLabelProbabilistically* _internal_mutable_drop_label_probabilistically();
  public:
  void unsafe_arena_set_allocated_drop_label_probabilistically(
      ::object_detection::protos::DropLabelProbabilistically* drop_label_probabilistically);
  ::object_detection::protos::DropLabelProbabilistically* unsafe_arena_release_drop_label_probabilistically();

  // .object_detection.protos.RemapLabels remap_labels = 33;
  bool has_remap_labels() const;
  private:
  bool _internal_has_remap_labels() const;
  public:
  void clear_remap_labels();
  const ::object_detection::protos::RemapLabels& remap_labels() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RemapLabels* release_remap_labels();
  ::object_detection::protos::RemapLabels* mutable_remap_labels();
  void set_allocated_remap_labels(::object_detection::protos::RemapLabels* remap_labels);
  private:
  const ::object_detection::protos::RemapLabels& _internal_remap_labels() const;
  ::object_detection::protos::RemapLabels* _internal_mutable_remap_labels();
  public:
  void unsafe_arena_set_allocated_remap_labels(
      ::object_detection::protos::RemapLabels* remap_labels);
  ::object_detection::protos::RemapLabels* unsafe_arena_release_remap_labels();

  void clear_preprocessing_step();
  PreprocessingStepCase preprocessing_step_case() const;
  // @@protoc_insertion_point(class_scope:object_detection.protos.PreprocessingStep)
 private:
  class _Internal;
  void set_has_normalize_image();
  void set_has_random_horizontal_flip();
  void set_has_random_pixel_value_scale();
  void set_has_random_image_scale();
  void set_has_random_rgb_to_gray();
  void set_has_random_adjust_brightness();
  void set_has_random_adjust_contrast();
  void set_has_random_adjust_hue();
  void set_has_random_adjust_saturation();
  void set_has_random_distort_color();
  void set_has_random_jitter_boxes();
  void set_has_random_crop_image();
  void set_has_random_pad_image();
  void set_has_random_crop_pad_image();
  void set_has_random_crop_to_aspect_ratio();
  void set_has_random_black_patches();
  void set_has_random_resize_method();
  void set_has_scale_boxes_to_pixel_coordinates();
  void set_has_resize_image();
  void set_has_subtract_channel_mean();
  void set_has_ssd_random_crop();
  void set_has_ssd_random_crop_pad();
  void set_has_ssd_random_crop_fixed_aspect_ratio();
  void set_has_ssd_random_crop_pad_fixed_aspect_ratio();
  void set_has_random_vertical_flip();
  void set_has_random_rotation90();
  void set_has_rgb_to_gray();
  void set_has_convert_class_logits_to_softmax();
  void set_has_random_absolute_pad_image();
  void set_has_random_self_concat_image();
  void set_has_autoaugment_image();
  void set_has_drop_label_probabilistically();
  void set_has_remap_labels();

  inline bool has_preprocessing_step() const;
  inline void clear_has_preprocessing_step();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union PreprocessingStepUnion {
      constexpr PreprocessingStepUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::object_detection::protos::NormalizeImage* normalize_image_;
      ::object_detection::protos::RandomHorizontalFlip* random_horizontal_flip_;
      ::object_detection::protos::RandomPixelValueScale* random_pixel_value_scale_;
      ::object_detection::protos::RandomImageScale* random_image_scale_;
      ::object_detection::protos::RandomRGBtoGray* random_rgb_to_gray_;
      ::object_detection::protos::RandomAdjustBrightness* random_adjust_brightness_;
      ::object_detection::protos::RandomAdjustContrast* random_adjust_contrast_;
      ::object_detection::protos::RandomAdjustHue* random_adjust_hue_;
      ::object_detection::protos::RandomAdjustSaturation* random_adjust_saturation_;
      ::object_detection::protos::RandomDistortColor* random_distort_color_;
      ::object_detection::protos::RandomJitterBoxes* random_jitter_boxes_;
      ::object_detection::protos::RandomCropImage* random_crop_image_;
      ::object_detection::protos::RandomPadImage* random_pad_image_;
      ::object_detection::protos::RandomCropPadImage* random_crop_pad_image_;
      ::object_detection::protos::RandomCropToAspectRatio* random_crop_to_aspect_ratio_;
      ::object_detection::protos::RandomBlackPatches* random_black_patches_;
      ::object_detection::protos::RandomResizeMethod* random_resize_method_;
      ::object_detection::protos::ScaleBoxesToPixelCoordinates* scale_boxes_to_pixel_coordinates_;
      ::object_detection::protos::ResizeImage* resize_image_;
      ::object_detection::protos::SubtractChannelMean* subtract_channel_mean_;
      ::object_detection::protos::SSDRandomCrop* ssd_random_crop_;
      ::object_detection::protos::SSDRandomCropPad* ssd_random_crop_pad_;
      ::object_detection::protos::SSDRandomCropFixedAspectRatio* ssd_random_crop_fixed_aspect_ratio_;
      ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* ssd_random_crop_pad_fixed_aspect_ratio_;
      ::object_detection::protos::RandomVerticalFlip* random_vertical_flip_;
      ::object_detection::protos::RandomRotation90* random_rotation90_;
      ::object_detection::protos::RGBtoGray* rgb_to_gray_;
      ::object_detection::protos::ConvertClassLogitsToSoftmax* convert_class_logits_to_softmax_;
      ::object_detection::protos::RandomAbsolutePadImage* random_absolute_pad_image_;
      ::object_detection::protos::RandomSelfConcatImage* random_self_concat_image_;
      ::object_detection::protos::AutoAugmentImage* autoaugment_image_;
      ::object_detection::protos::DropLabelProbabilistically* drop_label_probabilistically_;
      ::object_detection::protos::RemapLabels* remap_labels_;
    } preprocessing_step_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class NormalizeImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.NormalizeImage) */ {
 public:
  inline NormalizeImage() : NormalizeImage(nullptr) {}
  ~NormalizeImage() override;
  explicit PROTOBUF_CONSTEXPR NormalizeImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NormalizeImage(const NormalizeImage& from);
  NormalizeImage(NormalizeImage&& from) noexcept
    : NormalizeImage() {
    *this = ::std::move(from);
  }

  inline NormalizeImage& operator=(const NormalizeImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline NormalizeImage& operator=(NormalizeImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NormalizeImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const NormalizeImage* internal_default_instance() {
    return reinterpret_cast<const NormalizeImage*>(
               &_NormalizeImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(NormalizeImage& a, NormalizeImage& b) {
    a.Swap(&b);
  }
  inline void Swap(NormalizeImage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NormalizeImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NormalizeImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NormalizeImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NormalizeImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NormalizeImage& from) {
    NormalizeImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NormalizeImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.NormalizeImage";
  }
  protected:
  explicit NormalizeImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOriginalMinvalFieldNumber = 1,
    kOriginalMaxvalFieldNumber = 2,
    kTargetMinvalFieldNumber = 3,
    kTargetMaxvalFieldNumber = 4,
  };
  // optional float original_minval = 1;
  bool has_original_minval() const;
  private:
  bool _internal_has_original_minval() const;
  public:
  void clear_original_minval();
  float original_minval() const;
  void set_original_minval(float value);
  private:
  float _internal_original_minval() const;
  void _internal_set_original_minval(float value);
  public:

  // optional float original_maxval = 2;
  bool has_original_maxval() const;
  private:
  bool _internal_has_original_maxval() const;
  public:
  void clear_original_maxval();
  float original_maxval() const;
  void set_original_maxval(float value);
  private:
  float _internal_original_maxval() const;
  void _internal_set_original_maxval(float value);
  public:

  // optional float target_minval = 3 [default = 0];
  bool has_target_minval() const;
  private:
  bool _internal_has_target_minval() const;
  public:
  void clear_target_minval();
  float target_minval() const;
  void set_target_minval(float value);
  private:
  float _internal_target_minval() const;
  void _internal_set_target_minval(float value);
  public:

  // optional float target_maxval = 4 [default = 1];
  bool has_target_maxval() const;
  private:
  bool _internal_has_target_maxval() const;
  public:
  void clear_target_maxval();
  float target_maxval() const;
  void set_target_maxval(float value);
  private:
  float _internal_target_maxval() const;
  void _internal_set_target_maxval(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.NormalizeImage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float original_minval_;
    float original_maxval_;
    float target_minval_;
    float target_maxval_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomHorizontalFlip final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomHorizontalFlip) */ {
 public:
  inline RandomHorizontalFlip() : RandomHorizontalFlip(nullptr) {}
  ~RandomHorizontalFlip() override;
  explicit PROTOBUF_CONSTEXPR RandomHorizontalFlip(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomHorizontalFlip(const RandomHorizontalFlip& from);
  RandomHorizontalFlip(RandomHorizontalFlip&& from) noexcept
    : RandomHorizontalFlip() {
    *this = ::std::move(from);
  }

  inline RandomHorizontalFlip& operator=(const RandomHorizontalFlip& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomHorizontalFlip& operator=(RandomHorizontalFlip&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomHorizontalFlip& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomHorizontalFlip* internal_default_instance() {
    return reinterpret_cast<const RandomHorizontalFlip*>(
               &_RandomHorizontalFlip_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(RandomHorizontalFlip& a, RandomHorizontalFlip& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomHorizontalFlip* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomHorizontalFlip* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomHorizontalFlip* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomHorizontalFlip>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomHorizontalFlip& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomHorizontalFlip& from) {
    RandomHorizontalFlip::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomHorizontalFlip* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomHorizontalFlip";
  }
  protected:
  explicit RandomHorizontalFlip(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeypointFlipPermutationFieldNumber = 1,
  };
  // repeated int32 keypoint_flip_permutation = 1;
  int keypoint_flip_permutation_size() const;
  private:
  int _internal_keypoint_flip_permutation_size() const;
  public:
  void clear_keypoint_flip_permutation();
  private:
  int32_t _internal_keypoint_flip_permutation(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_keypoint_flip_permutation() const;
  void _internal_add_keypoint_flip_permutation(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_keypoint_flip_permutation();
  public:
  int32_t keypoint_flip_permutation(int index) const;
  void set_keypoint_flip_permutation(int index, int32_t value);
  void add_keypoint_flip_permutation(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      keypoint_flip_permutation() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_keypoint_flip_permutation();

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomHorizontalFlip)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > keypoint_flip_permutation_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomVerticalFlip final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomVerticalFlip) */ {
 public:
  inline RandomVerticalFlip() : RandomVerticalFlip(nullptr) {}
  ~RandomVerticalFlip() override;
  explicit PROTOBUF_CONSTEXPR RandomVerticalFlip(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomVerticalFlip(const RandomVerticalFlip& from);
  RandomVerticalFlip(RandomVerticalFlip&& from) noexcept
    : RandomVerticalFlip() {
    *this = ::std::move(from);
  }

  inline RandomVerticalFlip& operator=(const RandomVerticalFlip& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomVerticalFlip& operator=(RandomVerticalFlip&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomVerticalFlip& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomVerticalFlip* internal_default_instance() {
    return reinterpret_cast<const RandomVerticalFlip*>(
               &_RandomVerticalFlip_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(RandomVerticalFlip& a, RandomVerticalFlip& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomVerticalFlip* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomVerticalFlip* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomVerticalFlip* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomVerticalFlip>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomVerticalFlip& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomVerticalFlip& from) {
    RandomVerticalFlip::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomVerticalFlip* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomVerticalFlip";
  }
  protected:
  explicit RandomVerticalFlip(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeypointFlipPermutationFieldNumber = 1,
  };
  // repeated int32 keypoint_flip_permutation = 1;
  int keypoint_flip_permutation_size() const;
  private:
  int _internal_keypoint_flip_permutation_size() const;
  public:
  void clear_keypoint_flip_permutation();
  private:
  int32_t _internal_keypoint_flip_permutation(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_keypoint_flip_permutation() const;
  void _internal_add_keypoint_flip_permutation(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_keypoint_flip_permutation();
  public:
  int32_t keypoint_flip_permutation(int index) const;
  void set_keypoint_flip_permutation(int index, int32_t value);
  void add_keypoint_flip_permutation(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      keypoint_flip_permutation() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_keypoint_flip_permutation();

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomVerticalFlip)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > keypoint_flip_permutation_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomRotation90 final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomRotation90) */ {
 public:
  inline RandomRotation90() : RandomRotation90(nullptr) {}
  explicit PROTOBUF_CONSTEXPR RandomRotation90(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomRotation90(const RandomRotation90& from);
  RandomRotation90(RandomRotation90&& from) noexcept
    : RandomRotation90() {
    *this = ::std::move(from);
  }

  inline RandomRotation90& operator=(const RandomRotation90& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomRotation90& operator=(RandomRotation90&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomRotation90& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomRotation90* internal_default_instance() {
    return reinterpret_cast<const RandomRotation90*>(
               &_RandomRotation90_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(RandomRotation90& a, RandomRotation90& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomRotation90* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomRotation90* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomRotation90* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomRotation90>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const RandomRotation90& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const RandomRotation90& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomRotation90";
  }
  protected:
  explicit RandomRotation90(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomRotation90)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomPixelValueScale final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomPixelValueScale) */ {
 public:
  inline RandomPixelValueScale() : RandomPixelValueScale(nullptr) {}
  ~RandomPixelValueScale() override;
  explicit PROTOBUF_CONSTEXPR RandomPixelValueScale(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomPixelValueScale(const RandomPixelValueScale& from);
  RandomPixelValueScale(RandomPixelValueScale&& from) noexcept
    : RandomPixelValueScale() {
    *this = ::std::move(from);
  }

  inline RandomPixelValueScale& operator=(const RandomPixelValueScale& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomPixelValueScale& operator=(RandomPixelValueScale&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomPixelValueScale& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomPixelValueScale* internal_default_instance() {
    return reinterpret_cast<const RandomPixelValueScale*>(
               &_RandomPixelValueScale_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(RandomPixelValueScale& a, RandomPixelValueScale& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomPixelValueScale* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomPixelValueScale* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomPixelValueScale* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomPixelValueScale>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomPixelValueScale& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomPixelValueScale& from) {
    RandomPixelValueScale::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomPixelValueScale* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomPixelValueScale";
  }
  protected:
  explicit RandomPixelValueScale(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinvalFieldNumber = 1,
    kMaxvalFieldNumber = 2,
  };
  // optional float minval = 1 [default = 0.9];
  bool has_minval() const;
  private:
  bool _internal_has_minval() const;
  public:
  void clear_minval();
  float minval() const;
  void set_minval(float value);
  private:
  float _internal_minval() const;
  void _internal_set_minval(float value);
  public:

  // optional float maxval = 2 [default = 1.1];
  bool has_maxval() const;
  private:
  bool _internal_has_maxval() const;
  public:
  void clear_maxval();
  float maxval() const;
  void set_maxval(float value);
  private:
  float _internal_maxval() const;
  void _internal_set_maxval(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomPixelValueScale)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float minval_;
    float maxval_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomImageScale final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomImageScale) */ {
 public:
  inline RandomImageScale() : RandomImageScale(nullptr) {}
  ~RandomImageScale() override;
  explicit PROTOBUF_CONSTEXPR RandomImageScale(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomImageScale(const RandomImageScale& from);
  RandomImageScale(RandomImageScale&& from) noexcept
    : RandomImageScale() {
    *this = ::std::move(from);
  }

  inline RandomImageScale& operator=(const RandomImageScale& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomImageScale& operator=(RandomImageScale&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomImageScale& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomImageScale* internal_default_instance() {
    return reinterpret_cast<const RandomImageScale*>(
               &_RandomImageScale_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(RandomImageScale& a, RandomImageScale& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomImageScale* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomImageScale* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomImageScale* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomImageScale>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomImageScale& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomImageScale& from) {
    RandomImageScale::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomImageScale* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomImageScale";
  }
  protected:
  explicit RandomImageScale(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinScaleRatioFieldNumber = 1,
    kMaxScaleRatioFieldNumber = 2,
  };
  // optional float min_scale_ratio = 1 [default = 0.5];
  bool has_min_scale_ratio() const;
  private:
  bool _internal_has_min_scale_ratio() const;
  public:
  void clear_min_scale_ratio();
  float min_scale_ratio() const;
  void set_min_scale_ratio(float value);
  private:
  float _internal_min_scale_ratio() const;
  void _internal_set_min_scale_ratio(float value);
  public:

  // optional float max_scale_ratio = 2 [default = 2];
  bool has_max_scale_ratio() const;
  private:
  bool _internal_has_max_scale_ratio() const;
  public:
  void clear_max_scale_ratio();
  float max_scale_ratio() const;
  void set_max_scale_ratio(float value);
  private:
  float _internal_max_scale_ratio() const;
  void _internal_set_max_scale_ratio(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomImageScale)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float min_scale_ratio_;
    float max_scale_ratio_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomRGBtoGray final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomRGBtoGray) */ {
 public:
  inline RandomRGBtoGray() : RandomRGBtoGray(nullptr) {}
  ~RandomRGBtoGray() override;
  explicit PROTOBUF_CONSTEXPR RandomRGBtoGray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomRGBtoGray(const RandomRGBtoGray& from);
  RandomRGBtoGray(RandomRGBtoGray&& from) noexcept
    : RandomRGBtoGray() {
    *this = ::std::move(from);
  }

  inline RandomRGBtoGray& operator=(const RandomRGBtoGray& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomRGBtoGray& operator=(RandomRGBtoGray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomRGBtoGray& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomRGBtoGray* internal_default_instance() {
    return reinterpret_cast<const RandomRGBtoGray*>(
               &_RandomRGBtoGray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(RandomRGBtoGray& a, RandomRGBtoGray& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomRGBtoGray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomRGBtoGray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomRGBtoGray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomRGBtoGray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomRGBtoGray& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomRGBtoGray& from) {
    RandomRGBtoGray::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomRGBtoGray* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomRGBtoGray";
  }
  protected:
  explicit RandomRGBtoGray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProbabilityFieldNumber = 1,
  };
  // optional float probability = 1 [default = 0.1];
  bool has_probability() const;
  private:
  bool _internal_has_probability() const;
  public:
  void clear_probability();
  float probability() const;
  void set_probability(float value);
  private:
  float _internal_probability() const;
  void _internal_set_probability(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomRGBtoGray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float probability_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomAdjustBrightness final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomAdjustBrightness) */ {
 public:
  inline RandomAdjustBrightness() : RandomAdjustBrightness(nullptr) {}
  ~RandomAdjustBrightness() override;
  explicit PROTOBUF_CONSTEXPR RandomAdjustBrightness(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomAdjustBrightness(const RandomAdjustBrightness& from);
  RandomAdjustBrightness(RandomAdjustBrightness&& from) noexcept
    : RandomAdjustBrightness() {
    *this = ::std::move(from);
  }

  inline RandomAdjustBrightness& operator=(const RandomAdjustBrightness& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomAdjustBrightness& operator=(RandomAdjustBrightness&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomAdjustBrightness& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomAdjustBrightness* internal_default_instance() {
    return reinterpret_cast<const RandomAdjustBrightness*>(
               &_RandomAdjustBrightness_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(RandomAdjustBrightness& a, RandomAdjustBrightness& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomAdjustBrightness* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomAdjustBrightness* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomAdjustBrightness* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomAdjustBrightness>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomAdjustBrightness& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomAdjustBrightness& from) {
    RandomAdjustBrightness::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomAdjustBrightness* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomAdjustBrightness";
  }
  protected:
  explicit RandomAdjustBrightness(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMaxDeltaFieldNumber = 1,
  };
  // optional float max_delta = 1 [default = 0.2];
  bool has_max_delta() const;
  private:
  bool _internal_has_max_delta() const;
  public:
  void clear_max_delta();
  float max_delta() const;
  void set_max_delta(float value);
  private:
  float _internal_max_delta() const;
  void _internal_set_max_delta(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomAdjustBrightness)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float max_delta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomAdjustContrast final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomAdjustContrast) */ {
 public:
  inline RandomAdjustContrast() : RandomAdjustContrast(nullptr) {}
  ~RandomAdjustContrast() override;
  explicit PROTOBUF_CONSTEXPR RandomAdjustContrast(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomAdjustContrast(const RandomAdjustContrast& from);
  RandomAdjustContrast(RandomAdjustContrast&& from) noexcept
    : RandomAdjustContrast() {
    *this = ::std::move(from);
  }

  inline RandomAdjustContrast& operator=(const RandomAdjustContrast& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomAdjustContrast& operator=(RandomAdjustContrast&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomAdjustContrast& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomAdjustContrast* internal_default_instance() {
    return reinterpret_cast<const RandomAdjustContrast*>(
               &_RandomAdjustContrast_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(RandomAdjustContrast& a, RandomAdjustContrast& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomAdjustContrast* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomAdjustContrast* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomAdjustContrast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomAdjustContrast>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomAdjustContrast& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomAdjustContrast& from) {
    RandomAdjustContrast::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomAdjustContrast* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomAdjustContrast";
  }
  protected:
  explicit RandomAdjustContrast(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinDeltaFieldNumber = 1,
    kMaxDeltaFieldNumber = 2,
  };
  // optional float min_delta = 1 [default = 0.8];
  bool has_min_delta() const;
  private:
  bool _internal_has_min_delta() const;
  public:
  void clear_min_delta();
  float min_delta() const;
  void set_min_delta(float value);
  private:
  float _internal_min_delta() const;
  void _internal_set_min_delta(float value);
  public:

  // optional float max_delta = 2 [default = 1.25];
  bool has_max_delta() const;
  private:
  bool _internal_has_max_delta() const;
  public:
  void clear_max_delta();
  float max_delta() const;
  void set_max_delta(float value);
  private:
  float _internal_max_delta() const;
  void _internal_set_max_delta(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomAdjustContrast)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float min_delta_;
    float max_delta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomAdjustHue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomAdjustHue) */ {
 public:
  inline RandomAdjustHue() : RandomAdjustHue(nullptr) {}
  ~RandomAdjustHue() override;
  explicit PROTOBUF_CONSTEXPR RandomAdjustHue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomAdjustHue(const RandomAdjustHue& from);
  RandomAdjustHue(RandomAdjustHue&& from) noexcept
    : RandomAdjustHue() {
    *this = ::std::move(from);
  }

  inline RandomAdjustHue& operator=(const RandomAdjustHue& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomAdjustHue& operator=(RandomAdjustHue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomAdjustHue& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomAdjustHue* internal_default_instance() {
    return reinterpret_cast<const RandomAdjustHue*>(
               &_RandomAdjustHue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(RandomAdjustHue& a, RandomAdjustHue& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomAdjustHue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomAdjustHue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomAdjustHue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomAdjustHue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomAdjustHue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomAdjustHue& from) {
    RandomAdjustHue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomAdjustHue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomAdjustHue";
  }
  protected:
  explicit RandomAdjustHue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMaxDeltaFieldNumber = 1,
  };
  // optional float max_delta = 1 [default = 0.02];
  bool has_max_delta() const;
  private:
  bool _internal_has_max_delta() const;
  public:
  void clear_max_delta();
  float max_delta() const;
  void set_max_delta(float value);
  private:
  float _internal_max_delta() const;
  void _internal_set_max_delta(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomAdjustHue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float max_delta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomAdjustSaturation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomAdjustSaturation) */ {
 public:
  inline RandomAdjustSaturation() : RandomAdjustSaturation(nullptr) {}
  ~RandomAdjustSaturation() override;
  explicit PROTOBUF_CONSTEXPR RandomAdjustSaturation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomAdjustSaturation(const RandomAdjustSaturation& from);
  RandomAdjustSaturation(RandomAdjustSaturation&& from) noexcept
    : RandomAdjustSaturation() {
    *this = ::std::move(from);
  }

  inline RandomAdjustSaturation& operator=(const RandomAdjustSaturation& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomAdjustSaturation& operator=(RandomAdjustSaturation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomAdjustSaturation& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomAdjustSaturation* internal_default_instance() {
    return reinterpret_cast<const RandomAdjustSaturation*>(
               &_RandomAdjustSaturation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(RandomAdjustSaturation& a, RandomAdjustSaturation& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomAdjustSaturation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomAdjustSaturation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomAdjustSaturation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomAdjustSaturation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomAdjustSaturation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomAdjustSaturation& from) {
    RandomAdjustSaturation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomAdjustSaturation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomAdjustSaturation";
  }
  protected:
  explicit RandomAdjustSaturation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinDeltaFieldNumber = 1,
    kMaxDeltaFieldNumber = 2,
  };
  // optional float min_delta = 1 [default = 0.8];
  bool has_min_delta() const;
  private:
  bool _internal_has_min_delta() const;
  public:
  void clear_min_delta();
  float min_delta() const;
  void set_min_delta(float value);
  private:
  float _internal_min_delta() const;
  void _internal_set_min_delta(float value);
  public:

  // optional float max_delta = 2 [default = 1.25];
  bool has_max_delta() const;
  private:
  bool _internal_has_max_delta() const;
  public:
  void clear_max_delta();
  float max_delta() const;
  void set_max_delta(float value);
  private:
  float _internal_max_delta() const;
  void _internal_set_max_delta(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomAdjustSaturation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float min_delta_;
    float max_delta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomDistortColor final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomDistortColor) */ {
 public:
  inline RandomDistortColor() : RandomDistortColor(nullptr) {}
  ~RandomDistortColor() override;
  explicit PROTOBUF_CONSTEXPR RandomDistortColor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomDistortColor(const RandomDistortColor& from);
  RandomDistortColor(RandomDistortColor&& from) noexcept
    : RandomDistortColor() {
    *this = ::std::move(from);
  }

  inline RandomDistortColor& operator=(const RandomDistortColor& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomDistortColor& operator=(RandomDistortColor&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomDistortColor& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomDistortColor* internal_default_instance() {
    return reinterpret_cast<const RandomDistortColor*>(
               &_RandomDistortColor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(RandomDistortColor& a, RandomDistortColor& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomDistortColor* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomDistortColor* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomDistortColor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomDistortColor>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomDistortColor& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomDistortColor& from) {
    RandomDistortColor::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomDistortColor* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomDistortColor";
  }
  protected:
  explicit RandomDistortColor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kColorOrderingFieldNumber = 1,
  };
  // optional int32 color_ordering = 1;
  bool has_color_ordering() const;
  private:
  bool _internal_has_color_ordering() const;
  public:
  void clear_color_ordering();
  int32_t color_ordering() const;
  void set_color_ordering(int32_t value);
  private:
  int32_t _internal_color_ordering() const;
  void _internal_set_color_ordering(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomDistortColor)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t color_ordering_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomJitterBoxes final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomJitterBoxes) */ {
 public:
  inline RandomJitterBoxes() : RandomJitterBoxes(nullptr) {}
  ~RandomJitterBoxes() override;
  explicit PROTOBUF_CONSTEXPR RandomJitterBoxes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomJitterBoxes(const RandomJitterBoxes& from);
  RandomJitterBoxes(RandomJitterBoxes&& from) noexcept
    : RandomJitterBoxes() {
    *this = ::std::move(from);
  }

  inline RandomJitterBoxes& operator=(const RandomJitterBoxes& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomJitterBoxes& operator=(RandomJitterBoxes&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomJitterBoxes& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomJitterBoxes* internal_default_instance() {
    return reinterpret_cast<const RandomJitterBoxes*>(
               &_RandomJitterBoxes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(RandomJitterBoxes& a, RandomJitterBoxes& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomJitterBoxes* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomJitterBoxes* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomJitterBoxes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomJitterBoxes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomJitterBoxes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomJitterBoxes& from) {
    RandomJitterBoxes::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomJitterBoxes* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomJitterBoxes";
  }
  protected:
  explicit RandomJitterBoxes(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRatioFieldNumber = 1,
  };
  // optional float ratio = 1 [default = 0.05];
  bool has_ratio() const;
  private:
  bool _internal_has_ratio() const;
  public:
  void clear_ratio();
  float ratio() const;
  void set_ratio(float value);
  private:
  float _internal_ratio() const;
  void _internal_set_ratio(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomJitterBoxes)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float ratio_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomCropImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomCropImage) */ {
 public:
  inline RandomCropImage() : RandomCropImage(nullptr) {}
  ~RandomCropImage() override;
  explicit PROTOBUF_CONSTEXPR RandomCropImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomCropImage(const RandomCropImage& from);
  RandomCropImage(RandomCropImage&& from) noexcept
    : RandomCropImage() {
    *this = ::std::move(from);
  }

  inline RandomCropImage& operator=(const RandomCropImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomCropImage& operator=(RandomCropImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomCropImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomCropImage* internal_default_instance() {
    return reinterpret_cast<const RandomCropImage*>(
               &_RandomCropImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(RandomCropImage& a, RandomCropImage& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomCropImage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomCropImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomCropImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomCropImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomCropImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomCropImage& from) {
    RandomCropImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomCropImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomCropImage";
  }
  protected:
  explicit RandomCropImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRandomCoefFieldNumber = 7,
    kClipBoxesFieldNumber = 8,
    kMinObjectCoveredFieldNumber = 1,
    kMinAspectRatioFieldNumber = 2,
    kMaxAspectRatioFieldNumber = 3,
    kMinAreaFieldNumber = 4,
    kMaxAreaFieldNumber = 5,
    kOverlapThreshFieldNumber = 6,
  };
  // optional float random_coef = 7 [default = 0];
  bool has_random_coef() const;
  private:
  bool _internal_has_random_coef() const;
  public:
  void clear_random_coef();
  float random_coef() const;
  void set_random_coef(float value);
  private:
  float _internal_random_coef() const;
  void _internal_set_random_coef(float value);
  public:

  // optional bool clip_boxes = 8 [default = true];
  bool has_clip_boxes() const;
  private:
  bool _internal_has_clip_boxes() const;
  public:
  void clear_clip_boxes();
  bool clip_boxes() const;
  void set_clip_boxes(bool value);
  private:
  bool _internal_clip_boxes() const;
  void _internal_set_clip_boxes(bool value);
  public:

  // optional float min_object_covered = 1 [default = 1];
  bool has_min_object_covered() const;
  private:
  bool _internal_has_min_object_covered() const;
  public:
  void clear_min_object_covered();
  float min_object_covered() const;
  void set_min_object_covered(float value);
  private:
  float _internal_min_object_covered() const;
  void _internal_set_min_object_covered(float value);
  public:

  // optional float min_aspect_ratio = 2 [default = 0.75];
  bool has_min_aspect_ratio() const;
  private:
  bool _internal_has_min_aspect_ratio() const;
  public:
  void clear_min_aspect_ratio();
  float min_aspect_ratio() const;
  void set_min_aspect_ratio(float value);
  private:
  float _internal_min_aspect_ratio() const;
  void _internal_set_min_aspect_ratio(float value);
  public:

  // optional float max_aspect_ratio = 3 [default = 1.33];
  bool has_max_aspect_ratio() const;
  private:
  bool _internal_has_max_aspect_ratio() const;
  public:
  void clear_max_aspect_ratio();
  float max_aspect_ratio() const;
  void set_max_aspect_ratio(float value);
  private:
  float _internal_max_aspect_ratio() const;
  void _internal_set_max_aspect_ratio(float value);
  public:

  // optional float min_area = 4 [default = 0.1];
  bool has_min_area() const;
  private:
  bool _internal_has_min_area() const;
  public:
  void clear_min_area();
  float min_area() const;
  void set_min_area(float value);
  private:
  float _internal_min_area() const;
  void _internal_set_min_area(float value);
  public:

  // optional float max_area = 5 [default = 1];
  bool has_max_area() const;
  private:
  bool _internal_has_max_area() const;
  public:
  void clear_max_area();
  float max_area() const;
  void set_max_area(float value);
  private:
  float _internal_max_area() const;
  void _internal_set_max_area(float value);
  public:

  // optional float overlap_thresh = 6 [default = 0.3];
  bool has_overlap_thresh() const;
  private:
  bool _internal_has_overlap_thresh() const;
  public:
  void clear_overlap_thresh();
  float overlap_thresh() const;
  void set_overlap_thresh(float value);
  private:
  float _internal_overlap_thresh() const;
  void _internal_set_overlap_thresh(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomCropImage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float random_coef_;
    bool clip_boxes_;
    float min_object_covered_;
    float min_aspect_ratio_;
    float max_aspect_ratio_;
    float min_area_;
    float max_area_;
    float overlap_thresh_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomPadImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomPadImage) */ {
 public:
  inline RandomPadImage() : RandomPadImage(nullptr) {}
  ~RandomPadImage() override;
  explicit PROTOBUF_CONSTEXPR RandomPadImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomPadImage(const RandomPadImage& from);
  RandomPadImage(RandomPadImage&& from) noexcept
    : RandomPadImage() {
    *this = ::std::move(from);
  }

  inline RandomPadImage& operator=(const RandomPadImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomPadImage& operator=(RandomPadImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomPadImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomPadImage* internal_default_instance() {
    return reinterpret_cast<const RandomPadImage*>(
               &_RandomPadImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(RandomPadImage& a, RandomPadImage& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomPadImage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomPadImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomPadImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomPadImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomPadImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomPadImage& from) {
    RandomPadImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomPadImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomPadImage";
  }
  protected:
  explicit RandomPadImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPadColorFieldNumber = 5,
    kMinImageHeightFieldNumber = 1,
    kMinImageWidthFieldNumber = 2,
    kMaxImageHeightFieldNumber = 3,
    kMaxImageWidthFieldNumber = 4,
  };
  // repeated float pad_color = 5;
  int pad_color_size() const;
  private:
  int _internal_pad_color_size() const;
  public:
  void clear_pad_color();
  private:
  float _internal_pad_color(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_pad_color() const;
  void _internal_add_pad_color(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_pad_color();
  public:
  float pad_color(int index) const;
  void set_pad_color(int index, float value);
  void add_pad_color(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      pad_color() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_pad_color();

  // optional int32 min_image_height = 1;
  bool has_min_image_height() const;
  private:
  bool _internal_has_min_image_height() const;
  public:
  void clear_min_image_height();
  int32_t min_image_height() const;
  void set_min_image_height(int32_t value);
  private:
  int32_t _internal_min_image_height() const;
  void _internal_set_min_image_height(int32_t value);
  public:

  // optional int32 min_image_width = 2;
  bool has_min_image_width() const;
  private:
  bool _internal_has_min_image_width() const;
  public:
  void clear_min_image_width();
  int32_t min_image_width() const;
  void set_min_image_width(int32_t value);
  private:
  int32_t _internal_min_image_width() const;
  void _internal_set_min_image_width(int32_t value);
  public:

  // optional int32 max_image_height = 3;
  bool has_max_image_height() const;
  private:
  bool _internal_has_max_image_height() const;
  public:
  void clear_max_image_height();
  int32_t max_image_height() const;
  void set_max_image_height(int32_t value);
  private:
  int32_t _internal_max_image_height() const;
  void _internal_set_max_image_height(int32_t value);
  public:

  // optional int32 max_image_width = 4;
  bool has_max_image_width() const;
  private:
  bool _internal_has_max_image_width() const;
  public:
  void clear_max_image_width();
  int32_t max_image_width() const;
  void set_max_image_width(int32_t value);
  private:
  int32_t _internal_max_image_width() const;
  void _internal_set_max_image_width(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomPadImage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > pad_color_;
    int32_t min_image_height_;
    int32_t min_image_width_;
    int32_t max_image_height_;
    int32_t max_image_width_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomAbsolutePadImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomAbsolutePadImage) */ {
 public:
  inline RandomAbsolutePadImage() : RandomAbsolutePadImage(nullptr) {}
  ~RandomAbsolutePadImage() override;
  explicit PROTOBUF_CONSTEXPR RandomAbsolutePadImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomAbsolutePadImage(const RandomAbsolutePadImage& from);
  RandomAbsolutePadImage(RandomAbsolutePadImage&& from) noexcept
    : RandomAbsolutePadImage() {
    *this = ::std::move(from);
  }

  inline RandomAbsolutePadImage& operator=(const RandomAbsolutePadImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomAbsolutePadImage& operator=(RandomAbsolutePadImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomAbsolutePadImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomAbsolutePadImage* internal_default_instance() {
    return reinterpret_cast<const RandomAbsolutePadImage*>(
               &_RandomAbsolutePadImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(RandomAbsolutePadImage& a, RandomAbsolutePadImage& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomAbsolutePadImage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomAbsolutePadImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomAbsolutePadImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomAbsolutePadImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomAbsolutePadImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomAbsolutePadImage& from) {
    RandomAbsolutePadImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomAbsolutePadImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomAbsolutePadImage";
  }
  protected:
  explicit RandomAbsolutePadImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPadColorFieldNumber = 3,
    kMaxHeightPaddingFieldNumber = 1,
    kMaxWidthPaddingFieldNumber = 2,
  };
  // repeated float pad_color = 3;
  int pad_color_size() const;
  private:
  int _internal_pad_color_size() const;
  public:
  void clear_pad_color();
  private:
  float _internal_pad_color(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_pad_color() const;
  void _internal_add_pad_color(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_pad_color();
  public:
  float pad_color(int index) const;
  void set_pad_color(int index, float value);
  void add_pad_color(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      pad_color() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_pad_color();

  // optional int32 max_height_padding = 1;
  bool has_max_height_padding() const;
  private:
  bool _internal_has_max_height_padding() const;
  public:
  void clear_max_height_padding();
  int32_t max_height_padding() const;
  void set_max_height_padding(int32_t value);
  private:
  int32_t _internal_max_height_padding() const;
  void _internal_set_max_height_padding(int32_t value);
  public:

  // optional int32 max_width_padding = 2;
  bool has_max_width_padding() const;
  private:
  bool _internal_has_max_width_padding() const;
  public:
  void clear_max_width_padding();
  int32_t max_width_padding() const;
  void set_max_width_padding(int32_t value);
  private:
  int32_t _internal_max_width_padding() const;
  void _internal_set_max_width_padding(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomAbsolutePadImage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > pad_color_;
    int32_t max_height_padding_;
    int32_t max_width_padding_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomCropPadImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomCropPadImage) */ {
 public:
  inline RandomCropPadImage() : RandomCropPadImage(nullptr) {}
  ~RandomCropPadImage() override;
  explicit PROTOBUF_CONSTEXPR RandomCropPadImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomCropPadImage(const RandomCropPadImage& from);
  RandomCropPadImage(RandomCropPadImage&& from) noexcept
    : RandomCropPadImage() {
    *this = ::std::move(from);
  }

  inline RandomCropPadImage& operator=(const RandomCropPadImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomCropPadImage& operator=(RandomCropPadImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomCropPadImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomCropPadImage* internal_default_instance() {
    return reinterpret_cast<const RandomCropPadImage*>(
               &_RandomCropPadImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(RandomCropPadImage& a, RandomCropPadImage& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomCropPadImage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomCropPadImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomCropPadImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomCropPadImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomCropPadImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomCropPadImage& from) {
    RandomCropPadImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomCropPadImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomCropPadImage";
  }
  protected:
  explicit RandomCropPadImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinPaddedSizeRatioFieldNumber = 8,
    kMaxPaddedSizeRatioFieldNumber = 9,
    kPadColorFieldNumber = 10,
    kRandomCoefFieldNumber = 7,
    kClipBoxesFieldNumber = 11,
    kMinObjectCoveredFieldNumber = 1,
    kMinAspectRatioFieldNumber = 2,
    kMaxAspectRatioFieldNumber = 3,
    kMinAreaFieldNumber = 4,
    kMaxAreaFieldNumber = 5,
    kOverlapThreshFieldNumber = 6,
  };
  // repeated float min_padded_size_ratio = 8;
  int min_padded_size_ratio_size() const;
  private:
  int _internal_min_padded_size_ratio_size() const;
  public:
  void clear_min_padded_size_ratio();
  private:
  float _internal_min_padded_size_ratio(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_min_padded_size_ratio() const;
  void _internal_add_min_padded_size_ratio(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_min_padded_size_ratio();
  public:
  float min_padded_size_ratio(int index) const;
  void set_min_padded_size_ratio(int index, float value);
  void add_min_padded_size_ratio(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      min_padded_size_ratio() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_min_padded_size_ratio();

  // repeated float max_padded_size_ratio = 9;
  int max_padded_size_ratio_size() const;
  private:
  int _internal_max_padded_size_ratio_size() const;
  public:
  void clear_max_padded_size_ratio();
  private:
  float _internal_max_padded_size_ratio(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_max_padded_size_ratio() const;
  void _internal_add_max_padded_size_ratio(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_max_padded_size_ratio();
  public:
  float max_padded_size_ratio(int index) const;
  void set_max_padded_size_ratio(int index, float value);
  void add_max_padded_size_ratio(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      max_padded_size_ratio() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_max_padded_size_ratio();

  // repeated float pad_color = 10;
  int pad_color_size() const;
  private:
  int _internal_pad_color_size() const;
  public:
  void clear_pad_color();
  private:
  float _internal_pad_color(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_pad_color() const;
  void _internal_add_pad_color(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_pad_color();
  public:
  float pad_color(int index) const;
  void set_pad_color(int index, float value);
  void add_pad_color(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      pad_color() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_pad_color();

  // optional float random_coef = 7 [default = 0];
  bool has_random_coef() const;
  private:
  bool _internal_has_random_coef() const;
  public:
  void clear_random_coef();
  float random_coef() const;
  void set_random_coef(float value);
  private:
  float _internal_random_coef() const;
  void _internal_set_random_coef(float value);
  public:

  // optional bool clip_boxes = 11 [default = true];
  bool has_clip_boxes() const;
  private:
  bool _internal_has_clip_boxes() const;
  public:
  void clear_clip_boxes();
  bool clip_boxes() const;
  void set_clip_boxes(bool value);
  private:
  bool _internal_clip_boxes() const;
  void _internal_set_clip_boxes(bool value);
  public:

  // optional float min_object_covered = 1 [default = 1];
  bool has_min_object_covered() const;
  private:
  bool _internal_has_min_object_covered() const;
  public:
  void clear_min_object_covered();
  float min_object_covered() const;
  void set_min_object_covered(float value);
  private:
  float _internal_min_object_covered() const;
  void _internal_set_min_object_covered(float value);
  public:

  // optional float min_aspect_ratio = 2 [default = 0.75];
  bool has_min_aspect_ratio() const;
  private:
  bool _internal_has_min_aspect_ratio() const;
  public:
  void clear_min_aspect_ratio();
  float min_aspect_ratio() const;
  void set_min_aspect_ratio(float value);
  private:
  float _internal_min_aspect_ratio() const;
  void _internal_set_min_aspect_ratio(float value);
  public:

  // optional float max_aspect_ratio = 3 [default = 1.33];
  bool has_max_aspect_ratio() const;
  private:
  bool _internal_has_max_aspect_ratio() const;
  public:
  void clear_max_aspect_ratio();
  float max_aspect_ratio() const;
  void set_max_aspect_ratio(float value);
  private:
  float _internal_max_aspect_ratio() const;
  void _internal_set_max_aspect_ratio(float value);
  public:

  // optional float min_area = 4 [default = 0.1];
  bool has_min_area() const;
  private:
  bool _internal_has_min_area() const;
  public:
  void clear_min_area();
  float min_area() const;
  void set_min_area(float value);
  private:
  float _internal_min_area() const;
  void _internal_set_min_area(float value);
  public:

  // optional float max_area = 5 [default = 1];
  bool has_max_area() const;
  private:
  bool _internal_has_max_area() const;
  public:
  void clear_max_area();
  float max_area() const;
  void set_max_area(float value);
  private:
  float _internal_max_area() const;
  void _internal_set_max_area(float value);
  public:

  // optional float overlap_thresh = 6 [default = 0.3];
  bool has_overlap_thresh() const;
  private:
  bool _internal_has_overlap_thresh() const;
  public:
  void clear_overlap_thresh();
  float overlap_thresh() const;
  void set_overlap_thresh(float value);
  private:
  float _internal_overlap_thresh() const;
  void _internal_set_overlap_thresh(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomCropPadImage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > min_padded_size_ratio_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > max_padded_size_ratio_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > pad_color_;
    float random_coef_;
    bool clip_boxes_;
    float min_object_covered_;
    float min_aspect_ratio_;
    float max_aspect_ratio_;
    float min_area_;
    float max_area_;
    float overlap_thresh_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomCropToAspectRatio final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomCropToAspectRatio) */ {
 public:
  inline RandomCropToAspectRatio() : RandomCropToAspectRatio(nullptr) {}
  ~RandomCropToAspectRatio() override;
  explicit PROTOBUF_CONSTEXPR RandomCropToAspectRatio(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomCropToAspectRatio(const RandomCropToAspectRatio& from);
  RandomCropToAspectRatio(RandomCropToAspectRatio&& from) noexcept
    : RandomCropToAspectRatio() {
    *this = ::std::move(from);
  }

  inline RandomCropToAspectRatio& operator=(const RandomCropToAspectRatio& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomCropToAspectRatio& operator=(RandomCropToAspectRatio&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomCropToAspectRatio& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomCropToAspectRatio* internal_default_instance() {
    return reinterpret_cast<const RandomCropToAspectRatio*>(
               &_RandomCropToAspectRatio_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(RandomCropToAspectRatio& a, RandomCropToAspectRatio& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomCropToAspectRatio* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomCropToAspectRatio* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomCropToAspectRatio* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomCropToAspectRatio>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomCropToAspectRatio& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomCropToAspectRatio& from) {
    RandomCropToAspectRatio::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomCropToAspectRatio* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomCropToAspectRatio";
  }
  protected:
  explicit RandomCropToAspectRatio(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kClipBoxesFieldNumber = 3,
    kAspectRatioFieldNumber = 1,
    kOverlapThreshFieldNumber = 2,
  };
  // optional bool clip_boxes = 3 [default = true];
  bool has_clip_boxes() const;
  private:
  bool _internal_has_clip_boxes() const;
  public:
  void clear_clip_boxes();
  bool clip_boxes() const;
  void set_clip_boxes(bool value);
  private:
  bool _internal_clip_boxes() const;
  void _internal_set_clip_boxes(bool value);
  public:

  // optional float aspect_ratio = 1 [default = 1];
  bool has_aspect_ratio() const;
  private:
  bool _internal_has_aspect_ratio() const;
  public:
  void clear_aspect_ratio();
  float aspect_ratio() const;
  void set_aspect_ratio(float value);
  private:
  float _internal_aspect_ratio() const;
  void _internal_set_aspect_ratio(float value);
  public:

  // optional float overlap_thresh = 2 [default = 0.3];
  bool has_overlap_thresh() const;
  private:
  bool _internal_has_overlap_thresh() const;
  public:
  void clear_overlap_thresh();
  float overlap_thresh() const;
  void set_overlap_thresh(float value);
  private:
  float _internal_overlap_thresh() const;
  void _internal_set_overlap_thresh(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomCropToAspectRatio)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool clip_boxes_;
    float aspect_ratio_;
    float overlap_thresh_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomBlackPatches final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomBlackPatches) */ {
 public:
  inline RandomBlackPatches() : RandomBlackPatches(nullptr) {}
  ~RandomBlackPatches() override;
  explicit PROTOBUF_CONSTEXPR RandomBlackPatches(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomBlackPatches(const RandomBlackPatches& from);
  RandomBlackPatches(RandomBlackPatches&& from) noexcept
    : RandomBlackPatches() {
    *this = ::std::move(from);
  }

  inline RandomBlackPatches& operator=(const RandomBlackPatches& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomBlackPatches& operator=(RandomBlackPatches&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomBlackPatches& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomBlackPatches* internal_default_instance() {
    return reinterpret_cast<const RandomBlackPatches*>(
               &_RandomBlackPatches_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(RandomBlackPatches& a, RandomBlackPatches& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomBlackPatches* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomBlackPatches* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomBlackPatches* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomBlackPatches>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomBlackPatches& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomBlackPatches& from) {
    RandomBlackPatches::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomBlackPatches* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomBlackPatches";
  }
  protected:
  explicit RandomBlackPatches(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSizeToImageRatioFieldNumber = 3,
    kMaxBlackPatchesFieldNumber = 1,
    kProbabilityFieldNumber = 2,
  };
  // optional float size_to_image_ratio = 3 [default = 0.1];
  bool has_size_to_image_ratio() const;
  private:
  bool _internal_has_size_to_image_ratio() const;
  public:
  void clear_size_to_image_ratio();
  float size_to_image_ratio() const;
  void set_size_to_image_ratio(float value);
  private:
  float _internal_size_to_image_ratio() const;
  void _internal_set_size_to_image_ratio(float value);
  public:

  // optional int32 max_black_patches = 1 [default = 10];
  bool has_max_black_patches() const;
  private:
  bool _internal_has_max_black_patches() const;
  public:
  void clear_max_black_patches();
  int32_t max_black_patches() const;
  void set_max_black_patches(int32_t value);
  private:
  int32_t _internal_max_black_patches() const;
  void _internal_set_max_black_patches(int32_t value);
  public:

  // optional float probability = 2 [default = 0.5];
  bool has_probability() const;
  private:
  bool _internal_has_probability() const;
  public:
  void clear_probability();
  float probability() const;
  void set_probability(float value);
  private:
  float _internal_probability() const;
  void _internal_set_probability(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomBlackPatches)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float size_to_image_ratio_;
    int32_t max_black_patches_;
    float probability_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomResizeMethod final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomResizeMethod) */ {
 public:
  inline RandomResizeMethod() : RandomResizeMethod(nullptr) {}
  ~RandomResizeMethod() override;
  explicit PROTOBUF_CONSTEXPR RandomResizeMethod(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomResizeMethod(const RandomResizeMethod& from);
  RandomResizeMethod(RandomResizeMethod&& from) noexcept
    : RandomResizeMethod() {
    *this = ::std::move(from);
  }

  inline RandomResizeMethod& operator=(const RandomResizeMethod& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomResizeMethod& operator=(RandomResizeMethod&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomResizeMethod& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomResizeMethod* internal_default_instance() {
    return reinterpret_cast<const RandomResizeMethod*>(
               &_RandomResizeMethod_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(RandomResizeMethod& a, RandomResizeMethod& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomResizeMethod* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomResizeMethod* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomResizeMethod* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomResizeMethod>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomResizeMethod& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomResizeMethod& from) {
    RandomResizeMethod::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomResizeMethod* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomResizeMethod";
  }
  protected:
  explicit RandomResizeMethod(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTargetHeightFieldNumber = 1,
    kTargetWidthFieldNumber = 2,
  };
  // optional int32 target_height = 1;
  bool has_target_height() const;
  private:
  bool _internal_has_target_height() const;
  public:
  void clear_target_height();
  int32_t target_height() const;
  void set_target_height(int32_t value);
  private:
  int32_t _internal_target_height() const;
  void _internal_set_target_height(int32_t value);
  public:

  // optional int32 target_width = 2;
  bool has_target_width() const;
  private:
  bool _internal_has_target_width() const;
  public:
  void clear_target_width();
  int32_t target_width() const;
  void set_target_width(int32_t value);
  private:
  int32_t _internal_target_width() const;
  void _internal_set_target_width(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomResizeMethod)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t target_height_;
    int32_t target_width_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RGBtoGray final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:object_detection.protos.RGBtoGray) */ {
 public:
  inline RGBtoGray() : RGBtoGray(nullptr) {}
  explicit PROTOBUF_CONSTEXPR RGBtoGray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RGBtoGray(const RGBtoGray& from);
  RGBtoGray(RGBtoGray&& from) noexcept
    : RGBtoGray() {
    *this = ::std::move(from);
  }

  inline RGBtoGray& operator=(const RGBtoGray& from) {
    CopyFrom(from);
    return *this;
  }
  inline RGBtoGray& operator=(RGBtoGray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RGBtoGray& default_instance() {
    return *internal_default_instance();
  }
  static inline const RGBtoGray* internal_default_instance() {
    return reinterpret_cast<const RGBtoGray*>(
               &_RGBtoGray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(RGBtoGray& a, RGBtoGray& b) {
    a.Swap(&b);
  }
  inline void Swap(RGBtoGray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RGBtoGray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RGBtoGray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RGBtoGray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const RGBtoGray& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const RGBtoGray& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RGBtoGray";
  }
  protected:
  explicit RGBtoGray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:object_detection.protos.RGBtoGray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class ScaleBoxesToPixelCoordinates final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:object_detection.protos.ScaleBoxesToPixelCoordinates) */ {
 public:
  inline ScaleBoxesToPixelCoordinates() : ScaleBoxesToPixelCoordinates(nullptr) {}
  explicit PROTOBUF_CONSTEXPR ScaleBoxesToPixelCoordinates(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ScaleBoxesToPixelCoordinates(const ScaleBoxesToPixelCoordinates& from);
  ScaleBoxesToPixelCoordinates(ScaleBoxesToPixelCoordinates&& from) noexcept
    : ScaleBoxesToPixelCoordinates() {
    *this = ::std::move(from);
  }

  inline ScaleBoxesToPixelCoordinates& operator=(const ScaleBoxesToPixelCoordinates& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScaleBoxesToPixelCoordinates& operator=(ScaleBoxesToPixelCoordinates&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScaleBoxesToPixelCoordinates& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScaleBoxesToPixelCoordinates* internal_default_instance() {
    return reinterpret_cast<const ScaleBoxesToPixelCoordinates*>(
               &_ScaleBoxesToPixelCoordinates_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(ScaleBoxesToPixelCoordinates& a, ScaleBoxesToPixelCoordinates& b) {
    a.Swap(&b);
  }
  inline void Swap(ScaleBoxesToPixelCoordinates* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScaleBoxesToPixelCoordinates* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ScaleBoxesToPixelCoordinates* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ScaleBoxesToPixelCoordinates>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const ScaleBoxesToPixelCoordinates& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const ScaleBoxesToPixelCoordinates& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.ScaleBoxesToPixelCoordinates";
  }
  protected:
  explicit ScaleBoxesToPixelCoordinates(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:object_detection.protos.ScaleBoxesToPixelCoordinates)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class ResizeImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.ResizeImage) */ {
 public:
  inline ResizeImage() : ResizeImage(nullptr) {}
  ~ResizeImage() override;
  explicit PROTOBUF_CONSTEXPR ResizeImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ResizeImage(const ResizeImage& from);
  ResizeImage(ResizeImage&& from) noexcept
    : ResizeImage() {
    *this = ::std::move(from);
  }

  inline ResizeImage& operator=(const ResizeImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline ResizeImage& operator=(ResizeImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ResizeImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const ResizeImage* internal_default_instance() {
    return reinterpret_cast<const ResizeImage*>(
               &_ResizeImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(ResizeImage& a, ResizeImage& b) {
    a.Swap(&b);
  }
  inline void Swap(ResizeImage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ResizeImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ResizeImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ResizeImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ResizeImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ResizeImage& from) {
    ResizeImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ResizeImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.ResizeImage";
  }
  protected:
  explicit ResizeImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef ResizeImage_Method Method;
  static constexpr Method AREA =
    ResizeImage_Method_AREA;
  static constexpr Method BICUBIC =
    ResizeImage_Method_BICUBIC;
  static constexpr Method BILINEAR =
    ResizeImage_Method_BILINEAR;
  static constexpr Method NEAREST_NEIGHBOR =
    ResizeImage_Method_NEAREST_NEIGHBOR;
  static inline bool Method_IsValid(int value) {
    return ResizeImage_Method_IsValid(value);
  }
  static constexpr Method Method_MIN =
    ResizeImage_Method_Method_MIN;
  static constexpr Method Method_MAX =
    ResizeImage_Method_Method_MAX;
  static constexpr int Method_ARRAYSIZE =
    ResizeImage_Method_Method_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Method_descriptor() {
    return ResizeImage_Method_descriptor();
  }
  template<typename T>
  static inline const std::string& Method_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Method>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Method_Name.");
    return ResizeImage_Method_Name(enum_t_value);
  }
  static inline bool Method_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Method* value) {
    return ResizeImage_Method_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kNewHeightFieldNumber = 1,
    kNewWidthFieldNumber = 2,
    kMethodFieldNumber = 3,
  };
  // optional int32 new_height = 1;
  bool has_new_height() const;
  private:
  bool _internal_has_new_height() const;
  public:
  void clear_new_height();
  int32_t new_height() const;
  void set_new_height(int32_t value);
  private:
  int32_t _internal_new_height() const;
  void _internal_set_new_height(int32_t value);
  public:

  // optional int32 new_width = 2;
  bool has_new_width() const;
  private:
  bool _internal_has_new_width() const;
  public:
  void clear_new_width();
  int32_t new_width() const;
  void set_new_width(int32_t value);
  private:
  int32_t _internal_new_width() const;
  void _internal_set_new_width(int32_t value);
  public:

  // optional .object_detection.protos.ResizeImage.Method method = 3 [default = BILINEAR];
  bool has_method() const;
  private:
  bool _internal_has_method() const;
  public:
  void clear_method();
  ::object_detection::protos::ResizeImage_Method method() const;
  void set_method(::object_detection::protos::ResizeImage_Method value);
  private:
  ::object_detection::protos::ResizeImage_Method _internal_method() const;
  void _internal_set_method(::object_detection::protos::ResizeImage_Method value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.ResizeImage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t new_height_;
    int32_t new_width_;
    int method_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SubtractChannelMean final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SubtractChannelMean) */ {
 public:
  inline SubtractChannelMean() : SubtractChannelMean(nullptr) {}
  ~SubtractChannelMean() override;
  explicit PROTOBUF_CONSTEXPR SubtractChannelMean(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SubtractChannelMean(const SubtractChannelMean& from);
  SubtractChannelMean(SubtractChannelMean&& from) noexcept
    : SubtractChannelMean() {
    *this = ::std::move(from);
  }

  inline SubtractChannelMean& operator=(const SubtractChannelMean& from) {
    CopyFrom(from);
    return *this;
  }
  inline SubtractChannelMean& operator=(SubtractChannelMean&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SubtractChannelMean& default_instance() {
    return *internal_default_instance();
  }
  static inline const SubtractChannelMean* internal_default_instance() {
    return reinterpret_cast<const SubtractChannelMean*>(
               &_SubtractChannelMean_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(SubtractChannelMean& a, SubtractChannelMean& b) {
    a.Swap(&b);
  }
  inline void Swap(SubtractChannelMean* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubtractChannelMean* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SubtractChannelMean* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SubtractChannelMean>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SubtractChannelMean& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SubtractChannelMean& from) {
    SubtractChannelMean::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SubtractChannelMean* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SubtractChannelMean";
  }
  protected:
  explicit SubtractChannelMean(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMeansFieldNumber = 1,
  };
  // repeated float means = 1;
  int means_size() const;
  private:
  int _internal_means_size() const;
  public:
  void clear_means();
  private:
  float _internal_means(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_means() const;
  void _internal_add_means(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_means();
  public:
  float means(int index) const;
  void set_means(int index, float value);
  void add_means(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      means() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_means();

  // @@protoc_insertion_point(class_scope:object_detection.protos.SubtractChannelMean)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > means_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SSDRandomCropOperation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SSDRandomCropOperation) */ {
 public:
  inline SSDRandomCropOperation() : SSDRandomCropOperation(nullptr) {}
  ~SSDRandomCropOperation() override;
  explicit PROTOBUF_CONSTEXPR SSDRandomCropOperation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SSDRandomCropOperation(const SSDRandomCropOperation& from);
  SSDRandomCropOperation(SSDRandomCropOperation&& from) noexcept
    : SSDRandomCropOperation() {
    *this = ::std::move(from);
  }

  inline SSDRandomCropOperation& operator=(const SSDRandomCropOperation& from) {
    CopyFrom(from);
    return *this;
  }
  inline SSDRandomCropOperation& operator=(SSDRandomCropOperation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SSDRandomCropOperation& default_instance() {
    return *internal_default_instance();
  }
  static inline const SSDRandomCropOperation* internal_default_instance() {
    return reinterpret_cast<const SSDRandomCropOperation*>(
               &_SSDRandomCropOperation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(SSDRandomCropOperation& a, SSDRandomCropOperation& b) {
    a.Swap(&b);
  }
  inline void Swap(SSDRandomCropOperation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SSDRandomCropOperation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SSDRandomCropOperation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SSDRandomCropOperation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SSDRandomCropOperation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SSDRandomCropOperation& from) {
    SSDRandomCropOperation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SSDRandomCropOperation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SSDRandomCropOperation";
  }
  protected:
  explicit SSDRandomCropOperation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinObjectCoveredFieldNumber = 1,
    kMinAspectRatioFieldNumber = 2,
    kMaxAspectRatioFieldNumber = 3,
    kMinAreaFieldNumber = 4,
    kMaxAreaFieldNumber = 5,
    kOverlapThreshFieldNumber = 6,
    kRandomCoefFieldNumber = 7,
    kClipBoxesFieldNumber = 8,
  };
  // optional float min_object_covered = 1;
  bool has_min_object_covered() const;
  private:
  bool _internal_has_min_object_covered() const;
  public:
  void clear_min_object_covered();
  float min_object_covered() const;
  void set_min_object_covered(float value);
  private:
  float _internal_min_object_covered() const;
  void _internal_set_min_object_covered(float value);
  public:

  // optional float min_aspect_ratio = 2;
  bool has_min_aspect_ratio() const;
  private:
  bool _internal_has_min_aspect_ratio() const;
  public:
  void clear_min_aspect_ratio();
  float min_aspect_ratio() const;
  void set_min_aspect_ratio(float value);
  private:
  float _internal_min_aspect_ratio() const;
  void _internal_set_min_aspect_ratio(float value);
  public:

  // optional float max_aspect_ratio = 3;
  bool has_max_aspect_ratio() const;
  private:
  bool _internal_has_max_aspect_ratio() const;
  public:
  void clear_max_aspect_ratio();
  float max_aspect_ratio() const;
  void set_max_aspect_ratio(float value);
  private:
  float _internal_max_aspect_ratio() const;
  void _internal_set_max_aspect_ratio(float value);
  public:

  // optional float min_area = 4;
  bool has_min_area() const;
  private:
  bool _internal_has_min_area() const;
  public:
  void clear_min_area();
  float min_area() const;
  void set_min_area(float value);
  private:
  float _internal_min_area() const;
  void _internal_set_min_area(float value);
  public:

  // optional float max_area = 5;
  bool has_max_area() const;
  private:
  bool _internal_has_max_area() const;
  public:
  void clear_max_area();
  float max_area() const;
  void set_max_area(float value);
  private:
  float _internal_max_area() const;
  void _internal_set_max_area(float value);
  public:

  // optional float overlap_thresh = 6;
  bool has_overlap_thresh() const;
  private:
  bool _internal_has_overlap_thresh() const;
  public:
  void clear_overlap_thresh();
  float overlap_thresh() const;
  void set_overlap_thresh(float value);
  private:
  float _internal_overlap_thresh() const;
  void _internal_set_overlap_thresh(float value);
  public:

  // optional float random_coef = 7;
  bool has_random_coef() const;
  private:
  bool _internal_has_random_coef() const;
  public:
  void clear_random_coef();
  float random_coef() const;
  void set_random_coef(float value);
  private:
  float _internal_random_coef() const;
  void _internal_set_random_coef(float value);
  public:

  // optional bool clip_boxes = 8 [default = true];
  bool has_clip_boxes() const;
  private:
  bool _internal_has_clip_boxes() const;
  public:
  void clear_clip_boxes();
  bool clip_boxes() const;
  void set_clip_boxes(bool value);
  private:
  bool _internal_clip_boxes() const;
  void _internal_set_clip_boxes(bool value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropOperation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float min_object_covered_;
    float min_aspect_ratio_;
    float max_aspect_ratio_;
    float min_area_;
    float max_area_;
    float overlap_thresh_;
    float random_coef_;
    bool clip_boxes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SSDRandomCrop final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SSDRandomCrop) */ {
 public:
  inline SSDRandomCrop() : SSDRandomCrop(nullptr) {}
  ~SSDRandomCrop() override;
  explicit PROTOBUF_CONSTEXPR SSDRandomCrop(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SSDRandomCrop(const SSDRandomCrop& from);
  SSDRandomCrop(SSDRandomCrop&& from) noexcept
    : SSDRandomCrop() {
    *this = ::std::move(from);
  }

  inline SSDRandomCrop& operator=(const SSDRandomCrop& from) {
    CopyFrom(from);
    return *this;
  }
  inline SSDRandomCrop& operator=(SSDRandomCrop&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SSDRandomCrop& default_instance() {
    return *internal_default_instance();
  }
  static inline const SSDRandomCrop* internal_default_instance() {
    return reinterpret_cast<const SSDRandomCrop*>(
               &_SSDRandomCrop_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(SSDRandomCrop& a, SSDRandomCrop& b) {
    a.Swap(&b);
  }
  inline void Swap(SSDRandomCrop* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SSDRandomCrop* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SSDRandomCrop* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SSDRandomCrop>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SSDRandomCrop& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SSDRandomCrop& from) {
    SSDRandomCrop::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SSDRandomCrop* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SSDRandomCrop";
  }
  protected:
  explicit SSDRandomCrop(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOperationsFieldNumber = 1,
  };
  // repeated .object_detection.protos.SSDRandomCropOperation operations = 1;
  int operations_size() const;
  private:
  int _internal_operations_size() const;
  public:
  void clear_operations();
  ::object_detection::protos::SSDRandomCropOperation* mutable_operations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropOperation >*
      mutable_operations();
  private:
  const ::object_detection::protos::SSDRandomCropOperation& _internal_operations(int index) const;
  ::object_detection::protos::SSDRandomCropOperation* _internal_add_operations();
  public:
  const ::object_detection::protos::SSDRandomCropOperation& operations(int index) const;
  ::object_detection::protos::SSDRandomCropOperation* add_operations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropOperation >&
      operations() const;

  // @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCrop)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropOperation > operations_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SSDRandomCropPadOperation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SSDRandomCropPadOperation) */ {
 public:
  inline SSDRandomCropPadOperation() : SSDRandomCropPadOperation(nullptr) {}
  ~SSDRandomCropPadOperation() override;
  explicit PROTOBUF_CONSTEXPR SSDRandomCropPadOperation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SSDRandomCropPadOperation(const SSDRandomCropPadOperation& from);
  SSDRandomCropPadOperation(SSDRandomCropPadOperation&& from) noexcept
    : SSDRandomCropPadOperation() {
    *this = ::std::move(from);
  }

  inline SSDRandomCropPadOperation& operator=(const SSDRandomCropPadOperation& from) {
    CopyFrom(from);
    return *this;
  }
  inline SSDRandomCropPadOperation& operator=(SSDRandomCropPadOperation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SSDRandomCropPadOperation& default_instance() {
    return *internal_default_instance();
  }
  static inline const SSDRandomCropPadOperation* internal_default_instance() {
    return reinterpret_cast<const SSDRandomCropPadOperation*>(
               &_SSDRandomCropPadOperation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(SSDRandomCropPadOperation& a, SSDRandomCropPadOperation& b) {
    a.Swap(&b);
  }
  inline void Swap(SSDRandomCropPadOperation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SSDRandomCropPadOperation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SSDRandomCropPadOperation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SSDRandomCropPadOperation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SSDRandomCropPadOperation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SSDRandomCropPadOperation& from) {
    SSDRandomCropPadOperation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SSDRandomCropPadOperation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SSDRandomCropPadOperation";
  }
  protected:
  explicit SSDRandomCropPadOperation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinPaddedSizeRatioFieldNumber = 8,
    kMaxPaddedSizeRatioFieldNumber = 9,
    kMinObjectCoveredFieldNumber = 1,
    kMinAspectRatioFieldNumber = 2,
    kMaxAspectRatioFieldNumber = 3,
    kMinAreaFieldNumber = 4,
    kMaxAreaFieldNumber = 5,
    kOverlapThreshFieldNumber = 6,
    kRandomCoefFieldNumber = 7,
    kPadColorRFieldNumber = 10,
    kPadColorGFieldNumber = 11,
    kPadColorBFieldNumber = 12,
    kClipBoxesFieldNumber = 13,
  };
  // repeated float min_padded_size_ratio = 8;
  int min_padded_size_ratio_size() const;
  private:
  int _internal_min_padded_size_ratio_size() const;
  public:
  void clear_min_padded_size_ratio();
  private:
  float _internal_min_padded_size_ratio(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_min_padded_size_ratio() const;
  void _internal_add_min_padded_size_ratio(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_min_padded_size_ratio();
  public:
  float min_padded_size_ratio(int index) const;
  void set_min_padded_size_ratio(int index, float value);
  void add_min_padded_size_ratio(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      min_padded_size_ratio() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_min_padded_size_ratio();

  // repeated float max_padded_size_ratio = 9;
  int max_padded_size_ratio_size() const;
  private:
  int _internal_max_padded_size_ratio_size() const;
  public:
  void clear_max_padded_size_ratio();
  private:
  float _internal_max_padded_size_ratio(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_max_padded_size_ratio() const;
  void _internal_add_max_padded_size_ratio(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_max_padded_size_ratio();
  public:
  float max_padded_size_ratio(int index) const;
  void set_max_padded_size_ratio(int index, float value);
  void add_max_padded_size_ratio(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      max_padded_size_ratio() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_max_padded_size_ratio();

  // optional float min_object_covered = 1;
  bool has_min_object_covered() const;
  private:
  bool _internal_has_min_object_covered() const;
  public:
  void clear_min_object_covered();
  float min_object_covered() const;
  void set_min_object_covered(float value);
  private:
  float _internal_min_object_covered() const;
  void _internal_set_min_object_covered(float value);
  public:

  // optional float min_aspect_ratio = 2;
  bool has_min_aspect_ratio() const;
  private:
  bool _internal_has_min_aspect_ratio() const;
  public:
  void clear_min_aspect_ratio();
  float min_aspect_ratio() const;
  void set_min_aspect_ratio(float value);
  private:
  float _internal_min_aspect_ratio() const;
  void _internal_set_min_aspect_ratio(float value);
  public:

  // optional float max_aspect_ratio = 3;
  bool has_max_aspect_ratio() const;
  private:
  bool _internal_has_max_aspect_ratio() const;
  public:
  void clear_max_aspect_ratio();
  float max_aspect_ratio() const;
  void set_max_aspect_ratio(float value);
  private:
  float _internal_max_aspect_ratio() const;
  void _internal_set_max_aspect_ratio(float value);
  public:

  // optional float min_area = 4;
  bool has_min_area() const;
  private:
  bool _internal_has_min_area() const;
  public:
  void clear_min_area();
  float min_area() const;
  void set_min_area(float value);
  private:
  float _internal_min_area() const;
  void _internal_set_min_area(float value);
  public:

  // optional float max_area = 5;
  bool has_max_area() const;
  private:
  bool _internal_has_max_area() const;
  public:
  void clear_max_area();
  float max_area() const;
  void set_max_area(float value);
  private:
  float _internal_max_area() const;
  void _internal_set_max_area(float value);
  public:

  // optional float overlap_thresh = 6;
  bool has_overlap_thresh() const;
  private:
  bool _internal_has_overlap_thresh() const;
  public:
  void clear_overlap_thresh();
  float overlap_thresh() const;
  void set_overlap_thresh(float value);
  private:
  float _internal_overlap_thresh() const;
  void _internal_set_overlap_thresh(float value);
  public:

  // optional float random_coef = 7;
  bool has_random_coef() const;
  private:
  bool _internal_has_random_coef() const;
  public:
  void clear_random_coef();
  float random_coef() const;
  void set_random_coef(float value);
  private:
  float _internal_random_coef() const;
  void _internal_set_random_coef(float value);
  public:

  // optional float pad_color_r = 10;
  bool has_pad_color_r() const;
  private:
  bool _internal_has_pad_color_r() const;
  public:
  void clear_pad_color_r();
  float pad_color_r() const;
  void set_pad_color_r(float value);
  private:
  float _internal_pad_color_r() const;
  void _internal_set_pad_color_r(float value);
  public:

  // optional float pad_color_g = 11;
  bool has_pad_color_g() const;
  private:
  bool _internal_has_pad_color_g() const;
  public:
  void clear_pad_color_g();
  float pad_color_g() const;
  void set_pad_color_g(float value);
  private:
  float _internal_pad_color_g() const;
  void _internal_set_pad_color_g(float value);
  public:

  // optional float pad_color_b = 12;
  bool has_pad_color_b() const;
  private:
  bool _internal_has_pad_color_b() const;
  public:
  void clear_pad_color_b();
  float pad_color_b() const;
  void set_pad_color_b(float value);
  private:
  float _internal_pad_color_b() const;
  void _internal_set_pad_color_b(float value);
  public:

  // optional bool clip_boxes = 13 [default = true];
  bool has_clip_boxes() const;
  private:
  bool _internal_has_clip_boxes() const;
  public:
  void clear_clip_boxes();
  bool clip_boxes() const;
  void set_clip_boxes(bool value);
  private:
  bool _internal_clip_boxes() const;
  void _internal_set_clip_boxes(bool value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropPadOperation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > min_padded_size_ratio_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > max_padded_size_ratio_;
    float min_object_covered_;
    float min_aspect_ratio_;
    float max_aspect_ratio_;
    float min_area_;
    float max_area_;
    float overlap_thresh_;
    float random_coef_;
    float pad_color_r_;
    float pad_color_g_;
    float pad_color_b_;
    bool clip_boxes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SSDRandomCropPad final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SSDRandomCropPad) */ {
 public:
  inline SSDRandomCropPad() : SSDRandomCropPad(nullptr) {}
  ~SSDRandomCropPad() override;
  explicit PROTOBUF_CONSTEXPR SSDRandomCropPad(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SSDRandomCropPad(const SSDRandomCropPad& from);
  SSDRandomCropPad(SSDRandomCropPad&& from) noexcept
    : SSDRandomCropPad() {
    *this = ::std::move(from);
  }

  inline SSDRandomCropPad& operator=(const SSDRandomCropPad& from) {
    CopyFrom(from);
    return *this;
  }
  inline SSDRandomCropPad& operator=(SSDRandomCropPad&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SSDRandomCropPad& default_instance() {
    return *internal_default_instance();
  }
  static inline const SSDRandomCropPad* internal_default_instance() {
    return reinterpret_cast<const SSDRandomCropPad*>(
               &_SSDRandomCropPad_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(SSDRandomCropPad& a, SSDRandomCropPad& b) {
    a.Swap(&b);
  }
  inline void Swap(SSDRandomCropPad* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SSDRandomCropPad* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SSDRandomCropPad* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SSDRandomCropPad>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SSDRandomCropPad& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SSDRandomCropPad& from) {
    SSDRandomCropPad::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SSDRandomCropPad* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SSDRandomCropPad";
  }
  protected:
  explicit SSDRandomCropPad(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOperationsFieldNumber = 1,
  };
  // repeated .object_detection.protos.SSDRandomCropPadOperation operations = 1;
  int operations_size() const;
  private:
  int _internal_operations_size() const;
  public:
  void clear_operations();
  ::object_detection::protos::SSDRandomCropPadOperation* mutable_operations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadOperation >*
      mutable_operations();
  private:
  const ::object_detection::protos::SSDRandomCropPadOperation& _internal_operations(int index) const;
  ::object_detection::protos::SSDRandomCropPadOperation* _internal_add_operations();
  public:
  const ::object_detection::protos::SSDRandomCropPadOperation& operations(int index) const;
  ::object_detection::protos::SSDRandomCropPadOperation* add_operations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadOperation >&
      operations() const;

  // @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropPad)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadOperation > operations_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SSDRandomCropFixedAspectRatioOperation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SSDRandomCropFixedAspectRatioOperation) */ {
 public:
  inline SSDRandomCropFixedAspectRatioOperation() : SSDRandomCropFixedAspectRatioOperation(nullptr) {}
  ~SSDRandomCropFixedAspectRatioOperation() override;
  explicit PROTOBUF_CONSTEXPR SSDRandomCropFixedAspectRatioOperation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SSDRandomCropFixedAspectRatioOperation(const SSDRandomCropFixedAspectRatioOperation& from);
  SSDRandomCropFixedAspectRatioOperation(SSDRandomCropFixedAspectRatioOperation&& from) noexcept
    : SSDRandomCropFixedAspectRatioOperation() {
    *this = ::std::move(from);
  }

  inline SSDRandomCropFixedAspectRatioOperation& operator=(const SSDRandomCropFixedAspectRatioOperation& from) {
    CopyFrom(from);
    return *this;
  }
  inline SSDRandomCropFixedAspectRatioOperation& operator=(SSDRandomCropFixedAspectRatioOperation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SSDRandomCropFixedAspectRatioOperation& default_instance() {
    return *internal_default_instance();
  }
  static inline const SSDRandomCropFixedAspectRatioOperation* internal_default_instance() {
    return reinterpret_cast<const SSDRandomCropFixedAspectRatioOperation*>(
               &_SSDRandomCropFixedAspectRatioOperation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(SSDRandomCropFixedAspectRatioOperation& a, SSDRandomCropFixedAspectRatioOperation& b) {
    a.Swap(&b);
  }
  inline void Swap(SSDRandomCropFixedAspectRatioOperation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SSDRandomCropFixedAspectRatioOperation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SSDRandomCropFixedAspectRatioOperation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SSDRandomCropFixedAspectRatioOperation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SSDRandomCropFixedAspectRatioOperation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SSDRandomCropFixedAspectRatioOperation& from) {
    SSDRandomCropFixedAspectRatioOperation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SSDRandomCropFixedAspectRatioOperation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SSDRandomCropFixedAspectRatioOperation";
  }
  protected:
  explicit SSDRandomCropFixedAspectRatioOperation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinObjectCoveredFieldNumber = 1,
    kMinAreaFieldNumber = 4,
    kMaxAreaFieldNumber = 5,
    kOverlapThreshFieldNumber = 6,
    kRandomCoefFieldNumber = 7,
    kClipBoxesFieldNumber = 8,
  };
  // optional float min_object_covered = 1;
  bool has_min_object_covered() const;
  private:
  bool _internal_has_min_object_covered() const;
  public:
  void clear_min_object_covered();
  float min_object_covered() const;
  void set_min_object_covered(float value);
  private:
  float _internal_min_object_covered() const;
  void _internal_set_min_object_covered(float value);
  public:

  // optional float min_area = 4;
  bool has_min_area() const;
  private:
  bool _internal_has_min_area() const;
  public:
  void clear_min_area();
  float min_area() const;
  void set_min_area(float value);
  private:
  float _internal_min_area() const;
  void _internal_set_min_area(float value);
  public:

  // optional float max_area = 5;
  bool has_max_area() const;
  private:
  bool _internal_has_max_area() const;
  public:
  void clear_max_area();
  float max_area() const;
  void set_max_area(float value);
  private:
  float _internal_max_area() const;
  void _internal_set_max_area(float value);
  public:

  // optional float overlap_thresh = 6;
  bool has_overlap_thresh() const;
  private:
  bool _internal_has_overlap_thresh() const;
  public:
  void clear_overlap_thresh();
  float overlap_thresh() const;
  void set_overlap_thresh(float value);
  private:
  float _internal_overlap_thresh() const;
  void _internal_set_overlap_thresh(float value);
  public:

  // optional float random_coef = 7;
  bool has_random_coef() const;
  private:
  bool _internal_has_random_coef() const;
  public:
  void clear_random_coef();
  float random_coef() const;
  void set_random_coef(float value);
  private:
  float _internal_random_coef() const;
  void _internal_set_random_coef(float value);
  public:

  // optional bool clip_boxes = 8 [default = true];
  bool has_clip_boxes() const;
  private:
  bool _internal_has_clip_boxes() const;
  public:
  void clear_clip_boxes();
  bool clip_boxes() const;
  void set_clip_boxes(bool value);
  private:
  bool _internal_clip_boxes() const;
  void _internal_set_clip_boxes(bool value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropFixedAspectRatioOperation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float min_object_covered_;
    float min_area_;
    float max_area_;
    float overlap_thresh_;
    float random_coef_;
    bool clip_boxes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SSDRandomCropFixedAspectRatio final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SSDRandomCropFixedAspectRatio) */ {
 public:
  inline SSDRandomCropFixedAspectRatio() : SSDRandomCropFixedAspectRatio(nullptr) {}
  ~SSDRandomCropFixedAspectRatio() override;
  explicit PROTOBUF_CONSTEXPR SSDRandomCropFixedAspectRatio(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SSDRandomCropFixedAspectRatio(const SSDRandomCropFixedAspectRatio& from);
  SSDRandomCropFixedAspectRatio(SSDRandomCropFixedAspectRatio&& from) noexcept
    : SSDRandomCropFixedAspectRatio() {
    *this = ::std::move(from);
  }

  inline SSDRandomCropFixedAspectRatio& operator=(const SSDRandomCropFixedAspectRatio& from) {
    CopyFrom(from);
    return *this;
  }
  inline SSDRandomCropFixedAspectRatio& operator=(SSDRandomCropFixedAspectRatio&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SSDRandomCropFixedAspectRatio& default_instance() {
    return *internal_default_instance();
  }
  static inline const SSDRandomCropFixedAspectRatio* internal_default_instance() {
    return reinterpret_cast<const SSDRandomCropFixedAspectRatio*>(
               &_SSDRandomCropFixedAspectRatio_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  friend void swap(SSDRandomCropFixedAspectRatio& a, SSDRandomCropFixedAspectRatio& b) {
    a.Swap(&b);
  }
  inline void Swap(SSDRandomCropFixedAspectRatio* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SSDRandomCropFixedAspectRatio* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SSDRandomCropFixedAspectRatio* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SSDRandomCropFixedAspectRatio>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SSDRandomCropFixedAspectRatio& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SSDRandomCropFixedAspectRatio& from) {
    SSDRandomCropFixedAspectRatio::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SSDRandomCropFixedAspectRatio* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SSDRandomCropFixedAspectRatio";
  }
  protected:
  explicit SSDRandomCropFixedAspectRatio(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOperationsFieldNumber = 1,
    kAspectRatioFieldNumber = 2,
  };
  // repeated .object_detection.protos.SSDRandomCropFixedAspectRatioOperation operations = 1;
  int operations_size() const;
  private:
  int _internal_operations_size() const;
  public:
  void clear_operations();
  ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation* mutable_operations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation >*
      mutable_operations();
  private:
  const ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation& _internal_operations(int index) const;
  ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation* _internal_add_operations();
  public:
  const ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation& operations(int index) const;
  ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation* add_operations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation >&
      operations() const;

  // optional float aspect_ratio = 2 [default = 1];
  bool has_aspect_ratio() const;
  private:
  bool _internal_has_aspect_ratio() const;
  public:
  void clear_aspect_ratio();
  float aspect_ratio() const;
  void set_aspect_ratio(float value);
  private:
  float _internal_aspect_ratio() const;
  void _internal_set_aspect_ratio(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropFixedAspectRatio)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation > operations_;
    float aspect_ratio_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SSDRandomCropPadFixedAspectRatioOperation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation) */ {
 public:
  inline SSDRandomCropPadFixedAspectRatioOperation() : SSDRandomCropPadFixedAspectRatioOperation(nullptr) {}
  ~SSDRandomCropPadFixedAspectRatioOperation() override;
  explicit PROTOBUF_CONSTEXPR SSDRandomCropPadFixedAspectRatioOperation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SSDRandomCropPadFixedAspectRatioOperation(const SSDRandomCropPadFixedAspectRatioOperation& from);
  SSDRandomCropPadFixedAspectRatioOperation(SSDRandomCropPadFixedAspectRatioOperation&& from) noexcept
    : SSDRandomCropPadFixedAspectRatioOperation() {
    *this = ::std::move(from);
  }

  inline SSDRandomCropPadFixedAspectRatioOperation& operator=(const SSDRandomCropPadFixedAspectRatioOperation& from) {
    CopyFrom(from);
    return *this;
  }
  inline SSDRandomCropPadFixedAspectRatioOperation& operator=(SSDRandomCropPadFixedAspectRatioOperation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SSDRandomCropPadFixedAspectRatioOperation& default_instance() {
    return *internal_default_instance();
  }
  static inline const SSDRandomCropPadFixedAspectRatioOperation* internal_default_instance() {
    return reinterpret_cast<const SSDRandomCropPadFixedAspectRatioOperation*>(
               &_SSDRandomCropPadFixedAspectRatioOperation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  friend void swap(SSDRandomCropPadFixedAspectRatioOperation& a, SSDRandomCropPadFixedAspectRatioOperation& b) {
    a.Swap(&b);
  }
  inline void Swap(SSDRandomCropPadFixedAspectRatioOperation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SSDRandomCropPadFixedAspectRatioOperation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SSDRandomCropPadFixedAspectRatioOperation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SSDRandomCropPadFixedAspectRatioOperation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SSDRandomCropPadFixedAspectRatioOperation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SSDRandomCropPadFixedAspectRatioOperation& from) {
    SSDRandomCropPadFixedAspectRatioOperation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SSDRandomCropPadFixedAspectRatioOperation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation";
  }
  protected:
  explicit SSDRandomCropPadFixedAspectRatioOperation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMinObjectCoveredFieldNumber = 1,
    kMinAspectRatioFieldNumber = 2,
    kMaxAspectRatioFieldNumber = 3,
    kMinAreaFieldNumber = 4,
    kMaxAreaFieldNumber = 5,
    kOverlapThreshFieldNumber = 6,
    kRandomCoefFieldNumber = 7,
    kClipBoxesFieldNumber = 8,
  };
  // optional float min_object_covered = 1;
  bool has_min_object_covered() const;
  private:
  bool _internal_has_min_object_covered() const;
  public:
  void clear_min_object_covered();
  float min_object_covered() const;
  void set_min_object_covered(float value);
  private:
  float _internal_min_object_covered() const;
  void _internal_set_min_object_covered(float value);
  public:

  // optional float min_aspect_ratio = 2;
  bool has_min_aspect_ratio() const;
  private:
  bool _internal_has_min_aspect_ratio() const;
  public:
  void clear_min_aspect_ratio();
  float min_aspect_ratio() const;
  void set_min_aspect_ratio(float value);
  private:
  float _internal_min_aspect_ratio() const;
  void _internal_set_min_aspect_ratio(float value);
  public:

  // optional float max_aspect_ratio = 3;
  bool has_max_aspect_ratio() const;
  private:
  bool _internal_has_max_aspect_ratio() const;
  public:
  void clear_max_aspect_ratio();
  float max_aspect_ratio() const;
  void set_max_aspect_ratio(float value);
  private:
  float _internal_max_aspect_ratio() const;
  void _internal_set_max_aspect_ratio(float value);
  public:

  // optional float min_area = 4;
  bool has_min_area() const;
  private:
  bool _internal_has_min_area() const;
  public:
  void clear_min_area();
  float min_area() const;
  void set_min_area(float value);
  private:
  float _internal_min_area() const;
  void _internal_set_min_area(float value);
  public:

  // optional float max_area = 5;
  bool has_max_area() const;
  private:
  bool _internal_has_max_area() const;
  public:
  void clear_max_area();
  float max_area() const;
  void set_max_area(float value);
  private:
  float _internal_max_area() const;
  void _internal_set_max_area(float value);
  public:

  // optional float overlap_thresh = 6;
  bool has_overlap_thresh() const;
  private:
  bool _internal_has_overlap_thresh() const;
  public:
  void clear_overlap_thresh();
  float overlap_thresh() const;
  void set_overlap_thresh(float value);
  private:
  float _internal_overlap_thresh() const;
  void _internal_set_overlap_thresh(float value);
  public:

  // optional float random_coef = 7;
  bool has_random_coef() const;
  private:
  bool _internal_has_random_coef() const;
  public:
  void clear_random_coef();
  float random_coef() const;
  void set_random_coef(float value);
  private:
  float _internal_random_coef() const;
  void _internal_set_random_coef(float value);
  public:

  // optional bool clip_boxes = 8 [default = true];
  bool has_clip_boxes() const;
  private:
  bool _internal_has_clip_boxes() const;
  public:
  void clear_clip_boxes();
  bool clip_boxes() const;
  void set_clip_boxes(bool value);
  private:
  bool _internal_clip_boxes() const;
  void _internal_set_clip_boxes(bool value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float min_object_covered_;
    float min_aspect_ratio_;
    float max_aspect_ratio_;
    float min_area_;
    float max_area_;
    float overlap_thresh_;
    float random_coef_;
    bool clip_boxes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class SSDRandomCropPadFixedAspectRatio final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.SSDRandomCropPadFixedAspectRatio) */ {
 public:
  inline SSDRandomCropPadFixedAspectRatio() : SSDRandomCropPadFixedAspectRatio(nullptr) {}
  ~SSDRandomCropPadFixedAspectRatio() override;
  explicit PROTOBUF_CONSTEXPR SSDRandomCropPadFixedAspectRatio(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SSDRandomCropPadFixedAspectRatio(const SSDRandomCropPadFixedAspectRatio& from);
  SSDRandomCropPadFixedAspectRatio(SSDRandomCropPadFixedAspectRatio&& from) noexcept
    : SSDRandomCropPadFixedAspectRatio() {
    *this = ::std::move(from);
  }

  inline SSDRandomCropPadFixedAspectRatio& operator=(const SSDRandomCropPadFixedAspectRatio& from) {
    CopyFrom(from);
    return *this;
  }
  inline SSDRandomCropPadFixedAspectRatio& operator=(SSDRandomCropPadFixedAspectRatio&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SSDRandomCropPadFixedAspectRatio& default_instance() {
    return *internal_default_instance();
  }
  static inline const SSDRandomCropPadFixedAspectRatio* internal_default_instance() {
    return reinterpret_cast<const SSDRandomCropPadFixedAspectRatio*>(
               &_SSDRandomCropPadFixedAspectRatio_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(SSDRandomCropPadFixedAspectRatio& a, SSDRandomCropPadFixedAspectRatio& b) {
    a.Swap(&b);
  }
  inline void Swap(SSDRandomCropPadFixedAspectRatio* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SSDRandomCropPadFixedAspectRatio* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SSDRandomCropPadFixedAspectRatio* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SSDRandomCropPadFixedAspectRatio>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SSDRandomCropPadFixedAspectRatio& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SSDRandomCropPadFixedAspectRatio& from) {
    SSDRandomCropPadFixedAspectRatio::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SSDRandomCropPadFixedAspectRatio* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SSDRandomCropPadFixedAspectRatio";
  }
  protected:
  explicit SSDRandomCropPadFixedAspectRatio(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOperationsFieldNumber = 1,
    kMinPaddedSizeRatioFieldNumber = 3,
    kMaxPaddedSizeRatioFieldNumber = 4,
    kAspectRatioFieldNumber = 2,
  };
  // repeated .object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation operations = 1;
  int operations_size() const;
  private:
  int _internal_operations_size() const;
  public:
  void clear_operations();
  ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation* mutable_operations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation >*
      mutable_operations();
  private:
  const ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation& _internal_operations(int index) const;
  ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation* _internal_add_operations();
  public:
  const ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation& operations(int index) const;
  ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation* add_operations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation >&
      operations() const;

  // repeated float min_padded_size_ratio = 3;
  int min_padded_size_ratio_size() const;
  private:
  int _internal_min_padded_size_ratio_size() const;
  public:
  void clear_min_padded_size_ratio();
  private:
  float _internal_min_padded_size_ratio(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_min_padded_size_ratio() const;
  void _internal_add_min_padded_size_ratio(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_min_padded_size_ratio();
  public:
  float min_padded_size_ratio(int index) const;
  void set_min_padded_size_ratio(int index, float value);
  void add_min_padded_size_ratio(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      min_padded_size_ratio() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_min_padded_size_ratio();

  // repeated float max_padded_size_ratio = 4;
  int max_padded_size_ratio_size() const;
  private:
  int _internal_max_padded_size_ratio_size() const;
  public:
  void clear_max_padded_size_ratio();
  private:
  float _internal_max_padded_size_ratio(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_max_padded_size_ratio() const;
  void _internal_add_max_padded_size_ratio(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_max_padded_size_ratio();
  public:
  float max_padded_size_ratio(int index) const;
  void set_max_padded_size_ratio(int index, float value);
  void add_max_padded_size_ratio(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      max_padded_size_ratio() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_max_padded_size_ratio();

  // optional float aspect_ratio = 2 [default = 1];
  bool has_aspect_ratio() const;
  private:
  bool _internal_has_aspect_ratio() const;
  public:
  void clear_aspect_ratio();
  float aspect_ratio() const;
  void set_aspect_ratio(float value);
  private:
  float _internal_aspect_ratio() const;
  void _internal_set_aspect_ratio(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropPadFixedAspectRatio)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation > operations_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > min_padded_size_ratio_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > max_padded_size_ratio_;
    float aspect_ratio_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class ConvertClassLogitsToSoftmax final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.ConvertClassLogitsToSoftmax) */ {
 public:
  inline ConvertClassLogitsToSoftmax() : ConvertClassLogitsToSoftmax(nullptr) {}
  ~ConvertClassLogitsToSoftmax() override;
  explicit PROTOBUF_CONSTEXPR ConvertClassLogitsToSoftmax(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConvertClassLogitsToSoftmax(const ConvertClassLogitsToSoftmax& from);
  ConvertClassLogitsToSoftmax(ConvertClassLogitsToSoftmax&& from) noexcept
    : ConvertClassLogitsToSoftmax() {
    *this = ::std::move(from);
  }

  inline ConvertClassLogitsToSoftmax& operator=(const ConvertClassLogitsToSoftmax& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConvertClassLogitsToSoftmax& operator=(ConvertClassLogitsToSoftmax&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ConvertClassLogitsToSoftmax& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConvertClassLogitsToSoftmax* internal_default_instance() {
    return reinterpret_cast<const ConvertClassLogitsToSoftmax*>(
               &_ConvertClassLogitsToSoftmax_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  friend void swap(ConvertClassLogitsToSoftmax& a, ConvertClassLogitsToSoftmax& b) {
    a.Swap(&b);
  }
  inline void Swap(ConvertClassLogitsToSoftmax* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConvertClassLogitsToSoftmax* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ConvertClassLogitsToSoftmax* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConvertClassLogitsToSoftmax>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ConvertClassLogitsToSoftmax& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ConvertClassLogitsToSoftmax& from) {
    ConvertClassLogitsToSoftmax::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConvertClassLogitsToSoftmax* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.ConvertClassLogitsToSoftmax";
  }
  protected:
  explicit ConvertClassLogitsToSoftmax(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTemperatureFieldNumber = 1,
  };
  // optional float temperature = 1 [default = 1];
  bool has_temperature() const;
  private:
  bool _internal_has_temperature() const;
  public:
  void clear_temperature();
  float temperature() const;
  void set_temperature(float value);
  private:
  float _internal_temperature() const;
  void _internal_set_temperature(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.ConvertClassLogitsToSoftmax)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float temperature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RandomSelfConcatImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomSelfConcatImage) */ {
 public:
  inline RandomSelfConcatImage() : RandomSelfConcatImage(nullptr) {}
  ~RandomSelfConcatImage() override;
  explicit PROTOBUF_CONSTEXPR RandomSelfConcatImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RandomSelfConcatImage(const RandomSelfConcatImage& from);
  RandomSelfConcatImage(RandomSelfConcatImage&& from) noexcept
    : RandomSelfConcatImage() {
    *this = ::std::move(from);
  }

  inline RandomSelfConcatImage& operator=(const RandomSelfConcatImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomSelfConcatImage& operator=(RandomSelfConcatImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomSelfConcatImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const RandomSelfConcatImage* internal_default_instance() {
    return reinterpret_cast<const RandomSelfConcatImage*>(
               &_RandomSelfConcatImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(RandomSelfConcatImage& a, RandomSelfConcatImage& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomSelfConcatImage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomSelfConcatImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RandomSelfConcatImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomSelfConcatImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomSelfConcatImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomSelfConcatImage& from) {
    RandomSelfConcatImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomSelfConcatImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomSelfConcatImage";
  }
  protected:
  explicit RandomSelfConcatImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kConcatVerticalProbabilityFieldNumber = 1,
    kConcatHorizontalProbabilityFieldNumber = 2,
  };
  // optional float concat_vertical_probability = 1 [default = 0.1];
  bool has_concat_vertical_probability() const;
  private:
  bool _internal_has_concat_vertical_probability() const;
  public:
  void clear_concat_vertical_probability();
  float concat_vertical_probability() const;
  void set_concat_vertical_probability(float value);
  private:
  float _internal_concat_vertical_probability() const;
  void _internal_set_concat_vertical_probability(float value);
  public:

  // optional float concat_horizontal_probability = 2 [default = 0.1];
  bool has_concat_horizontal_probability() const;
  private:
  bool _internal_has_concat_horizontal_probability() const;
  public:
  void clear_concat_horizontal_probability();
  float concat_horizontal_probability() const;
  void set_concat_horizontal_probability(float value);
  private:
  float _internal_concat_horizontal_probability() const;
  void _internal_set_concat_horizontal_probability(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomSelfConcatImage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float concat_vertical_probability_;
    float concat_horizontal_probability_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class AutoAugmentImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.AutoAugmentImage) */ {
 public:
  inline AutoAugmentImage() : AutoAugmentImage(nullptr) {}
  ~AutoAugmentImage() override;
  explicit PROTOBUF_CONSTEXPR AutoAugmentImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AutoAugmentImage(const AutoAugmentImage& from);
  AutoAugmentImage(AutoAugmentImage&& from) noexcept
    : AutoAugmentImage() {
    *this = ::std::move(from);
  }

  inline AutoAugmentImage& operator=(const AutoAugmentImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline AutoAugmentImage& operator=(AutoAugmentImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AutoAugmentImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const AutoAugmentImage* internal_default_instance() {
    return reinterpret_cast<const AutoAugmentImage*>(
               &_AutoAugmentImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  friend void swap(AutoAugmentImage& a, AutoAugmentImage& b) {
    a.Swap(&b);
  }
  inline void Swap(AutoAugmentImage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AutoAugmentImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  AutoAugmentImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AutoAugmentImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AutoAugmentImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AutoAugmentImage& from) {
    AutoAugmentImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AutoAugmentImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.AutoAugmentImage";
  }
  protected:
  explicit AutoAugmentImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPolicyNameFieldNumber = 1,
  };
  // optional string policy_name = 1 [default = "v0"];
  bool has_policy_name() const;
  private:
  bool _internal_has_policy_name() const;
  public:
  void clear_policy_name();
  const std::string& policy_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_policy_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_policy_name();
  PROTOBUF_NODISCARD std::string* release_policy_name();
  void set_allocated_policy_name(std::string* policy_name);
  private:
  const std::string& _internal_policy_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_policy_name(const std::string& value);
  std::string* _internal_mutable_policy_name();
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.AutoAugmentImage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_policy_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class DropLabelProbabilistically final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.DropLabelProbabilistically) */ {
 public:
  inline DropLabelProbabilistically() : DropLabelProbabilistically(nullptr) {}
  ~DropLabelProbabilistically() override;
  explicit PROTOBUF_CONSTEXPR DropLabelProbabilistically(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DropLabelProbabilistically(const DropLabelProbabilistically& from);
  DropLabelProbabilistically(DropLabelProbabilistically&& from) noexcept
    : DropLabelProbabilistically() {
    *this = ::std::move(from);
  }

  inline DropLabelProbabilistically& operator=(const DropLabelProbabilistically& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropLabelProbabilistically& operator=(DropLabelProbabilistically&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DropLabelProbabilistically& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropLabelProbabilistically* internal_default_instance() {
    return reinterpret_cast<const DropLabelProbabilistically*>(
               &_DropLabelProbabilistically_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(DropLabelProbabilistically& a, DropLabelProbabilistically& b) {
    a.Swap(&b);
  }
  inline void Swap(DropLabelProbabilistically* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DropLabelProbabilistically* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DropLabelProbabilistically* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropLabelProbabilistically>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DropLabelProbabilistically& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DropLabelProbabilistically& from) {
    DropLabelProbabilistically::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropLabelProbabilistically* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.DropLabelProbabilistically";
  }
  protected:
  explicit DropLabelProbabilistically(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLabelFieldNumber = 1,
    kDropProbabilityFieldNumber = 2,
  };
  // optional int32 label = 1;
  bool has_label() const;
  private:
  bool _internal_has_label() const;
  public:
  void clear_label();
  int32_t label() const;
  void set_label(int32_t value);
  private:
  int32_t _internal_label() const;
  void _internal_set_label(int32_t value);
  public:

  // optional float drop_probability = 2 [default = 1];
  bool has_drop_probability() const;
  private:
  bool _internal_has_drop_probability() const;
  public:
  void clear_drop_probability();
  float drop_probability() const;
  void set_drop_probability(float value);
  private:
  float _internal_drop_probability() const;
  void _internal_set_drop_probability(float value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.DropLabelProbabilistically)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t label_;
    float drop_probability_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// -------------------------------------------------------------------

class RemapLabels final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RemapLabels) */ {
 public:
  inline RemapLabels() : RemapLabels(nullptr) {}
  ~RemapLabels() override;
  explicit PROTOBUF_CONSTEXPR RemapLabels(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RemapLabels(const RemapLabels& from);
  RemapLabels(RemapLabels&& from) noexcept
    : RemapLabels() {
    *this = ::std::move(from);
  }

  inline RemapLabels& operator=(const RemapLabels& from) {
    CopyFrom(from);
    return *this;
  }
  inline RemapLabels& operator=(RemapLabels&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RemapLabels& default_instance() {
    return *internal_default_instance();
  }
  static inline const RemapLabels* internal_default_instance() {
    return reinterpret_cast<const RemapLabels*>(
               &_RemapLabels_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    37;

  friend void swap(RemapLabels& a, RemapLabels& b) {
    a.Swap(&b);
  }
  inline void Swap(RemapLabels* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RemapLabels* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RemapLabels* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RemapLabels>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RemapLabels& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RemapLabels& from) {
    RemapLabels::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RemapLabels* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RemapLabels";
  }
  protected:
  explicit RemapLabels(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOriginalLabelsFieldNumber = 1,
    kNewLabelFieldNumber = 2,
  };
  // repeated int32 original_labels = 1;
  int original_labels_size() const;
  private:
  int _internal_original_labels_size() const;
  public:
  void clear_original_labels();
  private:
  int32_t _internal_original_labels(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_original_labels() const;
  void _internal_add_original_labels(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_original_labels();
  public:
  int32_t original_labels(int index) const;
  void set_original_labels(int index, int32_t value);
  void add_original_labels(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      original_labels() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_original_labels();

  // optional int32 new_label = 2;
  bool has_new_label() const;
  private:
  bool _internal_has_new_label() const;
  public:
  void clear_new_label();
  int32_t new_label() const;
  void set_new_label(int32_t value);
  private:
  int32_t _internal_new_label() const;
  void _internal_set_new_label(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.RemapLabels)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > original_labels_;
    int32_t new_label_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fpreprocessor_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// PreprocessingStep

// .object_detection.protos.NormalizeImage normalize_image = 1;
inline bool PreprocessingStep::_internal_has_normalize_image() const {
  return preprocessing_step_case() == kNormalizeImage;
}
inline bool PreprocessingStep::has_normalize_image() const {
  return _internal_has_normalize_image();
}
inline void PreprocessingStep::set_has_normalize_image() {
  _impl_._oneof_case_[0] = kNormalizeImage;
}
inline void PreprocessingStep::clear_normalize_image() {
  if (_internal_has_normalize_image()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.normalize_image_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::NormalizeImage* PreprocessingStep::release_normalize_image() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.normalize_image)
  if (_internal_has_normalize_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::NormalizeImage* temp = _impl_.preprocessing_step_.normalize_image_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.normalize_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::NormalizeImage& PreprocessingStep::_internal_normalize_image() const {
  return _internal_has_normalize_image()
      ? *_impl_.preprocessing_step_.normalize_image_
      : reinterpret_cast< ::object_detection::protos::NormalizeImage&>(::object_detection::protos::_NormalizeImage_default_instance_);
}
inline const ::object_detection::protos::NormalizeImage& PreprocessingStep::normalize_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.normalize_image)
  return _internal_normalize_image();
}
inline ::object_detection::protos::NormalizeImage* PreprocessingStep::unsafe_arena_release_normalize_image() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.normalize_image)
  if (_internal_has_normalize_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::NormalizeImage* temp = _impl_.preprocessing_step_.normalize_image_;
    _impl_.preprocessing_step_.normalize_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_normalize_image(::object_detection::protos::NormalizeImage* normalize_image) {
  clear_preprocessing_step();
  if (normalize_image) {
    set_has_normalize_image();
    _impl_.preprocessing_step_.normalize_image_ = normalize_image;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.normalize_image)
}
inline ::object_detection::protos::NormalizeImage* PreprocessingStep::_internal_mutable_normalize_image() {
  if (!_internal_has_normalize_image()) {
    clear_preprocessing_step();
    set_has_normalize_image();
    _impl_.preprocessing_step_.normalize_image_ = CreateMaybeMessage< ::object_detection::protos::NormalizeImage >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.normalize_image_;
}
inline ::object_detection::protos::NormalizeImage* PreprocessingStep::mutable_normalize_image() {
  ::object_detection::protos::NormalizeImage* _msg = _internal_mutable_normalize_image();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.normalize_image)
  return _msg;
}

// .object_detection.protos.RandomHorizontalFlip random_horizontal_flip = 2;
inline bool PreprocessingStep::_internal_has_random_horizontal_flip() const {
  return preprocessing_step_case() == kRandomHorizontalFlip;
}
inline bool PreprocessingStep::has_random_horizontal_flip() const {
  return _internal_has_random_horizontal_flip();
}
inline void PreprocessingStep::set_has_random_horizontal_flip() {
  _impl_._oneof_case_[0] = kRandomHorizontalFlip;
}
inline void PreprocessingStep::clear_random_horizontal_flip() {
  if (_internal_has_random_horizontal_flip()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_horizontal_flip_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomHorizontalFlip* PreprocessingStep::release_random_horizontal_flip() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_horizontal_flip)
  if (_internal_has_random_horizontal_flip()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomHorizontalFlip* temp = _impl_.preprocessing_step_.random_horizontal_flip_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_horizontal_flip_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomHorizontalFlip& PreprocessingStep::_internal_random_horizontal_flip() const {
  return _internal_has_random_horizontal_flip()
      ? *_impl_.preprocessing_step_.random_horizontal_flip_
      : reinterpret_cast< ::object_detection::protos::RandomHorizontalFlip&>(::object_detection::protos::_RandomHorizontalFlip_default_instance_);
}
inline const ::object_detection::protos::RandomHorizontalFlip& PreprocessingStep::random_horizontal_flip() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_horizontal_flip)
  return _internal_random_horizontal_flip();
}
inline ::object_detection::protos::RandomHorizontalFlip* PreprocessingStep::unsafe_arena_release_random_horizontal_flip() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_horizontal_flip)
  if (_internal_has_random_horizontal_flip()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomHorizontalFlip* temp = _impl_.preprocessing_step_.random_horizontal_flip_;
    _impl_.preprocessing_step_.random_horizontal_flip_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_horizontal_flip(::object_detection::protos::RandomHorizontalFlip* random_horizontal_flip) {
  clear_preprocessing_step();
  if (random_horizontal_flip) {
    set_has_random_horizontal_flip();
    _impl_.preprocessing_step_.random_horizontal_flip_ = random_horizontal_flip;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_horizontal_flip)
}
inline ::object_detection::protos::RandomHorizontalFlip* PreprocessingStep::_internal_mutable_random_horizontal_flip() {
  if (!_internal_has_random_horizontal_flip()) {
    clear_preprocessing_step();
    set_has_random_horizontal_flip();
    _impl_.preprocessing_step_.random_horizontal_flip_ = CreateMaybeMessage< ::object_detection::protos::RandomHorizontalFlip >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_horizontal_flip_;
}
inline ::object_detection::protos::RandomHorizontalFlip* PreprocessingStep::mutable_random_horizontal_flip() {
  ::object_detection::protos::RandomHorizontalFlip* _msg = _internal_mutable_random_horizontal_flip();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_horizontal_flip)
  return _msg;
}

// .object_detection.protos.RandomPixelValueScale random_pixel_value_scale = 3;
inline bool PreprocessingStep::_internal_has_random_pixel_value_scale() const {
  return preprocessing_step_case() == kRandomPixelValueScale;
}
inline bool PreprocessingStep::has_random_pixel_value_scale() const {
  return _internal_has_random_pixel_value_scale();
}
inline void PreprocessingStep::set_has_random_pixel_value_scale() {
  _impl_._oneof_case_[0] = kRandomPixelValueScale;
}
inline void PreprocessingStep::clear_random_pixel_value_scale() {
  if (_internal_has_random_pixel_value_scale()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_pixel_value_scale_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomPixelValueScale* PreprocessingStep::release_random_pixel_value_scale() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_pixel_value_scale)
  if (_internal_has_random_pixel_value_scale()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomPixelValueScale* temp = _impl_.preprocessing_step_.random_pixel_value_scale_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_pixel_value_scale_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomPixelValueScale& PreprocessingStep::_internal_random_pixel_value_scale() const {
  return _internal_has_random_pixel_value_scale()
      ? *_impl_.preprocessing_step_.random_pixel_value_scale_
      : reinterpret_cast< ::object_detection::protos::RandomPixelValueScale&>(::object_detection::protos::_RandomPixelValueScale_default_instance_);
}
inline const ::object_detection::protos::RandomPixelValueScale& PreprocessingStep::random_pixel_value_scale() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_pixel_value_scale)
  return _internal_random_pixel_value_scale();
}
inline ::object_detection::protos::RandomPixelValueScale* PreprocessingStep::unsafe_arena_release_random_pixel_value_scale() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_pixel_value_scale)
  if (_internal_has_random_pixel_value_scale()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomPixelValueScale* temp = _impl_.preprocessing_step_.random_pixel_value_scale_;
    _impl_.preprocessing_step_.random_pixel_value_scale_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_pixel_value_scale(::object_detection::protos::RandomPixelValueScale* random_pixel_value_scale) {
  clear_preprocessing_step();
  if (random_pixel_value_scale) {
    set_has_random_pixel_value_scale();
    _impl_.preprocessing_step_.random_pixel_value_scale_ = random_pixel_value_scale;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_pixel_value_scale)
}
inline ::object_detection::protos::RandomPixelValueScale* PreprocessingStep::_internal_mutable_random_pixel_value_scale() {
  if (!_internal_has_random_pixel_value_scale()) {
    clear_preprocessing_step();
    set_has_random_pixel_value_scale();
    _impl_.preprocessing_step_.random_pixel_value_scale_ = CreateMaybeMessage< ::object_detection::protos::RandomPixelValueScale >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_pixel_value_scale_;
}
inline ::object_detection::protos::RandomPixelValueScale* PreprocessingStep::mutable_random_pixel_value_scale() {
  ::object_detection::protos::RandomPixelValueScale* _msg = _internal_mutable_random_pixel_value_scale();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_pixel_value_scale)
  return _msg;
}

// .object_detection.protos.RandomImageScale random_image_scale = 4;
inline bool PreprocessingStep::_internal_has_random_image_scale() const {
  return preprocessing_step_case() == kRandomImageScale;
}
inline bool PreprocessingStep::has_random_image_scale() const {
  return _internal_has_random_image_scale();
}
inline void PreprocessingStep::set_has_random_image_scale() {
  _impl_._oneof_case_[0] = kRandomImageScale;
}
inline void PreprocessingStep::clear_random_image_scale() {
  if (_internal_has_random_image_scale()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_image_scale_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomImageScale* PreprocessingStep::release_random_image_scale() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_image_scale)
  if (_internal_has_random_image_scale()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomImageScale* temp = _impl_.preprocessing_step_.random_image_scale_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_image_scale_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomImageScale& PreprocessingStep::_internal_random_image_scale() const {
  return _internal_has_random_image_scale()
      ? *_impl_.preprocessing_step_.random_image_scale_
      : reinterpret_cast< ::object_detection::protos::RandomImageScale&>(::object_detection::protos::_RandomImageScale_default_instance_);
}
inline const ::object_detection::protos::RandomImageScale& PreprocessingStep::random_image_scale() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_image_scale)
  return _internal_random_image_scale();
}
inline ::object_detection::protos::RandomImageScale* PreprocessingStep::unsafe_arena_release_random_image_scale() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_image_scale)
  if (_internal_has_random_image_scale()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomImageScale* temp = _impl_.preprocessing_step_.random_image_scale_;
    _impl_.preprocessing_step_.random_image_scale_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_image_scale(::object_detection::protos::RandomImageScale* random_image_scale) {
  clear_preprocessing_step();
  if (random_image_scale) {
    set_has_random_image_scale();
    _impl_.preprocessing_step_.random_image_scale_ = random_image_scale;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_image_scale)
}
inline ::object_detection::protos::RandomImageScale* PreprocessingStep::_internal_mutable_random_image_scale() {
  if (!_internal_has_random_image_scale()) {
    clear_preprocessing_step();
    set_has_random_image_scale();
    _impl_.preprocessing_step_.random_image_scale_ = CreateMaybeMessage< ::object_detection::protos::RandomImageScale >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_image_scale_;
}
inline ::object_detection::protos::RandomImageScale* PreprocessingStep::mutable_random_image_scale() {
  ::object_detection::protos::RandomImageScale* _msg = _internal_mutable_random_image_scale();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_image_scale)
  return _msg;
}

// .object_detection.protos.RandomRGBtoGray random_rgb_to_gray = 5;
inline bool PreprocessingStep::_internal_has_random_rgb_to_gray() const {
  return preprocessing_step_case() == kRandomRgbToGray;
}
inline bool PreprocessingStep::has_random_rgb_to_gray() const {
  return _internal_has_random_rgb_to_gray();
}
inline void PreprocessingStep::set_has_random_rgb_to_gray() {
  _impl_._oneof_case_[0] = kRandomRgbToGray;
}
inline void PreprocessingStep::clear_random_rgb_to_gray() {
  if (_internal_has_random_rgb_to_gray()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_rgb_to_gray_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomRGBtoGray* PreprocessingStep::release_random_rgb_to_gray() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_rgb_to_gray)
  if (_internal_has_random_rgb_to_gray()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomRGBtoGray* temp = _impl_.preprocessing_step_.random_rgb_to_gray_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_rgb_to_gray_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomRGBtoGray& PreprocessingStep::_internal_random_rgb_to_gray() const {
  return _internal_has_random_rgb_to_gray()
      ? *_impl_.preprocessing_step_.random_rgb_to_gray_
      : reinterpret_cast< ::object_detection::protos::RandomRGBtoGray&>(::object_detection::protos::_RandomRGBtoGray_default_instance_);
}
inline const ::object_detection::protos::RandomRGBtoGray& PreprocessingStep::random_rgb_to_gray() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_rgb_to_gray)
  return _internal_random_rgb_to_gray();
}
inline ::object_detection::protos::RandomRGBtoGray* PreprocessingStep::unsafe_arena_release_random_rgb_to_gray() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_rgb_to_gray)
  if (_internal_has_random_rgb_to_gray()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomRGBtoGray* temp = _impl_.preprocessing_step_.random_rgb_to_gray_;
    _impl_.preprocessing_step_.random_rgb_to_gray_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_rgb_to_gray(::object_detection::protos::RandomRGBtoGray* random_rgb_to_gray) {
  clear_preprocessing_step();
  if (random_rgb_to_gray) {
    set_has_random_rgb_to_gray();
    _impl_.preprocessing_step_.random_rgb_to_gray_ = random_rgb_to_gray;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_rgb_to_gray)
}
inline ::object_detection::protos::RandomRGBtoGray* PreprocessingStep::_internal_mutable_random_rgb_to_gray() {
  if (!_internal_has_random_rgb_to_gray()) {
    clear_preprocessing_step();
    set_has_random_rgb_to_gray();
    _impl_.preprocessing_step_.random_rgb_to_gray_ = CreateMaybeMessage< ::object_detection::protos::RandomRGBtoGray >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_rgb_to_gray_;
}
inline ::object_detection::protos::RandomRGBtoGray* PreprocessingStep::mutable_random_rgb_to_gray() {
  ::object_detection::protos::RandomRGBtoGray* _msg = _internal_mutable_random_rgb_to_gray();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_rgb_to_gray)
  return _msg;
}

// .object_detection.protos.RandomAdjustBrightness random_adjust_brightness = 6;
inline bool PreprocessingStep::_internal_has_random_adjust_brightness() const {
  return preprocessing_step_case() == kRandomAdjustBrightness;
}
inline bool PreprocessingStep::has_random_adjust_brightness() const {
  return _internal_has_random_adjust_brightness();
}
inline void PreprocessingStep::set_has_random_adjust_brightness() {
  _impl_._oneof_case_[0] = kRandomAdjustBrightness;
}
inline void PreprocessingStep::clear_random_adjust_brightness() {
  if (_internal_has_random_adjust_brightness()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_adjust_brightness_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomAdjustBrightness* PreprocessingStep::release_random_adjust_brightness() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_adjust_brightness)
  if (_internal_has_random_adjust_brightness()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAdjustBrightness* temp = _impl_.preprocessing_step_.random_adjust_brightness_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_adjust_brightness_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomAdjustBrightness& PreprocessingStep::_internal_random_adjust_brightness() const {
  return _internal_has_random_adjust_brightness()
      ? *_impl_.preprocessing_step_.random_adjust_brightness_
      : reinterpret_cast< ::object_detection::protos::RandomAdjustBrightness&>(::object_detection::protos::_RandomAdjustBrightness_default_instance_);
}
inline const ::object_detection::protos::RandomAdjustBrightness& PreprocessingStep::random_adjust_brightness() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_adjust_brightness)
  return _internal_random_adjust_brightness();
}
inline ::object_detection::protos::RandomAdjustBrightness* PreprocessingStep::unsafe_arena_release_random_adjust_brightness() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_adjust_brightness)
  if (_internal_has_random_adjust_brightness()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAdjustBrightness* temp = _impl_.preprocessing_step_.random_adjust_brightness_;
    _impl_.preprocessing_step_.random_adjust_brightness_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_adjust_brightness(::object_detection::protos::RandomAdjustBrightness* random_adjust_brightness) {
  clear_preprocessing_step();
  if (random_adjust_brightness) {
    set_has_random_adjust_brightness();
    _impl_.preprocessing_step_.random_adjust_brightness_ = random_adjust_brightness;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_adjust_brightness)
}
inline ::object_detection::protos::RandomAdjustBrightness* PreprocessingStep::_internal_mutable_random_adjust_brightness() {
  if (!_internal_has_random_adjust_brightness()) {
    clear_preprocessing_step();
    set_has_random_adjust_brightness();
    _impl_.preprocessing_step_.random_adjust_brightness_ = CreateMaybeMessage< ::object_detection::protos::RandomAdjustBrightness >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_adjust_brightness_;
}
inline ::object_detection::protos::RandomAdjustBrightness* PreprocessingStep::mutable_random_adjust_brightness() {
  ::object_detection::protos::RandomAdjustBrightness* _msg = _internal_mutable_random_adjust_brightness();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_adjust_brightness)
  return _msg;
}

// .object_detection.protos.RandomAdjustContrast random_adjust_contrast = 7;
inline bool PreprocessingStep::_internal_has_random_adjust_contrast() const {
  return preprocessing_step_case() == kRandomAdjustContrast;
}
inline bool PreprocessingStep::has_random_adjust_contrast() const {
  return _internal_has_random_adjust_contrast();
}
inline void PreprocessingStep::set_has_random_adjust_contrast() {
  _impl_._oneof_case_[0] = kRandomAdjustContrast;
}
inline void PreprocessingStep::clear_random_adjust_contrast() {
  if (_internal_has_random_adjust_contrast()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_adjust_contrast_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomAdjustContrast* PreprocessingStep::release_random_adjust_contrast() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_adjust_contrast)
  if (_internal_has_random_adjust_contrast()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAdjustContrast* temp = _impl_.preprocessing_step_.random_adjust_contrast_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_adjust_contrast_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomAdjustContrast& PreprocessingStep::_internal_random_adjust_contrast() const {
  return _internal_has_random_adjust_contrast()
      ? *_impl_.preprocessing_step_.random_adjust_contrast_
      : reinterpret_cast< ::object_detection::protos::RandomAdjustContrast&>(::object_detection::protos::_RandomAdjustContrast_default_instance_);
}
inline const ::object_detection::protos::RandomAdjustContrast& PreprocessingStep::random_adjust_contrast() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_adjust_contrast)
  return _internal_random_adjust_contrast();
}
inline ::object_detection::protos::RandomAdjustContrast* PreprocessingStep::unsafe_arena_release_random_adjust_contrast() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_adjust_contrast)
  if (_internal_has_random_adjust_contrast()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAdjustContrast* temp = _impl_.preprocessing_step_.random_adjust_contrast_;
    _impl_.preprocessing_step_.random_adjust_contrast_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_adjust_contrast(::object_detection::protos::RandomAdjustContrast* random_adjust_contrast) {
  clear_preprocessing_step();
  if (random_adjust_contrast) {
    set_has_random_adjust_contrast();
    _impl_.preprocessing_step_.random_adjust_contrast_ = random_adjust_contrast;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_adjust_contrast)
}
inline ::object_detection::protos::RandomAdjustContrast* PreprocessingStep::_internal_mutable_random_adjust_contrast() {
  if (!_internal_has_random_adjust_contrast()) {
    clear_preprocessing_step();
    set_has_random_adjust_contrast();
    _impl_.preprocessing_step_.random_adjust_contrast_ = CreateMaybeMessage< ::object_detection::protos::RandomAdjustContrast >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_adjust_contrast_;
}
inline ::object_detection::protos::RandomAdjustContrast* PreprocessingStep::mutable_random_adjust_contrast() {
  ::object_detection::protos::RandomAdjustContrast* _msg = _internal_mutable_random_adjust_contrast();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_adjust_contrast)
  return _msg;
}

// .object_detection.protos.RandomAdjustHue random_adjust_hue = 8;
inline bool PreprocessingStep::_internal_has_random_adjust_hue() const {
  return preprocessing_step_case() == kRandomAdjustHue;
}
inline bool PreprocessingStep::has_random_adjust_hue() const {
  return _internal_has_random_adjust_hue();
}
inline void PreprocessingStep::set_has_random_adjust_hue() {
  _impl_._oneof_case_[0] = kRandomAdjustHue;
}
inline void PreprocessingStep::clear_random_adjust_hue() {
  if (_internal_has_random_adjust_hue()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_adjust_hue_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomAdjustHue* PreprocessingStep::release_random_adjust_hue() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_adjust_hue)
  if (_internal_has_random_adjust_hue()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAdjustHue* temp = _impl_.preprocessing_step_.random_adjust_hue_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_adjust_hue_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomAdjustHue& PreprocessingStep::_internal_random_adjust_hue() const {
  return _internal_has_random_adjust_hue()
      ? *_impl_.preprocessing_step_.random_adjust_hue_
      : reinterpret_cast< ::object_detection::protos::RandomAdjustHue&>(::object_detection::protos::_RandomAdjustHue_default_instance_);
}
inline const ::object_detection::protos::RandomAdjustHue& PreprocessingStep::random_adjust_hue() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_adjust_hue)
  return _internal_random_adjust_hue();
}
inline ::object_detection::protos::RandomAdjustHue* PreprocessingStep::unsafe_arena_release_random_adjust_hue() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_adjust_hue)
  if (_internal_has_random_adjust_hue()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAdjustHue* temp = _impl_.preprocessing_step_.random_adjust_hue_;
    _impl_.preprocessing_step_.random_adjust_hue_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_adjust_hue(::object_detection::protos::RandomAdjustHue* random_adjust_hue) {
  clear_preprocessing_step();
  if (random_adjust_hue) {
    set_has_random_adjust_hue();
    _impl_.preprocessing_step_.random_adjust_hue_ = random_adjust_hue;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_adjust_hue)
}
inline ::object_detection::protos::RandomAdjustHue* PreprocessingStep::_internal_mutable_random_adjust_hue() {
  if (!_internal_has_random_adjust_hue()) {
    clear_preprocessing_step();
    set_has_random_adjust_hue();
    _impl_.preprocessing_step_.random_adjust_hue_ = CreateMaybeMessage< ::object_detection::protos::RandomAdjustHue >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_adjust_hue_;
}
inline ::object_detection::protos::RandomAdjustHue* PreprocessingStep::mutable_random_adjust_hue() {
  ::object_detection::protos::RandomAdjustHue* _msg = _internal_mutable_random_adjust_hue();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_adjust_hue)
  return _msg;
}

// .object_detection.protos.RandomAdjustSaturation random_adjust_saturation = 9;
inline bool PreprocessingStep::_internal_has_random_adjust_saturation() const {
  return preprocessing_step_case() == kRandomAdjustSaturation;
}
inline bool PreprocessingStep::has_random_adjust_saturation() const {
  return _internal_has_random_adjust_saturation();
}
inline void PreprocessingStep::set_has_random_adjust_saturation() {
  _impl_._oneof_case_[0] = kRandomAdjustSaturation;
}
inline void PreprocessingStep::clear_random_adjust_saturation() {
  if (_internal_has_random_adjust_saturation()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_adjust_saturation_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomAdjustSaturation* PreprocessingStep::release_random_adjust_saturation() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_adjust_saturation)
  if (_internal_has_random_adjust_saturation()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAdjustSaturation* temp = _impl_.preprocessing_step_.random_adjust_saturation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_adjust_saturation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomAdjustSaturation& PreprocessingStep::_internal_random_adjust_saturation() const {
  return _internal_has_random_adjust_saturation()
      ? *_impl_.preprocessing_step_.random_adjust_saturation_
      : reinterpret_cast< ::object_detection::protos::RandomAdjustSaturation&>(::object_detection::protos::_RandomAdjustSaturation_default_instance_);
}
inline const ::object_detection::protos::RandomAdjustSaturation& PreprocessingStep::random_adjust_saturation() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_adjust_saturation)
  return _internal_random_adjust_saturation();
}
inline ::object_detection::protos::RandomAdjustSaturation* PreprocessingStep::unsafe_arena_release_random_adjust_saturation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_adjust_saturation)
  if (_internal_has_random_adjust_saturation()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAdjustSaturation* temp = _impl_.preprocessing_step_.random_adjust_saturation_;
    _impl_.preprocessing_step_.random_adjust_saturation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_adjust_saturation(::object_detection::protos::RandomAdjustSaturation* random_adjust_saturation) {
  clear_preprocessing_step();
  if (random_adjust_saturation) {
    set_has_random_adjust_saturation();
    _impl_.preprocessing_step_.random_adjust_saturation_ = random_adjust_saturation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_adjust_saturation)
}
inline ::object_detection::protos::RandomAdjustSaturation* PreprocessingStep::_internal_mutable_random_adjust_saturation() {
  if (!_internal_has_random_adjust_saturation()) {
    clear_preprocessing_step();
    set_has_random_adjust_saturation();
    _impl_.preprocessing_step_.random_adjust_saturation_ = CreateMaybeMessage< ::object_detection::protos::RandomAdjustSaturation >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_adjust_saturation_;
}
inline ::object_detection::protos::RandomAdjustSaturation* PreprocessingStep::mutable_random_adjust_saturation() {
  ::object_detection::protos::RandomAdjustSaturation* _msg = _internal_mutable_random_adjust_saturation();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_adjust_saturation)
  return _msg;
}

// .object_detection.protos.RandomDistortColor random_distort_color = 10;
inline bool PreprocessingStep::_internal_has_random_distort_color() const {
  return preprocessing_step_case() == kRandomDistortColor;
}
inline bool PreprocessingStep::has_random_distort_color() const {
  return _internal_has_random_distort_color();
}
inline void PreprocessingStep::set_has_random_distort_color() {
  _impl_._oneof_case_[0] = kRandomDistortColor;
}
inline void PreprocessingStep::clear_random_distort_color() {
  if (_internal_has_random_distort_color()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_distort_color_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomDistortColor* PreprocessingStep::release_random_distort_color() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_distort_color)
  if (_internal_has_random_distort_color()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomDistortColor* temp = _impl_.preprocessing_step_.random_distort_color_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_distort_color_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomDistortColor& PreprocessingStep::_internal_random_distort_color() const {
  return _internal_has_random_distort_color()
      ? *_impl_.preprocessing_step_.random_distort_color_
      : reinterpret_cast< ::object_detection::protos::RandomDistortColor&>(::object_detection::protos::_RandomDistortColor_default_instance_);
}
inline const ::object_detection::protos::RandomDistortColor& PreprocessingStep::random_distort_color() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_distort_color)
  return _internal_random_distort_color();
}
inline ::object_detection::protos::RandomDistortColor* PreprocessingStep::unsafe_arena_release_random_distort_color() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_distort_color)
  if (_internal_has_random_distort_color()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomDistortColor* temp = _impl_.preprocessing_step_.random_distort_color_;
    _impl_.preprocessing_step_.random_distort_color_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_distort_color(::object_detection::protos::RandomDistortColor* random_distort_color) {
  clear_preprocessing_step();
  if (random_distort_color) {
    set_has_random_distort_color();
    _impl_.preprocessing_step_.random_distort_color_ = random_distort_color;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_distort_color)
}
inline ::object_detection::protos::RandomDistortColor* PreprocessingStep::_internal_mutable_random_distort_color() {
  if (!_internal_has_random_distort_color()) {
    clear_preprocessing_step();
    set_has_random_distort_color();
    _impl_.preprocessing_step_.random_distort_color_ = CreateMaybeMessage< ::object_detection::protos::RandomDistortColor >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_distort_color_;
}
inline ::object_detection::protos::RandomDistortColor* PreprocessingStep::mutable_random_distort_color() {
  ::object_detection::protos::RandomDistortColor* _msg = _internal_mutable_random_distort_color();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_distort_color)
  return _msg;
}

// .object_detection.protos.RandomJitterBoxes random_jitter_boxes = 11;
inline bool PreprocessingStep::_internal_has_random_jitter_boxes() const {
  return preprocessing_step_case() == kRandomJitterBoxes;
}
inline bool PreprocessingStep::has_random_jitter_boxes() const {
  return _internal_has_random_jitter_boxes();
}
inline void PreprocessingStep::set_has_random_jitter_boxes() {
  _impl_._oneof_case_[0] = kRandomJitterBoxes;
}
inline void PreprocessingStep::clear_random_jitter_boxes() {
  if (_internal_has_random_jitter_boxes()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_jitter_boxes_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomJitterBoxes* PreprocessingStep::release_random_jitter_boxes() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_jitter_boxes)
  if (_internal_has_random_jitter_boxes()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomJitterBoxes* temp = _impl_.preprocessing_step_.random_jitter_boxes_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_jitter_boxes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomJitterBoxes& PreprocessingStep::_internal_random_jitter_boxes() const {
  return _internal_has_random_jitter_boxes()
      ? *_impl_.preprocessing_step_.random_jitter_boxes_
      : reinterpret_cast< ::object_detection::protos::RandomJitterBoxes&>(::object_detection::protos::_RandomJitterBoxes_default_instance_);
}
inline const ::object_detection::protos::RandomJitterBoxes& PreprocessingStep::random_jitter_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_jitter_boxes)
  return _internal_random_jitter_boxes();
}
inline ::object_detection::protos::RandomJitterBoxes* PreprocessingStep::unsafe_arena_release_random_jitter_boxes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_jitter_boxes)
  if (_internal_has_random_jitter_boxes()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomJitterBoxes* temp = _impl_.preprocessing_step_.random_jitter_boxes_;
    _impl_.preprocessing_step_.random_jitter_boxes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_jitter_boxes(::object_detection::protos::RandomJitterBoxes* random_jitter_boxes) {
  clear_preprocessing_step();
  if (random_jitter_boxes) {
    set_has_random_jitter_boxes();
    _impl_.preprocessing_step_.random_jitter_boxes_ = random_jitter_boxes;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_jitter_boxes)
}
inline ::object_detection::protos::RandomJitterBoxes* PreprocessingStep::_internal_mutable_random_jitter_boxes() {
  if (!_internal_has_random_jitter_boxes()) {
    clear_preprocessing_step();
    set_has_random_jitter_boxes();
    _impl_.preprocessing_step_.random_jitter_boxes_ = CreateMaybeMessage< ::object_detection::protos::RandomJitterBoxes >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_jitter_boxes_;
}
inline ::object_detection::protos::RandomJitterBoxes* PreprocessingStep::mutable_random_jitter_boxes() {
  ::object_detection::protos::RandomJitterBoxes* _msg = _internal_mutable_random_jitter_boxes();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_jitter_boxes)
  return _msg;
}

// .object_detection.protos.RandomCropImage random_crop_image = 12;
inline bool PreprocessingStep::_internal_has_random_crop_image() const {
  return preprocessing_step_case() == kRandomCropImage;
}
inline bool PreprocessingStep::has_random_crop_image() const {
  return _internal_has_random_crop_image();
}
inline void PreprocessingStep::set_has_random_crop_image() {
  _impl_._oneof_case_[0] = kRandomCropImage;
}
inline void PreprocessingStep::clear_random_crop_image() {
  if (_internal_has_random_crop_image()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_crop_image_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomCropImage* PreprocessingStep::release_random_crop_image() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_crop_image)
  if (_internal_has_random_crop_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomCropImage* temp = _impl_.preprocessing_step_.random_crop_image_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_crop_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomCropImage& PreprocessingStep::_internal_random_crop_image() const {
  return _internal_has_random_crop_image()
      ? *_impl_.preprocessing_step_.random_crop_image_
      : reinterpret_cast< ::object_detection::protos::RandomCropImage&>(::object_detection::protos::_RandomCropImage_default_instance_);
}
inline const ::object_detection::protos::RandomCropImage& PreprocessingStep::random_crop_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_crop_image)
  return _internal_random_crop_image();
}
inline ::object_detection::protos::RandomCropImage* PreprocessingStep::unsafe_arena_release_random_crop_image() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_crop_image)
  if (_internal_has_random_crop_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomCropImage* temp = _impl_.preprocessing_step_.random_crop_image_;
    _impl_.preprocessing_step_.random_crop_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_crop_image(::object_detection::protos::RandomCropImage* random_crop_image) {
  clear_preprocessing_step();
  if (random_crop_image) {
    set_has_random_crop_image();
    _impl_.preprocessing_step_.random_crop_image_ = random_crop_image;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_crop_image)
}
inline ::object_detection::protos::RandomCropImage* PreprocessingStep::_internal_mutable_random_crop_image() {
  if (!_internal_has_random_crop_image()) {
    clear_preprocessing_step();
    set_has_random_crop_image();
    _impl_.preprocessing_step_.random_crop_image_ = CreateMaybeMessage< ::object_detection::protos::RandomCropImage >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_crop_image_;
}
inline ::object_detection::protos::RandomCropImage* PreprocessingStep::mutable_random_crop_image() {
  ::object_detection::protos::RandomCropImage* _msg = _internal_mutable_random_crop_image();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_crop_image)
  return _msg;
}

// .object_detection.protos.RandomPadImage random_pad_image = 13;
inline bool PreprocessingStep::_internal_has_random_pad_image() const {
  return preprocessing_step_case() == kRandomPadImage;
}
inline bool PreprocessingStep::has_random_pad_image() const {
  return _internal_has_random_pad_image();
}
inline void PreprocessingStep::set_has_random_pad_image() {
  _impl_._oneof_case_[0] = kRandomPadImage;
}
inline void PreprocessingStep::clear_random_pad_image() {
  if (_internal_has_random_pad_image()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_pad_image_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomPadImage* PreprocessingStep::release_random_pad_image() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_pad_image)
  if (_internal_has_random_pad_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomPadImage* temp = _impl_.preprocessing_step_.random_pad_image_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_pad_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomPadImage& PreprocessingStep::_internal_random_pad_image() const {
  return _internal_has_random_pad_image()
      ? *_impl_.preprocessing_step_.random_pad_image_
      : reinterpret_cast< ::object_detection::protos::RandomPadImage&>(::object_detection::protos::_RandomPadImage_default_instance_);
}
inline const ::object_detection::protos::RandomPadImage& PreprocessingStep::random_pad_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_pad_image)
  return _internal_random_pad_image();
}
inline ::object_detection::protos::RandomPadImage* PreprocessingStep::unsafe_arena_release_random_pad_image() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_pad_image)
  if (_internal_has_random_pad_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomPadImage* temp = _impl_.preprocessing_step_.random_pad_image_;
    _impl_.preprocessing_step_.random_pad_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_pad_image(::object_detection::protos::RandomPadImage* random_pad_image) {
  clear_preprocessing_step();
  if (random_pad_image) {
    set_has_random_pad_image();
    _impl_.preprocessing_step_.random_pad_image_ = random_pad_image;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_pad_image)
}
inline ::object_detection::protos::RandomPadImage* PreprocessingStep::_internal_mutable_random_pad_image() {
  if (!_internal_has_random_pad_image()) {
    clear_preprocessing_step();
    set_has_random_pad_image();
    _impl_.preprocessing_step_.random_pad_image_ = CreateMaybeMessage< ::object_detection::protos::RandomPadImage >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_pad_image_;
}
inline ::object_detection::protos::RandomPadImage* PreprocessingStep::mutable_random_pad_image() {
  ::object_detection::protos::RandomPadImage* _msg = _internal_mutable_random_pad_image();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_pad_image)
  return _msg;
}

// .object_detection.protos.RandomCropPadImage random_crop_pad_image = 14;
inline bool PreprocessingStep::_internal_has_random_crop_pad_image() const {
  return preprocessing_step_case() == kRandomCropPadImage;
}
inline bool PreprocessingStep::has_random_crop_pad_image() const {
  return _internal_has_random_crop_pad_image();
}
inline void PreprocessingStep::set_has_random_crop_pad_image() {
  _impl_._oneof_case_[0] = kRandomCropPadImage;
}
inline void PreprocessingStep::clear_random_crop_pad_image() {
  if (_internal_has_random_crop_pad_image()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_crop_pad_image_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomCropPadImage* PreprocessingStep::release_random_crop_pad_image() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_crop_pad_image)
  if (_internal_has_random_crop_pad_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomCropPadImage* temp = _impl_.preprocessing_step_.random_crop_pad_image_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_crop_pad_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomCropPadImage& PreprocessingStep::_internal_random_crop_pad_image() const {
  return _internal_has_random_crop_pad_image()
      ? *_impl_.preprocessing_step_.random_crop_pad_image_
      : reinterpret_cast< ::object_detection::protos::RandomCropPadImage&>(::object_detection::protos::_RandomCropPadImage_default_instance_);
}
inline const ::object_detection::protos::RandomCropPadImage& PreprocessingStep::random_crop_pad_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_crop_pad_image)
  return _internal_random_crop_pad_image();
}
inline ::object_detection::protos::RandomCropPadImage* PreprocessingStep::unsafe_arena_release_random_crop_pad_image() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_crop_pad_image)
  if (_internal_has_random_crop_pad_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomCropPadImage* temp = _impl_.preprocessing_step_.random_crop_pad_image_;
    _impl_.preprocessing_step_.random_crop_pad_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_crop_pad_image(::object_detection::protos::RandomCropPadImage* random_crop_pad_image) {
  clear_preprocessing_step();
  if (random_crop_pad_image) {
    set_has_random_crop_pad_image();
    _impl_.preprocessing_step_.random_crop_pad_image_ = random_crop_pad_image;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_crop_pad_image)
}
inline ::object_detection::protos::RandomCropPadImage* PreprocessingStep::_internal_mutable_random_crop_pad_image() {
  if (!_internal_has_random_crop_pad_image()) {
    clear_preprocessing_step();
    set_has_random_crop_pad_image();
    _impl_.preprocessing_step_.random_crop_pad_image_ = CreateMaybeMessage< ::object_detection::protos::RandomCropPadImage >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_crop_pad_image_;
}
inline ::object_detection::protos::RandomCropPadImage* PreprocessingStep::mutable_random_crop_pad_image() {
  ::object_detection::protos::RandomCropPadImage* _msg = _internal_mutable_random_crop_pad_image();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_crop_pad_image)
  return _msg;
}

// .object_detection.protos.RandomCropToAspectRatio random_crop_to_aspect_ratio = 15;
inline bool PreprocessingStep::_internal_has_random_crop_to_aspect_ratio() const {
  return preprocessing_step_case() == kRandomCropToAspectRatio;
}
inline bool PreprocessingStep::has_random_crop_to_aspect_ratio() const {
  return _internal_has_random_crop_to_aspect_ratio();
}
inline void PreprocessingStep::set_has_random_crop_to_aspect_ratio() {
  _impl_._oneof_case_[0] = kRandomCropToAspectRatio;
}
inline void PreprocessingStep::clear_random_crop_to_aspect_ratio() {
  if (_internal_has_random_crop_to_aspect_ratio()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_crop_to_aspect_ratio_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomCropToAspectRatio* PreprocessingStep::release_random_crop_to_aspect_ratio() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_crop_to_aspect_ratio)
  if (_internal_has_random_crop_to_aspect_ratio()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomCropToAspectRatio* temp = _impl_.preprocessing_step_.random_crop_to_aspect_ratio_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_crop_to_aspect_ratio_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomCropToAspectRatio& PreprocessingStep::_internal_random_crop_to_aspect_ratio() const {
  return _internal_has_random_crop_to_aspect_ratio()
      ? *_impl_.preprocessing_step_.random_crop_to_aspect_ratio_
      : reinterpret_cast< ::object_detection::protos::RandomCropToAspectRatio&>(::object_detection::protos::_RandomCropToAspectRatio_default_instance_);
}
inline const ::object_detection::protos::RandomCropToAspectRatio& PreprocessingStep::random_crop_to_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_crop_to_aspect_ratio)
  return _internal_random_crop_to_aspect_ratio();
}
inline ::object_detection::protos::RandomCropToAspectRatio* PreprocessingStep::unsafe_arena_release_random_crop_to_aspect_ratio() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_crop_to_aspect_ratio)
  if (_internal_has_random_crop_to_aspect_ratio()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomCropToAspectRatio* temp = _impl_.preprocessing_step_.random_crop_to_aspect_ratio_;
    _impl_.preprocessing_step_.random_crop_to_aspect_ratio_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_crop_to_aspect_ratio(::object_detection::protos::RandomCropToAspectRatio* random_crop_to_aspect_ratio) {
  clear_preprocessing_step();
  if (random_crop_to_aspect_ratio) {
    set_has_random_crop_to_aspect_ratio();
    _impl_.preprocessing_step_.random_crop_to_aspect_ratio_ = random_crop_to_aspect_ratio;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_crop_to_aspect_ratio)
}
inline ::object_detection::protos::RandomCropToAspectRatio* PreprocessingStep::_internal_mutable_random_crop_to_aspect_ratio() {
  if (!_internal_has_random_crop_to_aspect_ratio()) {
    clear_preprocessing_step();
    set_has_random_crop_to_aspect_ratio();
    _impl_.preprocessing_step_.random_crop_to_aspect_ratio_ = CreateMaybeMessage< ::object_detection::protos::RandomCropToAspectRatio >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_crop_to_aspect_ratio_;
}
inline ::object_detection::protos::RandomCropToAspectRatio* PreprocessingStep::mutable_random_crop_to_aspect_ratio() {
  ::object_detection::protos::RandomCropToAspectRatio* _msg = _internal_mutable_random_crop_to_aspect_ratio();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_crop_to_aspect_ratio)
  return _msg;
}

// .object_detection.protos.RandomBlackPatches random_black_patches = 16;
inline bool PreprocessingStep::_internal_has_random_black_patches() const {
  return preprocessing_step_case() == kRandomBlackPatches;
}
inline bool PreprocessingStep::has_random_black_patches() const {
  return _internal_has_random_black_patches();
}
inline void PreprocessingStep::set_has_random_black_patches() {
  _impl_._oneof_case_[0] = kRandomBlackPatches;
}
inline void PreprocessingStep::clear_random_black_patches() {
  if (_internal_has_random_black_patches()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_black_patches_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomBlackPatches* PreprocessingStep::release_random_black_patches() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_black_patches)
  if (_internal_has_random_black_patches()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomBlackPatches* temp = _impl_.preprocessing_step_.random_black_patches_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_black_patches_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomBlackPatches& PreprocessingStep::_internal_random_black_patches() const {
  return _internal_has_random_black_patches()
      ? *_impl_.preprocessing_step_.random_black_patches_
      : reinterpret_cast< ::object_detection::protos::RandomBlackPatches&>(::object_detection::protos::_RandomBlackPatches_default_instance_);
}
inline const ::object_detection::protos::RandomBlackPatches& PreprocessingStep::random_black_patches() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_black_patches)
  return _internal_random_black_patches();
}
inline ::object_detection::protos::RandomBlackPatches* PreprocessingStep::unsafe_arena_release_random_black_patches() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_black_patches)
  if (_internal_has_random_black_patches()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomBlackPatches* temp = _impl_.preprocessing_step_.random_black_patches_;
    _impl_.preprocessing_step_.random_black_patches_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_black_patches(::object_detection::protos::RandomBlackPatches* random_black_patches) {
  clear_preprocessing_step();
  if (random_black_patches) {
    set_has_random_black_patches();
    _impl_.preprocessing_step_.random_black_patches_ = random_black_patches;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_black_patches)
}
inline ::object_detection::protos::RandomBlackPatches* PreprocessingStep::_internal_mutable_random_black_patches() {
  if (!_internal_has_random_black_patches()) {
    clear_preprocessing_step();
    set_has_random_black_patches();
    _impl_.preprocessing_step_.random_black_patches_ = CreateMaybeMessage< ::object_detection::protos::RandomBlackPatches >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_black_patches_;
}
inline ::object_detection::protos::RandomBlackPatches* PreprocessingStep::mutable_random_black_patches() {
  ::object_detection::protos::RandomBlackPatches* _msg = _internal_mutable_random_black_patches();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_black_patches)
  return _msg;
}

// .object_detection.protos.RandomResizeMethod random_resize_method = 17;
inline bool PreprocessingStep::_internal_has_random_resize_method() const {
  return preprocessing_step_case() == kRandomResizeMethod;
}
inline bool PreprocessingStep::has_random_resize_method() const {
  return _internal_has_random_resize_method();
}
inline void PreprocessingStep::set_has_random_resize_method() {
  _impl_._oneof_case_[0] = kRandomResizeMethod;
}
inline void PreprocessingStep::clear_random_resize_method() {
  if (_internal_has_random_resize_method()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_resize_method_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomResizeMethod* PreprocessingStep::release_random_resize_method() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_resize_method)
  if (_internal_has_random_resize_method()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomResizeMethod* temp = _impl_.preprocessing_step_.random_resize_method_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_resize_method_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomResizeMethod& PreprocessingStep::_internal_random_resize_method() const {
  return _internal_has_random_resize_method()
      ? *_impl_.preprocessing_step_.random_resize_method_
      : reinterpret_cast< ::object_detection::protos::RandomResizeMethod&>(::object_detection::protos::_RandomResizeMethod_default_instance_);
}
inline const ::object_detection::protos::RandomResizeMethod& PreprocessingStep::random_resize_method() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_resize_method)
  return _internal_random_resize_method();
}
inline ::object_detection::protos::RandomResizeMethod* PreprocessingStep::unsafe_arena_release_random_resize_method() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_resize_method)
  if (_internal_has_random_resize_method()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomResizeMethod* temp = _impl_.preprocessing_step_.random_resize_method_;
    _impl_.preprocessing_step_.random_resize_method_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_resize_method(::object_detection::protos::RandomResizeMethod* random_resize_method) {
  clear_preprocessing_step();
  if (random_resize_method) {
    set_has_random_resize_method();
    _impl_.preprocessing_step_.random_resize_method_ = random_resize_method;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_resize_method)
}
inline ::object_detection::protos::RandomResizeMethod* PreprocessingStep::_internal_mutable_random_resize_method() {
  if (!_internal_has_random_resize_method()) {
    clear_preprocessing_step();
    set_has_random_resize_method();
    _impl_.preprocessing_step_.random_resize_method_ = CreateMaybeMessage< ::object_detection::protos::RandomResizeMethod >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_resize_method_;
}
inline ::object_detection::protos::RandomResizeMethod* PreprocessingStep::mutable_random_resize_method() {
  ::object_detection::protos::RandomResizeMethod* _msg = _internal_mutable_random_resize_method();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_resize_method)
  return _msg;
}

// .object_detection.protos.ScaleBoxesToPixelCoordinates scale_boxes_to_pixel_coordinates = 18;
inline bool PreprocessingStep::_internal_has_scale_boxes_to_pixel_coordinates() const {
  return preprocessing_step_case() == kScaleBoxesToPixelCoordinates;
}
inline bool PreprocessingStep::has_scale_boxes_to_pixel_coordinates() const {
  return _internal_has_scale_boxes_to_pixel_coordinates();
}
inline void PreprocessingStep::set_has_scale_boxes_to_pixel_coordinates() {
  _impl_._oneof_case_[0] = kScaleBoxesToPixelCoordinates;
}
inline void PreprocessingStep::clear_scale_boxes_to_pixel_coordinates() {
  if (_internal_has_scale_boxes_to_pixel_coordinates()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::ScaleBoxesToPixelCoordinates* PreprocessingStep::release_scale_boxes_to_pixel_coordinates() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.scale_boxes_to_pixel_coordinates)
  if (_internal_has_scale_boxes_to_pixel_coordinates()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::ScaleBoxesToPixelCoordinates* temp = _impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::ScaleBoxesToPixelCoordinates& PreprocessingStep::_internal_scale_boxes_to_pixel_coordinates() const {
  return _internal_has_scale_boxes_to_pixel_coordinates()
      ? *_impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_
      : reinterpret_cast< ::object_detection::protos::ScaleBoxesToPixelCoordinates&>(::object_detection::protos::_ScaleBoxesToPixelCoordinates_default_instance_);
}
inline const ::object_detection::protos::ScaleBoxesToPixelCoordinates& PreprocessingStep::scale_boxes_to_pixel_coordinates() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.scale_boxes_to_pixel_coordinates)
  return _internal_scale_boxes_to_pixel_coordinates();
}
inline ::object_detection::protos::ScaleBoxesToPixelCoordinates* PreprocessingStep::unsafe_arena_release_scale_boxes_to_pixel_coordinates() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.scale_boxes_to_pixel_coordinates)
  if (_internal_has_scale_boxes_to_pixel_coordinates()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::ScaleBoxesToPixelCoordinates* temp = _impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_;
    _impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_scale_boxes_to_pixel_coordinates(::object_detection::protos::ScaleBoxesToPixelCoordinates* scale_boxes_to_pixel_coordinates) {
  clear_preprocessing_step();
  if (scale_boxes_to_pixel_coordinates) {
    set_has_scale_boxes_to_pixel_coordinates();
    _impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_ = scale_boxes_to_pixel_coordinates;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.scale_boxes_to_pixel_coordinates)
}
inline ::object_detection::protos::ScaleBoxesToPixelCoordinates* PreprocessingStep::_internal_mutable_scale_boxes_to_pixel_coordinates() {
  if (!_internal_has_scale_boxes_to_pixel_coordinates()) {
    clear_preprocessing_step();
    set_has_scale_boxes_to_pixel_coordinates();
    _impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_ = CreateMaybeMessage< ::object_detection::protos::ScaleBoxesToPixelCoordinates >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.scale_boxes_to_pixel_coordinates_;
}
inline ::object_detection::protos::ScaleBoxesToPixelCoordinates* PreprocessingStep::mutable_scale_boxes_to_pixel_coordinates() {
  ::object_detection::protos::ScaleBoxesToPixelCoordinates* _msg = _internal_mutable_scale_boxes_to_pixel_coordinates();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.scale_boxes_to_pixel_coordinates)
  return _msg;
}

// .object_detection.protos.ResizeImage resize_image = 19;
inline bool PreprocessingStep::_internal_has_resize_image() const {
  return preprocessing_step_case() == kResizeImage;
}
inline bool PreprocessingStep::has_resize_image() const {
  return _internal_has_resize_image();
}
inline void PreprocessingStep::set_has_resize_image() {
  _impl_._oneof_case_[0] = kResizeImage;
}
inline void PreprocessingStep::clear_resize_image() {
  if (_internal_has_resize_image()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.resize_image_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::ResizeImage* PreprocessingStep::release_resize_image() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.resize_image)
  if (_internal_has_resize_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::ResizeImage* temp = _impl_.preprocessing_step_.resize_image_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.resize_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::ResizeImage& PreprocessingStep::_internal_resize_image() const {
  return _internal_has_resize_image()
      ? *_impl_.preprocessing_step_.resize_image_
      : reinterpret_cast< ::object_detection::protos::ResizeImage&>(::object_detection::protos::_ResizeImage_default_instance_);
}
inline const ::object_detection::protos::ResizeImage& PreprocessingStep::resize_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.resize_image)
  return _internal_resize_image();
}
inline ::object_detection::protos::ResizeImage* PreprocessingStep::unsafe_arena_release_resize_image() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.resize_image)
  if (_internal_has_resize_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::ResizeImage* temp = _impl_.preprocessing_step_.resize_image_;
    _impl_.preprocessing_step_.resize_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_resize_image(::object_detection::protos::ResizeImage* resize_image) {
  clear_preprocessing_step();
  if (resize_image) {
    set_has_resize_image();
    _impl_.preprocessing_step_.resize_image_ = resize_image;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.resize_image)
}
inline ::object_detection::protos::ResizeImage* PreprocessingStep::_internal_mutable_resize_image() {
  if (!_internal_has_resize_image()) {
    clear_preprocessing_step();
    set_has_resize_image();
    _impl_.preprocessing_step_.resize_image_ = CreateMaybeMessage< ::object_detection::protos::ResizeImage >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.resize_image_;
}
inline ::object_detection::protos::ResizeImage* PreprocessingStep::mutable_resize_image() {
  ::object_detection::protos::ResizeImage* _msg = _internal_mutable_resize_image();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.resize_image)
  return _msg;
}

// .object_detection.protos.SubtractChannelMean subtract_channel_mean = 20;
inline bool PreprocessingStep::_internal_has_subtract_channel_mean() const {
  return preprocessing_step_case() == kSubtractChannelMean;
}
inline bool PreprocessingStep::has_subtract_channel_mean() const {
  return _internal_has_subtract_channel_mean();
}
inline void PreprocessingStep::set_has_subtract_channel_mean() {
  _impl_._oneof_case_[0] = kSubtractChannelMean;
}
inline void PreprocessingStep::clear_subtract_channel_mean() {
  if (_internal_has_subtract_channel_mean()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.subtract_channel_mean_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::SubtractChannelMean* PreprocessingStep::release_subtract_channel_mean() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.subtract_channel_mean)
  if (_internal_has_subtract_channel_mean()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SubtractChannelMean* temp = _impl_.preprocessing_step_.subtract_channel_mean_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.subtract_channel_mean_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::SubtractChannelMean& PreprocessingStep::_internal_subtract_channel_mean() const {
  return _internal_has_subtract_channel_mean()
      ? *_impl_.preprocessing_step_.subtract_channel_mean_
      : reinterpret_cast< ::object_detection::protos::SubtractChannelMean&>(::object_detection::protos::_SubtractChannelMean_default_instance_);
}
inline const ::object_detection::protos::SubtractChannelMean& PreprocessingStep::subtract_channel_mean() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.subtract_channel_mean)
  return _internal_subtract_channel_mean();
}
inline ::object_detection::protos::SubtractChannelMean* PreprocessingStep::unsafe_arena_release_subtract_channel_mean() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.subtract_channel_mean)
  if (_internal_has_subtract_channel_mean()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SubtractChannelMean* temp = _impl_.preprocessing_step_.subtract_channel_mean_;
    _impl_.preprocessing_step_.subtract_channel_mean_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_subtract_channel_mean(::object_detection::protos::SubtractChannelMean* subtract_channel_mean) {
  clear_preprocessing_step();
  if (subtract_channel_mean) {
    set_has_subtract_channel_mean();
    _impl_.preprocessing_step_.subtract_channel_mean_ = subtract_channel_mean;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.subtract_channel_mean)
}
inline ::object_detection::protos::SubtractChannelMean* PreprocessingStep::_internal_mutable_subtract_channel_mean() {
  if (!_internal_has_subtract_channel_mean()) {
    clear_preprocessing_step();
    set_has_subtract_channel_mean();
    _impl_.preprocessing_step_.subtract_channel_mean_ = CreateMaybeMessage< ::object_detection::protos::SubtractChannelMean >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.subtract_channel_mean_;
}
inline ::object_detection::protos::SubtractChannelMean* PreprocessingStep::mutable_subtract_channel_mean() {
  ::object_detection::protos::SubtractChannelMean* _msg = _internal_mutable_subtract_channel_mean();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.subtract_channel_mean)
  return _msg;
}

// .object_detection.protos.SSDRandomCrop ssd_random_crop = 21;
inline bool PreprocessingStep::_internal_has_ssd_random_crop() const {
  return preprocessing_step_case() == kSsdRandomCrop;
}
inline bool PreprocessingStep::has_ssd_random_crop() const {
  return _internal_has_ssd_random_crop();
}
inline void PreprocessingStep::set_has_ssd_random_crop() {
  _impl_._oneof_case_[0] = kSsdRandomCrop;
}
inline void PreprocessingStep::clear_ssd_random_crop() {
  if (_internal_has_ssd_random_crop()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.ssd_random_crop_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::SSDRandomCrop* PreprocessingStep::release_ssd_random_crop() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.ssd_random_crop)
  if (_internal_has_ssd_random_crop()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SSDRandomCrop* temp = _impl_.preprocessing_step_.ssd_random_crop_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.ssd_random_crop_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::SSDRandomCrop& PreprocessingStep::_internal_ssd_random_crop() const {
  return _internal_has_ssd_random_crop()
      ? *_impl_.preprocessing_step_.ssd_random_crop_
      : reinterpret_cast< ::object_detection::protos::SSDRandomCrop&>(::object_detection::protos::_SSDRandomCrop_default_instance_);
}
inline const ::object_detection::protos::SSDRandomCrop& PreprocessingStep::ssd_random_crop() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.ssd_random_crop)
  return _internal_ssd_random_crop();
}
inline ::object_detection::protos::SSDRandomCrop* PreprocessingStep::unsafe_arena_release_ssd_random_crop() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.ssd_random_crop)
  if (_internal_has_ssd_random_crop()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SSDRandomCrop* temp = _impl_.preprocessing_step_.ssd_random_crop_;
    _impl_.preprocessing_step_.ssd_random_crop_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_ssd_random_crop(::object_detection::protos::SSDRandomCrop* ssd_random_crop) {
  clear_preprocessing_step();
  if (ssd_random_crop) {
    set_has_ssd_random_crop();
    _impl_.preprocessing_step_.ssd_random_crop_ = ssd_random_crop;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.ssd_random_crop)
}
inline ::object_detection::protos::SSDRandomCrop* PreprocessingStep::_internal_mutable_ssd_random_crop() {
  if (!_internal_has_ssd_random_crop()) {
    clear_preprocessing_step();
    set_has_ssd_random_crop();
    _impl_.preprocessing_step_.ssd_random_crop_ = CreateMaybeMessage< ::object_detection::protos::SSDRandomCrop >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.ssd_random_crop_;
}
inline ::object_detection::protos::SSDRandomCrop* PreprocessingStep::mutable_ssd_random_crop() {
  ::object_detection::protos::SSDRandomCrop* _msg = _internal_mutable_ssd_random_crop();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.ssd_random_crop)
  return _msg;
}

// .object_detection.protos.SSDRandomCropPad ssd_random_crop_pad = 22;
inline bool PreprocessingStep::_internal_has_ssd_random_crop_pad() const {
  return preprocessing_step_case() == kSsdRandomCropPad;
}
inline bool PreprocessingStep::has_ssd_random_crop_pad() const {
  return _internal_has_ssd_random_crop_pad();
}
inline void PreprocessingStep::set_has_ssd_random_crop_pad() {
  _impl_._oneof_case_[0] = kSsdRandomCropPad;
}
inline void PreprocessingStep::clear_ssd_random_crop_pad() {
  if (_internal_has_ssd_random_crop_pad()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.ssd_random_crop_pad_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::SSDRandomCropPad* PreprocessingStep::release_ssd_random_crop_pad() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.ssd_random_crop_pad)
  if (_internal_has_ssd_random_crop_pad()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SSDRandomCropPad* temp = _impl_.preprocessing_step_.ssd_random_crop_pad_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.ssd_random_crop_pad_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::SSDRandomCropPad& PreprocessingStep::_internal_ssd_random_crop_pad() const {
  return _internal_has_ssd_random_crop_pad()
      ? *_impl_.preprocessing_step_.ssd_random_crop_pad_
      : reinterpret_cast< ::object_detection::protos::SSDRandomCropPad&>(::object_detection::protos::_SSDRandomCropPad_default_instance_);
}
inline const ::object_detection::protos::SSDRandomCropPad& PreprocessingStep::ssd_random_crop_pad() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.ssd_random_crop_pad)
  return _internal_ssd_random_crop_pad();
}
inline ::object_detection::protos::SSDRandomCropPad* PreprocessingStep::unsafe_arena_release_ssd_random_crop_pad() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.ssd_random_crop_pad)
  if (_internal_has_ssd_random_crop_pad()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SSDRandomCropPad* temp = _impl_.preprocessing_step_.ssd_random_crop_pad_;
    _impl_.preprocessing_step_.ssd_random_crop_pad_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_ssd_random_crop_pad(::object_detection::protos::SSDRandomCropPad* ssd_random_crop_pad) {
  clear_preprocessing_step();
  if (ssd_random_crop_pad) {
    set_has_ssd_random_crop_pad();
    _impl_.preprocessing_step_.ssd_random_crop_pad_ = ssd_random_crop_pad;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.ssd_random_crop_pad)
}
inline ::object_detection::protos::SSDRandomCropPad* PreprocessingStep::_internal_mutable_ssd_random_crop_pad() {
  if (!_internal_has_ssd_random_crop_pad()) {
    clear_preprocessing_step();
    set_has_ssd_random_crop_pad();
    _impl_.preprocessing_step_.ssd_random_crop_pad_ = CreateMaybeMessage< ::object_detection::protos::SSDRandomCropPad >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.ssd_random_crop_pad_;
}
inline ::object_detection::protos::SSDRandomCropPad* PreprocessingStep::mutable_ssd_random_crop_pad() {
  ::object_detection::protos::SSDRandomCropPad* _msg = _internal_mutable_ssd_random_crop_pad();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.ssd_random_crop_pad)
  return _msg;
}

// .object_detection.protos.SSDRandomCropFixedAspectRatio ssd_random_crop_fixed_aspect_ratio = 23;
inline bool PreprocessingStep::_internal_has_ssd_random_crop_fixed_aspect_ratio() const {
  return preprocessing_step_case() == kSsdRandomCropFixedAspectRatio;
}
inline bool PreprocessingStep::has_ssd_random_crop_fixed_aspect_ratio() const {
  return _internal_has_ssd_random_crop_fixed_aspect_ratio();
}
inline void PreprocessingStep::set_has_ssd_random_crop_fixed_aspect_ratio() {
  _impl_._oneof_case_[0] = kSsdRandomCropFixedAspectRatio;
}
inline void PreprocessingStep::clear_ssd_random_crop_fixed_aspect_ratio() {
  if (_internal_has_ssd_random_crop_fixed_aspect_ratio()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::SSDRandomCropFixedAspectRatio* PreprocessingStep::release_ssd_random_crop_fixed_aspect_ratio() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.ssd_random_crop_fixed_aspect_ratio)
  if (_internal_has_ssd_random_crop_fixed_aspect_ratio()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SSDRandomCropFixedAspectRatio* temp = _impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::SSDRandomCropFixedAspectRatio& PreprocessingStep::_internal_ssd_random_crop_fixed_aspect_ratio() const {
  return _internal_has_ssd_random_crop_fixed_aspect_ratio()
      ? *_impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_
      : reinterpret_cast< ::object_detection::protos::SSDRandomCropFixedAspectRatio&>(::object_detection::protos::_SSDRandomCropFixedAspectRatio_default_instance_);
}
inline const ::object_detection::protos::SSDRandomCropFixedAspectRatio& PreprocessingStep::ssd_random_crop_fixed_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.ssd_random_crop_fixed_aspect_ratio)
  return _internal_ssd_random_crop_fixed_aspect_ratio();
}
inline ::object_detection::protos::SSDRandomCropFixedAspectRatio* PreprocessingStep::unsafe_arena_release_ssd_random_crop_fixed_aspect_ratio() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.ssd_random_crop_fixed_aspect_ratio)
  if (_internal_has_ssd_random_crop_fixed_aspect_ratio()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SSDRandomCropFixedAspectRatio* temp = _impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_;
    _impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_ssd_random_crop_fixed_aspect_ratio(::object_detection::protos::SSDRandomCropFixedAspectRatio* ssd_random_crop_fixed_aspect_ratio) {
  clear_preprocessing_step();
  if (ssd_random_crop_fixed_aspect_ratio) {
    set_has_ssd_random_crop_fixed_aspect_ratio();
    _impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_ = ssd_random_crop_fixed_aspect_ratio;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.ssd_random_crop_fixed_aspect_ratio)
}
inline ::object_detection::protos::SSDRandomCropFixedAspectRatio* PreprocessingStep::_internal_mutable_ssd_random_crop_fixed_aspect_ratio() {
  if (!_internal_has_ssd_random_crop_fixed_aspect_ratio()) {
    clear_preprocessing_step();
    set_has_ssd_random_crop_fixed_aspect_ratio();
    _impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_ = CreateMaybeMessage< ::object_detection::protos::SSDRandomCropFixedAspectRatio >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.ssd_random_crop_fixed_aspect_ratio_;
}
inline ::object_detection::protos::SSDRandomCropFixedAspectRatio* PreprocessingStep::mutable_ssd_random_crop_fixed_aspect_ratio() {
  ::object_detection::protos::SSDRandomCropFixedAspectRatio* _msg = _internal_mutable_ssd_random_crop_fixed_aspect_ratio();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.ssd_random_crop_fixed_aspect_ratio)
  return _msg;
}

// .object_detection.protos.SSDRandomCropPadFixedAspectRatio ssd_random_crop_pad_fixed_aspect_ratio = 24;
inline bool PreprocessingStep::_internal_has_ssd_random_crop_pad_fixed_aspect_ratio() const {
  return preprocessing_step_case() == kSsdRandomCropPadFixedAspectRatio;
}
inline bool PreprocessingStep::has_ssd_random_crop_pad_fixed_aspect_ratio() const {
  return _internal_has_ssd_random_crop_pad_fixed_aspect_ratio();
}
inline void PreprocessingStep::set_has_ssd_random_crop_pad_fixed_aspect_ratio() {
  _impl_._oneof_case_[0] = kSsdRandomCropPadFixedAspectRatio;
}
inline void PreprocessingStep::clear_ssd_random_crop_pad_fixed_aspect_ratio() {
  if (_internal_has_ssd_random_crop_pad_fixed_aspect_ratio()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* PreprocessingStep::release_ssd_random_crop_pad_fixed_aspect_ratio() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.ssd_random_crop_pad_fixed_aspect_ratio)
  if (_internal_has_ssd_random_crop_pad_fixed_aspect_ratio()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* temp = _impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::SSDRandomCropPadFixedAspectRatio& PreprocessingStep::_internal_ssd_random_crop_pad_fixed_aspect_ratio() const {
  return _internal_has_ssd_random_crop_pad_fixed_aspect_ratio()
      ? *_impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_
      : reinterpret_cast< ::object_detection::protos::SSDRandomCropPadFixedAspectRatio&>(::object_detection::protos::_SSDRandomCropPadFixedAspectRatio_default_instance_);
}
inline const ::object_detection::protos::SSDRandomCropPadFixedAspectRatio& PreprocessingStep::ssd_random_crop_pad_fixed_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.ssd_random_crop_pad_fixed_aspect_ratio)
  return _internal_ssd_random_crop_pad_fixed_aspect_ratio();
}
inline ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* PreprocessingStep::unsafe_arena_release_ssd_random_crop_pad_fixed_aspect_ratio() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.ssd_random_crop_pad_fixed_aspect_ratio)
  if (_internal_has_ssd_random_crop_pad_fixed_aspect_ratio()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* temp = _impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_;
    _impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_ssd_random_crop_pad_fixed_aspect_ratio(::object_detection::protos::SSDRandomCropPadFixedAspectRatio* ssd_random_crop_pad_fixed_aspect_ratio) {
  clear_preprocessing_step();
  if (ssd_random_crop_pad_fixed_aspect_ratio) {
    set_has_ssd_random_crop_pad_fixed_aspect_ratio();
    _impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_ = ssd_random_crop_pad_fixed_aspect_ratio;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.ssd_random_crop_pad_fixed_aspect_ratio)
}
inline ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* PreprocessingStep::_internal_mutable_ssd_random_crop_pad_fixed_aspect_ratio() {
  if (!_internal_has_ssd_random_crop_pad_fixed_aspect_ratio()) {
    clear_preprocessing_step();
    set_has_ssd_random_crop_pad_fixed_aspect_ratio();
    _impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_ = CreateMaybeMessage< ::object_detection::protos::SSDRandomCropPadFixedAspectRatio >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.ssd_random_crop_pad_fixed_aspect_ratio_;
}
inline ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* PreprocessingStep::mutable_ssd_random_crop_pad_fixed_aspect_ratio() {
  ::object_detection::protos::SSDRandomCropPadFixedAspectRatio* _msg = _internal_mutable_ssd_random_crop_pad_fixed_aspect_ratio();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.ssd_random_crop_pad_fixed_aspect_ratio)
  return _msg;
}

// .object_detection.protos.RandomVerticalFlip random_vertical_flip = 25;
inline bool PreprocessingStep::_internal_has_random_vertical_flip() const {
  return preprocessing_step_case() == kRandomVerticalFlip;
}
inline bool PreprocessingStep::has_random_vertical_flip() const {
  return _internal_has_random_vertical_flip();
}
inline void PreprocessingStep::set_has_random_vertical_flip() {
  _impl_._oneof_case_[0] = kRandomVerticalFlip;
}
inline void PreprocessingStep::clear_random_vertical_flip() {
  if (_internal_has_random_vertical_flip()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_vertical_flip_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomVerticalFlip* PreprocessingStep::release_random_vertical_flip() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_vertical_flip)
  if (_internal_has_random_vertical_flip()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomVerticalFlip* temp = _impl_.preprocessing_step_.random_vertical_flip_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_vertical_flip_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomVerticalFlip& PreprocessingStep::_internal_random_vertical_flip() const {
  return _internal_has_random_vertical_flip()
      ? *_impl_.preprocessing_step_.random_vertical_flip_
      : reinterpret_cast< ::object_detection::protos::RandomVerticalFlip&>(::object_detection::protos::_RandomVerticalFlip_default_instance_);
}
inline const ::object_detection::protos::RandomVerticalFlip& PreprocessingStep::random_vertical_flip() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_vertical_flip)
  return _internal_random_vertical_flip();
}
inline ::object_detection::protos::RandomVerticalFlip* PreprocessingStep::unsafe_arena_release_random_vertical_flip() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_vertical_flip)
  if (_internal_has_random_vertical_flip()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomVerticalFlip* temp = _impl_.preprocessing_step_.random_vertical_flip_;
    _impl_.preprocessing_step_.random_vertical_flip_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_vertical_flip(::object_detection::protos::RandomVerticalFlip* random_vertical_flip) {
  clear_preprocessing_step();
  if (random_vertical_flip) {
    set_has_random_vertical_flip();
    _impl_.preprocessing_step_.random_vertical_flip_ = random_vertical_flip;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_vertical_flip)
}
inline ::object_detection::protos::RandomVerticalFlip* PreprocessingStep::_internal_mutable_random_vertical_flip() {
  if (!_internal_has_random_vertical_flip()) {
    clear_preprocessing_step();
    set_has_random_vertical_flip();
    _impl_.preprocessing_step_.random_vertical_flip_ = CreateMaybeMessage< ::object_detection::protos::RandomVerticalFlip >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_vertical_flip_;
}
inline ::object_detection::protos::RandomVerticalFlip* PreprocessingStep::mutable_random_vertical_flip() {
  ::object_detection::protos::RandomVerticalFlip* _msg = _internal_mutable_random_vertical_flip();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_vertical_flip)
  return _msg;
}

// .object_detection.protos.RandomRotation90 random_rotation90 = 26;
inline bool PreprocessingStep::_internal_has_random_rotation90() const {
  return preprocessing_step_case() == kRandomRotation90;
}
inline bool PreprocessingStep::has_random_rotation90() const {
  return _internal_has_random_rotation90();
}
inline void PreprocessingStep::set_has_random_rotation90() {
  _impl_._oneof_case_[0] = kRandomRotation90;
}
inline void PreprocessingStep::clear_random_rotation90() {
  if (_internal_has_random_rotation90()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_rotation90_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomRotation90* PreprocessingStep::release_random_rotation90() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_rotation90)
  if (_internal_has_random_rotation90()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomRotation90* temp = _impl_.preprocessing_step_.random_rotation90_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_rotation90_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomRotation90& PreprocessingStep::_internal_random_rotation90() const {
  return _internal_has_random_rotation90()
      ? *_impl_.preprocessing_step_.random_rotation90_
      : reinterpret_cast< ::object_detection::protos::RandomRotation90&>(::object_detection::protos::_RandomRotation90_default_instance_);
}
inline const ::object_detection::protos::RandomRotation90& PreprocessingStep::random_rotation90() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_rotation90)
  return _internal_random_rotation90();
}
inline ::object_detection::protos::RandomRotation90* PreprocessingStep::unsafe_arena_release_random_rotation90() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_rotation90)
  if (_internal_has_random_rotation90()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomRotation90* temp = _impl_.preprocessing_step_.random_rotation90_;
    _impl_.preprocessing_step_.random_rotation90_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_rotation90(::object_detection::protos::RandomRotation90* random_rotation90) {
  clear_preprocessing_step();
  if (random_rotation90) {
    set_has_random_rotation90();
    _impl_.preprocessing_step_.random_rotation90_ = random_rotation90;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_rotation90)
}
inline ::object_detection::protos::RandomRotation90* PreprocessingStep::_internal_mutable_random_rotation90() {
  if (!_internal_has_random_rotation90()) {
    clear_preprocessing_step();
    set_has_random_rotation90();
    _impl_.preprocessing_step_.random_rotation90_ = CreateMaybeMessage< ::object_detection::protos::RandomRotation90 >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_rotation90_;
}
inline ::object_detection::protos::RandomRotation90* PreprocessingStep::mutable_random_rotation90() {
  ::object_detection::protos::RandomRotation90* _msg = _internal_mutable_random_rotation90();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_rotation90)
  return _msg;
}

// .object_detection.protos.RGBtoGray rgb_to_gray = 27;
inline bool PreprocessingStep::_internal_has_rgb_to_gray() const {
  return preprocessing_step_case() == kRgbToGray;
}
inline bool PreprocessingStep::has_rgb_to_gray() const {
  return _internal_has_rgb_to_gray();
}
inline void PreprocessingStep::set_has_rgb_to_gray() {
  _impl_._oneof_case_[0] = kRgbToGray;
}
inline void PreprocessingStep::clear_rgb_to_gray() {
  if (_internal_has_rgb_to_gray()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.rgb_to_gray_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RGBtoGray* PreprocessingStep::release_rgb_to_gray() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.rgb_to_gray)
  if (_internal_has_rgb_to_gray()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RGBtoGray* temp = _impl_.preprocessing_step_.rgb_to_gray_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.rgb_to_gray_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RGBtoGray& PreprocessingStep::_internal_rgb_to_gray() const {
  return _internal_has_rgb_to_gray()
      ? *_impl_.preprocessing_step_.rgb_to_gray_
      : reinterpret_cast< ::object_detection::protos::RGBtoGray&>(::object_detection::protos::_RGBtoGray_default_instance_);
}
inline const ::object_detection::protos::RGBtoGray& PreprocessingStep::rgb_to_gray() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.rgb_to_gray)
  return _internal_rgb_to_gray();
}
inline ::object_detection::protos::RGBtoGray* PreprocessingStep::unsafe_arena_release_rgb_to_gray() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.rgb_to_gray)
  if (_internal_has_rgb_to_gray()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RGBtoGray* temp = _impl_.preprocessing_step_.rgb_to_gray_;
    _impl_.preprocessing_step_.rgb_to_gray_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_rgb_to_gray(::object_detection::protos::RGBtoGray* rgb_to_gray) {
  clear_preprocessing_step();
  if (rgb_to_gray) {
    set_has_rgb_to_gray();
    _impl_.preprocessing_step_.rgb_to_gray_ = rgb_to_gray;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.rgb_to_gray)
}
inline ::object_detection::protos::RGBtoGray* PreprocessingStep::_internal_mutable_rgb_to_gray() {
  if (!_internal_has_rgb_to_gray()) {
    clear_preprocessing_step();
    set_has_rgb_to_gray();
    _impl_.preprocessing_step_.rgb_to_gray_ = CreateMaybeMessage< ::object_detection::protos::RGBtoGray >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.rgb_to_gray_;
}
inline ::object_detection::protos::RGBtoGray* PreprocessingStep::mutable_rgb_to_gray() {
  ::object_detection::protos::RGBtoGray* _msg = _internal_mutable_rgb_to_gray();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.rgb_to_gray)
  return _msg;
}

// .object_detection.protos.ConvertClassLogitsToSoftmax convert_class_logits_to_softmax = 28;
inline bool PreprocessingStep::_internal_has_convert_class_logits_to_softmax() const {
  return preprocessing_step_case() == kConvertClassLogitsToSoftmax;
}
inline bool PreprocessingStep::has_convert_class_logits_to_softmax() const {
  return _internal_has_convert_class_logits_to_softmax();
}
inline void PreprocessingStep::set_has_convert_class_logits_to_softmax() {
  _impl_._oneof_case_[0] = kConvertClassLogitsToSoftmax;
}
inline void PreprocessingStep::clear_convert_class_logits_to_softmax() {
  if (_internal_has_convert_class_logits_to_softmax()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.convert_class_logits_to_softmax_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::ConvertClassLogitsToSoftmax* PreprocessingStep::release_convert_class_logits_to_softmax() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.convert_class_logits_to_softmax)
  if (_internal_has_convert_class_logits_to_softmax()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::ConvertClassLogitsToSoftmax* temp = _impl_.preprocessing_step_.convert_class_logits_to_softmax_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.convert_class_logits_to_softmax_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::ConvertClassLogitsToSoftmax& PreprocessingStep::_internal_convert_class_logits_to_softmax() const {
  return _internal_has_convert_class_logits_to_softmax()
      ? *_impl_.preprocessing_step_.convert_class_logits_to_softmax_
      : reinterpret_cast< ::object_detection::protos::ConvertClassLogitsToSoftmax&>(::object_detection::protos::_ConvertClassLogitsToSoftmax_default_instance_);
}
inline const ::object_detection::protos::ConvertClassLogitsToSoftmax& PreprocessingStep::convert_class_logits_to_softmax() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.convert_class_logits_to_softmax)
  return _internal_convert_class_logits_to_softmax();
}
inline ::object_detection::protos::ConvertClassLogitsToSoftmax* PreprocessingStep::unsafe_arena_release_convert_class_logits_to_softmax() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.convert_class_logits_to_softmax)
  if (_internal_has_convert_class_logits_to_softmax()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::ConvertClassLogitsToSoftmax* temp = _impl_.preprocessing_step_.convert_class_logits_to_softmax_;
    _impl_.preprocessing_step_.convert_class_logits_to_softmax_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_convert_class_logits_to_softmax(::object_detection::protos::ConvertClassLogitsToSoftmax* convert_class_logits_to_softmax) {
  clear_preprocessing_step();
  if (convert_class_logits_to_softmax) {
    set_has_convert_class_logits_to_softmax();
    _impl_.preprocessing_step_.convert_class_logits_to_softmax_ = convert_class_logits_to_softmax;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.convert_class_logits_to_softmax)
}
inline ::object_detection::protos::ConvertClassLogitsToSoftmax* PreprocessingStep::_internal_mutable_convert_class_logits_to_softmax() {
  if (!_internal_has_convert_class_logits_to_softmax()) {
    clear_preprocessing_step();
    set_has_convert_class_logits_to_softmax();
    _impl_.preprocessing_step_.convert_class_logits_to_softmax_ = CreateMaybeMessage< ::object_detection::protos::ConvertClassLogitsToSoftmax >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.convert_class_logits_to_softmax_;
}
inline ::object_detection::protos::ConvertClassLogitsToSoftmax* PreprocessingStep::mutable_convert_class_logits_to_softmax() {
  ::object_detection::protos::ConvertClassLogitsToSoftmax* _msg = _internal_mutable_convert_class_logits_to_softmax();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.convert_class_logits_to_softmax)
  return _msg;
}

// .object_detection.protos.RandomAbsolutePadImage random_absolute_pad_image = 29;
inline bool PreprocessingStep::_internal_has_random_absolute_pad_image() const {
  return preprocessing_step_case() == kRandomAbsolutePadImage;
}
inline bool PreprocessingStep::has_random_absolute_pad_image() const {
  return _internal_has_random_absolute_pad_image();
}
inline void PreprocessingStep::set_has_random_absolute_pad_image() {
  _impl_._oneof_case_[0] = kRandomAbsolutePadImage;
}
inline void PreprocessingStep::clear_random_absolute_pad_image() {
  if (_internal_has_random_absolute_pad_image()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_absolute_pad_image_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomAbsolutePadImage* PreprocessingStep::release_random_absolute_pad_image() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_absolute_pad_image)
  if (_internal_has_random_absolute_pad_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAbsolutePadImage* temp = _impl_.preprocessing_step_.random_absolute_pad_image_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_absolute_pad_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomAbsolutePadImage& PreprocessingStep::_internal_random_absolute_pad_image() const {
  return _internal_has_random_absolute_pad_image()
      ? *_impl_.preprocessing_step_.random_absolute_pad_image_
      : reinterpret_cast< ::object_detection::protos::RandomAbsolutePadImage&>(::object_detection::protos::_RandomAbsolutePadImage_default_instance_);
}
inline const ::object_detection::protos::RandomAbsolutePadImage& PreprocessingStep::random_absolute_pad_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_absolute_pad_image)
  return _internal_random_absolute_pad_image();
}
inline ::object_detection::protos::RandomAbsolutePadImage* PreprocessingStep::unsafe_arena_release_random_absolute_pad_image() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_absolute_pad_image)
  if (_internal_has_random_absolute_pad_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomAbsolutePadImage* temp = _impl_.preprocessing_step_.random_absolute_pad_image_;
    _impl_.preprocessing_step_.random_absolute_pad_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_absolute_pad_image(::object_detection::protos::RandomAbsolutePadImage* random_absolute_pad_image) {
  clear_preprocessing_step();
  if (random_absolute_pad_image) {
    set_has_random_absolute_pad_image();
    _impl_.preprocessing_step_.random_absolute_pad_image_ = random_absolute_pad_image;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_absolute_pad_image)
}
inline ::object_detection::protos::RandomAbsolutePadImage* PreprocessingStep::_internal_mutable_random_absolute_pad_image() {
  if (!_internal_has_random_absolute_pad_image()) {
    clear_preprocessing_step();
    set_has_random_absolute_pad_image();
    _impl_.preprocessing_step_.random_absolute_pad_image_ = CreateMaybeMessage< ::object_detection::protos::RandomAbsolutePadImage >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_absolute_pad_image_;
}
inline ::object_detection::protos::RandomAbsolutePadImage* PreprocessingStep::mutable_random_absolute_pad_image() {
  ::object_detection::protos::RandomAbsolutePadImage* _msg = _internal_mutable_random_absolute_pad_image();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_absolute_pad_image)
  return _msg;
}

// .object_detection.protos.RandomSelfConcatImage random_self_concat_image = 30;
inline bool PreprocessingStep::_internal_has_random_self_concat_image() const {
  return preprocessing_step_case() == kRandomSelfConcatImage;
}
inline bool PreprocessingStep::has_random_self_concat_image() const {
  return _internal_has_random_self_concat_image();
}
inline void PreprocessingStep::set_has_random_self_concat_image() {
  _impl_._oneof_case_[0] = kRandomSelfConcatImage;
}
inline void PreprocessingStep::clear_random_self_concat_image() {
  if (_internal_has_random_self_concat_image()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.random_self_concat_image_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RandomSelfConcatImage* PreprocessingStep::release_random_self_concat_image() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.random_self_concat_image)
  if (_internal_has_random_self_concat_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomSelfConcatImage* temp = _impl_.preprocessing_step_.random_self_concat_image_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.random_self_concat_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomSelfConcatImage& PreprocessingStep::_internal_random_self_concat_image() const {
  return _internal_has_random_self_concat_image()
      ? *_impl_.preprocessing_step_.random_self_concat_image_
      : reinterpret_cast< ::object_detection::protos::RandomSelfConcatImage&>(::object_detection::protos::_RandomSelfConcatImage_default_instance_);
}
inline const ::object_detection::protos::RandomSelfConcatImage& PreprocessingStep::random_self_concat_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.random_self_concat_image)
  return _internal_random_self_concat_image();
}
inline ::object_detection::protos::RandomSelfConcatImage* PreprocessingStep::unsafe_arena_release_random_self_concat_image() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.random_self_concat_image)
  if (_internal_has_random_self_concat_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RandomSelfConcatImage* temp = _impl_.preprocessing_step_.random_self_concat_image_;
    _impl_.preprocessing_step_.random_self_concat_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_random_self_concat_image(::object_detection::protos::RandomSelfConcatImage* random_self_concat_image) {
  clear_preprocessing_step();
  if (random_self_concat_image) {
    set_has_random_self_concat_image();
    _impl_.preprocessing_step_.random_self_concat_image_ = random_self_concat_image;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.random_self_concat_image)
}
inline ::object_detection::protos::RandomSelfConcatImage* PreprocessingStep::_internal_mutable_random_self_concat_image() {
  if (!_internal_has_random_self_concat_image()) {
    clear_preprocessing_step();
    set_has_random_self_concat_image();
    _impl_.preprocessing_step_.random_self_concat_image_ = CreateMaybeMessage< ::object_detection::protos::RandomSelfConcatImage >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.random_self_concat_image_;
}
inline ::object_detection::protos::RandomSelfConcatImage* PreprocessingStep::mutable_random_self_concat_image() {
  ::object_detection::protos::RandomSelfConcatImage* _msg = _internal_mutable_random_self_concat_image();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.random_self_concat_image)
  return _msg;
}

// .object_detection.protos.AutoAugmentImage autoaugment_image = 31;
inline bool PreprocessingStep::_internal_has_autoaugment_image() const {
  return preprocessing_step_case() == kAutoaugmentImage;
}
inline bool PreprocessingStep::has_autoaugment_image() const {
  return _internal_has_autoaugment_image();
}
inline void PreprocessingStep::set_has_autoaugment_image() {
  _impl_._oneof_case_[0] = kAutoaugmentImage;
}
inline void PreprocessingStep::clear_autoaugment_image() {
  if (_internal_has_autoaugment_image()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.autoaugment_image_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::AutoAugmentImage* PreprocessingStep::release_autoaugment_image() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.autoaugment_image)
  if (_internal_has_autoaugment_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::AutoAugmentImage* temp = _impl_.preprocessing_step_.autoaugment_image_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.autoaugment_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::AutoAugmentImage& PreprocessingStep::_internal_autoaugment_image() const {
  return _internal_has_autoaugment_image()
      ? *_impl_.preprocessing_step_.autoaugment_image_
      : reinterpret_cast< ::object_detection::protos::AutoAugmentImage&>(::object_detection::protos::_AutoAugmentImage_default_instance_);
}
inline const ::object_detection::protos::AutoAugmentImage& PreprocessingStep::autoaugment_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.autoaugment_image)
  return _internal_autoaugment_image();
}
inline ::object_detection::protos::AutoAugmentImage* PreprocessingStep::unsafe_arena_release_autoaugment_image() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.autoaugment_image)
  if (_internal_has_autoaugment_image()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::AutoAugmentImage* temp = _impl_.preprocessing_step_.autoaugment_image_;
    _impl_.preprocessing_step_.autoaugment_image_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_autoaugment_image(::object_detection::protos::AutoAugmentImage* autoaugment_image) {
  clear_preprocessing_step();
  if (autoaugment_image) {
    set_has_autoaugment_image();
    _impl_.preprocessing_step_.autoaugment_image_ = autoaugment_image;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.autoaugment_image)
}
inline ::object_detection::protos::AutoAugmentImage* PreprocessingStep::_internal_mutable_autoaugment_image() {
  if (!_internal_has_autoaugment_image()) {
    clear_preprocessing_step();
    set_has_autoaugment_image();
    _impl_.preprocessing_step_.autoaugment_image_ = CreateMaybeMessage< ::object_detection::protos::AutoAugmentImage >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.autoaugment_image_;
}
inline ::object_detection::protos::AutoAugmentImage* PreprocessingStep::mutable_autoaugment_image() {
  ::object_detection::protos::AutoAugmentImage* _msg = _internal_mutable_autoaugment_image();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.autoaugment_image)
  return _msg;
}

// .object_detection.protos.DropLabelProbabilistically drop_label_probabilistically = 32;
inline bool PreprocessingStep::_internal_has_drop_label_probabilistically() const {
  return preprocessing_step_case() == kDropLabelProbabilistically;
}
inline bool PreprocessingStep::has_drop_label_probabilistically() const {
  return _internal_has_drop_label_probabilistically();
}
inline void PreprocessingStep::set_has_drop_label_probabilistically() {
  _impl_._oneof_case_[0] = kDropLabelProbabilistically;
}
inline void PreprocessingStep::clear_drop_label_probabilistically() {
  if (_internal_has_drop_label_probabilistically()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.drop_label_probabilistically_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::DropLabelProbabilistically* PreprocessingStep::release_drop_label_probabilistically() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.drop_label_probabilistically)
  if (_internal_has_drop_label_probabilistically()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::DropLabelProbabilistically* temp = _impl_.preprocessing_step_.drop_label_probabilistically_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.drop_label_probabilistically_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::DropLabelProbabilistically& PreprocessingStep::_internal_drop_label_probabilistically() const {
  return _internal_has_drop_label_probabilistically()
      ? *_impl_.preprocessing_step_.drop_label_probabilistically_
      : reinterpret_cast< ::object_detection::protos::DropLabelProbabilistically&>(::object_detection::protos::_DropLabelProbabilistically_default_instance_);
}
inline const ::object_detection::protos::DropLabelProbabilistically& PreprocessingStep::drop_label_probabilistically() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.drop_label_probabilistically)
  return _internal_drop_label_probabilistically();
}
inline ::object_detection::protos::DropLabelProbabilistically* PreprocessingStep::unsafe_arena_release_drop_label_probabilistically() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.drop_label_probabilistically)
  if (_internal_has_drop_label_probabilistically()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::DropLabelProbabilistically* temp = _impl_.preprocessing_step_.drop_label_probabilistically_;
    _impl_.preprocessing_step_.drop_label_probabilistically_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_drop_label_probabilistically(::object_detection::protos::DropLabelProbabilistically* drop_label_probabilistically) {
  clear_preprocessing_step();
  if (drop_label_probabilistically) {
    set_has_drop_label_probabilistically();
    _impl_.preprocessing_step_.drop_label_probabilistically_ = drop_label_probabilistically;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.drop_label_probabilistically)
}
inline ::object_detection::protos::DropLabelProbabilistically* PreprocessingStep::_internal_mutable_drop_label_probabilistically() {
  if (!_internal_has_drop_label_probabilistically()) {
    clear_preprocessing_step();
    set_has_drop_label_probabilistically();
    _impl_.preprocessing_step_.drop_label_probabilistically_ = CreateMaybeMessage< ::object_detection::protos::DropLabelProbabilistically >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.drop_label_probabilistically_;
}
inline ::object_detection::protos::DropLabelProbabilistically* PreprocessingStep::mutable_drop_label_probabilistically() {
  ::object_detection::protos::DropLabelProbabilistically* _msg = _internal_mutable_drop_label_probabilistically();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.drop_label_probabilistically)
  return _msg;
}

// .object_detection.protos.RemapLabels remap_labels = 33;
inline bool PreprocessingStep::_internal_has_remap_labels() const {
  return preprocessing_step_case() == kRemapLabels;
}
inline bool PreprocessingStep::has_remap_labels() const {
  return _internal_has_remap_labels();
}
inline void PreprocessingStep::set_has_remap_labels() {
  _impl_._oneof_case_[0] = kRemapLabels;
}
inline void PreprocessingStep::clear_remap_labels() {
  if (_internal_has_remap_labels()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.preprocessing_step_.remap_labels_;
    }
    clear_has_preprocessing_step();
  }
}
inline ::object_detection::protos::RemapLabels* PreprocessingStep::release_remap_labels() {
  // @@protoc_insertion_point(field_release:object_detection.protos.PreprocessingStep.remap_labels)
  if (_internal_has_remap_labels()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RemapLabels* temp = _impl_.preprocessing_step_.remap_labels_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.preprocessing_step_.remap_labels_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RemapLabels& PreprocessingStep::_internal_remap_labels() const {
  return _internal_has_remap_labels()
      ? *_impl_.preprocessing_step_.remap_labels_
      : reinterpret_cast< ::object_detection::protos::RemapLabels&>(::object_detection::protos::_RemapLabels_default_instance_);
}
inline const ::object_detection::protos::RemapLabels& PreprocessingStep::remap_labels() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.PreprocessingStep.remap_labels)
  return _internal_remap_labels();
}
inline ::object_detection::protos::RemapLabels* PreprocessingStep::unsafe_arena_release_remap_labels() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.PreprocessingStep.remap_labels)
  if (_internal_has_remap_labels()) {
    clear_has_preprocessing_step();
    ::object_detection::protos::RemapLabels* temp = _impl_.preprocessing_step_.remap_labels_;
    _impl_.preprocessing_step_.remap_labels_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PreprocessingStep::unsafe_arena_set_allocated_remap_labels(::object_detection::protos::RemapLabels* remap_labels) {
  clear_preprocessing_step();
  if (remap_labels) {
    set_has_remap_labels();
    _impl_.preprocessing_step_.remap_labels_ = remap_labels;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.PreprocessingStep.remap_labels)
}
inline ::object_detection::protos::RemapLabels* PreprocessingStep::_internal_mutable_remap_labels() {
  if (!_internal_has_remap_labels()) {
    clear_preprocessing_step();
    set_has_remap_labels();
    _impl_.preprocessing_step_.remap_labels_ = CreateMaybeMessage< ::object_detection::protos::RemapLabels >(GetArenaForAllocation());
  }
  return _impl_.preprocessing_step_.remap_labels_;
}
inline ::object_detection::protos::RemapLabels* PreprocessingStep::mutable_remap_labels() {
  ::object_detection::protos::RemapLabels* _msg = _internal_mutable_remap_labels();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.PreprocessingStep.remap_labels)
  return _msg;
}

inline bool PreprocessingStep::has_preprocessing_step() const {
  return preprocessing_step_case() != PREPROCESSING_STEP_NOT_SET;
}
inline void PreprocessingStep::clear_has_preprocessing_step() {
  _impl_._oneof_case_[0] = PREPROCESSING_STEP_NOT_SET;
}
inline PreprocessingStep::PreprocessingStepCase PreprocessingStep::preprocessing_step_case() const {
  return PreprocessingStep::PreprocessingStepCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// NormalizeImage

// optional float original_minval = 1;
inline bool NormalizeImage::_internal_has_original_minval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NormalizeImage::has_original_minval() const {
  return _internal_has_original_minval();
}
inline void NormalizeImage::clear_original_minval() {
  _impl_.original_minval_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float NormalizeImage::_internal_original_minval() const {
  return _impl_.original_minval_;
}
inline float NormalizeImage::original_minval() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.NormalizeImage.original_minval)
  return _internal_original_minval();
}
inline void NormalizeImage::_internal_set_original_minval(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.original_minval_ = value;
}
inline void NormalizeImage::set_original_minval(float value) {
  _internal_set_original_minval(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.NormalizeImage.original_minval)
}

// optional float original_maxval = 2;
inline bool NormalizeImage::_internal_has_original_maxval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NormalizeImage::has_original_maxval() const {
  return _internal_has_original_maxval();
}
inline void NormalizeImage::clear_original_maxval() {
  _impl_.original_maxval_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float NormalizeImage::_internal_original_maxval() const {
  return _impl_.original_maxval_;
}
inline float NormalizeImage::original_maxval() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.NormalizeImage.original_maxval)
  return _internal_original_maxval();
}
inline void NormalizeImage::_internal_set_original_maxval(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.original_maxval_ = value;
}
inline void NormalizeImage::set_original_maxval(float value) {
  _internal_set_original_maxval(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.NormalizeImage.original_maxval)
}

// optional float target_minval = 3 [default = 0];
inline bool NormalizeImage::_internal_has_target_minval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NormalizeImage::has_target_minval() const {
  return _internal_has_target_minval();
}
inline void NormalizeImage::clear_target_minval() {
  _impl_.target_minval_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float NormalizeImage::_internal_target_minval() const {
  return _impl_.target_minval_;
}
inline float NormalizeImage::target_minval() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.NormalizeImage.target_minval)
  return _internal_target_minval();
}
inline void NormalizeImage::_internal_set_target_minval(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.target_minval_ = value;
}
inline void NormalizeImage::set_target_minval(float value) {
  _internal_set_target_minval(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.NormalizeImage.target_minval)
}

// optional float target_maxval = 4 [default = 1];
inline bool NormalizeImage::_internal_has_target_maxval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NormalizeImage::has_target_maxval() const {
  return _internal_has_target_maxval();
}
inline void NormalizeImage::clear_target_maxval() {
  _impl_.target_maxval_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float NormalizeImage::_internal_target_maxval() const {
  return _impl_.target_maxval_;
}
inline float NormalizeImage::target_maxval() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.NormalizeImage.target_maxval)
  return _internal_target_maxval();
}
inline void NormalizeImage::_internal_set_target_maxval(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.target_maxval_ = value;
}
inline void NormalizeImage::set_target_maxval(float value) {
  _internal_set_target_maxval(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.NormalizeImage.target_maxval)
}

// -------------------------------------------------------------------

// RandomHorizontalFlip

// repeated int32 keypoint_flip_permutation = 1;
inline int RandomHorizontalFlip::_internal_keypoint_flip_permutation_size() const {
  return _impl_.keypoint_flip_permutation_.size();
}
inline int RandomHorizontalFlip::keypoint_flip_permutation_size() const {
  return _internal_keypoint_flip_permutation_size();
}
inline void RandomHorizontalFlip::clear_keypoint_flip_permutation() {
  _impl_.keypoint_flip_permutation_.Clear();
}
inline int32_t RandomHorizontalFlip::_internal_keypoint_flip_permutation(int index) const {
  return _impl_.keypoint_flip_permutation_.Get(index);
}
inline int32_t RandomHorizontalFlip::keypoint_flip_permutation(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomHorizontalFlip.keypoint_flip_permutation)
  return _internal_keypoint_flip_permutation(index);
}
inline void RandomHorizontalFlip::set_keypoint_flip_permutation(int index, int32_t value) {
  _impl_.keypoint_flip_permutation_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomHorizontalFlip.keypoint_flip_permutation)
}
inline void RandomHorizontalFlip::_internal_add_keypoint_flip_permutation(int32_t value) {
  _impl_.keypoint_flip_permutation_.Add(value);
}
inline void RandomHorizontalFlip::add_keypoint_flip_permutation(int32_t value) {
  _internal_add_keypoint_flip_permutation(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.RandomHorizontalFlip.keypoint_flip_permutation)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
RandomHorizontalFlip::_internal_keypoint_flip_permutation() const {
  return _impl_.keypoint_flip_permutation_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
RandomHorizontalFlip::keypoint_flip_permutation() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.RandomHorizontalFlip.keypoint_flip_permutation)
  return _internal_keypoint_flip_permutation();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
RandomHorizontalFlip::_internal_mutable_keypoint_flip_permutation() {
  return &_impl_.keypoint_flip_permutation_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
RandomHorizontalFlip::mutable_keypoint_flip_permutation() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.RandomHorizontalFlip.keypoint_flip_permutation)
  return _internal_mutable_keypoint_flip_permutation();
}

// -------------------------------------------------------------------

// RandomVerticalFlip

// repeated int32 keypoint_flip_permutation = 1;
inline int RandomVerticalFlip::_internal_keypoint_flip_permutation_size() const {
  return _impl_.keypoint_flip_permutation_.size();
}
inline int RandomVerticalFlip::keypoint_flip_permutation_size() const {
  return _internal_keypoint_flip_permutation_size();
}
inline void RandomVerticalFlip::clear_keypoint_flip_permutation() {
  _impl_.keypoint_flip_permutation_.Clear();
}
inline int32_t RandomVerticalFlip::_internal_keypoint_flip_permutation(int index) const {
  return _impl_.keypoint_flip_permutation_.Get(index);
}
inline int32_t RandomVerticalFlip::keypoint_flip_permutation(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomVerticalFlip.keypoint_flip_permutation)
  return _internal_keypoint_flip_permutation(index);
}
inline void RandomVerticalFlip::set_keypoint_flip_permutation(int index, int32_t value) {
  _impl_.keypoint_flip_permutation_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomVerticalFlip.keypoint_flip_permutation)
}
inline void RandomVerticalFlip::_internal_add_keypoint_flip_permutation(int32_t value) {
  _impl_.keypoint_flip_permutation_.Add(value);
}
inline void RandomVerticalFlip::add_keypoint_flip_permutation(int32_t value) {
  _internal_add_keypoint_flip_permutation(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.RandomVerticalFlip.keypoint_flip_permutation)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
RandomVerticalFlip::_internal_keypoint_flip_permutation() const {
  return _impl_.keypoint_flip_permutation_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
RandomVerticalFlip::keypoint_flip_permutation() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.RandomVerticalFlip.keypoint_flip_permutation)
  return _internal_keypoint_flip_permutation();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
RandomVerticalFlip::_internal_mutable_keypoint_flip_permutation() {
  return &_impl_.keypoint_flip_permutation_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
RandomVerticalFlip::mutable_keypoint_flip_permutation() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.RandomVerticalFlip.keypoint_flip_permutation)
  return _internal_mutable_keypoint_flip_permutation();
}

// -------------------------------------------------------------------

// RandomRotation90

// -------------------------------------------------------------------

// RandomPixelValueScale

// optional float minval = 1 [default = 0.9];
inline bool RandomPixelValueScale::_internal_has_minval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomPixelValueScale::has_minval() const {
  return _internal_has_minval();
}
inline void RandomPixelValueScale::clear_minval() {
  _impl_.minval_ = 0.9f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomPixelValueScale::_internal_minval() const {
  return _impl_.minval_;
}
inline float RandomPixelValueScale::minval() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomPixelValueScale.minval)
  return _internal_minval();
}
inline void RandomPixelValueScale::_internal_set_minval(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.minval_ = value;
}
inline void RandomPixelValueScale::set_minval(float value) {
  _internal_set_minval(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomPixelValueScale.minval)
}

// optional float maxval = 2 [default = 1.1];
inline bool RandomPixelValueScale::_internal_has_maxval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomPixelValueScale::has_maxval() const {
  return _internal_has_maxval();
}
inline void RandomPixelValueScale::clear_maxval() {
  _impl_.maxval_ = 1.1f;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float RandomPixelValueScale::_internal_maxval() const {
  return _impl_.maxval_;
}
inline float RandomPixelValueScale::maxval() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomPixelValueScale.maxval)
  return _internal_maxval();
}
inline void RandomPixelValueScale::_internal_set_maxval(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.maxval_ = value;
}
inline void RandomPixelValueScale::set_maxval(float value) {
  _internal_set_maxval(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomPixelValueScale.maxval)
}

// -------------------------------------------------------------------

// RandomImageScale

// optional float min_scale_ratio = 1 [default = 0.5];
inline bool RandomImageScale::_internal_has_min_scale_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomImageScale::has_min_scale_ratio() const {
  return _internal_has_min_scale_ratio();
}
inline void RandomImageScale::clear_min_scale_ratio() {
  _impl_.min_scale_ratio_ = 0.5f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomImageScale::_internal_min_scale_ratio() const {
  return _impl_.min_scale_ratio_;
}
inline float RandomImageScale::min_scale_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomImageScale.min_scale_ratio)
  return _internal_min_scale_ratio();
}
inline void RandomImageScale::_internal_set_min_scale_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.min_scale_ratio_ = value;
}
inline void RandomImageScale::set_min_scale_ratio(float value) {
  _internal_set_min_scale_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomImageScale.min_scale_ratio)
}

// optional float max_scale_ratio = 2 [default = 2];
inline bool RandomImageScale::_internal_has_max_scale_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomImageScale::has_max_scale_ratio() const {
  return _internal_has_max_scale_ratio();
}
inline void RandomImageScale::clear_max_scale_ratio() {
  _impl_.max_scale_ratio_ = 2;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float RandomImageScale::_internal_max_scale_ratio() const {
  return _impl_.max_scale_ratio_;
}
inline float RandomImageScale::max_scale_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomImageScale.max_scale_ratio)
  return _internal_max_scale_ratio();
}
inline void RandomImageScale::_internal_set_max_scale_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.max_scale_ratio_ = value;
}
inline void RandomImageScale::set_max_scale_ratio(float value) {
  _internal_set_max_scale_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomImageScale.max_scale_ratio)
}

// -------------------------------------------------------------------

// RandomRGBtoGray

// optional float probability = 1 [default = 0.1];
inline bool RandomRGBtoGray::_internal_has_probability() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomRGBtoGray::has_probability() const {
  return _internal_has_probability();
}
inline void RandomRGBtoGray::clear_probability() {
  _impl_.probability_ = 0.1f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomRGBtoGray::_internal_probability() const {
  return _impl_.probability_;
}
inline float RandomRGBtoGray::probability() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomRGBtoGray.probability)
  return _internal_probability();
}
inline void RandomRGBtoGray::_internal_set_probability(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.probability_ = value;
}
inline void RandomRGBtoGray::set_probability(float value) {
  _internal_set_probability(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomRGBtoGray.probability)
}

// -------------------------------------------------------------------

// RandomAdjustBrightness

// optional float max_delta = 1 [default = 0.2];
inline bool RandomAdjustBrightness::_internal_has_max_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomAdjustBrightness::has_max_delta() const {
  return _internal_has_max_delta();
}
inline void RandomAdjustBrightness::clear_max_delta() {
  _impl_.max_delta_ = 0.2f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomAdjustBrightness::_internal_max_delta() const {
  return _impl_.max_delta_;
}
inline float RandomAdjustBrightness::max_delta() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAdjustBrightness.max_delta)
  return _internal_max_delta();
}
inline void RandomAdjustBrightness::_internal_set_max_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.max_delta_ = value;
}
inline void RandomAdjustBrightness::set_max_delta(float value) {
  _internal_set_max_delta(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAdjustBrightness.max_delta)
}

// -------------------------------------------------------------------

// RandomAdjustContrast

// optional float min_delta = 1 [default = 0.8];
inline bool RandomAdjustContrast::_internal_has_min_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomAdjustContrast::has_min_delta() const {
  return _internal_has_min_delta();
}
inline void RandomAdjustContrast::clear_min_delta() {
  _impl_.min_delta_ = 0.8f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomAdjustContrast::_internal_min_delta() const {
  return _impl_.min_delta_;
}
inline float RandomAdjustContrast::min_delta() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAdjustContrast.min_delta)
  return _internal_min_delta();
}
inline void RandomAdjustContrast::_internal_set_min_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.min_delta_ = value;
}
inline void RandomAdjustContrast::set_min_delta(float value) {
  _internal_set_min_delta(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAdjustContrast.min_delta)
}

// optional float max_delta = 2 [default = 1.25];
inline bool RandomAdjustContrast::_internal_has_max_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomAdjustContrast::has_max_delta() const {
  return _internal_has_max_delta();
}
inline void RandomAdjustContrast::clear_max_delta() {
  _impl_.max_delta_ = 1.25f;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float RandomAdjustContrast::_internal_max_delta() const {
  return _impl_.max_delta_;
}
inline float RandomAdjustContrast::max_delta() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAdjustContrast.max_delta)
  return _internal_max_delta();
}
inline void RandomAdjustContrast::_internal_set_max_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.max_delta_ = value;
}
inline void RandomAdjustContrast::set_max_delta(float value) {
  _internal_set_max_delta(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAdjustContrast.max_delta)
}

// -------------------------------------------------------------------

// RandomAdjustHue

// optional float max_delta = 1 [default = 0.02];
inline bool RandomAdjustHue::_internal_has_max_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomAdjustHue::has_max_delta() const {
  return _internal_has_max_delta();
}
inline void RandomAdjustHue::clear_max_delta() {
  _impl_.max_delta_ = 0.02f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomAdjustHue::_internal_max_delta() const {
  return _impl_.max_delta_;
}
inline float RandomAdjustHue::max_delta() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAdjustHue.max_delta)
  return _internal_max_delta();
}
inline void RandomAdjustHue::_internal_set_max_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.max_delta_ = value;
}
inline void RandomAdjustHue::set_max_delta(float value) {
  _internal_set_max_delta(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAdjustHue.max_delta)
}

// -------------------------------------------------------------------

// RandomAdjustSaturation

// optional float min_delta = 1 [default = 0.8];
inline bool RandomAdjustSaturation::_internal_has_min_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomAdjustSaturation::has_min_delta() const {
  return _internal_has_min_delta();
}
inline void RandomAdjustSaturation::clear_min_delta() {
  _impl_.min_delta_ = 0.8f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomAdjustSaturation::_internal_min_delta() const {
  return _impl_.min_delta_;
}
inline float RandomAdjustSaturation::min_delta() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAdjustSaturation.min_delta)
  return _internal_min_delta();
}
inline void RandomAdjustSaturation::_internal_set_min_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.min_delta_ = value;
}
inline void RandomAdjustSaturation::set_min_delta(float value) {
  _internal_set_min_delta(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAdjustSaturation.min_delta)
}

// optional float max_delta = 2 [default = 1.25];
inline bool RandomAdjustSaturation::_internal_has_max_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomAdjustSaturation::has_max_delta() const {
  return _internal_has_max_delta();
}
inline void RandomAdjustSaturation::clear_max_delta() {
  _impl_.max_delta_ = 1.25f;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float RandomAdjustSaturation::_internal_max_delta() const {
  return _impl_.max_delta_;
}
inline float RandomAdjustSaturation::max_delta() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAdjustSaturation.max_delta)
  return _internal_max_delta();
}
inline void RandomAdjustSaturation::_internal_set_max_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.max_delta_ = value;
}
inline void RandomAdjustSaturation::set_max_delta(float value) {
  _internal_set_max_delta(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAdjustSaturation.max_delta)
}

// -------------------------------------------------------------------

// RandomDistortColor

// optional int32 color_ordering = 1;
inline bool RandomDistortColor::_internal_has_color_ordering() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomDistortColor::has_color_ordering() const {
  return _internal_has_color_ordering();
}
inline void RandomDistortColor::clear_color_ordering() {
  _impl_.color_ordering_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t RandomDistortColor::_internal_color_ordering() const {
  return _impl_.color_ordering_;
}
inline int32_t RandomDistortColor::color_ordering() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomDistortColor.color_ordering)
  return _internal_color_ordering();
}
inline void RandomDistortColor::_internal_set_color_ordering(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.color_ordering_ = value;
}
inline void RandomDistortColor::set_color_ordering(int32_t value) {
  _internal_set_color_ordering(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomDistortColor.color_ordering)
}

// -------------------------------------------------------------------

// RandomJitterBoxes

// optional float ratio = 1 [default = 0.05];
inline bool RandomJitterBoxes::_internal_has_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomJitterBoxes::has_ratio() const {
  return _internal_has_ratio();
}
inline void RandomJitterBoxes::clear_ratio() {
  _impl_.ratio_ = 0.05f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomJitterBoxes::_internal_ratio() const {
  return _impl_.ratio_;
}
inline float RandomJitterBoxes::ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomJitterBoxes.ratio)
  return _internal_ratio();
}
inline void RandomJitterBoxes::_internal_set_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ratio_ = value;
}
inline void RandomJitterBoxes::set_ratio(float value) {
  _internal_set_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomJitterBoxes.ratio)
}

// -------------------------------------------------------------------

// RandomCropImage

// optional float min_object_covered = 1 [default = 1];
inline bool RandomCropImage::_internal_has_min_object_covered() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RandomCropImage::has_min_object_covered() const {
  return _internal_has_min_object_covered();
}
inline void RandomCropImage::clear_min_object_covered() {
  _impl_.min_object_covered_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float RandomCropImage::_internal_min_object_covered() const {
  return _impl_.min_object_covered_;
}
inline float RandomCropImage::min_object_covered() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropImage.min_object_covered)
  return _internal_min_object_covered();
}
inline void RandomCropImage::_internal_set_min_object_covered(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.min_object_covered_ = value;
}
inline void RandomCropImage::set_min_object_covered(float value) {
  _internal_set_min_object_covered(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropImage.min_object_covered)
}

// optional float min_aspect_ratio = 2 [default = 0.75];
inline bool RandomCropImage::_internal_has_min_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool RandomCropImage::has_min_aspect_ratio() const {
  return _internal_has_min_aspect_ratio();
}
inline void RandomCropImage::clear_min_aspect_ratio() {
  _impl_.min_aspect_ratio_ = 0.75f;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float RandomCropImage::_internal_min_aspect_ratio() const {
  return _impl_.min_aspect_ratio_;
}
inline float RandomCropImage::min_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropImage.min_aspect_ratio)
  return _internal_min_aspect_ratio();
}
inline void RandomCropImage::_internal_set_min_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.min_aspect_ratio_ = value;
}
inline void RandomCropImage::set_min_aspect_ratio(float value) {
  _internal_set_min_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropImage.min_aspect_ratio)
}

// optional float max_aspect_ratio = 3 [default = 1.33];
inline bool RandomCropImage::_internal_has_max_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool RandomCropImage::has_max_aspect_ratio() const {
  return _internal_has_max_aspect_ratio();
}
inline void RandomCropImage::clear_max_aspect_ratio() {
  _impl_.max_aspect_ratio_ = 1.33f;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float RandomCropImage::_internal_max_aspect_ratio() const {
  return _impl_.max_aspect_ratio_;
}
inline float RandomCropImage::max_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropImage.max_aspect_ratio)
  return _internal_max_aspect_ratio();
}
inline void RandomCropImage::_internal_set_max_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.max_aspect_ratio_ = value;
}
inline void RandomCropImage::set_max_aspect_ratio(float value) {
  _internal_set_max_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropImage.max_aspect_ratio)
}

// optional float min_area = 4 [default = 0.1];
inline bool RandomCropImage::_internal_has_min_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool RandomCropImage::has_min_area() const {
  return _internal_has_min_area();
}
inline void RandomCropImage::clear_min_area() {
  _impl_.min_area_ = 0.1f;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float RandomCropImage::_internal_min_area() const {
  return _impl_.min_area_;
}
inline float RandomCropImage::min_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropImage.min_area)
  return _internal_min_area();
}
inline void RandomCropImage::_internal_set_min_area(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.min_area_ = value;
}
inline void RandomCropImage::set_min_area(float value) {
  _internal_set_min_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropImage.min_area)
}

// optional float max_area = 5 [default = 1];
inline bool RandomCropImage::_internal_has_max_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool RandomCropImage::has_max_area() const {
  return _internal_has_max_area();
}
inline void RandomCropImage::clear_max_area() {
  _impl_.max_area_ = 1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float RandomCropImage::_internal_max_area() const {
  return _impl_.max_area_;
}
inline float RandomCropImage::max_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropImage.max_area)
  return _internal_max_area();
}
inline void RandomCropImage::_internal_set_max_area(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.max_area_ = value;
}
inline void RandomCropImage::set_max_area(float value) {
  _internal_set_max_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropImage.max_area)
}

// optional float overlap_thresh = 6 [default = 0.3];
inline bool RandomCropImage::_internal_has_overlap_thresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool RandomCropImage::has_overlap_thresh() const {
  return _internal_has_overlap_thresh();
}
inline void RandomCropImage::clear_overlap_thresh() {
  _impl_.overlap_thresh_ = 0.3f;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float RandomCropImage::_internal_overlap_thresh() const {
  return _impl_.overlap_thresh_;
}
inline float RandomCropImage::overlap_thresh() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropImage.overlap_thresh)
  return _internal_overlap_thresh();
}
inline void RandomCropImage::_internal_set_overlap_thresh(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.overlap_thresh_ = value;
}
inline void RandomCropImage::set_overlap_thresh(float value) {
  _internal_set_overlap_thresh(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropImage.overlap_thresh)
}

// optional bool clip_boxes = 8 [default = true];
inline bool RandomCropImage::_internal_has_clip_boxes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomCropImage::has_clip_boxes() const {
  return _internal_has_clip_boxes();
}
inline void RandomCropImage::clear_clip_boxes() {
  _impl_.clip_boxes_ = true;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool RandomCropImage::_internal_clip_boxes() const {
  return _impl_.clip_boxes_;
}
inline bool RandomCropImage::clip_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropImage.clip_boxes)
  return _internal_clip_boxes();
}
inline void RandomCropImage::_internal_set_clip_boxes(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.clip_boxes_ = value;
}
inline void RandomCropImage::set_clip_boxes(bool value) {
  _internal_set_clip_boxes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropImage.clip_boxes)
}

// optional float random_coef = 7 [default = 0];
inline bool RandomCropImage::_internal_has_random_coef() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomCropImage::has_random_coef() const {
  return _internal_has_random_coef();
}
inline void RandomCropImage::clear_random_coef() {
  _impl_.random_coef_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomCropImage::_internal_random_coef() const {
  return _impl_.random_coef_;
}
inline float RandomCropImage::random_coef() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropImage.random_coef)
  return _internal_random_coef();
}
inline void RandomCropImage::_internal_set_random_coef(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.random_coef_ = value;
}
inline void RandomCropImage::set_random_coef(float value) {
  _internal_set_random_coef(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropImage.random_coef)
}

// -------------------------------------------------------------------

// RandomPadImage

// optional int32 min_image_height = 1;
inline bool RandomPadImage::_internal_has_min_image_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomPadImage::has_min_image_height() const {
  return _internal_has_min_image_height();
}
inline void RandomPadImage::clear_min_image_height() {
  _impl_.min_image_height_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t RandomPadImage::_internal_min_image_height() const {
  return _impl_.min_image_height_;
}
inline int32_t RandomPadImage::min_image_height() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomPadImage.min_image_height)
  return _internal_min_image_height();
}
inline void RandomPadImage::_internal_set_min_image_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.min_image_height_ = value;
}
inline void RandomPadImage::set_min_image_height(int32_t value) {
  _internal_set_min_image_height(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomPadImage.min_image_height)
}

// optional int32 min_image_width = 2;
inline bool RandomPadImage::_internal_has_min_image_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomPadImage::has_min_image_width() const {
  return _internal_has_min_image_width();
}
inline void RandomPadImage::clear_min_image_width() {
  _impl_.min_image_width_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t RandomPadImage::_internal_min_image_width() const {
  return _impl_.min_image_width_;
}
inline int32_t RandomPadImage::min_image_width() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomPadImage.min_image_width)
  return _internal_min_image_width();
}
inline void RandomPadImage::_internal_set_min_image_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.min_image_width_ = value;
}
inline void RandomPadImage::set_min_image_width(int32_t value) {
  _internal_set_min_image_width(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomPadImage.min_image_width)
}

// optional int32 max_image_height = 3;
inline bool RandomPadImage::_internal_has_max_image_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RandomPadImage::has_max_image_height() const {
  return _internal_has_max_image_height();
}
inline void RandomPadImage::clear_max_image_height() {
  _impl_.max_image_height_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t RandomPadImage::_internal_max_image_height() const {
  return _impl_.max_image_height_;
}
inline int32_t RandomPadImage::max_image_height() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomPadImage.max_image_height)
  return _internal_max_image_height();
}
inline void RandomPadImage::_internal_set_max_image_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_image_height_ = value;
}
inline void RandomPadImage::set_max_image_height(int32_t value) {
  _internal_set_max_image_height(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomPadImage.max_image_height)
}

// optional int32 max_image_width = 4;
inline bool RandomPadImage::_internal_has_max_image_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool RandomPadImage::has_max_image_width() const {
  return _internal_has_max_image_width();
}
inline void RandomPadImage::clear_max_image_width() {
  _impl_.max_image_width_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t RandomPadImage::_internal_max_image_width() const {
  return _impl_.max_image_width_;
}
inline int32_t RandomPadImage::max_image_width() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomPadImage.max_image_width)
  return _internal_max_image_width();
}
inline void RandomPadImage::_internal_set_max_image_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.max_image_width_ = value;
}
inline void RandomPadImage::set_max_image_width(int32_t value) {
  _internal_set_max_image_width(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomPadImage.max_image_width)
}

// repeated float pad_color = 5;
inline int RandomPadImage::_internal_pad_color_size() const {
  return _impl_.pad_color_.size();
}
inline int RandomPadImage::pad_color_size() const {
  return _internal_pad_color_size();
}
inline void RandomPadImage::clear_pad_color() {
  _impl_.pad_color_.Clear();
}
inline float RandomPadImage::_internal_pad_color(int index) const {
  return _impl_.pad_color_.Get(index);
}
inline float RandomPadImage::pad_color(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomPadImage.pad_color)
  return _internal_pad_color(index);
}
inline void RandomPadImage::set_pad_color(int index, float value) {
  _impl_.pad_color_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomPadImage.pad_color)
}
inline void RandomPadImage::_internal_add_pad_color(float value) {
  _impl_.pad_color_.Add(value);
}
inline void RandomPadImage::add_pad_color(float value) {
  _internal_add_pad_color(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.RandomPadImage.pad_color)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomPadImage::_internal_pad_color() const {
  return _impl_.pad_color_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomPadImage::pad_color() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.RandomPadImage.pad_color)
  return _internal_pad_color();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomPadImage::_internal_mutable_pad_color() {
  return &_impl_.pad_color_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomPadImage::mutable_pad_color() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.RandomPadImage.pad_color)
  return _internal_mutable_pad_color();
}

// -------------------------------------------------------------------

// RandomAbsolutePadImage

// optional int32 max_height_padding = 1;
inline bool RandomAbsolutePadImage::_internal_has_max_height_padding() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomAbsolutePadImage::has_max_height_padding() const {
  return _internal_has_max_height_padding();
}
inline void RandomAbsolutePadImage::clear_max_height_padding() {
  _impl_.max_height_padding_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t RandomAbsolutePadImage::_internal_max_height_padding() const {
  return _impl_.max_height_padding_;
}
inline int32_t RandomAbsolutePadImage::max_height_padding() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAbsolutePadImage.max_height_padding)
  return _internal_max_height_padding();
}
inline void RandomAbsolutePadImage::_internal_set_max_height_padding(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.max_height_padding_ = value;
}
inline void RandomAbsolutePadImage::set_max_height_padding(int32_t value) {
  _internal_set_max_height_padding(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAbsolutePadImage.max_height_padding)
}

// optional int32 max_width_padding = 2;
inline bool RandomAbsolutePadImage::_internal_has_max_width_padding() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomAbsolutePadImage::has_max_width_padding() const {
  return _internal_has_max_width_padding();
}
inline void RandomAbsolutePadImage::clear_max_width_padding() {
  _impl_.max_width_padding_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t RandomAbsolutePadImage::_internal_max_width_padding() const {
  return _impl_.max_width_padding_;
}
inline int32_t RandomAbsolutePadImage::max_width_padding() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAbsolutePadImage.max_width_padding)
  return _internal_max_width_padding();
}
inline void RandomAbsolutePadImage::_internal_set_max_width_padding(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.max_width_padding_ = value;
}
inline void RandomAbsolutePadImage::set_max_width_padding(int32_t value) {
  _internal_set_max_width_padding(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAbsolutePadImage.max_width_padding)
}

// repeated float pad_color = 3;
inline int RandomAbsolutePadImage::_internal_pad_color_size() const {
  return _impl_.pad_color_.size();
}
inline int RandomAbsolutePadImage::pad_color_size() const {
  return _internal_pad_color_size();
}
inline void RandomAbsolutePadImage::clear_pad_color() {
  _impl_.pad_color_.Clear();
}
inline float RandomAbsolutePadImage::_internal_pad_color(int index) const {
  return _impl_.pad_color_.Get(index);
}
inline float RandomAbsolutePadImage::pad_color(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomAbsolutePadImage.pad_color)
  return _internal_pad_color(index);
}
inline void RandomAbsolutePadImage::set_pad_color(int index, float value) {
  _impl_.pad_color_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomAbsolutePadImage.pad_color)
}
inline void RandomAbsolutePadImage::_internal_add_pad_color(float value) {
  _impl_.pad_color_.Add(value);
}
inline void RandomAbsolutePadImage::add_pad_color(float value) {
  _internal_add_pad_color(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.RandomAbsolutePadImage.pad_color)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomAbsolutePadImage::_internal_pad_color() const {
  return _impl_.pad_color_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomAbsolutePadImage::pad_color() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.RandomAbsolutePadImage.pad_color)
  return _internal_pad_color();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomAbsolutePadImage::_internal_mutable_pad_color() {
  return &_impl_.pad_color_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomAbsolutePadImage::mutable_pad_color() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.RandomAbsolutePadImage.pad_color)
  return _internal_mutable_pad_color();
}

// -------------------------------------------------------------------

// RandomCropPadImage

// optional float min_object_covered = 1 [default = 1];
inline bool RandomCropPadImage::_internal_has_min_object_covered() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RandomCropPadImage::has_min_object_covered() const {
  return _internal_has_min_object_covered();
}
inline void RandomCropPadImage::clear_min_object_covered() {
  _impl_.min_object_covered_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float RandomCropPadImage::_internal_min_object_covered() const {
  return _impl_.min_object_covered_;
}
inline float RandomCropPadImage::min_object_covered() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.min_object_covered)
  return _internal_min_object_covered();
}
inline void RandomCropPadImage::_internal_set_min_object_covered(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.min_object_covered_ = value;
}
inline void RandomCropPadImage::set_min_object_covered(float value) {
  _internal_set_min_object_covered(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.min_object_covered)
}

// optional float min_aspect_ratio = 2 [default = 0.75];
inline bool RandomCropPadImage::_internal_has_min_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool RandomCropPadImage::has_min_aspect_ratio() const {
  return _internal_has_min_aspect_ratio();
}
inline void RandomCropPadImage::clear_min_aspect_ratio() {
  _impl_.min_aspect_ratio_ = 0.75f;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float RandomCropPadImage::_internal_min_aspect_ratio() const {
  return _impl_.min_aspect_ratio_;
}
inline float RandomCropPadImage::min_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.min_aspect_ratio)
  return _internal_min_aspect_ratio();
}
inline void RandomCropPadImage::_internal_set_min_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.min_aspect_ratio_ = value;
}
inline void RandomCropPadImage::set_min_aspect_ratio(float value) {
  _internal_set_min_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.min_aspect_ratio)
}

// optional float max_aspect_ratio = 3 [default = 1.33];
inline bool RandomCropPadImage::_internal_has_max_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool RandomCropPadImage::has_max_aspect_ratio() const {
  return _internal_has_max_aspect_ratio();
}
inline void RandomCropPadImage::clear_max_aspect_ratio() {
  _impl_.max_aspect_ratio_ = 1.33f;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float RandomCropPadImage::_internal_max_aspect_ratio() const {
  return _impl_.max_aspect_ratio_;
}
inline float RandomCropPadImage::max_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.max_aspect_ratio)
  return _internal_max_aspect_ratio();
}
inline void RandomCropPadImage::_internal_set_max_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.max_aspect_ratio_ = value;
}
inline void RandomCropPadImage::set_max_aspect_ratio(float value) {
  _internal_set_max_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.max_aspect_ratio)
}

// optional float min_area = 4 [default = 0.1];
inline bool RandomCropPadImage::_internal_has_min_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool RandomCropPadImage::has_min_area() const {
  return _internal_has_min_area();
}
inline void RandomCropPadImage::clear_min_area() {
  _impl_.min_area_ = 0.1f;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float RandomCropPadImage::_internal_min_area() const {
  return _impl_.min_area_;
}
inline float RandomCropPadImage::min_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.min_area)
  return _internal_min_area();
}
inline void RandomCropPadImage::_internal_set_min_area(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.min_area_ = value;
}
inline void RandomCropPadImage::set_min_area(float value) {
  _internal_set_min_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.min_area)
}

// optional float max_area = 5 [default = 1];
inline bool RandomCropPadImage::_internal_has_max_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool RandomCropPadImage::has_max_area() const {
  return _internal_has_max_area();
}
inline void RandomCropPadImage::clear_max_area() {
  _impl_.max_area_ = 1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float RandomCropPadImage::_internal_max_area() const {
  return _impl_.max_area_;
}
inline float RandomCropPadImage::max_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.max_area)
  return _internal_max_area();
}
inline void RandomCropPadImage::_internal_set_max_area(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.max_area_ = value;
}
inline void RandomCropPadImage::set_max_area(float value) {
  _internal_set_max_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.max_area)
}

// optional float overlap_thresh = 6 [default = 0.3];
inline bool RandomCropPadImage::_internal_has_overlap_thresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool RandomCropPadImage::has_overlap_thresh() const {
  return _internal_has_overlap_thresh();
}
inline void RandomCropPadImage::clear_overlap_thresh() {
  _impl_.overlap_thresh_ = 0.3f;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float RandomCropPadImage::_internal_overlap_thresh() const {
  return _impl_.overlap_thresh_;
}
inline float RandomCropPadImage::overlap_thresh() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.overlap_thresh)
  return _internal_overlap_thresh();
}
inline void RandomCropPadImage::_internal_set_overlap_thresh(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.overlap_thresh_ = value;
}
inline void RandomCropPadImage::set_overlap_thresh(float value) {
  _internal_set_overlap_thresh(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.overlap_thresh)
}

// optional bool clip_boxes = 11 [default = true];
inline bool RandomCropPadImage::_internal_has_clip_boxes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomCropPadImage::has_clip_boxes() const {
  return _internal_has_clip_boxes();
}
inline void RandomCropPadImage::clear_clip_boxes() {
  _impl_.clip_boxes_ = true;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool RandomCropPadImage::_internal_clip_boxes() const {
  return _impl_.clip_boxes_;
}
inline bool RandomCropPadImage::clip_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.clip_boxes)
  return _internal_clip_boxes();
}
inline void RandomCropPadImage::_internal_set_clip_boxes(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.clip_boxes_ = value;
}
inline void RandomCropPadImage::set_clip_boxes(bool value) {
  _internal_set_clip_boxes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.clip_boxes)
}

// optional float random_coef = 7 [default = 0];
inline bool RandomCropPadImage::_internal_has_random_coef() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomCropPadImage::has_random_coef() const {
  return _internal_has_random_coef();
}
inline void RandomCropPadImage::clear_random_coef() {
  _impl_.random_coef_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomCropPadImage::_internal_random_coef() const {
  return _impl_.random_coef_;
}
inline float RandomCropPadImage::random_coef() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.random_coef)
  return _internal_random_coef();
}
inline void RandomCropPadImage::_internal_set_random_coef(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.random_coef_ = value;
}
inline void RandomCropPadImage::set_random_coef(float value) {
  _internal_set_random_coef(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.random_coef)
}

// repeated float min_padded_size_ratio = 8;
inline int RandomCropPadImage::_internal_min_padded_size_ratio_size() const {
  return _impl_.min_padded_size_ratio_.size();
}
inline int RandomCropPadImage::min_padded_size_ratio_size() const {
  return _internal_min_padded_size_ratio_size();
}
inline void RandomCropPadImage::clear_min_padded_size_ratio() {
  _impl_.min_padded_size_ratio_.Clear();
}
inline float RandomCropPadImage::_internal_min_padded_size_ratio(int index) const {
  return _impl_.min_padded_size_ratio_.Get(index);
}
inline float RandomCropPadImage::min_padded_size_ratio(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.min_padded_size_ratio)
  return _internal_min_padded_size_ratio(index);
}
inline void RandomCropPadImage::set_min_padded_size_ratio(int index, float value) {
  _impl_.min_padded_size_ratio_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.min_padded_size_ratio)
}
inline void RandomCropPadImage::_internal_add_min_padded_size_ratio(float value) {
  _impl_.min_padded_size_ratio_.Add(value);
}
inline void RandomCropPadImage::add_min_padded_size_ratio(float value) {
  _internal_add_min_padded_size_ratio(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.RandomCropPadImage.min_padded_size_ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomCropPadImage::_internal_min_padded_size_ratio() const {
  return _impl_.min_padded_size_ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomCropPadImage::min_padded_size_ratio() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.RandomCropPadImage.min_padded_size_ratio)
  return _internal_min_padded_size_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomCropPadImage::_internal_mutable_min_padded_size_ratio() {
  return &_impl_.min_padded_size_ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomCropPadImage::mutable_min_padded_size_ratio() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.RandomCropPadImage.min_padded_size_ratio)
  return _internal_mutable_min_padded_size_ratio();
}

// repeated float max_padded_size_ratio = 9;
inline int RandomCropPadImage::_internal_max_padded_size_ratio_size() const {
  return _impl_.max_padded_size_ratio_.size();
}
inline int RandomCropPadImage::max_padded_size_ratio_size() const {
  return _internal_max_padded_size_ratio_size();
}
inline void RandomCropPadImage::clear_max_padded_size_ratio() {
  _impl_.max_padded_size_ratio_.Clear();
}
inline float RandomCropPadImage::_internal_max_padded_size_ratio(int index) const {
  return _impl_.max_padded_size_ratio_.Get(index);
}
inline float RandomCropPadImage::max_padded_size_ratio(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.max_padded_size_ratio)
  return _internal_max_padded_size_ratio(index);
}
inline void RandomCropPadImage::set_max_padded_size_ratio(int index, float value) {
  _impl_.max_padded_size_ratio_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.max_padded_size_ratio)
}
inline void RandomCropPadImage::_internal_add_max_padded_size_ratio(float value) {
  _impl_.max_padded_size_ratio_.Add(value);
}
inline void RandomCropPadImage::add_max_padded_size_ratio(float value) {
  _internal_add_max_padded_size_ratio(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.RandomCropPadImage.max_padded_size_ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomCropPadImage::_internal_max_padded_size_ratio() const {
  return _impl_.max_padded_size_ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomCropPadImage::max_padded_size_ratio() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.RandomCropPadImage.max_padded_size_ratio)
  return _internal_max_padded_size_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomCropPadImage::_internal_mutable_max_padded_size_ratio() {
  return &_impl_.max_padded_size_ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomCropPadImage::mutable_max_padded_size_ratio() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.RandomCropPadImage.max_padded_size_ratio)
  return _internal_mutable_max_padded_size_ratio();
}

// repeated float pad_color = 10;
inline int RandomCropPadImage::_internal_pad_color_size() const {
  return _impl_.pad_color_.size();
}
inline int RandomCropPadImage::pad_color_size() const {
  return _internal_pad_color_size();
}
inline void RandomCropPadImage::clear_pad_color() {
  _impl_.pad_color_.Clear();
}
inline float RandomCropPadImage::_internal_pad_color(int index) const {
  return _impl_.pad_color_.Get(index);
}
inline float RandomCropPadImage::pad_color(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropPadImage.pad_color)
  return _internal_pad_color(index);
}
inline void RandomCropPadImage::set_pad_color(int index, float value) {
  _impl_.pad_color_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropPadImage.pad_color)
}
inline void RandomCropPadImage::_internal_add_pad_color(float value) {
  _impl_.pad_color_.Add(value);
}
inline void RandomCropPadImage::add_pad_color(float value) {
  _internal_add_pad_color(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.RandomCropPadImage.pad_color)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomCropPadImage::_internal_pad_color() const {
  return _impl_.pad_color_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RandomCropPadImage::pad_color() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.RandomCropPadImage.pad_color)
  return _internal_pad_color();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomCropPadImage::_internal_mutable_pad_color() {
  return &_impl_.pad_color_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RandomCropPadImage::mutable_pad_color() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.RandomCropPadImage.pad_color)
  return _internal_mutable_pad_color();
}

// -------------------------------------------------------------------

// RandomCropToAspectRatio

// optional float aspect_ratio = 1 [default = 1];
inline bool RandomCropToAspectRatio::_internal_has_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomCropToAspectRatio::has_aspect_ratio() const {
  return _internal_has_aspect_ratio();
}
inline void RandomCropToAspectRatio::clear_aspect_ratio() {
  _impl_.aspect_ratio_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float RandomCropToAspectRatio::_internal_aspect_ratio() const {
  return _impl_.aspect_ratio_;
}
inline float RandomCropToAspectRatio::aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropToAspectRatio.aspect_ratio)
  return _internal_aspect_ratio();
}
inline void RandomCropToAspectRatio::_internal_set_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.aspect_ratio_ = value;
}
inline void RandomCropToAspectRatio::set_aspect_ratio(float value) {
  _internal_set_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropToAspectRatio.aspect_ratio)
}

// optional float overlap_thresh = 2 [default = 0.3];
inline bool RandomCropToAspectRatio::_internal_has_overlap_thresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RandomCropToAspectRatio::has_overlap_thresh() const {
  return _internal_has_overlap_thresh();
}
inline void RandomCropToAspectRatio::clear_overlap_thresh() {
  _impl_.overlap_thresh_ = 0.3f;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float RandomCropToAspectRatio::_internal_overlap_thresh() const {
  return _impl_.overlap_thresh_;
}
inline float RandomCropToAspectRatio::overlap_thresh() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropToAspectRatio.overlap_thresh)
  return _internal_overlap_thresh();
}
inline void RandomCropToAspectRatio::_internal_set_overlap_thresh(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.overlap_thresh_ = value;
}
inline void RandomCropToAspectRatio::set_overlap_thresh(float value) {
  _internal_set_overlap_thresh(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropToAspectRatio.overlap_thresh)
}

// optional bool clip_boxes = 3 [default = true];
inline bool RandomCropToAspectRatio::_internal_has_clip_boxes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomCropToAspectRatio::has_clip_boxes() const {
  return _internal_has_clip_boxes();
}
inline void RandomCropToAspectRatio::clear_clip_boxes() {
  _impl_.clip_boxes_ = true;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool RandomCropToAspectRatio::_internal_clip_boxes() const {
  return _impl_.clip_boxes_;
}
inline bool RandomCropToAspectRatio::clip_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomCropToAspectRatio.clip_boxes)
  return _internal_clip_boxes();
}
inline void RandomCropToAspectRatio::_internal_set_clip_boxes(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.clip_boxes_ = value;
}
inline void RandomCropToAspectRatio::set_clip_boxes(bool value) {
  _internal_set_clip_boxes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomCropToAspectRatio.clip_boxes)
}

// -------------------------------------------------------------------

// RandomBlackPatches

// optional int32 max_black_patches = 1 [default = 10];
inline bool RandomBlackPatches::_internal_has_max_black_patches() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomBlackPatches::has_max_black_patches() const {
  return _internal_has_max_black_patches();
}
inline void RandomBlackPatches::clear_max_black_patches() {
  _impl_.max_black_patches_ = 10;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t RandomBlackPatches::_internal_max_black_patches() const {
  return _impl_.max_black_patches_;
}
inline int32_t RandomBlackPatches::max_black_patches() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomBlackPatches.max_black_patches)
  return _internal_max_black_patches();
}
inline void RandomBlackPatches::_internal_set_max_black_patches(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.max_black_patches_ = value;
}
inline void RandomBlackPatches::set_max_black_patches(int32_t value) {
  _internal_set_max_black_patches(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomBlackPatches.max_black_patches)
}

// optional float probability = 2 [default = 0.5];
inline bool RandomBlackPatches::_internal_has_probability() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RandomBlackPatches::has_probability() const {
  return _internal_has_probability();
}
inline void RandomBlackPatches::clear_probability() {
  _impl_.probability_ = 0.5f;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float RandomBlackPatches::_internal_probability() const {
  return _impl_.probability_;
}
inline float RandomBlackPatches::probability() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomBlackPatches.probability)
  return _internal_probability();
}
inline void RandomBlackPatches::_internal_set_probability(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.probability_ = value;
}
inline void RandomBlackPatches::set_probability(float value) {
  _internal_set_probability(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomBlackPatches.probability)
}

// optional float size_to_image_ratio = 3 [default = 0.1];
inline bool RandomBlackPatches::_internal_has_size_to_image_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomBlackPatches::has_size_to_image_ratio() const {
  return _internal_has_size_to_image_ratio();
}
inline void RandomBlackPatches::clear_size_to_image_ratio() {
  _impl_.size_to_image_ratio_ = 0.1f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomBlackPatches::_internal_size_to_image_ratio() const {
  return _impl_.size_to_image_ratio_;
}
inline float RandomBlackPatches::size_to_image_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomBlackPatches.size_to_image_ratio)
  return _internal_size_to_image_ratio();
}
inline void RandomBlackPatches::_internal_set_size_to_image_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.size_to_image_ratio_ = value;
}
inline void RandomBlackPatches::set_size_to_image_ratio(float value) {
  _internal_set_size_to_image_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomBlackPatches.size_to_image_ratio)
}

// -------------------------------------------------------------------

// RandomResizeMethod

// optional int32 target_height = 1;
inline bool RandomResizeMethod::_internal_has_target_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomResizeMethod::has_target_height() const {
  return _internal_has_target_height();
}
inline void RandomResizeMethod::clear_target_height() {
  _impl_.target_height_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t RandomResizeMethod::_internal_target_height() const {
  return _impl_.target_height_;
}
inline int32_t RandomResizeMethod::target_height() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomResizeMethod.target_height)
  return _internal_target_height();
}
inline void RandomResizeMethod::_internal_set_target_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.target_height_ = value;
}
inline void RandomResizeMethod::set_target_height(int32_t value) {
  _internal_set_target_height(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomResizeMethod.target_height)
}

// optional int32 target_width = 2;
inline bool RandomResizeMethod::_internal_has_target_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomResizeMethod::has_target_width() const {
  return _internal_has_target_width();
}
inline void RandomResizeMethod::clear_target_width() {
  _impl_.target_width_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t RandomResizeMethod::_internal_target_width() const {
  return _impl_.target_width_;
}
inline int32_t RandomResizeMethod::target_width() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomResizeMethod.target_width)
  return _internal_target_width();
}
inline void RandomResizeMethod::_internal_set_target_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.target_width_ = value;
}
inline void RandomResizeMethod::set_target_width(int32_t value) {
  _internal_set_target_width(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomResizeMethod.target_width)
}

// -------------------------------------------------------------------

// RGBtoGray

// -------------------------------------------------------------------

// ScaleBoxesToPixelCoordinates

// -------------------------------------------------------------------

// ResizeImage

// optional int32 new_height = 1;
inline bool ResizeImage::_internal_has_new_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ResizeImage::has_new_height() const {
  return _internal_has_new_height();
}
inline void ResizeImage::clear_new_height() {
  _impl_.new_height_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t ResizeImage::_internal_new_height() const {
  return _impl_.new_height_;
}
inline int32_t ResizeImage::new_height() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ResizeImage.new_height)
  return _internal_new_height();
}
inline void ResizeImage::_internal_set_new_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.new_height_ = value;
}
inline void ResizeImage::set_new_height(int32_t value) {
  _internal_set_new_height(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.ResizeImage.new_height)
}

// optional int32 new_width = 2;
inline bool ResizeImage::_internal_has_new_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ResizeImage::has_new_width() const {
  return _internal_has_new_width();
}
inline void ResizeImage::clear_new_width() {
  _impl_.new_width_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t ResizeImage::_internal_new_width() const {
  return _impl_.new_width_;
}
inline int32_t ResizeImage::new_width() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ResizeImage.new_width)
  return _internal_new_width();
}
inline void ResizeImage::_internal_set_new_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.new_width_ = value;
}
inline void ResizeImage::set_new_width(int32_t value) {
  _internal_set_new_width(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.ResizeImage.new_width)
}

// optional .object_detection.protos.ResizeImage.Method method = 3 [default = BILINEAR];
inline bool ResizeImage::_internal_has_method() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ResizeImage::has_method() const {
  return _internal_has_method();
}
inline void ResizeImage::clear_method() {
  _impl_.method_ = 3;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::object_detection::protos::ResizeImage_Method ResizeImage::_internal_method() const {
  return static_cast< ::object_detection::protos::ResizeImage_Method >(_impl_.method_);
}
inline ::object_detection::protos::ResizeImage_Method ResizeImage::method() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ResizeImage.method)
  return _internal_method();
}
inline void ResizeImage::_internal_set_method(::object_detection::protos::ResizeImage_Method value) {
  assert(::object_detection::protos::ResizeImage_Method_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.method_ = value;
}
inline void ResizeImage::set_method(::object_detection::protos::ResizeImage_Method value) {
  _internal_set_method(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.ResizeImage.method)
}

// -------------------------------------------------------------------

// SubtractChannelMean

// repeated float means = 1;
inline int SubtractChannelMean::_internal_means_size() const {
  return _impl_.means_.size();
}
inline int SubtractChannelMean::means_size() const {
  return _internal_means_size();
}
inline void SubtractChannelMean::clear_means() {
  _impl_.means_.Clear();
}
inline float SubtractChannelMean::_internal_means(int index) const {
  return _impl_.means_.Get(index);
}
inline float SubtractChannelMean::means(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SubtractChannelMean.means)
  return _internal_means(index);
}
inline void SubtractChannelMean::set_means(int index, float value) {
  _impl_.means_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SubtractChannelMean.means)
}
inline void SubtractChannelMean::_internal_add_means(float value) {
  _impl_.means_.Add(value);
}
inline void SubtractChannelMean::add_means(float value) {
  _internal_add_means(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.SubtractChannelMean.means)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SubtractChannelMean::_internal_means() const {
  return _impl_.means_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SubtractChannelMean::means() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SubtractChannelMean.means)
  return _internal_means();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SubtractChannelMean::_internal_mutable_means() {
  return &_impl_.means_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SubtractChannelMean::mutable_means() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SubtractChannelMean.means)
  return _internal_mutable_means();
}

// -------------------------------------------------------------------

// SSDRandomCropOperation

// optional float min_object_covered = 1;
inline bool SSDRandomCropOperation::_internal_has_min_object_covered() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SSDRandomCropOperation::has_min_object_covered() const {
  return _internal_has_min_object_covered();
}
inline void SSDRandomCropOperation::clear_min_object_covered() {
  _impl_.min_object_covered_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float SSDRandomCropOperation::_internal_min_object_covered() const {
  return _impl_.min_object_covered_;
}
inline float SSDRandomCropOperation::min_object_covered() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropOperation.min_object_covered)
  return _internal_min_object_covered();
}
inline void SSDRandomCropOperation::_internal_set_min_object_covered(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.min_object_covered_ = value;
}
inline void SSDRandomCropOperation::set_min_object_covered(float value) {
  _internal_set_min_object_covered(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropOperation.min_object_covered)
}

// optional float min_aspect_ratio = 2;
inline bool SSDRandomCropOperation::_internal_has_min_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SSDRandomCropOperation::has_min_aspect_ratio() const {
  return _internal_has_min_aspect_ratio();
}
inline void SSDRandomCropOperation::clear_min_aspect_ratio() {
  _impl_.min_aspect_ratio_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float SSDRandomCropOperation::_internal_min_aspect_ratio() const {
  return _impl_.min_aspect_ratio_;
}
inline float SSDRandomCropOperation::min_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropOperation.min_aspect_ratio)
  return _internal_min_aspect_ratio();
}
inline void SSDRandomCropOperation::_internal_set_min_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.min_aspect_ratio_ = value;
}
inline void SSDRandomCropOperation::set_min_aspect_ratio(float value) {
  _internal_set_min_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropOperation.min_aspect_ratio)
}

// optional float max_aspect_ratio = 3;
inline bool SSDRandomCropOperation::_internal_has_max_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SSDRandomCropOperation::has_max_aspect_ratio() const {
  return _internal_has_max_aspect_ratio();
}
inline void SSDRandomCropOperation::clear_max_aspect_ratio() {
  _impl_.max_aspect_ratio_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float SSDRandomCropOperation::_internal_max_aspect_ratio() const {
  return _impl_.max_aspect_ratio_;
}
inline float SSDRandomCropOperation::max_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropOperation.max_aspect_ratio)
  return _internal_max_aspect_ratio();
}
inline void SSDRandomCropOperation::_internal_set_max_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_aspect_ratio_ = value;
}
inline void SSDRandomCropOperation::set_max_aspect_ratio(float value) {
  _internal_set_max_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropOperation.max_aspect_ratio)
}

// optional float min_area = 4;
inline bool SSDRandomCropOperation::_internal_has_min_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SSDRandomCropOperation::has_min_area() const {
  return _internal_has_min_area();
}
inline void SSDRandomCropOperation::clear_min_area() {
  _impl_.min_area_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float SSDRandomCropOperation::_internal_min_area() const {
  return _impl_.min_area_;
}
inline float SSDRandomCropOperation::min_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropOperation.min_area)
  return _internal_min_area();
}
inline void SSDRandomCropOperation::_internal_set_min_area(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.min_area_ = value;
}
inline void SSDRandomCropOperation::set_min_area(float value) {
  _internal_set_min_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropOperation.min_area)
}

// optional float max_area = 5;
inline bool SSDRandomCropOperation::_internal_has_max_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SSDRandomCropOperation::has_max_area() const {
  return _internal_has_max_area();
}
inline void SSDRandomCropOperation::clear_max_area() {
  _impl_.max_area_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float SSDRandomCropOperation::_internal_max_area() const {
  return _impl_.max_area_;
}
inline float SSDRandomCropOperation::max_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropOperation.max_area)
  return _internal_max_area();
}
inline void SSDRandomCropOperation::_internal_set_max_area(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.max_area_ = value;
}
inline void SSDRandomCropOperation::set_max_area(float value) {
  _internal_set_max_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropOperation.max_area)
}

// optional float overlap_thresh = 6;
inline bool SSDRandomCropOperation::_internal_has_overlap_thresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SSDRandomCropOperation::has_overlap_thresh() const {
  return _internal_has_overlap_thresh();
}
inline void SSDRandomCropOperation::clear_overlap_thresh() {
  _impl_.overlap_thresh_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float SSDRandomCropOperation::_internal_overlap_thresh() const {
  return _impl_.overlap_thresh_;
}
inline float SSDRandomCropOperation::overlap_thresh() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropOperation.overlap_thresh)
  return _internal_overlap_thresh();
}
inline void SSDRandomCropOperation::_internal_set_overlap_thresh(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.overlap_thresh_ = value;
}
inline void SSDRandomCropOperation::set_overlap_thresh(float value) {
  _internal_set_overlap_thresh(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropOperation.overlap_thresh)
}

// optional bool clip_boxes = 8 [default = true];
inline bool SSDRandomCropOperation::_internal_has_clip_boxes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SSDRandomCropOperation::has_clip_boxes() const {
  return _internal_has_clip_boxes();
}
inline void SSDRandomCropOperation::clear_clip_boxes() {
  _impl_.clip_boxes_ = true;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool SSDRandomCropOperation::_internal_clip_boxes() const {
  return _impl_.clip_boxes_;
}
inline bool SSDRandomCropOperation::clip_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropOperation.clip_boxes)
  return _internal_clip_boxes();
}
inline void SSDRandomCropOperation::_internal_set_clip_boxes(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.clip_boxes_ = value;
}
inline void SSDRandomCropOperation::set_clip_boxes(bool value) {
  _internal_set_clip_boxes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropOperation.clip_boxes)
}

// optional float random_coef = 7;
inline bool SSDRandomCropOperation::_internal_has_random_coef() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SSDRandomCropOperation::has_random_coef() const {
  return _internal_has_random_coef();
}
inline void SSDRandomCropOperation::clear_random_coef() {
  _impl_.random_coef_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float SSDRandomCropOperation::_internal_random_coef() const {
  return _impl_.random_coef_;
}
inline float SSDRandomCropOperation::random_coef() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropOperation.random_coef)
  return _internal_random_coef();
}
inline void SSDRandomCropOperation::_internal_set_random_coef(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.random_coef_ = value;
}
inline void SSDRandomCropOperation::set_random_coef(float value) {
  _internal_set_random_coef(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropOperation.random_coef)
}

// -------------------------------------------------------------------

// SSDRandomCrop

// repeated .object_detection.protos.SSDRandomCropOperation operations = 1;
inline int SSDRandomCrop::_internal_operations_size() const {
  return _impl_.operations_.size();
}
inline int SSDRandomCrop::operations_size() const {
  return _internal_operations_size();
}
inline void SSDRandomCrop::clear_operations() {
  _impl_.operations_.Clear();
}
inline ::object_detection::protos::SSDRandomCropOperation* SSDRandomCrop::mutable_operations(int index) {
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SSDRandomCrop.operations)
  return _impl_.operations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropOperation >*
SSDRandomCrop::mutable_operations() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SSDRandomCrop.operations)
  return &_impl_.operations_;
}
inline const ::object_detection::protos::SSDRandomCropOperation& SSDRandomCrop::_internal_operations(int index) const {
  return _impl_.operations_.Get(index);
}
inline const ::object_detection::protos::SSDRandomCropOperation& SSDRandomCrop::operations(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCrop.operations)
  return _internal_operations(index);
}
inline ::object_detection::protos::SSDRandomCropOperation* SSDRandomCrop::_internal_add_operations() {
  return _impl_.operations_.Add();
}
inline ::object_detection::protos::SSDRandomCropOperation* SSDRandomCrop::add_operations() {
  ::object_detection::protos::SSDRandomCropOperation* _add = _internal_add_operations();
  // @@protoc_insertion_point(field_add:object_detection.protos.SSDRandomCrop.operations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropOperation >&
SSDRandomCrop::operations() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SSDRandomCrop.operations)
  return _impl_.operations_;
}

// -------------------------------------------------------------------

// SSDRandomCropPadOperation

// optional float min_object_covered = 1;
inline bool SSDRandomCropPadOperation::_internal_has_min_object_covered() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_min_object_covered() const {
  return _internal_has_min_object_covered();
}
inline void SSDRandomCropPadOperation::clear_min_object_covered() {
  _impl_.min_object_covered_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float SSDRandomCropPadOperation::_internal_min_object_covered() const {
  return _impl_.min_object_covered_;
}
inline float SSDRandomCropPadOperation::min_object_covered() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.min_object_covered)
  return _internal_min_object_covered();
}
inline void SSDRandomCropPadOperation::_internal_set_min_object_covered(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.min_object_covered_ = value;
}
inline void SSDRandomCropPadOperation::set_min_object_covered(float value) {
  _internal_set_min_object_covered(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.min_object_covered)
}

// optional float min_aspect_ratio = 2;
inline bool SSDRandomCropPadOperation::_internal_has_min_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_min_aspect_ratio() const {
  return _internal_has_min_aspect_ratio();
}
inline void SSDRandomCropPadOperation::clear_min_aspect_ratio() {
  _impl_.min_aspect_ratio_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float SSDRandomCropPadOperation::_internal_min_aspect_ratio() const {
  return _impl_.min_aspect_ratio_;
}
inline float SSDRandomCropPadOperation::min_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.min_aspect_ratio)
  return _internal_min_aspect_ratio();
}
inline void SSDRandomCropPadOperation::_internal_set_min_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.min_aspect_ratio_ = value;
}
inline void SSDRandomCropPadOperation::set_min_aspect_ratio(float value) {
  _internal_set_min_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.min_aspect_ratio)
}

// optional float max_aspect_ratio = 3;
inline bool SSDRandomCropPadOperation::_internal_has_max_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_max_aspect_ratio() const {
  return _internal_has_max_aspect_ratio();
}
inline void SSDRandomCropPadOperation::clear_max_aspect_ratio() {
  _impl_.max_aspect_ratio_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float SSDRandomCropPadOperation::_internal_max_aspect_ratio() const {
  return _impl_.max_aspect_ratio_;
}
inline float SSDRandomCropPadOperation::max_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.max_aspect_ratio)
  return _internal_max_aspect_ratio();
}
inline void SSDRandomCropPadOperation::_internal_set_max_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_aspect_ratio_ = value;
}
inline void SSDRandomCropPadOperation::set_max_aspect_ratio(float value) {
  _internal_set_max_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.max_aspect_ratio)
}

// optional float min_area = 4;
inline bool SSDRandomCropPadOperation::_internal_has_min_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_min_area() const {
  return _internal_has_min_area();
}
inline void SSDRandomCropPadOperation::clear_min_area() {
  _impl_.min_area_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float SSDRandomCropPadOperation::_internal_min_area() const {
  return _impl_.min_area_;
}
inline float SSDRandomCropPadOperation::min_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.min_area)
  return _internal_min_area();
}
inline void SSDRandomCropPadOperation::_internal_set_min_area(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.min_area_ = value;
}
inline void SSDRandomCropPadOperation::set_min_area(float value) {
  _internal_set_min_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.min_area)
}

// optional float max_area = 5;
inline bool SSDRandomCropPadOperation::_internal_has_max_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_max_area() const {
  return _internal_has_max_area();
}
inline void SSDRandomCropPadOperation::clear_max_area() {
  _impl_.max_area_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float SSDRandomCropPadOperation::_internal_max_area() const {
  return _impl_.max_area_;
}
inline float SSDRandomCropPadOperation::max_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.max_area)
  return _internal_max_area();
}
inline void SSDRandomCropPadOperation::_internal_set_max_area(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.max_area_ = value;
}
inline void SSDRandomCropPadOperation::set_max_area(float value) {
  _internal_set_max_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.max_area)
}

// optional float overlap_thresh = 6;
inline bool SSDRandomCropPadOperation::_internal_has_overlap_thresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_overlap_thresh() const {
  return _internal_has_overlap_thresh();
}
inline void SSDRandomCropPadOperation::clear_overlap_thresh() {
  _impl_.overlap_thresh_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float SSDRandomCropPadOperation::_internal_overlap_thresh() const {
  return _impl_.overlap_thresh_;
}
inline float SSDRandomCropPadOperation::overlap_thresh() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.overlap_thresh)
  return _internal_overlap_thresh();
}
inline void SSDRandomCropPadOperation::_internal_set_overlap_thresh(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.overlap_thresh_ = value;
}
inline void SSDRandomCropPadOperation::set_overlap_thresh(float value) {
  _internal_set_overlap_thresh(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.overlap_thresh)
}

// optional bool clip_boxes = 13 [default = true];
inline bool SSDRandomCropPadOperation::_internal_has_clip_boxes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_clip_boxes() const {
  return _internal_has_clip_boxes();
}
inline void SSDRandomCropPadOperation::clear_clip_boxes() {
  _impl_.clip_boxes_ = true;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool SSDRandomCropPadOperation::_internal_clip_boxes() const {
  return _impl_.clip_boxes_;
}
inline bool SSDRandomCropPadOperation::clip_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.clip_boxes)
  return _internal_clip_boxes();
}
inline void SSDRandomCropPadOperation::_internal_set_clip_boxes(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.clip_boxes_ = value;
}
inline void SSDRandomCropPadOperation::set_clip_boxes(bool value) {
  _internal_set_clip_boxes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.clip_boxes)
}

// optional float random_coef = 7;
inline bool SSDRandomCropPadOperation::_internal_has_random_coef() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_random_coef() const {
  return _internal_has_random_coef();
}
inline void SSDRandomCropPadOperation::clear_random_coef() {
  _impl_.random_coef_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float SSDRandomCropPadOperation::_internal_random_coef() const {
  return _impl_.random_coef_;
}
inline float SSDRandomCropPadOperation::random_coef() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.random_coef)
  return _internal_random_coef();
}
inline void SSDRandomCropPadOperation::_internal_set_random_coef(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.random_coef_ = value;
}
inline void SSDRandomCropPadOperation::set_random_coef(float value) {
  _internal_set_random_coef(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.random_coef)
}

// repeated float min_padded_size_ratio = 8;
inline int SSDRandomCropPadOperation::_internal_min_padded_size_ratio_size() const {
  return _impl_.min_padded_size_ratio_.size();
}
inline int SSDRandomCropPadOperation::min_padded_size_ratio_size() const {
  return _internal_min_padded_size_ratio_size();
}
inline void SSDRandomCropPadOperation::clear_min_padded_size_ratio() {
  _impl_.min_padded_size_ratio_.Clear();
}
inline float SSDRandomCropPadOperation::_internal_min_padded_size_ratio(int index) const {
  return _impl_.min_padded_size_ratio_.Get(index);
}
inline float SSDRandomCropPadOperation::min_padded_size_ratio(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.min_padded_size_ratio)
  return _internal_min_padded_size_ratio(index);
}
inline void SSDRandomCropPadOperation::set_min_padded_size_ratio(int index, float value) {
  _impl_.min_padded_size_ratio_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.min_padded_size_ratio)
}
inline void SSDRandomCropPadOperation::_internal_add_min_padded_size_ratio(float value) {
  _impl_.min_padded_size_ratio_.Add(value);
}
inline void SSDRandomCropPadOperation::add_min_padded_size_ratio(float value) {
  _internal_add_min_padded_size_ratio(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.SSDRandomCropPadOperation.min_padded_size_ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SSDRandomCropPadOperation::_internal_min_padded_size_ratio() const {
  return _impl_.min_padded_size_ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SSDRandomCropPadOperation::min_padded_size_ratio() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SSDRandomCropPadOperation.min_padded_size_ratio)
  return _internal_min_padded_size_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SSDRandomCropPadOperation::_internal_mutable_min_padded_size_ratio() {
  return &_impl_.min_padded_size_ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SSDRandomCropPadOperation::mutable_min_padded_size_ratio() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SSDRandomCropPadOperation.min_padded_size_ratio)
  return _internal_mutable_min_padded_size_ratio();
}

// repeated float max_padded_size_ratio = 9;
inline int SSDRandomCropPadOperation::_internal_max_padded_size_ratio_size() const {
  return _impl_.max_padded_size_ratio_.size();
}
inline int SSDRandomCropPadOperation::max_padded_size_ratio_size() const {
  return _internal_max_padded_size_ratio_size();
}
inline void SSDRandomCropPadOperation::clear_max_padded_size_ratio() {
  _impl_.max_padded_size_ratio_.Clear();
}
inline float SSDRandomCropPadOperation::_internal_max_padded_size_ratio(int index) const {
  return _impl_.max_padded_size_ratio_.Get(index);
}
inline float SSDRandomCropPadOperation::max_padded_size_ratio(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.max_padded_size_ratio)
  return _internal_max_padded_size_ratio(index);
}
inline void SSDRandomCropPadOperation::set_max_padded_size_ratio(int index, float value) {
  _impl_.max_padded_size_ratio_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.max_padded_size_ratio)
}
inline void SSDRandomCropPadOperation::_internal_add_max_padded_size_ratio(float value) {
  _impl_.max_padded_size_ratio_.Add(value);
}
inline void SSDRandomCropPadOperation::add_max_padded_size_ratio(float value) {
  _internal_add_max_padded_size_ratio(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.SSDRandomCropPadOperation.max_padded_size_ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SSDRandomCropPadOperation::_internal_max_padded_size_ratio() const {
  return _impl_.max_padded_size_ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SSDRandomCropPadOperation::max_padded_size_ratio() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SSDRandomCropPadOperation.max_padded_size_ratio)
  return _internal_max_padded_size_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SSDRandomCropPadOperation::_internal_mutable_max_padded_size_ratio() {
  return &_impl_.max_padded_size_ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SSDRandomCropPadOperation::mutable_max_padded_size_ratio() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SSDRandomCropPadOperation.max_padded_size_ratio)
  return _internal_mutable_max_padded_size_ratio();
}

// optional float pad_color_r = 10;
inline bool SSDRandomCropPadOperation::_internal_has_pad_color_r() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_pad_color_r() const {
  return _internal_has_pad_color_r();
}
inline void SSDRandomCropPadOperation::clear_pad_color_r() {
  _impl_.pad_color_r_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float SSDRandomCropPadOperation::_internal_pad_color_r() const {
  return _impl_.pad_color_r_;
}
inline float SSDRandomCropPadOperation::pad_color_r() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.pad_color_r)
  return _internal_pad_color_r();
}
inline void SSDRandomCropPadOperation::_internal_set_pad_color_r(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.pad_color_r_ = value;
}
inline void SSDRandomCropPadOperation::set_pad_color_r(float value) {
  _internal_set_pad_color_r(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.pad_color_r)
}

// optional float pad_color_g = 11;
inline bool SSDRandomCropPadOperation::_internal_has_pad_color_g() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_pad_color_g() const {
  return _internal_has_pad_color_g();
}
inline void SSDRandomCropPadOperation::clear_pad_color_g() {
  _impl_.pad_color_g_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float SSDRandomCropPadOperation::_internal_pad_color_g() const {
  return _impl_.pad_color_g_;
}
inline float SSDRandomCropPadOperation::pad_color_g() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.pad_color_g)
  return _internal_pad_color_g();
}
inline void SSDRandomCropPadOperation::_internal_set_pad_color_g(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.pad_color_g_ = value;
}
inline void SSDRandomCropPadOperation::set_pad_color_g(float value) {
  _internal_set_pad_color_g(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.pad_color_g)
}

// optional float pad_color_b = 12;
inline bool SSDRandomCropPadOperation::_internal_has_pad_color_b() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SSDRandomCropPadOperation::has_pad_color_b() const {
  return _internal_has_pad_color_b();
}
inline void SSDRandomCropPadOperation::clear_pad_color_b() {
  _impl_.pad_color_b_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline float SSDRandomCropPadOperation::_internal_pad_color_b() const {
  return _impl_.pad_color_b_;
}
inline float SSDRandomCropPadOperation::pad_color_b() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadOperation.pad_color_b)
  return _internal_pad_color_b();
}
inline void SSDRandomCropPadOperation::_internal_set_pad_color_b(float value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.pad_color_b_ = value;
}
inline void SSDRandomCropPadOperation::set_pad_color_b(float value) {
  _internal_set_pad_color_b(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadOperation.pad_color_b)
}

// -------------------------------------------------------------------

// SSDRandomCropPad

// repeated .object_detection.protos.SSDRandomCropPadOperation operations = 1;
inline int SSDRandomCropPad::_internal_operations_size() const {
  return _impl_.operations_.size();
}
inline int SSDRandomCropPad::operations_size() const {
  return _internal_operations_size();
}
inline void SSDRandomCropPad::clear_operations() {
  _impl_.operations_.Clear();
}
inline ::object_detection::protos::SSDRandomCropPadOperation* SSDRandomCropPad::mutable_operations(int index) {
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SSDRandomCropPad.operations)
  return _impl_.operations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadOperation >*
SSDRandomCropPad::mutable_operations() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SSDRandomCropPad.operations)
  return &_impl_.operations_;
}
inline const ::object_detection::protos::SSDRandomCropPadOperation& SSDRandomCropPad::_internal_operations(int index) const {
  return _impl_.operations_.Get(index);
}
inline const ::object_detection::protos::SSDRandomCropPadOperation& SSDRandomCropPad::operations(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPad.operations)
  return _internal_operations(index);
}
inline ::object_detection::protos::SSDRandomCropPadOperation* SSDRandomCropPad::_internal_add_operations() {
  return _impl_.operations_.Add();
}
inline ::object_detection::protos::SSDRandomCropPadOperation* SSDRandomCropPad::add_operations() {
  ::object_detection::protos::SSDRandomCropPadOperation* _add = _internal_add_operations();
  // @@protoc_insertion_point(field_add:object_detection.protos.SSDRandomCropPad.operations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadOperation >&
SSDRandomCropPad::operations() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SSDRandomCropPad.operations)
  return _impl_.operations_;
}

// -------------------------------------------------------------------

// SSDRandomCropFixedAspectRatioOperation

// optional float min_object_covered = 1;
inline bool SSDRandomCropFixedAspectRatioOperation::_internal_has_min_object_covered() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SSDRandomCropFixedAspectRatioOperation::has_min_object_covered() const {
  return _internal_has_min_object_covered();
}
inline void SSDRandomCropFixedAspectRatioOperation::clear_min_object_covered() {
  _impl_.min_object_covered_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float SSDRandomCropFixedAspectRatioOperation::_internal_min_object_covered() const {
  return _impl_.min_object_covered_;
}
inline float SSDRandomCropFixedAspectRatioOperation::min_object_covered() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.min_object_covered)
  return _internal_min_object_covered();
}
inline void SSDRandomCropFixedAspectRatioOperation::_internal_set_min_object_covered(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.min_object_covered_ = value;
}
inline void SSDRandomCropFixedAspectRatioOperation::set_min_object_covered(float value) {
  _internal_set_min_object_covered(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.min_object_covered)
}

// optional float min_area = 4;
inline bool SSDRandomCropFixedAspectRatioOperation::_internal_has_min_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SSDRandomCropFixedAspectRatioOperation::has_min_area() const {
  return _internal_has_min_area();
}
inline void SSDRandomCropFixedAspectRatioOperation::clear_min_area() {
  _impl_.min_area_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float SSDRandomCropFixedAspectRatioOperation::_internal_min_area() const {
  return _impl_.min_area_;
}
inline float SSDRandomCropFixedAspectRatioOperation::min_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.min_area)
  return _internal_min_area();
}
inline void SSDRandomCropFixedAspectRatioOperation::_internal_set_min_area(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.min_area_ = value;
}
inline void SSDRandomCropFixedAspectRatioOperation::set_min_area(float value) {
  _internal_set_min_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.min_area)
}

// optional float max_area = 5;
inline bool SSDRandomCropFixedAspectRatioOperation::_internal_has_max_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SSDRandomCropFixedAspectRatioOperation::has_max_area() const {
  return _internal_has_max_area();
}
inline void SSDRandomCropFixedAspectRatioOperation::clear_max_area() {
  _impl_.max_area_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float SSDRandomCropFixedAspectRatioOperation::_internal_max_area() const {
  return _impl_.max_area_;
}
inline float SSDRandomCropFixedAspectRatioOperation::max_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.max_area)
  return _internal_max_area();
}
inline void SSDRandomCropFixedAspectRatioOperation::_internal_set_max_area(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_area_ = value;
}
inline void SSDRandomCropFixedAspectRatioOperation::set_max_area(float value) {
  _internal_set_max_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.max_area)
}

// optional float overlap_thresh = 6;
inline bool SSDRandomCropFixedAspectRatioOperation::_internal_has_overlap_thresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SSDRandomCropFixedAspectRatioOperation::has_overlap_thresh() const {
  return _internal_has_overlap_thresh();
}
inline void SSDRandomCropFixedAspectRatioOperation::clear_overlap_thresh() {
  _impl_.overlap_thresh_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float SSDRandomCropFixedAspectRatioOperation::_internal_overlap_thresh() const {
  return _impl_.overlap_thresh_;
}
inline float SSDRandomCropFixedAspectRatioOperation::overlap_thresh() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.overlap_thresh)
  return _internal_overlap_thresh();
}
inline void SSDRandomCropFixedAspectRatioOperation::_internal_set_overlap_thresh(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.overlap_thresh_ = value;
}
inline void SSDRandomCropFixedAspectRatioOperation::set_overlap_thresh(float value) {
  _internal_set_overlap_thresh(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.overlap_thresh)
}

// optional bool clip_boxes = 8 [default = true];
inline bool SSDRandomCropFixedAspectRatioOperation::_internal_has_clip_boxes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SSDRandomCropFixedAspectRatioOperation::has_clip_boxes() const {
  return _internal_has_clip_boxes();
}
inline void SSDRandomCropFixedAspectRatioOperation::clear_clip_boxes() {
  _impl_.clip_boxes_ = true;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool SSDRandomCropFixedAspectRatioOperation::_internal_clip_boxes() const {
  return _impl_.clip_boxes_;
}
inline bool SSDRandomCropFixedAspectRatioOperation::clip_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.clip_boxes)
  return _internal_clip_boxes();
}
inline void SSDRandomCropFixedAspectRatioOperation::_internal_set_clip_boxes(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.clip_boxes_ = value;
}
inline void SSDRandomCropFixedAspectRatioOperation::set_clip_boxes(bool value) {
  _internal_set_clip_boxes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.clip_boxes)
}

// optional float random_coef = 7;
inline bool SSDRandomCropFixedAspectRatioOperation::_internal_has_random_coef() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SSDRandomCropFixedAspectRatioOperation::has_random_coef() const {
  return _internal_has_random_coef();
}
inline void SSDRandomCropFixedAspectRatioOperation::clear_random_coef() {
  _impl_.random_coef_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float SSDRandomCropFixedAspectRatioOperation::_internal_random_coef() const {
  return _impl_.random_coef_;
}
inline float SSDRandomCropFixedAspectRatioOperation::random_coef() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.random_coef)
  return _internal_random_coef();
}
inline void SSDRandomCropFixedAspectRatioOperation::_internal_set_random_coef(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.random_coef_ = value;
}
inline void SSDRandomCropFixedAspectRatioOperation::set_random_coef(float value) {
  _internal_set_random_coef(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropFixedAspectRatioOperation.random_coef)
}

// -------------------------------------------------------------------

// SSDRandomCropFixedAspectRatio

// repeated .object_detection.protos.SSDRandomCropFixedAspectRatioOperation operations = 1;
inline int SSDRandomCropFixedAspectRatio::_internal_operations_size() const {
  return _impl_.operations_.size();
}
inline int SSDRandomCropFixedAspectRatio::operations_size() const {
  return _internal_operations_size();
}
inline void SSDRandomCropFixedAspectRatio::clear_operations() {
  _impl_.operations_.Clear();
}
inline ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation* SSDRandomCropFixedAspectRatio::mutable_operations(int index) {
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SSDRandomCropFixedAspectRatio.operations)
  return _impl_.operations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation >*
SSDRandomCropFixedAspectRatio::mutable_operations() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SSDRandomCropFixedAspectRatio.operations)
  return &_impl_.operations_;
}
inline const ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation& SSDRandomCropFixedAspectRatio::_internal_operations(int index) const {
  return _impl_.operations_.Get(index);
}
inline const ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation& SSDRandomCropFixedAspectRatio::operations(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropFixedAspectRatio.operations)
  return _internal_operations(index);
}
inline ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation* SSDRandomCropFixedAspectRatio::_internal_add_operations() {
  return _impl_.operations_.Add();
}
inline ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation* SSDRandomCropFixedAspectRatio::add_operations() {
  ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation* _add = _internal_add_operations();
  // @@protoc_insertion_point(field_add:object_detection.protos.SSDRandomCropFixedAspectRatio.operations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropFixedAspectRatioOperation >&
SSDRandomCropFixedAspectRatio::operations() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SSDRandomCropFixedAspectRatio.operations)
  return _impl_.operations_;
}

// optional float aspect_ratio = 2 [default = 1];
inline bool SSDRandomCropFixedAspectRatio::_internal_has_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SSDRandomCropFixedAspectRatio::has_aspect_ratio() const {
  return _internal_has_aspect_ratio();
}
inline void SSDRandomCropFixedAspectRatio::clear_aspect_ratio() {
  _impl_.aspect_ratio_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float SSDRandomCropFixedAspectRatio::_internal_aspect_ratio() const {
  return _impl_.aspect_ratio_;
}
inline float SSDRandomCropFixedAspectRatio::aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropFixedAspectRatio.aspect_ratio)
  return _internal_aspect_ratio();
}
inline void SSDRandomCropFixedAspectRatio::_internal_set_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.aspect_ratio_ = value;
}
inline void SSDRandomCropFixedAspectRatio::set_aspect_ratio(float value) {
  _internal_set_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropFixedAspectRatio.aspect_ratio)
}

// -------------------------------------------------------------------

// SSDRandomCropPadFixedAspectRatioOperation

// optional float min_object_covered = 1;
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_has_min_object_covered() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::has_min_object_covered() const {
  return _internal_has_min_object_covered();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::clear_min_object_covered() {
  _impl_.min_object_covered_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::_internal_min_object_covered() const {
  return _impl_.min_object_covered_;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::min_object_covered() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.min_object_covered)
  return _internal_min_object_covered();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::_internal_set_min_object_covered(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.min_object_covered_ = value;
}
inline void SSDRandomCropPadFixedAspectRatioOperation::set_min_object_covered(float value) {
  _internal_set_min_object_covered(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.min_object_covered)
}

// optional float min_aspect_ratio = 2;
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_has_min_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::has_min_aspect_ratio() const {
  return _internal_has_min_aspect_ratio();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::clear_min_aspect_ratio() {
  _impl_.min_aspect_ratio_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::_internal_min_aspect_ratio() const {
  return _impl_.min_aspect_ratio_;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::min_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.min_aspect_ratio)
  return _internal_min_aspect_ratio();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::_internal_set_min_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.min_aspect_ratio_ = value;
}
inline void SSDRandomCropPadFixedAspectRatioOperation::set_min_aspect_ratio(float value) {
  _internal_set_min_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.min_aspect_ratio)
}

// optional float max_aspect_ratio = 3;
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_has_max_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::has_max_aspect_ratio() const {
  return _internal_has_max_aspect_ratio();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::clear_max_aspect_ratio() {
  _impl_.max_aspect_ratio_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::_internal_max_aspect_ratio() const {
  return _impl_.max_aspect_ratio_;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::max_aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.max_aspect_ratio)
  return _internal_max_aspect_ratio();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::_internal_set_max_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_aspect_ratio_ = value;
}
inline void SSDRandomCropPadFixedAspectRatioOperation::set_max_aspect_ratio(float value) {
  _internal_set_max_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.max_aspect_ratio)
}

// optional float min_area = 4;
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_has_min_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::has_min_area() const {
  return _internal_has_min_area();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::clear_min_area() {
  _impl_.min_area_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::_internal_min_area() const {
  return _impl_.min_area_;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::min_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.min_area)
  return _internal_min_area();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::_internal_set_min_area(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.min_area_ = value;
}
inline void SSDRandomCropPadFixedAspectRatioOperation::set_min_area(float value) {
  _internal_set_min_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.min_area)
}

// optional float max_area = 5;
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_has_max_area() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::has_max_area() const {
  return _internal_has_max_area();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::clear_max_area() {
  _impl_.max_area_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::_internal_max_area() const {
  return _impl_.max_area_;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::max_area() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.max_area)
  return _internal_max_area();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::_internal_set_max_area(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.max_area_ = value;
}
inline void SSDRandomCropPadFixedAspectRatioOperation::set_max_area(float value) {
  _internal_set_max_area(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.max_area)
}

// optional float overlap_thresh = 6;
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_has_overlap_thresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::has_overlap_thresh() const {
  return _internal_has_overlap_thresh();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::clear_overlap_thresh() {
  _impl_.overlap_thresh_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::_internal_overlap_thresh() const {
  return _impl_.overlap_thresh_;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::overlap_thresh() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.overlap_thresh)
  return _internal_overlap_thresh();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::_internal_set_overlap_thresh(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.overlap_thresh_ = value;
}
inline void SSDRandomCropPadFixedAspectRatioOperation::set_overlap_thresh(float value) {
  _internal_set_overlap_thresh(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.overlap_thresh)
}

// optional bool clip_boxes = 8 [default = true];
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_has_clip_boxes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::has_clip_boxes() const {
  return _internal_has_clip_boxes();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::clear_clip_boxes() {
  _impl_.clip_boxes_ = true;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_clip_boxes() const {
  return _impl_.clip_boxes_;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::clip_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.clip_boxes)
  return _internal_clip_boxes();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::_internal_set_clip_boxes(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.clip_boxes_ = value;
}
inline void SSDRandomCropPadFixedAspectRatioOperation::set_clip_boxes(bool value) {
  _internal_set_clip_boxes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.clip_boxes)
}

// optional float random_coef = 7;
inline bool SSDRandomCropPadFixedAspectRatioOperation::_internal_has_random_coef() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatioOperation::has_random_coef() const {
  return _internal_has_random_coef();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::clear_random_coef() {
  _impl_.random_coef_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::_internal_random_coef() const {
  return _impl_.random_coef_;
}
inline float SSDRandomCropPadFixedAspectRatioOperation::random_coef() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.random_coef)
  return _internal_random_coef();
}
inline void SSDRandomCropPadFixedAspectRatioOperation::_internal_set_random_coef(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.random_coef_ = value;
}
inline void SSDRandomCropPadFixedAspectRatioOperation::set_random_coef(float value) {
  _internal_set_random_coef(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation.random_coef)
}

// -------------------------------------------------------------------

// SSDRandomCropPadFixedAspectRatio

// repeated .object_detection.protos.SSDRandomCropPadFixedAspectRatioOperation operations = 1;
inline int SSDRandomCropPadFixedAspectRatio::_internal_operations_size() const {
  return _impl_.operations_.size();
}
inline int SSDRandomCropPadFixedAspectRatio::operations_size() const {
  return _internal_operations_size();
}
inline void SSDRandomCropPadFixedAspectRatio::clear_operations() {
  _impl_.operations_.Clear();
}
inline ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation* SSDRandomCropPadFixedAspectRatio::mutable_operations(int index) {
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SSDRandomCropPadFixedAspectRatio.operations)
  return _impl_.operations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation >*
SSDRandomCropPadFixedAspectRatio::mutable_operations() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SSDRandomCropPadFixedAspectRatio.operations)
  return &_impl_.operations_;
}
inline const ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation& SSDRandomCropPadFixedAspectRatio::_internal_operations(int index) const {
  return _impl_.operations_.Get(index);
}
inline const ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation& SSDRandomCropPadFixedAspectRatio::operations(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatio.operations)
  return _internal_operations(index);
}
inline ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation* SSDRandomCropPadFixedAspectRatio::_internal_add_operations() {
  return _impl_.operations_.Add();
}
inline ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation* SSDRandomCropPadFixedAspectRatio::add_operations() {
  ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation* _add = _internal_add_operations();
  // @@protoc_insertion_point(field_add:object_detection.protos.SSDRandomCropPadFixedAspectRatio.operations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::object_detection::protos::SSDRandomCropPadFixedAspectRatioOperation >&
SSDRandomCropPadFixedAspectRatio::operations() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SSDRandomCropPadFixedAspectRatio.operations)
  return _impl_.operations_;
}

// optional float aspect_ratio = 2 [default = 1];
inline bool SSDRandomCropPadFixedAspectRatio::_internal_has_aspect_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SSDRandomCropPadFixedAspectRatio::has_aspect_ratio() const {
  return _internal_has_aspect_ratio();
}
inline void SSDRandomCropPadFixedAspectRatio::clear_aspect_ratio() {
  _impl_.aspect_ratio_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float SSDRandomCropPadFixedAspectRatio::_internal_aspect_ratio() const {
  return _impl_.aspect_ratio_;
}
inline float SSDRandomCropPadFixedAspectRatio::aspect_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatio.aspect_ratio)
  return _internal_aspect_ratio();
}
inline void SSDRandomCropPadFixedAspectRatio::_internal_set_aspect_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.aspect_ratio_ = value;
}
inline void SSDRandomCropPadFixedAspectRatio::set_aspect_ratio(float value) {
  _internal_set_aspect_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatio.aspect_ratio)
}

// repeated float min_padded_size_ratio = 3;
inline int SSDRandomCropPadFixedAspectRatio::_internal_min_padded_size_ratio_size() const {
  return _impl_.min_padded_size_ratio_.size();
}
inline int SSDRandomCropPadFixedAspectRatio::min_padded_size_ratio_size() const {
  return _internal_min_padded_size_ratio_size();
}
inline void SSDRandomCropPadFixedAspectRatio::clear_min_padded_size_ratio() {
  _impl_.min_padded_size_ratio_.Clear();
}
inline float SSDRandomCropPadFixedAspectRatio::_internal_min_padded_size_ratio(int index) const {
  return _impl_.min_padded_size_ratio_.Get(index);
}
inline float SSDRandomCropPadFixedAspectRatio::min_padded_size_ratio(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatio.min_padded_size_ratio)
  return _internal_min_padded_size_ratio(index);
}
inline void SSDRandomCropPadFixedAspectRatio::set_min_padded_size_ratio(int index, float value) {
  _impl_.min_padded_size_ratio_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatio.min_padded_size_ratio)
}
inline void SSDRandomCropPadFixedAspectRatio::_internal_add_min_padded_size_ratio(float value) {
  _impl_.min_padded_size_ratio_.Add(value);
}
inline void SSDRandomCropPadFixedAspectRatio::add_min_padded_size_ratio(float value) {
  _internal_add_min_padded_size_ratio(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.SSDRandomCropPadFixedAspectRatio.min_padded_size_ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SSDRandomCropPadFixedAspectRatio::_internal_min_padded_size_ratio() const {
  return _impl_.min_padded_size_ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SSDRandomCropPadFixedAspectRatio::min_padded_size_ratio() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SSDRandomCropPadFixedAspectRatio.min_padded_size_ratio)
  return _internal_min_padded_size_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SSDRandomCropPadFixedAspectRatio::_internal_mutable_min_padded_size_ratio() {
  return &_impl_.min_padded_size_ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SSDRandomCropPadFixedAspectRatio::mutable_min_padded_size_ratio() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SSDRandomCropPadFixedAspectRatio.min_padded_size_ratio)
  return _internal_mutable_min_padded_size_ratio();
}

// repeated float max_padded_size_ratio = 4;
inline int SSDRandomCropPadFixedAspectRatio::_internal_max_padded_size_ratio_size() const {
  return _impl_.max_padded_size_ratio_.size();
}
inline int SSDRandomCropPadFixedAspectRatio::max_padded_size_ratio_size() const {
  return _internal_max_padded_size_ratio_size();
}
inline void SSDRandomCropPadFixedAspectRatio::clear_max_padded_size_ratio() {
  _impl_.max_padded_size_ratio_.Clear();
}
inline float SSDRandomCropPadFixedAspectRatio::_internal_max_padded_size_ratio(int index) const {
  return _impl_.max_padded_size_ratio_.Get(index);
}
inline float SSDRandomCropPadFixedAspectRatio::max_padded_size_ratio(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SSDRandomCropPadFixedAspectRatio.max_padded_size_ratio)
  return _internal_max_padded_size_ratio(index);
}
inline void SSDRandomCropPadFixedAspectRatio::set_max_padded_size_ratio(int index, float value) {
  _impl_.max_padded_size_ratio_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SSDRandomCropPadFixedAspectRatio.max_padded_size_ratio)
}
inline void SSDRandomCropPadFixedAspectRatio::_internal_add_max_padded_size_ratio(float value) {
  _impl_.max_padded_size_ratio_.Add(value);
}
inline void SSDRandomCropPadFixedAspectRatio::add_max_padded_size_ratio(float value) {
  _internal_add_max_padded_size_ratio(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.SSDRandomCropPadFixedAspectRatio.max_padded_size_ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SSDRandomCropPadFixedAspectRatio::_internal_max_padded_size_ratio() const {
  return _impl_.max_padded_size_ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SSDRandomCropPadFixedAspectRatio::max_padded_size_ratio() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.SSDRandomCropPadFixedAspectRatio.max_padded_size_ratio)
  return _internal_max_padded_size_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SSDRandomCropPadFixedAspectRatio::_internal_mutable_max_padded_size_ratio() {
  return &_impl_.max_padded_size_ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SSDRandomCropPadFixedAspectRatio::mutable_max_padded_size_ratio() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.SSDRandomCropPadFixedAspectRatio.max_padded_size_ratio)
  return _internal_mutable_max_padded_size_ratio();
}

// -------------------------------------------------------------------

// ConvertClassLogitsToSoftmax

// optional float temperature = 1 [default = 1];
inline bool ConvertClassLogitsToSoftmax::_internal_has_temperature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ConvertClassLogitsToSoftmax::has_temperature() const {
  return _internal_has_temperature();
}
inline void ConvertClassLogitsToSoftmax::clear_temperature() {
  _impl_.temperature_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float ConvertClassLogitsToSoftmax::_internal_temperature() const {
  return _impl_.temperature_;
}
inline float ConvertClassLogitsToSoftmax::temperature() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ConvertClassLogitsToSoftmax.temperature)
  return _internal_temperature();
}
inline void ConvertClassLogitsToSoftmax::_internal_set_temperature(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.temperature_ = value;
}
inline void ConvertClassLogitsToSoftmax::set_temperature(float value) {
  _internal_set_temperature(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.ConvertClassLogitsToSoftmax.temperature)
}

// -------------------------------------------------------------------

// RandomSelfConcatImage

// optional float concat_vertical_probability = 1 [default = 0.1];
inline bool RandomSelfConcatImage::_internal_has_concat_vertical_probability() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomSelfConcatImage::has_concat_vertical_probability() const {
  return _internal_has_concat_vertical_probability();
}
inline void RandomSelfConcatImage::clear_concat_vertical_probability() {
  _impl_.concat_vertical_probability_ = 0.1f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomSelfConcatImage::_internal_concat_vertical_probability() const {
  return _impl_.concat_vertical_probability_;
}
inline float RandomSelfConcatImage::concat_vertical_probability() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomSelfConcatImage.concat_vertical_probability)
  return _internal_concat_vertical_probability();
}
inline void RandomSelfConcatImage::_internal_set_concat_vertical_probability(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.concat_vertical_probability_ = value;
}
inline void RandomSelfConcatImage::set_concat_vertical_probability(float value) {
  _internal_set_concat_vertical_probability(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomSelfConcatImage.concat_vertical_probability)
}

// optional float concat_horizontal_probability = 2 [default = 0.1];
inline bool RandomSelfConcatImage::_internal_has_concat_horizontal_probability() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RandomSelfConcatImage::has_concat_horizontal_probability() const {
  return _internal_has_concat_horizontal_probability();
}
inline void RandomSelfConcatImage::clear_concat_horizontal_probability() {
  _impl_.concat_horizontal_probability_ = 0.1f;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float RandomSelfConcatImage::_internal_concat_horizontal_probability() const {
  return _impl_.concat_horizontal_probability_;
}
inline float RandomSelfConcatImage::concat_horizontal_probability() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomSelfConcatImage.concat_horizontal_probability)
  return _internal_concat_horizontal_probability();
}
inline void RandomSelfConcatImage::_internal_set_concat_horizontal_probability(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.concat_horizontal_probability_ = value;
}
inline void RandomSelfConcatImage::set_concat_horizontal_probability(float value) {
  _internal_set_concat_horizontal_probability(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomSelfConcatImage.concat_horizontal_probability)
}

// -------------------------------------------------------------------

// AutoAugmentImage

// optional string policy_name = 1 [default = "v0"];
inline bool AutoAugmentImage::_internal_has_policy_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool AutoAugmentImage::has_policy_name() const {
  return _internal_has_policy_name();
}
inline void AutoAugmentImage::clear_policy_name() {
  _impl_.policy_name_.ClearToDefault(::object_detection::protos::AutoAugmentImage::Impl_::_i_give_permission_to_break_this_code_default_policy_name_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& AutoAugmentImage::policy_name() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.AutoAugmentImage.policy_name)
  if (_impl_.policy_name_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_policy_name_.get();
  return _internal_policy_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AutoAugmentImage::set_policy_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.policy_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:object_detection.protos.AutoAugmentImage.policy_name)
}
inline std::string* AutoAugmentImage::mutable_policy_name() {
  std::string* _s = _internal_mutable_policy_name();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.AutoAugmentImage.policy_name)
  return _s;
}
inline const std::string& AutoAugmentImage::_internal_policy_name() const {
  return _impl_.policy_name_.Get();
}
inline void AutoAugmentImage::_internal_set_policy_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.policy_name_.Set(value, GetArenaForAllocation());
}
inline std::string* AutoAugmentImage::_internal_mutable_policy_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.policy_name_.Mutable(::object_detection::protos::AutoAugmentImage::Impl_::_i_give_permission_to_break_this_code_default_policy_name_, GetArenaForAllocation());
}
inline std::string* AutoAugmentImage::release_policy_name() {
  // @@protoc_insertion_point(field_release:object_detection.protos.AutoAugmentImage.policy_name)
  if (!_internal_has_policy_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.policy_name_.Release();
  return p;
}
inline void AutoAugmentImage::set_allocated_policy_name(std::string* policy_name) {
  if (policy_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.policy_name_.SetAllocated(policy_name, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.AutoAugmentImage.policy_name)
}

// -------------------------------------------------------------------

// DropLabelProbabilistically

// optional int32 label = 1;
inline bool DropLabelProbabilistically::_internal_has_label() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DropLabelProbabilistically::has_label() const {
  return _internal_has_label();
}
inline void DropLabelProbabilistically::clear_label() {
  _impl_.label_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t DropLabelProbabilistically::_internal_label() const {
  return _impl_.label_;
}
inline int32_t DropLabelProbabilistically::label() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.DropLabelProbabilistically.label)
  return _internal_label();
}
inline void DropLabelProbabilistically::_internal_set_label(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.label_ = value;
}
inline void DropLabelProbabilistically::set_label(int32_t value) {
  _internal_set_label(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.DropLabelProbabilistically.label)
}

// optional float drop_probability = 2 [default = 1];
inline bool DropLabelProbabilistically::_internal_has_drop_probability() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DropLabelProbabilistically::has_drop_probability() const {
  return _internal_has_drop_probability();
}
inline void DropLabelProbabilistically::clear_drop_probability() {
  _impl_.drop_probability_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float DropLabelProbabilistically::_internal_drop_probability() const {
  return _impl_.drop_probability_;
}
inline float DropLabelProbabilistically::drop_probability() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.DropLabelProbabilistically.drop_probability)
  return _internal_drop_probability();
}
inline void DropLabelProbabilistically::_internal_set_drop_probability(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.drop_probability_ = value;
}
inline void DropLabelProbabilistically::set_drop_probability(float value) {
  _internal_set_drop_probability(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.DropLabelProbabilistically.drop_probability)
}

// -------------------------------------------------------------------

// RemapLabels

// repeated int32 original_labels = 1;
inline int RemapLabels::_internal_original_labels_size() const {
  return _impl_.original_labels_.size();
}
inline int RemapLabels::original_labels_size() const {
  return _internal_original_labels_size();
}
inline void RemapLabels::clear_original_labels() {
  _impl_.original_labels_.Clear();
}
inline int32_t RemapLabels::_internal_original_labels(int index) const {
  return _impl_.original_labels_.Get(index);
}
inline int32_t RemapLabels::original_labels(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RemapLabels.original_labels)
  return _internal_original_labels(index);
}
inline void RemapLabels::set_original_labels(int index, int32_t value) {
  _impl_.original_labels_.Set(index, value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RemapLabels.original_labels)
}
inline void RemapLabels::_internal_add_original_labels(int32_t value) {
  _impl_.original_labels_.Add(value);
}
inline void RemapLabels::add_original_labels(int32_t value) {
  _internal_add_original_labels(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.RemapLabels.original_labels)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
RemapLabels::_internal_original_labels() const {
  return _impl_.original_labels_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
RemapLabels::original_labels() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.RemapLabels.original_labels)
  return _internal_original_labels();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
RemapLabels::_internal_mutable_original_labels() {
  return &_impl_.original_labels_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
RemapLabels::mutable_original_labels() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.RemapLabels.original_labels)
  return _internal_mutable_original_labels();
}

// optional int32 new_label = 2;
inline bool RemapLabels::_internal_has_new_label() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RemapLabels::has_new_label() const {
  return _internal_has_new_label();
}
inline void RemapLabels::clear_new_label() {
  _impl_.new_label_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t RemapLabels::_internal_new_label() const {
  return _impl_.new_label_;
}
inline int32_t RemapLabels::new_label() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RemapLabels.new_label)
  return _internal_new_label();
}
inline void RemapLabels::_internal_set_new_label(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.new_label_ = value;
}
inline void RemapLabels::set_new_label(int32_t value) {
  _internal_set_new_label(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.RemapLabels.new_label)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace object_detection

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::object_detection::protos::ResizeImage_Method> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::object_detection::protos::ResizeImage_Method>() {
  return ::object_detection::protos::ResizeImage_Method_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2fpreprocessor_2eproto
