mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-12-16 02:19:12 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
bedabc15ae
opencv/modules/dnn/misc/caffe/opencv-caffe.pb.h
Lubov Batanina 5a6b23e8f3 Support for several min and max sizes in PriorBox layer (Merge pull request #15076) 
* Support for several min and max sizes in PriorBox layer

* Fix minSize

* Check size

* Modify initInfEngine

* Fix tests

* Fix IE support

* Add priorbox test

* Remove inputs
2019-07-30 17:23:47 +03:00

32722 lines
1.2 MiB
Raw Blame History

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: opencv-caffe.proto
#ifndef PROTOBUF_opencv_2dcaffe_2eproto__INCLUDED
#define PROTOBUF_opencv_2dcaffe_2eproto__INCLUDED
#include <string>
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 3005000
#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 3005001 < GOOGLE_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/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.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)
namespace protobuf_opencv_2dcaffe_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
static const ::google::protobuf::internal::ParseTableField entries[];
static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
static const ::google::protobuf::internal::ParseTable schema[71];
static const ::google::protobuf::internal::FieldMetadata field_metadata[];
static const ::google::protobuf::internal::SerializationTable serialization_table[];
static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
void InitDefaultsBlobShapeImpl();
void InitDefaultsBlobShape();
void InitDefaultsBlobProtoImpl();
void InitDefaultsBlobProto();
void InitDefaultsBlobProtoVectorImpl();
void InitDefaultsBlobProtoVector();
void InitDefaultsPermuteParameterImpl();
void InitDefaultsPermuteParameter();
void InitDefaultsNormalizeBBoxParameterImpl();
void InitDefaultsNormalizeBBoxParameter();
void InitDefaultsPriorBoxParameterImpl();
void InitDefaultsPriorBoxParameter();
void InitDefaultsDetectionOutputParameterImpl();
void InitDefaultsDetectionOutputParameter();
void InitDefaultsDatumImpl();
void InitDefaultsDatum();
void InitDefaultsFillerParameterImpl();
void InitDefaultsFillerParameter();
void InitDefaultsNetParameterImpl();
void InitDefaultsNetParameter();
void InitDefaultsSolverParameterImpl();
void InitDefaultsSolverParameter();
void InitDefaultsSolverStateImpl();
void InitDefaultsSolverState();
void InitDefaultsNetStateImpl();
void InitDefaultsNetState();
void InitDefaultsNetStateRuleImpl();
void InitDefaultsNetStateRule();
void InitDefaultsParamSpecImpl();
void InitDefaultsParamSpec();
void InitDefaultsLayerParameterImpl();
void InitDefaultsLayerParameter();
void InitDefaultsTransformationParameterImpl();
void InitDefaultsTransformationParameter();
void InitDefaultsLossParameterImpl();
void InitDefaultsLossParameter();
void InitDefaultsAccuracyParameterImpl();
void InitDefaultsAccuracyParameter();
void InitDefaultsArgMaxParameterImpl();
void InitDefaultsArgMaxParameter();
void InitDefaultsConcatParameterImpl();
void InitDefaultsConcatParameter();
void InitDefaultsBatchNormParameterImpl();
void InitDefaultsBatchNormParameter();
void InitDefaultsBiasParameterImpl();
void InitDefaultsBiasParameter();
void InitDefaultsContrastiveLossParameterImpl();
void InitDefaultsContrastiveLossParameter();
void InitDefaultsConvolutionParameterImpl();
void InitDefaultsConvolutionParameter();
void InitDefaultsCropParameterImpl();
void InitDefaultsCropParameter();
void InitDefaultsDataParameterImpl();
void InitDefaultsDataParameter();
void InitDefaultsNonMaximumSuppressionParameterImpl();
void InitDefaultsNonMaximumSuppressionParameter();
void InitDefaultsSaveOutputParameterImpl();
void InitDefaultsSaveOutputParameter();
void InitDefaultsDropoutParameterImpl();
void InitDefaultsDropoutParameter();
void InitDefaultsDummyDataParameterImpl();
void InitDefaultsDummyDataParameter();
void InitDefaultsEltwiseParameterImpl();
void InitDefaultsEltwiseParameter();
void InitDefaultsELUParameterImpl();
void InitDefaultsELUParameter();
void InitDefaultsEmbedParameterImpl();
void InitDefaultsEmbedParameter();
void InitDefaultsExpParameterImpl();
void InitDefaultsExpParameter();
void InitDefaultsFlattenParameterImpl();
void InitDefaultsFlattenParameter();
void InitDefaultsHDF5DataParameterImpl();
void InitDefaultsHDF5DataParameter();
void InitDefaultsHDF5OutputParameterImpl();
void InitDefaultsHDF5OutputParameter();
void InitDefaultsHingeLossParameterImpl();
void InitDefaultsHingeLossParameter();
void InitDefaultsImageDataParameterImpl();
void InitDefaultsImageDataParameter();
void InitDefaultsInfogainLossParameterImpl();
void InitDefaultsInfogainLossParameter();
void InitDefaultsInnerProductParameterImpl();
void InitDefaultsInnerProductParameter();
void InitDefaultsInputParameterImpl();
void InitDefaultsInputParameter();
void InitDefaultsLogParameterImpl();
void InitDefaultsLogParameter();
void InitDefaultsLRNParameterImpl();
void InitDefaultsLRNParameter();
void InitDefaultsMemoryDataParameterImpl();
void InitDefaultsMemoryDataParameter();
void InitDefaultsMVNParameterImpl();
void InitDefaultsMVNParameter();
void InitDefaultsParameterParameterImpl();
void InitDefaultsParameterParameter();
void InitDefaultsPoolingParameterImpl();
void InitDefaultsPoolingParameter();
void InitDefaultsPowerParameterImpl();
void InitDefaultsPowerParameter();
void InitDefaultsPythonParameterImpl();
void InitDefaultsPythonParameter();
void InitDefaultsRecurrentParameterImpl();
void InitDefaultsRecurrentParameter();
void InitDefaultsReductionParameterImpl();
void InitDefaultsReductionParameter();
void InitDefaultsReLUParameterImpl();
void InitDefaultsReLUParameter();
void InitDefaultsReshapeParameterImpl();
void InitDefaultsReshapeParameter();
void InitDefaultsScaleParameterImpl();
void InitDefaultsScaleParameter();
void InitDefaultsSigmoidParameterImpl();
void InitDefaultsSigmoidParameter();
void InitDefaultsSliceParameterImpl();
void InitDefaultsSliceParameter();
void InitDefaultsSoftmaxParameterImpl();
void InitDefaultsSoftmaxParameter();
void InitDefaultsTanHParameterImpl();
void InitDefaultsTanHParameter();
void InitDefaultsTileParameterImpl();
void InitDefaultsTileParameter();
void InitDefaultsThresholdParameterImpl();
void InitDefaultsThresholdParameter();
void InitDefaultsWindowDataParameterImpl();
void InitDefaultsWindowDataParameter();
void InitDefaultsSPPParameterImpl();
void InitDefaultsSPPParameter();
void InitDefaultsV1LayerParameterImpl();
void InitDefaultsV1LayerParameter();
void InitDefaultsV0LayerParameterImpl();
void InitDefaultsV0LayerParameter();
void InitDefaultsPReLUParameterImpl();
void InitDefaultsPReLUParameter();
void InitDefaultsNormalizedBBoxImpl();
void InitDefaultsNormalizedBBox();
void InitDefaultsROIPoolingParameterImpl();
void InitDefaultsROIPoolingParameter();
void InitDefaultsProposalParameterImpl();
void InitDefaultsProposalParameter();
void InitDefaultsPSROIPoolingParameterImpl();
void InitDefaultsPSROIPoolingParameter();
inline void InitDefaults() {
InitDefaultsBlobShape();
InitDefaultsBlobProto();
InitDefaultsBlobProtoVector();
InitDefaultsPermuteParameter();
InitDefaultsNormalizeBBoxParameter();
InitDefaultsPriorBoxParameter();
InitDefaultsDetectionOutputParameter();
InitDefaultsDatum();
InitDefaultsFillerParameter();
InitDefaultsNetParameter();
InitDefaultsSolverParameter();
InitDefaultsSolverState();
InitDefaultsNetState();
InitDefaultsNetStateRule();
InitDefaultsParamSpec();
InitDefaultsLayerParameter();
InitDefaultsTransformationParameter();
InitDefaultsLossParameter();
InitDefaultsAccuracyParameter();
InitDefaultsArgMaxParameter();
InitDefaultsConcatParameter();
InitDefaultsBatchNormParameter();
InitDefaultsBiasParameter();
InitDefaultsContrastiveLossParameter();
InitDefaultsConvolutionParameter();
InitDefaultsCropParameter();
InitDefaultsDataParameter();
InitDefaultsNonMaximumSuppressionParameter();
InitDefaultsSaveOutputParameter();
InitDefaultsDropoutParameter();
InitDefaultsDummyDataParameter();
InitDefaultsEltwiseParameter();
InitDefaultsELUParameter();
InitDefaultsEmbedParameter();
InitDefaultsExpParameter();
InitDefaultsFlattenParameter();
InitDefaultsHDF5DataParameter();
InitDefaultsHDF5OutputParameter();
InitDefaultsHingeLossParameter();
InitDefaultsImageDataParameter();
InitDefaultsInfogainLossParameter();
InitDefaultsInnerProductParameter();
InitDefaultsInputParameter();
InitDefaultsLogParameter();
InitDefaultsLRNParameter();
InitDefaultsMemoryDataParameter();
InitDefaultsMVNParameter();
InitDefaultsParameterParameter();
InitDefaultsPoolingParameter();
InitDefaultsPowerParameter();
InitDefaultsPythonParameter();
InitDefaultsRecurrentParameter();
InitDefaultsReductionParameter();
InitDefaultsReLUParameter();
InitDefaultsReshapeParameter();
InitDefaultsScaleParameter();
InitDefaultsSigmoidParameter();
InitDefaultsSliceParameter();
InitDefaultsSoftmaxParameter();
InitDefaultsTanHParameter();
InitDefaultsTileParameter();
InitDefaultsThresholdParameter();
InitDefaultsWindowDataParameter();
InitDefaultsSPPParameter();
InitDefaultsV1LayerParameter();
InitDefaultsV0LayerParameter();
InitDefaultsPReLUParameter();
InitDefaultsNormalizedBBox();
InitDefaultsROIPoolingParameter();
InitDefaultsProposalParameter();
InitDefaultsPSROIPoolingParameter();
}
} // namespace protobuf_opencv_2dcaffe_2eproto
namespace opencv_caffe {
class AccuracyParameter;
class AccuracyParameterDefaultTypeInternal;
extern AccuracyParameterDefaultTypeInternal _AccuracyParameter_default_instance_;
class ArgMaxParameter;
class ArgMaxParameterDefaultTypeInternal;
extern ArgMaxParameterDefaultTypeInternal _ArgMaxParameter_default_instance_;
class BatchNormParameter;
class BatchNormParameterDefaultTypeInternal;
extern BatchNormParameterDefaultTypeInternal _BatchNormParameter_default_instance_;
class BiasParameter;
class BiasParameterDefaultTypeInternal;
extern BiasParameterDefaultTypeInternal _BiasParameter_default_instance_;
class BlobProto;
class BlobProtoDefaultTypeInternal;
extern BlobProtoDefaultTypeInternal _BlobProto_default_instance_;
class BlobProtoVector;
class BlobProtoVectorDefaultTypeInternal;
extern BlobProtoVectorDefaultTypeInternal _BlobProtoVector_default_instance_;
class BlobShape;
class BlobShapeDefaultTypeInternal;
extern BlobShapeDefaultTypeInternal _BlobShape_default_instance_;
class ConcatParameter;
class ConcatParameterDefaultTypeInternal;
extern ConcatParameterDefaultTypeInternal _ConcatParameter_default_instance_;
class ContrastiveLossParameter;
class ContrastiveLossParameterDefaultTypeInternal;
extern ContrastiveLossParameterDefaultTypeInternal _ContrastiveLossParameter_default_instance_;
class ConvolutionParameter;
class ConvolutionParameterDefaultTypeInternal;
extern ConvolutionParameterDefaultTypeInternal _ConvolutionParameter_default_instance_;
class CropParameter;
class CropParameterDefaultTypeInternal;
extern CropParameterDefaultTypeInternal _CropParameter_default_instance_;
class DataParameter;
class DataParameterDefaultTypeInternal;
extern DataParameterDefaultTypeInternal _DataParameter_default_instance_;
class Datum;
class DatumDefaultTypeInternal;
extern DatumDefaultTypeInternal _Datum_default_instance_;
class DetectionOutputParameter;
class DetectionOutputParameterDefaultTypeInternal;
extern DetectionOutputParameterDefaultTypeInternal _DetectionOutputParameter_default_instance_;
class DropoutParameter;
class DropoutParameterDefaultTypeInternal;
extern DropoutParameterDefaultTypeInternal _DropoutParameter_default_instance_;
class DummyDataParameter;
class DummyDataParameterDefaultTypeInternal;
extern DummyDataParameterDefaultTypeInternal _DummyDataParameter_default_instance_;
class ELUParameter;
class ELUParameterDefaultTypeInternal;
extern ELUParameterDefaultTypeInternal _ELUParameter_default_instance_;
class EltwiseParameter;
class EltwiseParameterDefaultTypeInternal;
extern EltwiseParameterDefaultTypeInternal _EltwiseParameter_default_instance_;
class EmbedParameter;
class EmbedParameterDefaultTypeInternal;
extern EmbedParameterDefaultTypeInternal _EmbedParameter_default_instance_;
class ExpParameter;
class ExpParameterDefaultTypeInternal;
extern ExpParameterDefaultTypeInternal _ExpParameter_default_instance_;
class FillerParameter;
class FillerParameterDefaultTypeInternal;
extern FillerParameterDefaultTypeInternal _FillerParameter_default_instance_;
class FlattenParameter;
class FlattenParameterDefaultTypeInternal;
extern FlattenParameterDefaultTypeInternal _FlattenParameter_default_instance_;
class HDF5DataParameter;
class HDF5DataParameterDefaultTypeInternal;
extern HDF5DataParameterDefaultTypeInternal _HDF5DataParameter_default_instance_;
class HDF5OutputParameter;
class HDF5OutputParameterDefaultTypeInternal;
extern HDF5OutputParameterDefaultTypeInternal _HDF5OutputParameter_default_instance_;
class HingeLossParameter;
class HingeLossParameterDefaultTypeInternal;
extern HingeLossParameterDefaultTypeInternal _HingeLossParameter_default_instance_;
class ImageDataParameter;
class ImageDataParameterDefaultTypeInternal;
extern ImageDataParameterDefaultTypeInternal _ImageDataParameter_default_instance_;
class InfogainLossParameter;
class InfogainLossParameterDefaultTypeInternal;
extern InfogainLossParameterDefaultTypeInternal _InfogainLossParameter_default_instance_;
class InnerProductParameter;
class InnerProductParameterDefaultTypeInternal;
extern InnerProductParameterDefaultTypeInternal _InnerProductParameter_default_instance_;
class InputParameter;
class InputParameterDefaultTypeInternal;
extern InputParameterDefaultTypeInternal _InputParameter_default_instance_;
class LRNParameter;
class LRNParameterDefaultTypeInternal;
extern LRNParameterDefaultTypeInternal _LRNParameter_default_instance_;
class LayerParameter;
class LayerParameterDefaultTypeInternal;
extern LayerParameterDefaultTypeInternal _LayerParameter_default_instance_;
class LogParameter;
class LogParameterDefaultTypeInternal;
extern LogParameterDefaultTypeInternal _LogParameter_default_instance_;
class LossParameter;
class LossParameterDefaultTypeInternal;
extern LossParameterDefaultTypeInternal _LossParameter_default_instance_;
class MVNParameter;
class MVNParameterDefaultTypeInternal;
extern MVNParameterDefaultTypeInternal _MVNParameter_default_instance_;
class MemoryDataParameter;
class MemoryDataParameterDefaultTypeInternal;
extern MemoryDataParameterDefaultTypeInternal _MemoryDataParameter_default_instance_;
class NetParameter;
class NetParameterDefaultTypeInternal;
extern NetParameterDefaultTypeInternal _NetParameter_default_instance_;
class NetState;
class NetStateDefaultTypeInternal;
extern NetStateDefaultTypeInternal _NetState_default_instance_;
class NetStateRule;
class NetStateRuleDefaultTypeInternal;
extern NetStateRuleDefaultTypeInternal _NetStateRule_default_instance_;
class NonMaximumSuppressionParameter;
class NonMaximumSuppressionParameterDefaultTypeInternal;
extern NonMaximumSuppressionParameterDefaultTypeInternal _NonMaximumSuppressionParameter_default_instance_;
class NormalizeBBoxParameter;
class NormalizeBBoxParameterDefaultTypeInternal;
extern NormalizeBBoxParameterDefaultTypeInternal _NormalizeBBoxParameter_default_instance_;
class NormalizedBBox;
class NormalizedBBoxDefaultTypeInternal;
extern NormalizedBBoxDefaultTypeInternal _NormalizedBBox_default_instance_;
class PReLUParameter;
class PReLUParameterDefaultTypeInternal;
extern PReLUParameterDefaultTypeInternal _PReLUParameter_default_instance_;
class PSROIPoolingParameter;
class PSROIPoolingParameterDefaultTypeInternal;
extern PSROIPoolingParameterDefaultTypeInternal _PSROIPoolingParameter_default_instance_;
class ParamSpec;
class ParamSpecDefaultTypeInternal;
extern ParamSpecDefaultTypeInternal _ParamSpec_default_instance_;
class ParameterParameter;
class ParameterParameterDefaultTypeInternal;
extern ParameterParameterDefaultTypeInternal _ParameterParameter_default_instance_;
class PermuteParameter;
class PermuteParameterDefaultTypeInternal;
extern PermuteParameterDefaultTypeInternal _PermuteParameter_default_instance_;
class PoolingParameter;
class PoolingParameterDefaultTypeInternal;
extern PoolingParameterDefaultTypeInternal _PoolingParameter_default_instance_;
class PowerParameter;
class PowerParameterDefaultTypeInternal;
extern PowerParameterDefaultTypeInternal _PowerParameter_default_instance_;
class PriorBoxParameter;
class PriorBoxParameterDefaultTypeInternal;
extern PriorBoxParameterDefaultTypeInternal _PriorBoxParameter_default_instance_;
class ProposalParameter;
class ProposalParameterDefaultTypeInternal;
extern ProposalParameterDefaultTypeInternal _ProposalParameter_default_instance_;
class PythonParameter;
class PythonParameterDefaultTypeInternal;
extern PythonParameterDefaultTypeInternal _PythonParameter_default_instance_;
class ROIPoolingParameter;
class ROIPoolingParameterDefaultTypeInternal;
extern ROIPoolingParameterDefaultTypeInternal _ROIPoolingParameter_default_instance_;
class ReLUParameter;
class ReLUParameterDefaultTypeInternal;
extern ReLUParameterDefaultTypeInternal _ReLUParameter_default_instance_;
class RecurrentParameter;
class RecurrentParameterDefaultTypeInternal;
extern RecurrentParameterDefaultTypeInternal _RecurrentParameter_default_instance_;
class ReductionParameter;
class ReductionParameterDefaultTypeInternal;
extern ReductionParameterDefaultTypeInternal _ReductionParameter_default_instance_;
class ReshapeParameter;
class ReshapeParameterDefaultTypeInternal;
extern ReshapeParameterDefaultTypeInternal _ReshapeParameter_default_instance_;
class SPPParameter;
class SPPParameterDefaultTypeInternal;
extern SPPParameterDefaultTypeInternal _SPPParameter_default_instance_;
class SaveOutputParameter;
class SaveOutputParameterDefaultTypeInternal;
extern SaveOutputParameterDefaultTypeInternal _SaveOutputParameter_default_instance_;
class ScaleParameter;
class ScaleParameterDefaultTypeInternal;
extern ScaleParameterDefaultTypeInternal _ScaleParameter_default_instance_;
class SigmoidParameter;
class SigmoidParameterDefaultTypeInternal;
extern SigmoidParameterDefaultTypeInternal _SigmoidParameter_default_instance_;
class SliceParameter;
class SliceParameterDefaultTypeInternal;
extern SliceParameterDefaultTypeInternal _SliceParameter_default_instance_;
class SoftmaxParameter;
class SoftmaxParameterDefaultTypeInternal;
extern SoftmaxParameterDefaultTypeInternal _SoftmaxParameter_default_instance_;
class SolverParameter;
class SolverParameterDefaultTypeInternal;
extern SolverParameterDefaultTypeInternal _SolverParameter_default_instance_;
class SolverState;
class SolverStateDefaultTypeInternal;
extern SolverStateDefaultTypeInternal _SolverState_default_instance_;
class TanHParameter;
class TanHParameterDefaultTypeInternal;
extern TanHParameterDefaultTypeInternal _TanHParameter_default_instance_;
class ThresholdParameter;
class ThresholdParameterDefaultTypeInternal;
extern ThresholdParameterDefaultTypeInternal _ThresholdParameter_default_instance_;
class TileParameter;
class TileParameterDefaultTypeInternal;
extern TileParameterDefaultTypeInternal _TileParameter_default_instance_;
class TransformationParameter;
class TransformationParameterDefaultTypeInternal;
extern TransformationParameterDefaultTypeInternal _TransformationParameter_default_instance_;
class V0LayerParameter;
class V0LayerParameterDefaultTypeInternal;
extern V0LayerParameterDefaultTypeInternal _V0LayerParameter_default_instance_;
class V1LayerParameter;
class V1LayerParameterDefaultTypeInternal;
extern V1LayerParameterDefaultTypeInternal _V1LayerParameter_default_instance_;
class WindowDataParameter;
class WindowDataParameterDefaultTypeInternal;
extern WindowDataParameterDefaultTypeInternal _WindowDataParameter_default_instance_;
} // namespace opencv_caffe
namespace opencv_caffe {
enum PriorBoxParameter_CodeType {
PriorBoxParameter_CodeType_CORNER = 1,
PriorBoxParameter_CodeType_CENTER_SIZE = 2
};
bool PriorBoxParameter_CodeType_IsValid(int value);
const PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MIN = PriorBoxParameter_CodeType_CORNER;
const PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MAX = PriorBoxParameter_CodeType_CENTER_SIZE;
const int PriorBoxParameter_CodeType_CodeType_ARRAYSIZE = PriorBoxParameter_CodeType_CodeType_MAX + 1;
const ::google::protobuf::EnumDescriptor* PriorBoxParameter_CodeType_descriptor();
inline const ::std::string& PriorBoxParameter_CodeType_Name(PriorBoxParameter_CodeType value) {
return ::google::protobuf::internal::NameOfEnum(
PriorBoxParameter_CodeType_descriptor(), value);
}
inline bool PriorBoxParameter_CodeType_Parse(
const ::std::string& name, PriorBoxParameter_CodeType* value) {
return ::google::protobuf::internal::ParseNamedEnum<PriorBoxParameter_CodeType>(
PriorBoxParameter_CodeType_descriptor(), name, value);
}
enum FillerParameter_VarianceNorm {
FillerParameter_VarianceNorm_FAN_IN = 0,
FillerParameter_VarianceNorm_FAN_OUT = 1,
FillerParameter_VarianceNorm_AVERAGE = 2
};
bool FillerParameter_VarianceNorm_IsValid(int value);
const FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MIN = FillerParameter_VarianceNorm_FAN_IN;
const FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MAX = FillerParameter_VarianceNorm_AVERAGE;
const int FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE = FillerParameter_VarianceNorm_VarianceNorm_MAX + 1;
const ::google::protobuf::EnumDescriptor* FillerParameter_VarianceNorm_descriptor();
inline const ::std::string& FillerParameter_VarianceNorm_Name(FillerParameter_VarianceNorm value) {
return ::google::protobuf::internal::NameOfEnum(
FillerParameter_VarianceNorm_descriptor(), value);
}
inline bool FillerParameter_VarianceNorm_Parse(
const ::std::string& name, FillerParameter_VarianceNorm* value) {
return ::google::protobuf::internal::ParseNamedEnum<FillerParameter_VarianceNorm>(
FillerParameter_VarianceNorm_descriptor(), name, value);
}
enum SolverParameter_SnapshotFormat {
SolverParameter_SnapshotFormat_HDF5 = 0,
SolverParameter_SnapshotFormat_BINARYPROTO = 1
};
bool SolverParameter_SnapshotFormat_IsValid(int value);
const SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MIN = SolverParameter_SnapshotFormat_HDF5;
const SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MAX = SolverParameter_SnapshotFormat_BINARYPROTO;
const int SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE = SolverParameter_SnapshotFormat_SnapshotFormat_MAX + 1;
const ::google::protobuf::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor();
inline const ::std::string& SolverParameter_SnapshotFormat_Name(SolverParameter_SnapshotFormat value) {
return ::google::protobuf::internal::NameOfEnum(
SolverParameter_SnapshotFormat_descriptor(), value);
}
inline bool SolverParameter_SnapshotFormat_Parse(
const ::std::string& name, SolverParameter_SnapshotFormat* value) {
return ::google::protobuf::internal::ParseNamedEnum<SolverParameter_SnapshotFormat>(
SolverParameter_SnapshotFormat_descriptor(), name, value);
}
enum SolverParameter_SolverMode {
SolverParameter_SolverMode_CPU = 0,
SolverParameter_SolverMode_GPU = 1
};
bool SolverParameter_SolverMode_IsValid(int value);
const SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MIN = SolverParameter_SolverMode_CPU;
const SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MAX = SolverParameter_SolverMode_GPU;
const int SolverParameter_SolverMode_SolverMode_ARRAYSIZE = SolverParameter_SolverMode_SolverMode_MAX + 1;
const ::google::protobuf::EnumDescriptor* SolverParameter_SolverMode_descriptor();
inline const ::std::string& SolverParameter_SolverMode_Name(SolverParameter_SolverMode value) {
return ::google::protobuf::internal::NameOfEnum(
SolverParameter_SolverMode_descriptor(), value);
}
inline bool SolverParameter_SolverMode_Parse(
const ::std::string& name, SolverParameter_SolverMode* value) {
return ::google::protobuf::internal::ParseNamedEnum<SolverParameter_SolverMode>(
SolverParameter_SolverMode_descriptor(), name, value);
}
enum SolverParameter_SolverType {
SolverParameter_SolverType_SGD = 0,
SolverParameter_SolverType_NESTEROV = 1,
SolverParameter_SolverType_ADAGRAD = 2,
SolverParameter_SolverType_RMSPROP = 3,
SolverParameter_SolverType_ADADELTA = 4,
SolverParameter_SolverType_ADAM = 5
};
bool SolverParameter_SolverType_IsValid(int value);
const SolverParameter_SolverType SolverParameter_SolverType_SolverType_MIN = SolverParameter_SolverType_SGD;
const SolverParameter_SolverType SolverParameter_SolverType_SolverType_MAX = SolverParameter_SolverType_ADAM;
const int SolverParameter_SolverType_SolverType_ARRAYSIZE = SolverParameter_SolverType_SolverType_MAX + 1;
const ::google::protobuf::EnumDescriptor* SolverParameter_SolverType_descriptor();
inline const ::std::string& SolverParameter_SolverType_Name(SolverParameter_SolverType value) {
return ::google::protobuf::internal::NameOfEnum(
SolverParameter_SolverType_descriptor(), value);
}
inline bool SolverParameter_SolverType_Parse(
const ::std::string& name, SolverParameter_SolverType* value) {
return ::google::protobuf::internal::ParseNamedEnum<SolverParameter_SolverType>(
SolverParameter_SolverType_descriptor(), name, value);
}
enum ParamSpec_DimCheckMode {
ParamSpec_DimCheckMode_STRICT = 0,
ParamSpec_DimCheckMode_PERMISSIVE = 1
};
bool ParamSpec_DimCheckMode_IsValid(int value);
const ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MIN = ParamSpec_DimCheckMode_STRICT;
const ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MAX = ParamSpec_DimCheckMode_PERMISSIVE;
const int ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE = ParamSpec_DimCheckMode_DimCheckMode_MAX + 1;
const ::google::protobuf::EnumDescriptor* ParamSpec_DimCheckMode_descriptor();
inline const ::std::string& ParamSpec_DimCheckMode_Name(ParamSpec_DimCheckMode value) {
return ::google::protobuf::internal::NameOfEnum(
ParamSpec_DimCheckMode_descriptor(), value);
}
inline bool ParamSpec_DimCheckMode_Parse(
const ::std::string& name, ParamSpec_DimCheckMode* value) {
return ::google::protobuf::internal::ParseNamedEnum<ParamSpec_DimCheckMode>(
ParamSpec_DimCheckMode_descriptor(), name, value);
}
enum LossParameter_NormalizationMode {
LossParameter_NormalizationMode_FULL = 0,
LossParameter_NormalizationMode_VALID = 1,
LossParameter_NormalizationMode_BATCH_SIZE = 2,
LossParameter_NormalizationMode_NONE = 3
};
bool LossParameter_NormalizationMode_IsValid(int value);
const LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MIN = LossParameter_NormalizationMode_FULL;
const LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MAX = LossParameter_NormalizationMode_NONE;
const int LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE = LossParameter_NormalizationMode_NormalizationMode_MAX + 1;
const ::google::protobuf::EnumDescriptor* LossParameter_NormalizationMode_descriptor();
inline const ::std::string& LossParameter_NormalizationMode_Name(LossParameter_NormalizationMode value) {
return ::google::protobuf::internal::NameOfEnum(
LossParameter_NormalizationMode_descriptor(), value);
}
inline bool LossParameter_NormalizationMode_Parse(
const ::std::string& name, LossParameter_NormalizationMode* value) {
return ::google::protobuf::internal::ParseNamedEnum<LossParameter_NormalizationMode>(
LossParameter_NormalizationMode_descriptor(), name, value);
}
enum ConvolutionParameter_Engine {
ConvolutionParameter_Engine_DEFAULT = 0,
ConvolutionParameter_Engine_CAFFE = 1,
ConvolutionParameter_Engine_CUDNN = 2
};
bool ConvolutionParameter_Engine_IsValid(int value);
const ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MIN = ConvolutionParameter_Engine_DEFAULT;
const ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MAX = ConvolutionParameter_Engine_CUDNN;
const int ConvolutionParameter_Engine_Engine_ARRAYSIZE = ConvolutionParameter_Engine_Engine_MAX + 1;
const ::google::protobuf::EnumDescriptor* ConvolutionParameter_Engine_descriptor();
inline const ::std::string& ConvolutionParameter_Engine_Name(ConvolutionParameter_Engine value) {
return ::google::protobuf::internal::NameOfEnum(
ConvolutionParameter_Engine_descriptor(), value);
}
inline bool ConvolutionParameter_Engine_Parse(
const ::std::string& name, ConvolutionParameter_Engine* value) {
return ::google::protobuf::internal::ParseNamedEnum<ConvolutionParameter_Engine>(
ConvolutionParameter_Engine_descriptor(), name, value);
}
enum DataParameter_DB {
DataParameter_DB_LEVELDB = 0,
DataParameter_DB_LMDB = 1
};
bool DataParameter_DB_IsValid(int value);
const DataParameter_DB DataParameter_DB_DB_MIN = DataParameter_DB_LEVELDB;
const DataParameter_DB DataParameter_DB_DB_MAX = DataParameter_DB_LMDB;
const int DataParameter_DB_DB_ARRAYSIZE = DataParameter_DB_DB_MAX + 1;
const ::google::protobuf::EnumDescriptor* DataParameter_DB_descriptor();
inline const ::std::string& DataParameter_DB_Name(DataParameter_DB value) {
return ::google::protobuf::internal::NameOfEnum(
DataParameter_DB_descriptor(), value);
}
inline bool DataParameter_DB_Parse(
const ::std::string& name, DataParameter_DB* value) {
return ::google::protobuf::internal::ParseNamedEnum<DataParameter_DB>(
DataParameter_DB_descriptor(), name, value);
}
enum EltwiseParameter_EltwiseOp {
EltwiseParameter_EltwiseOp_PROD = 0,
EltwiseParameter_EltwiseOp_SUM = 1,
EltwiseParameter_EltwiseOp_MAX = 2
};
bool EltwiseParameter_EltwiseOp_IsValid(int value);
const EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MIN = EltwiseParameter_EltwiseOp_PROD;
const EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MAX = EltwiseParameter_EltwiseOp_MAX;
const int EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE = EltwiseParameter_EltwiseOp_EltwiseOp_MAX + 1;
const ::google::protobuf::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor();
inline const ::std::string& EltwiseParameter_EltwiseOp_Name(EltwiseParameter_EltwiseOp value) {
return ::google::protobuf::internal::NameOfEnum(
EltwiseParameter_EltwiseOp_descriptor(), value);
}
inline bool EltwiseParameter_EltwiseOp_Parse(
const ::std::string& name, EltwiseParameter_EltwiseOp* value) {
return ::google::protobuf::internal::ParseNamedEnum<EltwiseParameter_EltwiseOp>(
EltwiseParameter_EltwiseOp_descriptor(), name, value);
}
enum HingeLossParameter_Norm {
HingeLossParameter_Norm_L1 = 1,
HingeLossParameter_Norm_L2 = 2
};
bool HingeLossParameter_Norm_IsValid(int value);
const HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MIN = HingeLossParameter_Norm_L1;
const HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MAX = HingeLossParameter_Norm_L2;
const int HingeLossParameter_Norm_Norm_ARRAYSIZE = HingeLossParameter_Norm_Norm_MAX + 1;
const ::google::protobuf::EnumDescriptor* HingeLossParameter_Norm_descriptor();
inline const ::std::string& HingeLossParameter_Norm_Name(HingeLossParameter_Norm value) {
return ::google::protobuf::internal::NameOfEnum(
HingeLossParameter_Norm_descriptor(), value);
}
inline bool HingeLossParameter_Norm_Parse(
const ::std::string& name, HingeLossParameter_Norm* value) {
return ::google::protobuf::internal::ParseNamedEnum<HingeLossParameter_Norm>(
HingeLossParameter_Norm_descriptor(), name, value);
}
enum LRNParameter_NormRegion {
LRNParameter_NormRegion_ACROSS_CHANNELS = 0,
LRNParameter_NormRegion_WITHIN_CHANNEL = 1
};
bool LRNParameter_NormRegion_IsValid(int value);
const LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MIN = LRNParameter_NormRegion_ACROSS_CHANNELS;
const LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MAX = LRNParameter_NormRegion_WITHIN_CHANNEL;
const int LRNParameter_NormRegion_NormRegion_ARRAYSIZE = LRNParameter_NormRegion_NormRegion_MAX + 1;
const ::google::protobuf::EnumDescriptor* LRNParameter_NormRegion_descriptor();
inline const ::std::string& LRNParameter_NormRegion_Name(LRNParameter_NormRegion value) {
return ::google::protobuf::internal::NameOfEnum(
LRNParameter_NormRegion_descriptor(), value);
}
inline bool LRNParameter_NormRegion_Parse(
const ::std::string& name, LRNParameter_NormRegion* value) {
return ::google::protobuf::internal::ParseNamedEnum<LRNParameter_NormRegion>(
LRNParameter_NormRegion_descriptor(), name, value);
}
enum LRNParameter_Engine {
LRNParameter_Engine_DEFAULT = 0,
LRNParameter_Engine_CAFFE = 1,
LRNParameter_Engine_CUDNN = 2
};
bool LRNParameter_Engine_IsValid(int value);
const LRNParameter_Engine LRNParameter_Engine_Engine_MIN = LRNParameter_Engine_DEFAULT;
const LRNParameter_Engine LRNParameter_Engine_Engine_MAX = LRNParameter_Engine_CUDNN;
const int LRNParameter_Engine_Engine_ARRAYSIZE = LRNParameter_Engine_Engine_MAX + 1;
const ::google::protobuf::EnumDescriptor* LRNParameter_Engine_descriptor();
inline const ::std::string& LRNParameter_Engine_Name(LRNParameter_Engine value) {
return ::google::protobuf::internal::NameOfEnum(
LRNParameter_Engine_descriptor(), value);
}
inline bool LRNParameter_Engine_Parse(
const ::std::string& name, LRNParameter_Engine* value) {
return ::google::protobuf::internal::ParseNamedEnum<LRNParameter_Engine>(
LRNParameter_Engine_descriptor(), name, value);
}
enum PoolingParameter_PoolMethod {
PoolingParameter_PoolMethod_MAX = 0,
PoolingParameter_PoolMethod_AVE = 1,
PoolingParameter_PoolMethod_STOCHASTIC = 2
};
bool PoolingParameter_PoolMethod_IsValid(int value);
const PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MIN = PoolingParameter_PoolMethod_MAX;
const PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MAX = PoolingParameter_PoolMethod_STOCHASTIC;
const int PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE = PoolingParameter_PoolMethod_PoolMethod_MAX + 1;
const ::google::protobuf::EnumDescriptor* PoolingParameter_PoolMethod_descriptor();
inline const ::std::string& PoolingParameter_PoolMethod_Name(PoolingParameter_PoolMethod value) {
return ::google::protobuf::internal::NameOfEnum(
PoolingParameter_PoolMethod_descriptor(), value);
}
inline bool PoolingParameter_PoolMethod_Parse(
const ::std::string& name, PoolingParameter_PoolMethod* value) {
return ::google::protobuf::internal::ParseNamedEnum<PoolingParameter_PoolMethod>(
PoolingParameter_PoolMethod_descriptor(), name, value);
}
enum PoolingParameter_Engine {
PoolingParameter_Engine_DEFAULT = 0,
PoolingParameter_Engine_CAFFE = 1,
PoolingParameter_Engine_CUDNN = 2
};
bool PoolingParameter_Engine_IsValid(int value);
const PoolingParameter_Engine PoolingParameter_Engine_Engine_MIN = PoolingParameter_Engine_DEFAULT;
const PoolingParameter_Engine PoolingParameter_Engine_Engine_MAX = PoolingParameter_Engine_CUDNN;
const int PoolingParameter_Engine_Engine_ARRAYSIZE = PoolingParameter_Engine_Engine_MAX + 1;
const ::google::protobuf::EnumDescriptor* PoolingParameter_Engine_descriptor();
inline const ::std::string& PoolingParameter_Engine_Name(PoolingParameter_Engine value) {
return ::google::protobuf::internal::NameOfEnum(
PoolingParameter_Engine_descriptor(), value);
}
inline bool PoolingParameter_Engine_Parse(
const ::std::string& name, PoolingParameter_Engine* value) {
return ::google::protobuf::internal::ParseNamedEnum<PoolingParameter_Engine>(
PoolingParameter_Engine_descriptor(), name, value);
}
enum ReductionParameter_ReductionOp {
ReductionParameter_ReductionOp_SUM = 1,
ReductionParameter_ReductionOp_ASUM = 2,
ReductionParameter_ReductionOp_SUMSQ = 3,
ReductionParameter_ReductionOp_MEAN = 4
};
bool ReductionParameter_ReductionOp_IsValid(int value);
const ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MIN = ReductionParameter_ReductionOp_SUM;
const ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MAX = ReductionParameter_ReductionOp_MEAN;
const int ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE = ReductionParameter_ReductionOp_ReductionOp_MAX + 1;
const ::google::protobuf::EnumDescriptor* ReductionParameter_ReductionOp_descriptor();
inline const ::std::string& ReductionParameter_ReductionOp_Name(ReductionParameter_ReductionOp value) {
return ::google::protobuf::internal::NameOfEnum(
ReductionParameter_ReductionOp_descriptor(), value);
}
inline bool ReductionParameter_ReductionOp_Parse(
const ::std::string& name, ReductionParameter_ReductionOp* value) {
return ::google::protobuf::internal::ParseNamedEnum<ReductionParameter_ReductionOp>(
ReductionParameter_ReductionOp_descriptor(), name, value);
}
enum ReLUParameter_Engine {
ReLUParameter_Engine_DEFAULT = 0,
ReLUParameter_Engine_CAFFE = 1,
ReLUParameter_Engine_CUDNN = 2
};
bool ReLUParameter_Engine_IsValid(int value);
const ReLUParameter_Engine ReLUParameter_Engine_Engine_MIN = ReLUParameter_Engine_DEFAULT;
const ReLUParameter_Engine ReLUParameter_Engine_Engine_MAX = ReLUParameter_Engine_CUDNN;
const int ReLUParameter_Engine_Engine_ARRAYSIZE = ReLUParameter_Engine_Engine_MAX + 1;
const ::google::protobuf::EnumDescriptor* ReLUParameter_Engine_descriptor();
inline const ::std::string& ReLUParameter_Engine_Name(ReLUParameter_Engine value) {
return ::google::protobuf::internal::NameOfEnum(
ReLUParameter_Engine_descriptor(), value);
}
inline bool ReLUParameter_Engine_Parse(
const ::std::string& name, ReLUParameter_Engine* value) {
return ::google::protobuf::internal::ParseNamedEnum<ReLUParameter_Engine>(
ReLUParameter_Engine_descriptor(), name, value);
}
enum SigmoidParameter_Engine {
SigmoidParameter_Engine_DEFAULT = 0,
SigmoidParameter_Engine_CAFFE = 1,
SigmoidParameter_Engine_CUDNN = 2
};
bool SigmoidParameter_Engine_IsValid(int value);
const SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MIN = SigmoidParameter_Engine_DEFAULT;
const SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MAX = SigmoidParameter_Engine_CUDNN;
const int SigmoidParameter_Engine_Engine_ARRAYSIZE = SigmoidParameter_Engine_Engine_MAX + 1;
const ::google::protobuf::EnumDescriptor* SigmoidParameter_Engine_descriptor();
inline const ::std::string& SigmoidParameter_Engine_Name(SigmoidParameter_Engine value) {
return ::google::protobuf::internal::NameOfEnum(
SigmoidParameter_Engine_descriptor(), value);
}
inline bool SigmoidParameter_Engine_Parse(
const ::std::string& name, SigmoidParameter_Engine* value) {
return ::google::protobuf::internal::ParseNamedEnum<SigmoidParameter_Engine>(
SigmoidParameter_Engine_descriptor(), name, value);
}
enum SoftmaxParameter_Engine {
SoftmaxParameter_Engine_DEFAULT = 0,
SoftmaxParameter_Engine_CAFFE = 1,
SoftmaxParameter_Engine_CUDNN = 2
};
bool SoftmaxParameter_Engine_IsValid(int value);
const SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MIN = SoftmaxParameter_Engine_DEFAULT;
const SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MAX = SoftmaxParameter_Engine_CUDNN;
const int SoftmaxParameter_Engine_Engine_ARRAYSIZE = SoftmaxParameter_Engine_Engine_MAX + 1;
const ::google::protobuf::EnumDescriptor* SoftmaxParameter_Engine_descriptor();
inline const ::std::string& SoftmaxParameter_Engine_Name(SoftmaxParameter_Engine value) {
return ::google::protobuf::internal::NameOfEnum(
SoftmaxParameter_Engine_descriptor(), value);
}
inline bool SoftmaxParameter_Engine_Parse(
const ::std::string& name, SoftmaxParameter_Engine* value) {
return ::google::protobuf::internal::ParseNamedEnum<SoftmaxParameter_Engine>(
SoftmaxParameter_Engine_descriptor(), name, value);
}
enum TanHParameter_Engine {
TanHParameter_Engine_DEFAULT = 0,
TanHParameter_Engine_CAFFE = 1,
TanHParameter_Engine_CUDNN = 2
};
bool TanHParameter_Engine_IsValid(int value);
const TanHParameter_Engine TanHParameter_Engine_Engine_MIN = TanHParameter_Engine_DEFAULT;
const TanHParameter_Engine TanHParameter_Engine_Engine_MAX = TanHParameter_Engine_CUDNN;
const int TanHParameter_Engine_Engine_ARRAYSIZE = TanHParameter_Engine_Engine_MAX + 1;
const ::google::protobuf::EnumDescriptor* TanHParameter_Engine_descriptor();
inline const ::std::string& TanHParameter_Engine_Name(TanHParameter_Engine value) {
return ::google::protobuf::internal::NameOfEnum(
TanHParameter_Engine_descriptor(), value);
}
inline bool TanHParameter_Engine_Parse(
const ::std::string& name, TanHParameter_Engine* value) {
return ::google::protobuf::internal::ParseNamedEnum<TanHParameter_Engine>(
TanHParameter_Engine_descriptor(), name, value);
}
enum SPPParameter_PoolMethod {
SPPParameter_PoolMethod_MAX = 0,
SPPParameter_PoolMethod_AVE = 1,
SPPParameter_PoolMethod_STOCHASTIC = 2
};
bool SPPParameter_PoolMethod_IsValid(int value);
const SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MIN = SPPParameter_PoolMethod_MAX;
const SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MAX = SPPParameter_PoolMethod_STOCHASTIC;
const int SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE = SPPParameter_PoolMethod_PoolMethod_MAX + 1;
const ::google::protobuf::EnumDescriptor* SPPParameter_PoolMethod_descriptor();
inline const ::std::string& SPPParameter_PoolMethod_Name(SPPParameter_PoolMethod value) {
return ::google::protobuf::internal::NameOfEnum(
SPPParameter_PoolMethod_descriptor(), value);
}
inline bool SPPParameter_PoolMethod_Parse(
const ::std::string& name, SPPParameter_PoolMethod* value) {
return ::google::protobuf::internal::ParseNamedEnum<SPPParameter_PoolMethod>(
SPPParameter_PoolMethod_descriptor(), name, value);
}
enum SPPParameter_Engine {
SPPParameter_Engine_DEFAULT = 0,
SPPParameter_Engine_CAFFE = 1,
SPPParameter_Engine_CUDNN = 2
};
bool SPPParameter_Engine_IsValid(int value);
const SPPParameter_Engine SPPParameter_Engine_Engine_MIN = SPPParameter_Engine_DEFAULT;
const SPPParameter_Engine SPPParameter_Engine_Engine_MAX = SPPParameter_Engine_CUDNN;
const int SPPParameter_Engine_Engine_ARRAYSIZE = SPPParameter_Engine_Engine_MAX + 1;
const ::google::protobuf::EnumDescriptor* SPPParameter_Engine_descriptor();
inline const ::std::string& SPPParameter_Engine_Name(SPPParameter_Engine value) {
return ::google::protobuf::internal::NameOfEnum(
SPPParameter_Engine_descriptor(), value);
}
inline bool SPPParameter_Engine_Parse(
const ::std::string& name, SPPParameter_Engine* value) {
return ::google::protobuf::internal::ParseNamedEnum<SPPParameter_Engine>(
SPPParameter_Engine_descriptor(), name, value);
}
enum V1LayerParameter_LayerType {
V1LayerParameter_LayerType_NONE = 0,
V1LayerParameter_LayerType_ABSVAL = 35,
V1LayerParameter_LayerType_ACCURACY = 1,
V1LayerParameter_LayerType_ARGMAX = 30,
V1LayerParameter_LayerType_BNLL = 2,
V1LayerParameter_LayerType_CONCAT = 3,
V1LayerParameter_LayerType_CONTRASTIVE_LOSS = 37,
V1LayerParameter_LayerType_CONVOLUTION = 4,
V1LayerParameter_LayerType_DATA = 5,
V1LayerParameter_LayerType_DECONVOLUTION = 39,
V1LayerParameter_LayerType_DROPOUT = 6,
V1LayerParameter_LayerType_DUMMY_DATA = 32,
V1LayerParameter_LayerType_EUCLIDEAN_LOSS = 7,
V1LayerParameter_LayerType_ELTWISE = 25,
V1LayerParameter_LayerType_EXP = 38,
V1LayerParameter_LayerType_FLATTEN = 8,
V1LayerParameter_LayerType_HDF5_DATA = 9,
V1LayerParameter_LayerType_HDF5_OUTPUT = 10,
V1LayerParameter_LayerType_HINGE_LOSS = 28,
V1LayerParameter_LayerType_IM2COL = 11,
V1LayerParameter_LayerType_IMAGE_DATA = 12,
V1LayerParameter_LayerType_INFOGAIN_LOSS = 13,
V1LayerParameter_LayerType_INNER_PRODUCT = 14,
V1LayerParameter_LayerType_LRN = 15,
V1LayerParameter_LayerType_MEMORY_DATA = 29,
V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS = 16,
V1LayerParameter_LayerType_MVN = 34,
V1LayerParameter_LayerType_POOLING = 17,
V1LayerParameter_LayerType_POWER = 26,
V1LayerParameter_LayerType_RELU = 18,
V1LayerParameter_LayerType_SIGMOID = 19,
V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS = 27,
V1LayerParameter_LayerType_SILENCE = 36,
V1LayerParameter_LayerType_SOFTMAX = 20,
V1LayerParameter_LayerType_SOFTMAX_LOSS = 21,
V1LayerParameter_LayerType_SPLIT = 22,
V1LayerParameter_LayerType_SLICE = 33,
V1LayerParameter_LayerType_TANH = 23,
V1LayerParameter_LayerType_WINDOW_DATA = 24,
V1LayerParameter_LayerType_THRESHOLD = 31
};
bool V1LayerParameter_LayerType_IsValid(int value);
const V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MIN = V1LayerParameter_LayerType_NONE;
const V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MAX = V1LayerParameter_LayerType_DECONVOLUTION;
const int V1LayerParameter_LayerType_LayerType_ARRAYSIZE = V1LayerParameter_LayerType_LayerType_MAX + 1;
const ::google::protobuf::EnumDescriptor* V1LayerParameter_LayerType_descriptor();
inline const ::std::string& V1LayerParameter_LayerType_Name(V1LayerParameter_LayerType value) {
return ::google::protobuf::internal::NameOfEnum(
V1LayerParameter_LayerType_descriptor(), value);
}
inline bool V1LayerParameter_LayerType_Parse(
const ::std::string& name, V1LayerParameter_LayerType* value) {
return ::google::protobuf::internal::ParseNamedEnum<V1LayerParameter_LayerType>(
V1LayerParameter_LayerType_descriptor(), name, value);
}
enum V1LayerParameter_DimCheckMode {
V1LayerParameter_DimCheckMode_STRICT = 0,
V1LayerParameter_DimCheckMode_PERMISSIVE = 1
};
bool V1LayerParameter_DimCheckMode_IsValid(int value);
const V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MIN = V1LayerParameter_DimCheckMode_STRICT;
const V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MAX = V1LayerParameter_DimCheckMode_PERMISSIVE;
const int V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE = V1LayerParameter_DimCheckMode_DimCheckMode_MAX + 1;
const ::google::protobuf::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor();
inline const ::std::string& V1LayerParameter_DimCheckMode_Name(V1LayerParameter_DimCheckMode value) {
return ::google::protobuf::internal::NameOfEnum(
V1LayerParameter_DimCheckMode_descriptor(), value);
}
inline bool V1LayerParameter_DimCheckMode_Parse(
const ::std::string& name, V1LayerParameter_DimCheckMode* value) {
return ::google::protobuf::internal::ParseNamedEnum<V1LayerParameter_DimCheckMode>(
V1LayerParameter_DimCheckMode_descriptor(), name, value);
}
enum V0LayerParameter_PoolMethod {
V0LayerParameter_PoolMethod_MAX = 0,
V0LayerParameter_PoolMethod_AVE = 1,
V0LayerParameter_PoolMethod_STOCHASTIC = 2
};
bool V0LayerParameter_PoolMethod_IsValid(int value);
const V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MIN = V0LayerParameter_PoolMethod_MAX;
const V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MAX = V0LayerParameter_PoolMethod_STOCHASTIC;
const int V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE = V0LayerParameter_PoolMethod_PoolMethod_MAX + 1;
const ::google::protobuf::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor();
inline const ::std::string& V0LayerParameter_PoolMethod_Name(V0LayerParameter_PoolMethod value) {
return ::google::protobuf::internal::NameOfEnum(
V0LayerParameter_PoolMethod_descriptor(), value);
}
inline bool V0LayerParameter_PoolMethod_Parse(
const ::std::string& name, V0LayerParameter_PoolMethod* value) {
return ::google::protobuf::internal::ParseNamedEnum<V0LayerParameter_PoolMethod>(
V0LayerParameter_PoolMethod_descriptor(), name, value);
}
enum Type {
DOUBLE = 0,
FLOAT = 1,
FLOAT16 = 2,
INT = 3,
UINT = 4
};
bool Type_IsValid(int value);
const Type Type_MIN = DOUBLE;
const Type Type_MAX = UINT;
const int Type_ARRAYSIZE = Type_MAX + 1;
const ::google::protobuf::EnumDescriptor* Type_descriptor();
inline const ::std::string& Type_Name(Type value) {
return ::google::protobuf::internal::NameOfEnum(
Type_descriptor(), value);
}
inline bool Type_Parse(
const ::std::string& name, Type* value) {
return ::google::protobuf::internal::ParseNamedEnum<Type>(
Type_descriptor(), name, value);
}
enum Phase {
TRAIN = 0,
TEST = 1
};
bool Phase_IsValid(int value);
const Phase Phase_MIN = TRAIN;
const Phase Phase_MAX = TEST;
const int Phase_ARRAYSIZE = Phase_MAX + 1;
const ::google::protobuf::EnumDescriptor* Phase_descriptor();
inline const ::std::string& Phase_Name(Phase value) {
return ::google::protobuf::internal::NameOfEnum(
Phase_descriptor(), value);
}
inline bool Phase_Parse(
const ::std::string& name, Phase* value) {
return ::google::protobuf::internal::ParseNamedEnum<Phase>(
Phase_descriptor(), name, value);
}
// ===================================================================
class BlobShape : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobShape) */ {
public:
BlobShape();
virtual ~BlobShape();
BlobShape(const BlobShape& from);
inline BlobShape& operator=(const BlobShape& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
BlobShape(BlobShape&& from) noexcept
: BlobShape() {
*this = ::std::move(from);
}
inline BlobShape& operator=(BlobShape&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const BlobShape& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const BlobShape* internal_default_instance() {
return reinterpret_cast<const BlobShape*>(
&_BlobShape_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
0;
void Swap(BlobShape* other);
friend void swap(BlobShape& a, BlobShape& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline BlobShape* New() const PROTOBUF_FINAL { return New(NULL); }
BlobShape* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const BlobShape& from);
void MergeFrom(const BlobShape& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(BlobShape* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated int64 dim = 1 [packed = true];
int dim_size() const;
void clear_dim();
static const int kDimFieldNumber = 1;
::google::protobuf::int64 dim(int index) const;
void set_dim(int index, ::google::protobuf::int64 value);
void add_dim(::google::protobuf::int64 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
dim() const;
::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
mutable_dim();
// @@protoc_insertion_point(class_scope:opencv_caffe.BlobShape)
private:
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< ::google::protobuf::int64 > dim_;
mutable int _dim_cached_byte_size_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShapeImpl();
};
// -------------------------------------------------------------------
class BlobProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobProto) */ {
public:
BlobProto();
virtual ~BlobProto();
BlobProto(const BlobProto& from);
inline BlobProto& operator=(const BlobProto& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
BlobProto(BlobProto&& from) noexcept
: BlobProto() {
*this = ::std::move(from);
}
inline BlobProto& operator=(BlobProto&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const BlobProto& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const BlobProto* internal_default_instance() {
return reinterpret_cast<const BlobProto*>(
&_BlobProto_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
1;
void Swap(BlobProto* other);
friend void swap(BlobProto& a, BlobProto& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline BlobProto* New() const PROTOBUF_FINAL { return New(NULL); }
BlobProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const BlobProto& from);
void MergeFrom(const BlobProto& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(BlobProto* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated float data = 5 [packed = true];
int data_size() const;
void clear_data();
static const int kDataFieldNumber = 5;
float data(int index) const;
void set_data(int index, float value);
void add_data(float value);
const ::google::protobuf::RepeatedField< float >&
data() const;
::google::protobuf::RepeatedField< float >*
mutable_data();
// repeated float diff = 6 [packed = true];
int diff_size() const;
void clear_diff();
static const int kDiffFieldNumber = 6;
float diff(int index) const;
void set_diff(int index, float value);
void add_diff(float value);
const ::google::protobuf::RepeatedField< float >&
diff() const;
::google::protobuf::RepeatedField< float >*
mutable_diff();
// repeated double double_data = 8 [packed = true];
int double_data_size() const;
void clear_double_data();
static const int kDoubleDataFieldNumber = 8;
double double_data(int index) const;
void set_double_data(int index, double value);
void add_double_data(double value);
const ::google::protobuf::RepeatedField< double >&
double_data() const;
::google::protobuf::RepeatedField< double >*
mutable_double_data();
// repeated double double_diff = 9 [packed = true];
int double_diff_size() const;
void clear_double_diff();
static const int kDoubleDiffFieldNumber = 9;
double double_diff(int index) const;
void set_double_diff(int index, double value);
void add_double_diff(double value);
const ::google::protobuf::RepeatedField< double >&
double_diff() const;
::google::protobuf::RepeatedField< double >*
mutable_double_diff();
// optional bytes raw_data = 12 [packed = false];
bool has_raw_data() const;
void clear_raw_data();
static const int kRawDataFieldNumber = 12;
const ::std::string& raw_data() const;
void set_raw_data(const ::std::string& value);
#if LANG_CXX11
void set_raw_data(::std::string&& value);
#endif
void set_raw_data(const char* value);
void set_raw_data(const void* value, size_t size);
::std::string* mutable_raw_data();
::std::string* release_raw_data();
void set_allocated_raw_data(::std::string* raw_data);
// optional .opencv_caffe.BlobShape shape = 7;
bool has_shape() const;
void clear_shape();
static const int kShapeFieldNumber = 7;
const ::opencv_caffe::BlobShape& shape() const;
::opencv_caffe::BlobShape* release_shape();
::opencv_caffe::BlobShape* mutable_shape();
void set_allocated_shape(::opencv_caffe::BlobShape* shape);
// optional int32 num = 1 [default = 0];
bool has_num() const;
void clear_num();
static const int kNumFieldNumber = 1;
::google::protobuf::int32 num() const;
void set_num(::google::protobuf::int32 value);
// optional int32 channels = 2 [default = 0];
bool has_channels() const;
void clear_channels();
static const int kChannelsFieldNumber = 2;
::google::protobuf::int32 channels() const;
void set_channels(::google::protobuf::int32 value);
// optional int32 height = 3 [default = 0];
bool has_height() const;
void clear_height();
static const int kHeightFieldNumber = 3;
::google::protobuf::int32 height() const;
void set_height(::google::protobuf::int32 value);
// optional int32 width = 4 [default = 0];
bool has_width() const;
void clear_width();
static const int kWidthFieldNumber = 4;
::google::protobuf::int32 width() const;
void set_width(::google::protobuf::int32 value);
// optional .opencv_caffe.Type raw_data_type = 10;
bool has_raw_data_type() const;
void clear_raw_data_type();
static const int kRawDataTypeFieldNumber = 10;
::opencv_caffe::Type raw_data_type() const;
void set_raw_data_type(::opencv_caffe::Type value);
// @@protoc_insertion_point(class_scope:opencv_caffe.BlobProto)
private:
void set_has_shape();
void clear_has_shape();
void set_has_raw_data_type();
void clear_has_raw_data_type();
void set_has_raw_data();
void clear_has_raw_data();
void set_has_num();
void clear_has_num();
void set_has_channels();
void clear_has_channels();
void set_has_height();
void clear_has_height();
void set_has_width();
void clear_has_width();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< float > data_;
mutable int _data_cached_byte_size_;
::google::protobuf::RepeatedField< float > diff_;
mutable int _diff_cached_byte_size_;
::google::protobuf::RepeatedField< double > double_data_;
mutable int _double_data_cached_byte_size_;
::google::protobuf::RepeatedField< double > double_diff_;
mutable int _double_diff_cached_byte_size_;
::google::protobuf::internal::ArenaStringPtr raw_data_;
::opencv_caffe::BlobShape* shape_;
::google::protobuf::int32 num_;
::google::protobuf::int32 channels_;
::google::protobuf::int32 height_;
::google::protobuf::int32 width_;
int raw_data_type_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProtoImpl();
};
// -------------------------------------------------------------------
class BlobProtoVector : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobProtoVector) */ {
public:
BlobProtoVector();
virtual ~BlobProtoVector();
BlobProtoVector(const BlobProtoVector& from);
inline BlobProtoVector& operator=(const BlobProtoVector& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
BlobProtoVector(BlobProtoVector&& from) noexcept
: BlobProtoVector() {
*this = ::std::move(from);
}
inline BlobProtoVector& operator=(BlobProtoVector&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const BlobProtoVector& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const BlobProtoVector* internal_default_instance() {
return reinterpret_cast<const BlobProtoVector*>(
&_BlobProtoVector_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
2;
void Swap(BlobProtoVector* other);
friend void swap(BlobProtoVector& a, BlobProtoVector& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline BlobProtoVector* New() const PROTOBUF_FINAL { return New(NULL); }
BlobProtoVector* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const BlobProtoVector& from);
void MergeFrom(const BlobProtoVector& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(BlobProtoVector* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated .opencv_caffe.BlobProto blobs = 1;
int blobs_size() const;
void clear_blobs();
static const int kBlobsFieldNumber = 1;
const ::opencv_caffe::BlobProto& blobs(int index) const;
::opencv_caffe::BlobProto* mutable_blobs(int index);
::opencv_caffe::BlobProto* add_blobs();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
mutable_blobs();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
blobs() const;
// @@protoc_insertion_point(class_scope:opencv_caffe.BlobProtoVector)
private:
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProtoVectorImpl();
};
// -------------------------------------------------------------------
class PermuteParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PermuteParameter) */ {
public:
PermuteParameter();
virtual ~PermuteParameter();
PermuteParameter(const PermuteParameter& from);
inline PermuteParameter& operator=(const PermuteParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
PermuteParameter(PermuteParameter&& from) noexcept
: PermuteParameter() {
*this = ::std::move(from);
}
inline PermuteParameter& operator=(PermuteParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const PermuteParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PermuteParameter* internal_default_instance() {
return reinterpret_cast<const PermuteParameter*>(
&_PermuteParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
3;
void Swap(PermuteParameter* other);
friend void swap(PermuteParameter& a, PermuteParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline PermuteParameter* New() const PROTOBUF_FINAL { return New(NULL); }
PermuteParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const PermuteParameter& from);
void MergeFrom(const PermuteParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(PermuteParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated uint32 order = 1;
int order_size() const;
void clear_order();
static const int kOrderFieldNumber = 1;
::google::protobuf::uint32 order(int index) const;
void set_order(int index, ::google::protobuf::uint32 value);
void add_order(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
order() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_order();
// @@protoc_insertion_point(class_scope:opencv_caffe.PermuteParameter)
private:
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > order_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPermuteParameterImpl();
};
// -------------------------------------------------------------------
class NormalizeBBoxParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NormalizeBBoxParameter) */ {
public:
NormalizeBBoxParameter();
virtual ~NormalizeBBoxParameter();
NormalizeBBoxParameter(const NormalizeBBoxParameter& from);
inline NormalizeBBoxParameter& operator=(const NormalizeBBoxParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
NormalizeBBoxParameter(NormalizeBBoxParameter&& from) noexcept
: NormalizeBBoxParameter() {
*this = ::std::move(from);
}
inline NormalizeBBoxParameter& operator=(NormalizeBBoxParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const NormalizeBBoxParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const NormalizeBBoxParameter* internal_default_instance() {
return reinterpret_cast<const NormalizeBBoxParameter*>(
&_NormalizeBBoxParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
4;
void Swap(NormalizeBBoxParameter* other);
friend void swap(NormalizeBBoxParameter& a, NormalizeBBoxParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline NormalizeBBoxParameter* New() const PROTOBUF_FINAL { return New(NULL); }
NormalizeBBoxParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const NormalizeBBoxParameter& from);
void MergeFrom(const NormalizeBBoxParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(NormalizeBBoxParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.FillerParameter scale_filler = 2;
bool has_scale_filler() const;
void clear_scale_filler();
static const int kScaleFillerFieldNumber = 2;
const ::opencv_caffe::FillerParameter& scale_filler() const;
::opencv_caffe::FillerParameter* release_scale_filler();
::opencv_caffe::FillerParameter* mutable_scale_filler();
void set_allocated_scale_filler(::opencv_caffe::FillerParameter* scale_filler);
// optional bool across_spatial = 1 [default = true];
bool has_across_spatial() const;
void clear_across_spatial();
static const int kAcrossSpatialFieldNumber = 1;
bool across_spatial() const;
void set_across_spatial(bool value);
// optional bool channel_shared = 3 [default = true];
bool has_channel_shared() const;
void clear_channel_shared();
static const int kChannelSharedFieldNumber = 3;
bool channel_shared() const;
void set_channel_shared(bool value);
// optional float eps = 4 [default = 1e-10];
bool has_eps() const;
void clear_eps();
static const int kEpsFieldNumber = 4;
float eps() const;
void set_eps(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.NormalizeBBoxParameter)
private:
void set_has_across_spatial();
void clear_has_across_spatial();
void set_has_scale_filler();
void clear_has_scale_filler();
void set_has_channel_shared();
void clear_has_channel_shared();
void set_has_eps();
void clear_has_eps();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::FillerParameter* scale_filler_;
bool across_spatial_;
bool channel_shared_;
float eps_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNormalizeBBoxParameterImpl();
};
// -------------------------------------------------------------------
class PriorBoxParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PriorBoxParameter) */ {
public:
PriorBoxParameter();
virtual ~PriorBoxParameter();
PriorBoxParameter(const PriorBoxParameter& from);
inline PriorBoxParameter& operator=(const PriorBoxParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
PriorBoxParameter(PriorBoxParameter&& from) noexcept
: PriorBoxParameter() {
*this = ::std::move(from);
}
inline PriorBoxParameter& operator=(PriorBoxParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const PriorBoxParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PriorBoxParameter* internal_default_instance() {
return reinterpret_cast<const PriorBoxParameter*>(
&_PriorBoxParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
5;
void Swap(PriorBoxParameter* other);
friend void swap(PriorBoxParameter& a, PriorBoxParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline PriorBoxParameter* New() const PROTOBUF_FINAL { return New(NULL); }
PriorBoxParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const PriorBoxParameter& from);
void MergeFrom(const PriorBoxParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(PriorBoxParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef PriorBoxParameter_CodeType CodeType;
static const CodeType CORNER =
PriorBoxParameter_CodeType_CORNER;
static const CodeType CENTER_SIZE =
PriorBoxParameter_CodeType_CENTER_SIZE;
static inline bool CodeType_IsValid(int value) {
return PriorBoxParameter_CodeType_IsValid(value);
}
static const CodeType CodeType_MIN =
PriorBoxParameter_CodeType_CodeType_MIN;
static const CodeType CodeType_MAX =
PriorBoxParameter_CodeType_CodeType_MAX;
static const int CodeType_ARRAYSIZE =
PriorBoxParameter_CodeType_CodeType_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
CodeType_descriptor() {
return PriorBoxParameter_CodeType_descriptor();
}
static inline const ::std::string& CodeType_Name(CodeType value) {
return PriorBoxParameter_CodeType_Name(value);
}
static inline bool CodeType_Parse(const ::std::string& name,
CodeType* value) {
return PriorBoxParameter_CodeType_Parse(name, value);
}
// accessors -------------------------------------------------------
// repeated float min_size = 1;
int min_size_size() const;
void clear_min_size();
static const int kMinSizeFieldNumber = 1;
float min_size(int index) const;
void set_min_size(int index, float value);
void add_min_size(float value);
const ::google::protobuf::RepeatedField< float >&
min_size() const;
::google::protobuf::RepeatedField< float >*
mutable_min_size();
// repeated float max_size = 2;
int max_size_size() const;
void clear_max_size();
static const int kMaxSizeFieldNumber = 2;
float max_size(int index) const;
void set_max_size(int index, float value);
void add_max_size(float value);
const ::google::protobuf::RepeatedField< float >&
max_size() const;
::google::protobuf::RepeatedField< float >*
mutable_max_size();
// repeated float aspect_ratio = 3;
int aspect_ratio_size() const;
void clear_aspect_ratio();
static const int kAspectRatioFieldNumber = 3;
float aspect_ratio(int index) const;
void set_aspect_ratio(int index, float value);
void add_aspect_ratio(float value);
const ::google::protobuf::RepeatedField< float >&
aspect_ratio() const;
::google::protobuf::RepeatedField< float >*
mutable_aspect_ratio();
// repeated float variance = 6;
int variance_size() const;
void clear_variance();
static const int kVarianceFieldNumber = 6;
float variance(int index) const;
void set_variance(int index, float value);
void add_variance(float value);
const ::google::protobuf::RepeatedField< float >&
variance() const;
::google::protobuf::RepeatedField< float >*
mutable_variance();
// repeated float offset_h = 14;
int offset_h_size() const;
void clear_offset_h();
static const int kOffsetHFieldNumber = 14;
float offset_h(int index) const;
void set_offset_h(int index, float value);
void add_offset_h(float value);
const ::google::protobuf::RepeatedField< float >&
offset_h() const;
::google::protobuf::RepeatedField< float >*
mutable_offset_h();
// repeated float offset_w = 15;
int offset_w_size() const;
void clear_offset_w();
static const int kOffsetWFieldNumber = 15;
float offset_w(int index) const;
void set_offset_w(int index, float value);
void add_offset_w(float value);
const ::google::protobuf::RepeatedField< float >&
offset_w() const;
::google::protobuf::RepeatedField< float >*
mutable_offset_w();
// repeated float width = 16;
int width_size() const;
void clear_width();
static const int kWidthFieldNumber = 16;
float width(int index) const;
void set_width(int index, float value);
void add_width(float value);
const ::google::protobuf::RepeatedField< float >&
width() const;
::google::protobuf::RepeatedField< float >*
mutable_width();
// repeated float height = 17;
int height_size() const;
void clear_height();
static const int kHeightFieldNumber = 17;
float height(int index) const;
void set_height(int index, float value);
void add_height(float value);
const ::google::protobuf::RepeatedField< float >&
height() const;
::google::protobuf::RepeatedField< float >*
mutable_height();
// optional uint32 img_size = 7;
bool has_img_size() const;
void clear_img_size();
static const int kImgSizeFieldNumber = 7;
::google::protobuf::uint32 img_size() const;
void set_img_size(::google::protobuf::uint32 value);
// optional uint32 img_h = 8;
bool has_img_h() const;
void clear_img_h();
static const int kImgHFieldNumber = 8;
::google::protobuf::uint32 img_h() const;
void set_img_h(::google::protobuf::uint32 value);
// optional uint32 img_w = 9;
bool has_img_w() const;
void clear_img_w();
static const int kImgWFieldNumber = 9;
::google::protobuf::uint32 img_w() const;
void set_img_w(::google::protobuf::uint32 value);
// optional float step = 10;
bool has_step() const;
void clear_step();
static const int kStepFieldNumber = 10;
float step() const;
void set_step(float value);
// optional float step_h = 11;
bool has_step_h() const;
void clear_step_h();
static const int kStepHFieldNumber = 11;
float step_h() const;
void set_step_h(float value);
// optional float step_w = 12;
bool has_step_w() const;
void clear_step_w();
static const int kStepWFieldNumber = 12;
float step_w() const;
void set_step_w(float value);
// optional bool flip = 4 [default = true];
bool has_flip() const;
void clear_flip();
static const int kFlipFieldNumber = 4;
bool flip() const;
void set_flip(bool value);
// optional bool clip = 5 [default = true];
bool has_clip() const;
void clear_clip();
static const int kClipFieldNumber = 5;
bool clip() const;
void set_clip(bool value);
// optional float offset = 13 [default = 0.5];
bool has_offset() const;
void clear_offset();
static const int kOffsetFieldNumber = 13;
float offset() const;
void set_offset(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.PriorBoxParameter)
private:
void set_has_flip();
void clear_has_flip();
void set_has_clip();
void clear_has_clip();
void set_has_img_size();
void clear_has_img_size();
void set_has_img_h();
void clear_has_img_h();
void set_has_img_w();
void clear_has_img_w();
void set_has_step();
void clear_has_step();
void set_has_step_h();
void clear_has_step_h();
void set_has_step_w();
void clear_has_step_w();
void set_has_offset();
void clear_has_offset();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< float > min_size_;
::google::protobuf::RepeatedField< float > max_size_;
::google::protobuf::RepeatedField< float > aspect_ratio_;
::google::protobuf::RepeatedField< float > variance_;
::google::protobuf::RepeatedField< float > offset_h_;
::google::protobuf::RepeatedField< float > offset_w_;
::google::protobuf::RepeatedField< float > width_;
::google::protobuf::RepeatedField< float > height_;
::google::protobuf::uint32 img_size_;
::google::protobuf::uint32 img_h_;
::google::protobuf::uint32 img_w_;
float step_;
float step_h_;
float step_w_;
bool flip_;
bool clip_;
float offset_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPriorBoxParameterImpl();
};
// -------------------------------------------------------------------
class DetectionOutputParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DetectionOutputParameter) */ {
public:
DetectionOutputParameter();
virtual ~DetectionOutputParameter();
DetectionOutputParameter(const DetectionOutputParameter& from);
inline DetectionOutputParameter& operator=(const DetectionOutputParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
DetectionOutputParameter(DetectionOutputParameter&& from) noexcept
: DetectionOutputParameter() {
*this = ::std::move(from);
}
inline DetectionOutputParameter& operator=(DetectionOutputParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const DetectionOutputParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DetectionOutputParameter* internal_default_instance() {
return reinterpret_cast<const DetectionOutputParameter*>(
&_DetectionOutputParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
6;
void Swap(DetectionOutputParameter* other);
friend void swap(DetectionOutputParameter& a, DetectionOutputParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline DetectionOutputParameter* New() const PROTOBUF_FINAL { return New(NULL); }
DetectionOutputParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const DetectionOutputParameter& from);
void MergeFrom(const DetectionOutputParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(DetectionOutputParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4;
bool has_nms_param() const;
void clear_nms_param();
static const int kNmsParamFieldNumber = 4;
const ::opencv_caffe::NonMaximumSuppressionParameter& nms_param() const;
::opencv_caffe::NonMaximumSuppressionParameter* release_nms_param();
::opencv_caffe::NonMaximumSuppressionParameter* mutable_nms_param();
void set_allocated_nms_param(::opencv_caffe::NonMaximumSuppressionParameter* nms_param);
// optional .opencv_caffe.SaveOutputParameter save_output_param = 5;
bool has_save_output_param() const;
void clear_save_output_param();
static const int kSaveOutputParamFieldNumber = 5;
const ::opencv_caffe::SaveOutputParameter& save_output_param() const;
::opencv_caffe::SaveOutputParameter* release_save_output_param();
::opencv_caffe::SaveOutputParameter* mutable_save_output_param();
void set_allocated_save_output_param(::opencv_caffe::SaveOutputParameter* save_output_param);
// optional uint32 num_classes = 1;
bool has_num_classes() const;
void clear_num_classes();
static const int kNumClassesFieldNumber = 1;
::google::protobuf::uint32 num_classes() const;
void set_num_classes(::google::protobuf::uint32 value);
// optional int32 background_label_id = 3 [default = 0];
bool has_background_label_id() const;
void clear_background_label_id();
static const int kBackgroundLabelIdFieldNumber = 3;
::google::protobuf::int32 background_label_id() const;
void set_background_label_id(::google::protobuf::int32 value);
// optional bool variance_encoded_in_target = 8 [default = false];
bool has_variance_encoded_in_target() const;
void clear_variance_encoded_in_target();
static const int kVarianceEncodedInTargetFieldNumber = 8;
bool variance_encoded_in_target() const;
void set_variance_encoded_in_target(bool value);
// optional float confidence_threshold = 9;
bool has_confidence_threshold() const;
void clear_confidence_threshold();
static const int kConfidenceThresholdFieldNumber = 9;
float confidence_threshold() const;
void set_confidence_threshold(float value);
// optional int32 keep_top_k = 7 [default = -1];
bool has_keep_top_k() const;
void clear_keep_top_k();
static const int kKeepTopKFieldNumber = 7;
::google::protobuf::int32 keep_top_k() const;
void set_keep_top_k(::google::protobuf::int32 value);
// optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
bool has_code_type() const;
void clear_code_type();
static const int kCodeTypeFieldNumber = 6;
::opencv_caffe::PriorBoxParameter_CodeType code_type() const;
void set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value);
// optional bool share_location = 2 [default = true];
bool has_share_location() const;
void clear_share_location();
static const int kShareLocationFieldNumber = 2;
bool share_location() const;
void set_share_location(bool value);
// optional bool normalized_bbox = 10 [default = true];
bool has_normalized_bbox() const;
void clear_normalized_bbox();
static const int kNormalizedBboxFieldNumber = 10;
bool normalized_bbox() const;
void set_normalized_bbox(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.DetectionOutputParameter)
private:
void set_has_num_classes();
void clear_has_num_classes();
void set_has_share_location();
void clear_has_share_location();
void set_has_background_label_id();
void clear_has_background_label_id();
void set_has_nms_param();
void clear_has_nms_param();
void set_has_save_output_param();
void clear_has_save_output_param();
void set_has_code_type();
void clear_has_code_type();
void set_has_variance_encoded_in_target();
void clear_has_variance_encoded_in_target();
void set_has_keep_top_k();
void clear_has_keep_top_k();
void set_has_confidence_threshold();
void clear_has_confidence_threshold();
void set_has_normalized_bbox();
void clear_has_normalized_bbox();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::NonMaximumSuppressionParameter* nms_param_;
::opencv_caffe::SaveOutputParameter* save_output_param_;
::google::protobuf::uint32 num_classes_;
::google::protobuf::int32 background_label_id_;
bool variance_encoded_in_target_;
float confidence_threshold_;
::google::protobuf::int32 keep_top_k_;
int code_type_;
bool share_location_;
bool normalized_bbox_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDetectionOutputParameterImpl();
};
// -------------------------------------------------------------------
class Datum : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.Datum) */ {
public:
Datum();
virtual ~Datum();
Datum(const Datum& from);
inline Datum& operator=(const Datum& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
Datum(Datum&& from) noexcept
: Datum() {
*this = ::std::move(from);
}
inline Datum& operator=(Datum&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const Datum& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const Datum* internal_default_instance() {
return reinterpret_cast<const Datum*>(
&_Datum_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
7;
void Swap(Datum* other);
friend void swap(Datum& a, Datum& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline Datum* New() const PROTOBUF_FINAL { return New(NULL); }
Datum* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const Datum& from);
void MergeFrom(const Datum& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(Datum* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated float float_data = 6;
int float_data_size() const;
void clear_float_data();
static const int kFloatDataFieldNumber = 6;
float float_data(int index) const;
void set_float_data(int index, float value);
void add_float_data(float value);
const ::google::protobuf::RepeatedField< float >&
float_data() const;
::google::protobuf::RepeatedField< float >*
mutable_float_data();
// optional bytes data = 4;
bool has_data() const;
void clear_data();
static const int kDataFieldNumber = 4;
const ::std::string& data() const;
void set_data(const ::std::string& value);
#if LANG_CXX11
void set_data(::std::string&& value);
#endif
void set_data(const char* value);
void set_data(const void* value, size_t size);
::std::string* mutable_data();
::std::string* release_data();
void set_allocated_data(::std::string* data);
// optional int32 channels = 1;
bool has_channels() const;
void clear_channels();
static const int kChannelsFieldNumber = 1;
::google::protobuf::int32 channels() const;
void set_channels(::google::protobuf::int32 value);
// optional int32 height = 2;
bool has_height() const;
void clear_height();
static const int kHeightFieldNumber = 2;
::google::protobuf::int32 height() const;
void set_height(::google::protobuf::int32 value);
// optional int32 width = 3;
bool has_width() const;
void clear_width();
static const int kWidthFieldNumber = 3;
::google::protobuf::int32 width() const;
void set_width(::google::protobuf::int32 value);
// optional int32 label = 5;
bool has_label() const;
void clear_label();
static const int kLabelFieldNumber = 5;
::google::protobuf::int32 label() const;
void set_label(::google::protobuf::int32 value);
// optional bool encoded = 7 [default = false];
bool has_encoded() const;
void clear_encoded();
static const int kEncodedFieldNumber = 7;
bool encoded() const;
void set_encoded(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.Datum)
private:
void set_has_channels();
void clear_has_channels();
void set_has_height();
void clear_has_height();
void set_has_width();
void clear_has_width();
void set_has_data();
void clear_has_data();
void set_has_label();
void clear_has_label();
void set_has_encoded();
void clear_has_encoded();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< float > float_data_;
::google::protobuf::internal::ArenaStringPtr data_;
::google::protobuf::int32 channels_;
::google::protobuf::int32 height_;
::google::protobuf::int32 width_;
::google::protobuf::int32 label_;
bool encoded_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDatumImpl();
};
// -------------------------------------------------------------------
class FillerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.FillerParameter) */ {
public:
FillerParameter();
virtual ~FillerParameter();
FillerParameter(const FillerParameter& from);
inline FillerParameter& operator=(const FillerParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
FillerParameter(FillerParameter&& from) noexcept
: FillerParameter() {
*this = ::std::move(from);
}
inline FillerParameter& operator=(FillerParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const FillerParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const FillerParameter* internal_default_instance() {
return reinterpret_cast<const FillerParameter*>(
&_FillerParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
8;
void Swap(FillerParameter* other);
friend void swap(FillerParameter& a, FillerParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline FillerParameter* New() const PROTOBUF_FINAL { return New(NULL); }
FillerParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const FillerParameter& from);
void MergeFrom(const FillerParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(FillerParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef FillerParameter_VarianceNorm VarianceNorm;
static const VarianceNorm FAN_IN =
FillerParameter_VarianceNorm_FAN_IN;
static const VarianceNorm FAN_OUT =
FillerParameter_VarianceNorm_FAN_OUT;
static const VarianceNorm AVERAGE =
FillerParameter_VarianceNorm_AVERAGE;
static inline bool VarianceNorm_IsValid(int value) {
return FillerParameter_VarianceNorm_IsValid(value);
}
static const VarianceNorm VarianceNorm_MIN =
FillerParameter_VarianceNorm_VarianceNorm_MIN;
static const VarianceNorm VarianceNorm_MAX =
FillerParameter_VarianceNorm_VarianceNorm_MAX;
static const int VarianceNorm_ARRAYSIZE =
FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
VarianceNorm_descriptor() {
return FillerParameter_VarianceNorm_descriptor();
}
static inline const ::std::string& VarianceNorm_Name(VarianceNorm value) {
return FillerParameter_VarianceNorm_Name(value);
}
static inline bool VarianceNorm_Parse(const ::std::string& name,
VarianceNorm* value) {
return FillerParameter_VarianceNorm_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional string type = 1 [default = "constant"];
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 1;
const ::std::string& type() const;
void set_type(const ::std::string& value);
#if LANG_CXX11
void set_type(::std::string&& value);
#endif
void set_type(const char* value);
void set_type(const char* value, size_t size);
::std::string* mutable_type();
::std::string* release_type();
void set_allocated_type(::std::string* type);
// optional float value = 2 [default = 0];
bool has_value() const;
void clear_value();
static const int kValueFieldNumber = 2;
float value() const;
void set_value(float value);
// optional float min = 3 [default = 0];
bool has_min() const;
void clear_min();
static const int kMinFieldNumber = 3;
float min() const;
void set_min(float value);
// optional float mean = 5 [default = 0];
bool has_mean() const;
void clear_mean();
static const int kMeanFieldNumber = 5;
float mean() const;
void set_mean(float value);
// optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
bool has_variance_norm() const;
void clear_variance_norm();
static const int kVarianceNormFieldNumber = 8;
::opencv_caffe::FillerParameter_VarianceNorm variance_norm() const;
void set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value);
// optional int32 sparse = 7 [default = -1];
bool has_sparse() const;
void clear_sparse();
static const int kSparseFieldNumber = 7;
::google::protobuf::int32 sparse() const;
void set_sparse(::google::protobuf::int32 value);
// optional float max = 4 [default = 1];
bool has_max() const;
void clear_max();
static const int kMaxFieldNumber = 4;
float max() const;
void set_max(float value);
// optional float std = 6 [default = 1];
bool has_std() const;
void clear_std();
static const int kStdFieldNumber = 6;
float std() const;
void set_std(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.FillerParameter)
private:
void set_has_type();
void clear_has_type();
void set_has_value();
void clear_has_value();
void set_has_min();
void clear_has_min();
void set_has_max();
void clear_has_max();
void set_has_mean();
void clear_has_mean();
void set_has_std();
void clear_has_std();
void set_has_sparse();
void clear_has_sparse();
void set_has_variance_norm();
void clear_has_variance_norm();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _default_type_;
::google::protobuf::internal::ArenaStringPtr type_;
float value_;
float min_;
float mean_;
int variance_norm_;
::google::protobuf::int32 sparse_;
float max_;
float std_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameterImpl();
};
// -------------------------------------------------------------------
class NetParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetParameter) */ {
public:
NetParameter();
virtual ~NetParameter();
NetParameter(const NetParameter& from);
inline NetParameter& operator=(const NetParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
NetParameter(NetParameter&& from) noexcept
: NetParameter() {
*this = ::std::move(from);
}
inline NetParameter& operator=(NetParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const NetParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const NetParameter* internal_default_instance() {
return reinterpret_cast<const NetParameter*>(
&_NetParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
9;
void Swap(NetParameter* other);
friend void swap(NetParameter& a, NetParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline NetParameter* New() const PROTOBUF_FINAL { return New(NULL); }
NetParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const NetParameter& from);
void MergeFrom(const NetParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(NetParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated .opencv_caffe.V1LayerParameter layers = 2;
int layers_size() const;
void clear_layers();
static const int kLayersFieldNumber = 2;
const ::opencv_caffe::V1LayerParameter& layers(int index) const;
::opencv_caffe::V1LayerParameter* mutable_layers(int index);
::opencv_caffe::V1LayerParameter* add_layers();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >*
mutable_layers();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >&
layers() const;
// repeated string input = 3;
int input_size() const;
void clear_input();
static const int kInputFieldNumber = 3;
const ::std::string& input(int index) const;
::std::string* mutable_input(int index);
void set_input(int index, const ::std::string& value);
#if LANG_CXX11
void set_input(int index, ::std::string&& value);
#endif
void set_input(int index, const char* value);
void set_input(int index, const char* value, size_t size);
::std::string* add_input();
void add_input(const ::std::string& value);
#if LANG_CXX11
void add_input(::std::string&& value);
#endif
void add_input(const char* value);
void add_input(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input();
// repeated int32 input_dim = 4;
int input_dim_size() const;
void clear_input_dim();
static const int kInputDimFieldNumber = 4;
::google::protobuf::int32 input_dim(int index) const;
void set_input_dim(int index, ::google::protobuf::int32 value);
void add_input_dim(::google::protobuf::int32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
input_dim() const;
::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_input_dim();
// repeated .opencv_caffe.BlobShape input_shape = 8;
int input_shape_size() const;
void clear_input_shape();
static const int kInputShapeFieldNumber = 8;
const ::opencv_caffe::BlobShape& input_shape(int index) const;
::opencv_caffe::BlobShape* mutable_input_shape(int index);
::opencv_caffe::BlobShape* add_input_shape();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >*
mutable_input_shape();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >&
input_shape() const;
// repeated .opencv_caffe.LayerParameter layer = 100;
int layer_size() const;
void clear_layer();
static const int kLayerFieldNumber = 100;
const ::opencv_caffe::LayerParameter& layer(int index) const;
::opencv_caffe::LayerParameter* mutable_layer(int index);
::opencv_caffe::LayerParameter* add_layer();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::LayerParameter >*
mutable_layer();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::LayerParameter >&
layer() const;
// optional string name = 1;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string& name() const;
void set_name(const ::std::string& value);
#if LANG_CXX11
void set_name(::std::string&& value);
#endif
void set_name(const char* value);
void set_name(const char* value, size_t size);
::std::string* mutable_name();
::std::string* release_name();
void set_allocated_name(::std::string* name);
// optional .opencv_caffe.NetState state = 6;
bool has_state() const;
void clear_state();
static const int kStateFieldNumber = 6;
const ::opencv_caffe::NetState& state() const;
::opencv_caffe::NetState* release_state();
::opencv_caffe::NetState* mutable_state();
void set_allocated_state(::opencv_caffe::NetState* state);
// optional bool force_backward = 5 [default = false];
bool has_force_backward() const;
void clear_force_backward();
static const int kForceBackwardFieldNumber = 5;
bool force_backward() const;
void set_force_backward(bool value);
// optional bool debug_info = 7 [default = false];
bool has_debug_info() const;
void clear_debug_info();
static const int kDebugInfoFieldNumber = 7;
bool debug_info() const;
void set_debug_info(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.NetParameter)
private:
void set_has_name();
void clear_has_name();
void set_has_force_backward();
void clear_has_force_backward();
void set_has_state();
void clear_has_state();
void set_has_debug_info();
void clear_has_debug_info();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::V1LayerParameter > layers_;
::google::protobuf::RepeatedPtrField< ::std::string> input_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > input_dim_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape > input_shape_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::LayerParameter > layer_;
::google::protobuf::internal::ArenaStringPtr name_;
::opencv_caffe::NetState* state_;
bool force_backward_;
bool debug_info_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetParameterImpl();
};
// -------------------------------------------------------------------
class SolverParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SolverParameter) */ {
public:
SolverParameter();
virtual ~SolverParameter();
SolverParameter(const SolverParameter& from);
inline SolverParameter& operator=(const SolverParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
SolverParameter(SolverParameter&& from) noexcept
: SolverParameter() {
*this = ::std::move(from);
}
inline SolverParameter& operator=(SolverParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const SolverParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const SolverParameter* internal_default_instance() {
return reinterpret_cast<const SolverParameter*>(
&_SolverParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
10;
void Swap(SolverParameter* other);
friend void swap(SolverParameter& a, SolverParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline SolverParameter* New() const PROTOBUF_FINAL { return New(NULL); }
SolverParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const SolverParameter& from);
void MergeFrom(const SolverParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(SolverParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef SolverParameter_SnapshotFormat SnapshotFormat;
static const SnapshotFormat HDF5 =
SolverParameter_SnapshotFormat_HDF5;
static const SnapshotFormat BINARYPROTO =
SolverParameter_SnapshotFormat_BINARYPROTO;
static inline bool SnapshotFormat_IsValid(int value) {
return SolverParameter_SnapshotFormat_IsValid(value);
}
static const SnapshotFormat SnapshotFormat_MIN =
SolverParameter_SnapshotFormat_SnapshotFormat_MIN;
static const SnapshotFormat SnapshotFormat_MAX =
SolverParameter_SnapshotFormat_SnapshotFormat_MAX;
static const int SnapshotFormat_ARRAYSIZE =
SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
SnapshotFormat_descriptor() {
return SolverParameter_SnapshotFormat_descriptor();
}
static inline const ::std::string& SnapshotFormat_Name(SnapshotFormat value) {
return SolverParameter_SnapshotFormat_Name(value);
}
static inline bool SnapshotFormat_Parse(const ::std::string& name,
SnapshotFormat* value) {
return SolverParameter_SnapshotFormat_Parse(name, value);
}
typedef SolverParameter_SolverMode SolverMode;
static const SolverMode CPU =
SolverParameter_SolverMode_CPU;
static const SolverMode GPU =
SolverParameter_SolverMode_GPU;
static inline bool SolverMode_IsValid(int value) {
return SolverParameter_SolverMode_IsValid(value);
}
static const SolverMode SolverMode_MIN =
SolverParameter_SolverMode_SolverMode_MIN;
static const SolverMode SolverMode_MAX =
SolverParameter_SolverMode_SolverMode_MAX;
static const int SolverMode_ARRAYSIZE =
SolverParameter_SolverMode_SolverMode_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
SolverMode_descriptor() {
return SolverParameter_SolverMode_descriptor();
}
static inline const ::std::string& SolverMode_Name(SolverMode value) {
return SolverParameter_SolverMode_Name(value);
}
static inline bool SolverMode_Parse(const ::std::string& name,
SolverMode* value) {
return SolverParameter_SolverMode_Parse(name, value);
}
typedef SolverParameter_SolverType SolverType;
static const SolverType SGD =
SolverParameter_SolverType_SGD;
static const SolverType NESTEROV =
SolverParameter_SolverType_NESTEROV;
static const SolverType ADAGRAD =
SolverParameter_SolverType_ADAGRAD;
static const SolverType RMSPROP =
SolverParameter_SolverType_RMSPROP;
static const SolverType ADADELTA =
SolverParameter_SolverType_ADADELTA;
static const SolverType ADAM =
SolverParameter_SolverType_ADAM;
static inline bool SolverType_IsValid(int value) {
return SolverParameter_SolverType_IsValid(value);
}
static const SolverType SolverType_MIN =
SolverParameter_SolverType_SolverType_MIN;
static const SolverType SolverType_MAX =
SolverParameter_SolverType_SolverType_MAX;
static const int SolverType_ARRAYSIZE =
SolverParameter_SolverType_SolverType_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
SolverType_descriptor() {
return SolverParameter_SolverType_descriptor();
}
static inline const ::std::string& SolverType_Name(SolverType value) {
return SolverParameter_SolverType_Name(value);
}
static inline bool SolverType_Parse(const ::std::string& name,
SolverType* value) {
return SolverParameter_SolverType_Parse(name, value);
}
// accessors -------------------------------------------------------
// repeated string test_net = 2;
int test_net_size() const;
void clear_test_net();
static const int kTestNetFieldNumber = 2;
const ::std::string& test_net(int index) const;
::std::string* mutable_test_net(int index);
void set_test_net(int index, const ::std::string& value);
#if LANG_CXX11
void set_test_net(int index, ::std::string&& value);
#endif
void set_test_net(int index, const char* value);
void set_test_net(int index, const char* value, size_t size);
::std::string* add_test_net();
void add_test_net(const ::std::string& value);
#if LANG_CXX11
void add_test_net(::std::string&& value);
#endif
void add_test_net(const char* value);
void add_test_net(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& test_net() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_test_net();
// repeated int32 test_iter = 3;
int test_iter_size() const;
void clear_test_iter();
static const int kTestIterFieldNumber = 3;
::google::protobuf::int32 test_iter(int index) const;
void set_test_iter(int index, ::google::protobuf::int32 value);
void add_test_iter(::google::protobuf::int32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
test_iter() const;
::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_test_iter();
// repeated .opencv_caffe.NetParameter test_net_param = 22;
int test_net_param_size() const;
void clear_test_net_param();
static const int kTestNetParamFieldNumber = 22;
const ::opencv_caffe::NetParameter& test_net_param(int index) const;
::opencv_caffe::NetParameter* mutable_test_net_param(int index);
::opencv_caffe::NetParameter* add_test_net_param();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetParameter >*
mutable_test_net_param();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetParameter >&
test_net_param() const;
// repeated .opencv_caffe.NetState test_state = 27;
int test_state_size() const;
void clear_test_state();
static const int kTestStateFieldNumber = 27;
const ::opencv_caffe::NetState& test_state(int index) const;
::opencv_caffe::NetState* mutable_test_state(int index);
::opencv_caffe::NetState* add_test_state();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetState >*
mutable_test_state();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetState >&
test_state() const;
// repeated int32 stepvalue = 34;
int stepvalue_size() const;
void clear_stepvalue();
static const int kStepvalueFieldNumber = 34;
::google::protobuf::int32 stepvalue(int index) const;
void set_stepvalue(int index, ::google::protobuf::int32 value);
void add_stepvalue(::google::protobuf::int32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
stepvalue() const;
::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_stepvalue();
// optional string train_net = 1;
bool has_train_net() const;
void clear_train_net();
static const int kTrainNetFieldNumber = 1;
const ::std::string& train_net() const;
void set_train_net(const ::std::string& value);
#if LANG_CXX11
void set_train_net(::std::string&& value);
#endif
void set_train_net(const char* value);
void set_train_net(const char* value, size_t size);
::std::string* mutable_train_net();
::std::string* release_train_net();
void set_allocated_train_net(::std::string* train_net);
// optional string lr_policy = 8;
bool has_lr_policy() const;
void clear_lr_policy();
static const int kLrPolicyFieldNumber = 8;
const ::std::string& lr_policy() const;
void set_lr_policy(const ::std::string& value);
#if LANG_CXX11
void set_lr_policy(::std::string&& value);
#endif
void set_lr_policy(const char* value);
void set_lr_policy(const char* value, size_t size);
::std::string* mutable_lr_policy();
::std::string* release_lr_policy();
void set_allocated_lr_policy(::std::string* lr_policy);
// optional string snapshot_prefix = 15;
bool has_snapshot_prefix() const;
void clear_snapshot_prefix();
static const int kSnapshotPrefixFieldNumber = 15;
const ::std::string& snapshot_prefix() const;
void set_snapshot_prefix(const ::std::string& value);
#if LANG_CXX11
void set_snapshot_prefix(::std::string&& value);
#endif
void set_snapshot_prefix(const char* value);
void set_snapshot_prefix(const char* value, size_t size);
::std::string* mutable_snapshot_prefix();
::std::string* release_snapshot_prefix();
void set_allocated_snapshot_prefix(::std::string* snapshot_prefix);
// optional string net = 24;
bool has_net() const;
void clear_net();
static const int kNetFieldNumber = 24;
const ::std::string& net() const;
void set_net(const ::std::string& value);
#if LANG_CXX11
void set_net(::std::string&& value);
#endif
void set_net(const char* value);
void set_net(const char* value, size_t size);
::std::string* mutable_net();
::std::string* release_net();
void set_allocated_net(::std::string* net);
// optional string regularization_type = 29 [default = "L2"];
bool has_regularization_type() const;
void clear_regularization_type();
static const int kRegularizationTypeFieldNumber = 29;
const ::std::string& regularization_type() const;
void set_regularization_type(const ::std::string& value);
#if LANG_CXX11
void set_regularization_type(::std::string&& value);
#endif
void set_regularization_type(const char* value);
void set_regularization_type(const char* value, size_t size);
::std::string* mutable_regularization_type();
::std::string* release_regularization_type();
void set_allocated_regularization_type(::std::string* regularization_type);
// optional string type = 40 [default = "SGD"];
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 40;
const ::std::string& type() const;
void set_type(const ::std::string& value);
#if LANG_CXX11
void set_type(::std::string&& value);
#endif
void set_type(const char* value);
void set_type(const char* value, size_t size);
::std::string* mutable_type();
::std::string* release_type();
void set_allocated_type(::std::string* type);
// optional .opencv_caffe.NetParameter train_net_param = 21;
bool has_train_net_param() const;
void clear_train_net_param();
static const int kTrainNetParamFieldNumber = 21;
const ::opencv_caffe::NetParameter& train_net_param() const;
::opencv_caffe::NetParameter* release_train_net_param();
::opencv_caffe::NetParameter* mutable_train_net_param();
void set_allocated_train_net_param(::opencv_caffe::NetParameter* train_net_param);
// optional .opencv_caffe.NetParameter net_param = 25;
bool has_net_param() const;
void clear_net_param();
static const int kNetParamFieldNumber = 25;
const ::opencv_caffe::NetParameter& net_param() const;
::opencv_caffe::NetParameter* release_net_param();
::opencv_caffe::NetParameter* mutable_net_param();
void set_allocated_net_param(::opencv_caffe::NetParameter* net_param);
// optional .opencv_caffe.NetState train_state = 26;
bool has_train_state() const;
void clear_train_state();
static const int kTrainStateFieldNumber = 26;
const ::opencv_caffe::NetState& train_state() const;
::opencv_caffe::NetState* release_train_state();
::opencv_caffe::NetState* mutable_train_state();
void set_allocated_train_state(::opencv_caffe::NetState* train_state);
// optional int32 test_interval = 4 [default = 0];
bool has_test_interval() const;
void clear_test_interval();
static const int kTestIntervalFieldNumber = 4;
::google::protobuf::int32 test_interval() const;
void set_test_interval(::google::protobuf::int32 value);
// optional float base_lr = 5;
bool has_base_lr() const;
void clear_base_lr();
static const int kBaseLrFieldNumber = 5;
float base_lr() const;
void set_base_lr(float value);
// optional int32 display = 6;
bool has_display() const;
void clear_display();
static const int kDisplayFieldNumber = 6;
::google::protobuf::int32 display() const;
void set_display(::google::protobuf::int32 value);
// optional int32 max_iter = 7;
bool has_max_iter() const;
void clear_max_iter();
static const int kMaxIterFieldNumber = 7;
::google::protobuf::int32 max_iter() const;
void set_max_iter(::google::protobuf::int32 value);
// optional float gamma = 9;
bool has_gamma() const;
void clear_gamma();
static const int kGammaFieldNumber = 9;
float gamma() const;
void set_gamma(float value);
// optional float power = 10;
bool has_power() const;
void clear_power();
static const int kPowerFieldNumber = 10;
float power() const;
void set_power(float value);
// optional float momentum = 11;
bool has_momentum() const;
void clear_momentum();
static const int kMomentumFieldNumber = 11;
float momentum() const;
void set_momentum(float value);
// optional float weight_decay = 12;
bool has_weight_decay() const;
void clear_weight_decay();
static const int kWeightDecayFieldNumber = 12;
float weight_decay() const;
void set_weight_decay(float value);
// optional int32 stepsize = 13;
bool has_stepsize() const;
void clear_stepsize();
static const int kStepsizeFieldNumber = 13;
::google::protobuf::int32 stepsize() const;
void set_stepsize(::google::protobuf::int32 value);
// optional int32 snapshot = 14 [default = 0];
bool has_snapshot() const;
void clear_snapshot();
static const int kSnapshotFieldNumber = 14;
::google::protobuf::int32 snapshot() const;
void set_snapshot(::google::protobuf::int32 value);
// optional int32 device_id = 18 [default = 0];
bool has_device_id() const;
void clear_device_id();
static const int kDeviceIdFieldNumber = 18;
::google::protobuf::int32 device_id() const;
void set_device_id(::google::protobuf::int32 value);
// optional bool test_compute_loss = 19 [default = false];
bool has_test_compute_loss() const;
void clear_test_compute_loss();
static const int kTestComputeLossFieldNumber = 19;
bool test_compute_loss() const;
void set_test_compute_loss(bool value);
// optional bool snapshot_diff = 16 [default = false];
bool has_snapshot_diff() const;
void clear_snapshot_diff();
static const int kSnapshotDiffFieldNumber = 16;
bool snapshot_diff() const;
void set_snapshot_diff(bool value);
// optional bool debug_info = 23 [default = false];
bool has_debug_info() const;
void clear_debug_info();
static const int kDebugInfoFieldNumber = 23;
bool debug_info() const;
void set_debug_info(bool value);
// optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
bool has_solver_type() const;
void clear_solver_type();
static const int kSolverTypeFieldNumber = 30;
::opencv_caffe::SolverParameter_SolverType solver_type() const;
void set_solver_type(::opencv_caffe::SolverParameter_SolverType value);
// optional float momentum2 = 39 [default = 0.999];
bool has_momentum2() const;
void clear_momentum2();
static const int kMomentum2FieldNumber = 39;
float momentum2() const;
void set_momentum2(float value);
// optional int64 random_seed = 20 [default = -1];
bool has_random_seed() const;
void clear_random_seed();
static const int kRandomSeedFieldNumber = 20;
::google::protobuf::int64 random_seed() const;
void set_random_seed(::google::protobuf::int64 value);
// optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
bool has_solver_mode() const;
void clear_solver_mode();
static const int kSolverModeFieldNumber = 17;
::opencv_caffe::SolverParameter_SolverMode solver_mode() const;
void set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value);
// optional bool test_initialization = 32 [default = true];
bool has_test_initialization() const;
void clear_test_initialization();
static const int kTestInitializationFieldNumber = 32;
bool test_initialization() const;
void set_test_initialization(bool value);
// optional bool snapshot_after_train = 28 [default = true];
bool has_snapshot_after_train() const;
void clear_snapshot_after_train();
static const int kSnapshotAfterTrainFieldNumber = 28;
bool snapshot_after_train() const;
void set_snapshot_after_train(bool value);
// optional float delta = 31 [default = 1e-08];
bool has_delta() const;
void clear_delta();
static const int kDeltaFieldNumber = 31;
float delta() const;
void set_delta(float value);
// optional int32 average_loss = 33 [default = 1];
bool has_average_loss() const;
void clear_average_loss();
static const int kAverageLossFieldNumber = 33;
::google::protobuf::int32 average_loss() const;
void set_average_loss(::google::protobuf::int32 value);
// optional float clip_gradients = 35 [default = -1];
bool has_clip_gradients() const;
void clear_clip_gradients();
static const int kClipGradientsFieldNumber = 35;
float clip_gradients() const;
void set_clip_gradients(float value);
// optional int32 iter_size = 36 [default = 1];
bool has_iter_size() const;
void clear_iter_size();
static const int kIterSizeFieldNumber = 36;
::google::protobuf::int32 iter_size() const;
void set_iter_size(::google::protobuf::int32 value);
// optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
bool has_snapshot_format() const;
void clear_snapshot_format();
static const int kSnapshotFormatFieldNumber = 37;
::opencv_caffe::SolverParameter_SnapshotFormat snapshot_format() const;
void set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value);
// optional float rms_decay = 38 [default = 0.99];
bool has_rms_decay() const;
void clear_rms_decay();
static const int kRmsDecayFieldNumber = 38;
float rms_decay() const;
void set_rms_decay(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.SolverParameter)
private:
void set_has_net();
void clear_has_net();
void set_has_net_param();
void clear_has_net_param();
void set_has_train_net();
void clear_has_train_net();
void set_has_train_net_param();
void clear_has_train_net_param();
void set_has_train_state();
void clear_has_train_state();
void set_has_test_interval();
void clear_has_test_interval();
void set_has_test_compute_loss();
void clear_has_test_compute_loss();
void set_has_test_initialization();
void clear_has_test_initialization();
void set_has_base_lr();
void clear_has_base_lr();
void set_has_display();
void clear_has_display();
void set_has_average_loss();
void clear_has_average_loss();
void set_has_max_iter();
void clear_has_max_iter();
void set_has_iter_size();
void clear_has_iter_size();
void set_has_lr_policy();
void clear_has_lr_policy();
void set_has_gamma();
void clear_has_gamma();
void set_has_power();
void clear_has_power();
void set_has_momentum();
void clear_has_momentum();
void set_has_weight_decay();
void clear_has_weight_decay();
void set_has_regularization_type();
void clear_has_regularization_type();
void set_has_stepsize();
void clear_has_stepsize();
void set_has_clip_gradients();
void clear_has_clip_gradients();
void set_has_snapshot();
void clear_has_snapshot();
void set_has_snapshot_prefix();
void clear_has_snapshot_prefix();
void set_has_snapshot_diff();
void clear_has_snapshot_diff();
void set_has_snapshot_format();
void clear_has_snapshot_format();
void set_has_solver_mode();
void clear_has_solver_mode();
void set_has_device_id();
void clear_has_device_id();
void set_has_random_seed();
void clear_has_random_seed();
void set_has_type();
void clear_has_type();
void set_has_delta();
void clear_has_delta();
void set_has_momentum2();
void clear_has_momentum2();
void set_has_rms_decay();
void clear_has_rms_decay();
void set_has_debug_info();
void clear_has_debug_info();
void set_has_snapshot_after_train();
void clear_has_snapshot_after_train();
void set_has_solver_type();
void clear_has_solver_type();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<2> _has_bits_;
::google::protobuf::RepeatedPtrField< ::std::string> test_net_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > test_iter_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetParameter > test_net_param_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetState > test_state_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > stepvalue_;
::google::protobuf::internal::ArenaStringPtr train_net_;
::google::protobuf::internal::ArenaStringPtr lr_policy_;
::google::protobuf::internal::ArenaStringPtr snapshot_prefix_;
::google::protobuf::internal::ArenaStringPtr net_;
static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _default_regularization_type_;
::google::protobuf::internal::ArenaStringPtr regularization_type_;
static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _default_type_;
::google::protobuf::internal::ArenaStringPtr type_;
::opencv_caffe::NetParameter* train_net_param_;
::opencv_caffe::NetParameter* net_param_;
::opencv_caffe::NetState* train_state_;
::google::protobuf::int32 test_interval_;
float base_lr_;
::google::protobuf::int32 display_;
::google::protobuf::int32 max_iter_;
float gamma_;
float power_;
float momentum_;
float weight_decay_;
::google::protobuf::int32 stepsize_;
::google::protobuf::int32 snapshot_;
::google::protobuf::int32 device_id_;
bool test_compute_loss_;
bool snapshot_diff_;
bool debug_info_;
int solver_type_;
float momentum2_;
::google::protobuf::int64 random_seed_;
int solver_mode_;
bool test_initialization_;
bool snapshot_after_train_;
float delta_;
::google::protobuf::int32 average_loss_;
float clip_gradients_;
::google::protobuf::int32 iter_size_;
int snapshot_format_;
float rms_decay_;
mutable int _cached_size_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSolverParameterImpl();
};
// -------------------------------------------------------------------
class SolverState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SolverState) */ {
public:
SolverState();
virtual ~SolverState();
SolverState(const SolverState& from);
inline SolverState& operator=(const SolverState& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
SolverState(SolverState&& from) noexcept
: SolverState() {
*this = ::std::move(from);
}
inline SolverState& operator=(SolverState&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const SolverState& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const SolverState* internal_default_instance() {
return reinterpret_cast<const SolverState*>(
&_SolverState_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
11;
void Swap(SolverState* other);
friend void swap(SolverState& a, SolverState& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline SolverState* New() const PROTOBUF_FINAL { return New(NULL); }
SolverState* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const SolverState& from);
void MergeFrom(const SolverState& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(SolverState* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated .opencv_caffe.BlobProto history = 3;
int history_size() const;
void clear_history();
static const int kHistoryFieldNumber = 3;
const ::opencv_caffe::BlobProto& history(int index) const;
::opencv_caffe::BlobProto* mutable_history(int index);
::opencv_caffe::BlobProto* add_history();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
mutable_history();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
history() const;
// optional string learned_net = 2;
bool has_learned_net() const;
void clear_learned_net();
static const int kLearnedNetFieldNumber = 2;
const ::std::string& learned_net() const;
void set_learned_net(const ::std::string& value);
#if LANG_CXX11
void set_learned_net(::std::string&& value);
#endif
void set_learned_net(const char* value);
void set_learned_net(const char* value, size_t size);
::std::string* mutable_learned_net();
::std::string* release_learned_net();
void set_allocated_learned_net(::std::string* learned_net);
// optional int32 iter = 1;
bool has_iter() const;
void clear_iter();
static const int kIterFieldNumber = 1;
::google::protobuf::int32 iter() const;
void set_iter(::google::protobuf::int32 value);
// optional int32 current_step = 4 [default = 0];
bool has_current_step() const;
void clear_current_step();
static const int kCurrentStepFieldNumber = 4;
::google::protobuf::int32 current_step() const;
void set_current_step(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.SolverState)
private:
void set_has_iter();
void clear_has_iter();
void set_has_learned_net();
void clear_has_learned_net();
void set_has_current_step();
void clear_has_current_step();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto > history_;
::google::protobuf::internal::ArenaStringPtr learned_net_;
::google::protobuf::int32 iter_;
::google::protobuf::int32 current_step_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSolverStateImpl();
};
// -------------------------------------------------------------------
class NetState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetState) */ {
public:
NetState();
virtual ~NetState();
NetState(const NetState& from);
inline NetState& operator=(const NetState& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
NetState(NetState&& from) noexcept
: NetState() {
*this = ::std::move(from);
}
inline NetState& operator=(NetState&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const NetState& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const NetState* internal_default_instance() {
return reinterpret_cast<const NetState*>(
&_NetState_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
12;
void Swap(NetState* other);
friend void swap(NetState& a, NetState& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline NetState* New() const PROTOBUF_FINAL { return New(NULL); }
NetState* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const NetState& from);
void MergeFrom(const NetState& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(NetState* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated string stage = 3;
int stage_size() const;
void clear_stage();
static const int kStageFieldNumber = 3;
const ::std::string& stage(int index) const;
::std::string* mutable_stage(int index);
void set_stage(int index, const ::std::string& value);
#if LANG_CXX11
void set_stage(int index, ::std::string&& value);
#endif
void set_stage(int index, const char* value);
void set_stage(int index, const char* value, size_t size);
::std::string* add_stage();
void add_stage(const ::std::string& value);
#if LANG_CXX11
void add_stage(::std::string&& value);
#endif
void add_stage(const char* value);
void add_stage(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& stage() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_stage();
// optional int32 level = 2 [default = 0];
bool has_level() const;
void clear_level();
static const int kLevelFieldNumber = 2;
::google::protobuf::int32 level() const;
void set_level(::google::protobuf::int32 value);
// optional .opencv_caffe.Phase phase = 1 [default = TEST];
bool has_phase() const;
void clear_phase();
static const int kPhaseFieldNumber = 1;
::opencv_caffe::Phase phase() const;
void set_phase(::opencv_caffe::Phase value);
// @@protoc_insertion_point(class_scope:opencv_caffe.NetState)
private:
void set_has_phase();
void clear_has_phase();
void set_has_level();
void clear_has_level();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField< ::std::string> stage_;
::google::protobuf::int32 level_;
int phase_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetStateImpl();
};
// -------------------------------------------------------------------
class NetStateRule : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetStateRule) */ {
public:
NetStateRule();
virtual ~NetStateRule();
NetStateRule(const NetStateRule& from);
inline NetStateRule& operator=(const NetStateRule& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
NetStateRule(NetStateRule&& from) noexcept
: NetStateRule() {
*this = ::std::move(from);
}
inline NetStateRule& operator=(NetStateRule&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const NetStateRule& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const NetStateRule* internal_default_instance() {
return reinterpret_cast<const NetStateRule*>(
&_NetStateRule_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
13;
void Swap(NetStateRule* other);
friend void swap(NetStateRule& a, NetStateRule& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline NetStateRule* New() const PROTOBUF_FINAL { return New(NULL); }
NetStateRule* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const NetStateRule& from);
void MergeFrom(const NetStateRule& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(NetStateRule* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated string stage = 4;
int stage_size() const;
void clear_stage();
static const int kStageFieldNumber = 4;
const ::std::string& stage(int index) const;
::std::string* mutable_stage(int index);
void set_stage(int index, const ::std::string& value);
#if LANG_CXX11
void set_stage(int index, ::std::string&& value);
#endif
void set_stage(int index, const char* value);
void set_stage(int index, const char* value, size_t size);
::std::string* add_stage();
void add_stage(const ::std::string& value);
#if LANG_CXX11
void add_stage(::std::string&& value);
#endif
void add_stage(const char* value);
void add_stage(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& stage() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_stage();
// repeated string not_stage = 5;
int not_stage_size() const;
void clear_not_stage();
static const int kNotStageFieldNumber = 5;
const ::std::string& not_stage(int index) const;
::std::string* mutable_not_stage(int index);
void set_not_stage(int index, const ::std::string& value);
#if LANG_CXX11
void set_not_stage(int index, ::std::string&& value);
#endif
void set_not_stage(int index, const char* value);
void set_not_stage(int index, const char* value, size_t size);
::std::string* add_not_stage();
void add_not_stage(const ::std::string& value);
#if LANG_CXX11
void add_not_stage(::std::string&& value);
#endif
void add_not_stage(const char* value);
void add_not_stage(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& not_stage() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_not_stage();
// optional .opencv_caffe.Phase phase = 1;
bool has_phase() const;
void clear_phase();
static const int kPhaseFieldNumber = 1;
::opencv_caffe::Phase phase() const;
void set_phase(::opencv_caffe::Phase value);
// optional int32 min_level = 2;
bool has_min_level() const;
void clear_min_level();
static const int kMinLevelFieldNumber = 2;
::google::protobuf::int32 min_level() const;
void set_min_level(::google::protobuf::int32 value);
// optional int32 max_level = 3;
bool has_max_level() const;
void clear_max_level();
static const int kMaxLevelFieldNumber = 3;
::google::protobuf::int32 max_level() const;
void set_max_level(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.NetStateRule)
private:
void set_has_phase();
void clear_has_phase();
void set_has_min_level();
void clear_has_min_level();
void set_has_max_level();
void clear_has_max_level();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField< ::std::string> stage_;
::google::protobuf::RepeatedPtrField< ::std::string> not_stage_;
int phase_;
::google::protobuf::int32 min_level_;
::google::protobuf::int32 max_level_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetStateRuleImpl();
};
// -------------------------------------------------------------------
class ParamSpec : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ParamSpec) */ {
public:
ParamSpec();
virtual ~ParamSpec();
ParamSpec(const ParamSpec& from);
inline ParamSpec& operator=(const ParamSpec& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ParamSpec(ParamSpec&& from) noexcept
: ParamSpec() {
*this = ::std::move(from);
}
inline ParamSpec& operator=(ParamSpec&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ParamSpec& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ParamSpec* internal_default_instance() {
return reinterpret_cast<const ParamSpec*>(
&_ParamSpec_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
14;
void Swap(ParamSpec* other);
friend void swap(ParamSpec& a, ParamSpec& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ParamSpec* New() const PROTOBUF_FINAL { return New(NULL); }
ParamSpec* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ParamSpec& from);
void MergeFrom(const ParamSpec& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ParamSpec* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef ParamSpec_DimCheckMode DimCheckMode;
static const DimCheckMode STRICT =
ParamSpec_DimCheckMode_STRICT;
static const DimCheckMode PERMISSIVE =
ParamSpec_DimCheckMode_PERMISSIVE;
static inline bool DimCheckMode_IsValid(int value) {
return ParamSpec_DimCheckMode_IsValid(value);
}
static const DimCheckMode DimCheckMode_MIN =
ParamSpec_DimCheckMode_DimCheckMode_MIN;
static const DimCheckMode DimCheckMode_MAX =
ParamSpec_DimCheckMode_DimCheckMode_MAX;
static const int DimCheckMode_ARRAYSIZE =
ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
DimCheckMode_descriptor() {
return ParamSpec_DimCheckMode_descriptor();
}
static inline const ::std::string& DimCheckMode_Name(DimCheckMode value) {
return ParamSpec_DimCheckMode_Name(value);
}
static inline bool DimCheckMode_Parse(const ::std::string& name,
DimCheckMode* value) {
return ParamSpec_DimCheckMode_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional string name = 1;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string& name() const;
void set_name(const ::std::string& value);
#if LANG_CXX11
void set_name(::std::string&& value);
#endif
void set_name(const char* value);
void set_name(const char* value, size_t size);
::std::string* mutable_name();
::std::string* release_name();
void set_allocated_name(::std::string* name);
// optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2;
bool has_share_mode() const;
void clear_share_mode();
static const int kShareModeFieldNumber = 2;
::opencv_caffe::ParamSpec_DimCheckMode share_mode() const;
void set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value);
// optional float lr_mult = 3 [default = 1];
bool has_lr_mult() const;
void clear_lr_mult();
static const int kLrMultFieldNumber = 3;
float lr_mult() const;
void set_lr_mult(float value);
// optional float decay_mult = 4 [default = 1];
bool has_decay_mult() const;
void clear_decay_mult();
static const int kDecayMultFieldNumber = 4;
float decay_mult() const;
void set_decay_mult(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ParamSpec)
private:
void set_has_name();
void clear_has_name();
void set_has_share_mode();
void clear_has_share_mode();
void set_has_lr_mult();
void clear_has_lr_mult();
void set_has_decay_mult();
void clear_has_decay_mult();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr name_;
int share_mode_;
float lr_mult_;
float decay_mult_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsParamSpecImpl();
};
// -------------------------------------------------------------------
class LayerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LayerParameter) */ {
public:
LayerParameter();
virtual ~LayerParameter();
LayerParameter(const LayerParameter& from);
inline LayerParameter& operator=(const LayerParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
LayerParameter(LayerParameter&& from) noexcept
: LayerParameter() {
*this = ::std::move(from);
}
inline LayerParameter& operator=(LayerParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const LayerParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const LayerParameter* internal_default_instance() {
return reinterpret_cast<const LayerParameter*>(
&_LayerParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
15;
void Swap(LayerParameter* other);
friend void swap(LayerParameter& a, LayerParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline LayerParameter* New() const PROTOBUF_FINAL { return New(NULL); }
LayerParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const LayerParameter& from);
void MergeFrom(const LayerParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(LayerParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated string bottom = 3;
int bottom_size() const;
void clear_bottom();
static const int kBottomFieldNumber = 3;
const ::std::string& bottom(int index) const;
::std::string* mutable_bottom(int index);
void set_bottom(int index, const ::std::string& value);
#if LANG_CXX11
void set_bottom(int index, ::std::string&& value);
#endif
void set_bottom(int index, const char* value);
void set_bottom(int index, const char* value, size_t size);
::std::string* add_bottom();
void add_bottom(const ::std::string& value);
#if LANG_CXX11
void add_bottom(::std::string&& value);
#endif
void add_bottom(const char* value);
void add_bottom(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& bottom() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_bottom();
// repeated string top = 4;
int top_size() const;
void clear_top();
static const int kTopFieldNumber = 4;
const ::std::string& top(int index) const;
::std::string* mutable_top(int index);
void set_top(int index, const ::std::string& value);
#if LANG_CXX11
void set_top(int index, ::std::string&& value);
#endif
void set_top(int index, const char* value);
void set_top(int index, const char* value, size_t size);
::std::string* add_top();
void add_top(const ::std::string& value);
#if LANG_CXX11
void add_top(::std::string&& value);
#endif
void add_top(const char* value);
void add_top(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& top() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_top();
// repeated float loss_weight = 5;
int loss_weight_size() const;
void clear_loss_weight();
static const int kLossWeightFieldNumber = 5;
float loss_weight(int index) const;
void set_loss_weight(int index, float value);
void add_loss_weight(float value);
const ::google::protobuf::RepeatedField< float >&
loss_weight() const;
::google::protobuf::RepeatedField< float >*
mutable_loss_weight();
// repeated .opencv_caffe.ParamSpec param = 6;
int param_size() const;
void clear_param();
static const int kParamFieldNumber = 6;
const ::opencv_caffe::ParamSpec& param(int index) const;
::opencv_caffe::ParamSpec* mutable_param(int index);
::opencv_caffe::ParamSpec* add_param();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::ParamSpec >*
mutable_param();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::ParamSpec >&
param() const;
// repeated .opencv_caffe.BlobProto blobs = 7;
int blobs_size() const;
void clear_blobs();
static const int kBlobsFieldNumber = 7;
const ::opencv_caffe::BlobProto& blobs(int index) const;
::opencv_caffe::BlobProto* mutable_blobs(int index);
::opencv_caffe::BlobProto* add_blobs();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
mutable_blobs();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
blobs() const;
// repeated .opencv_caffe.NetStateRule include = 8;
int include_size() const;
void clear_include();
static const int kIncludeFieldNumber = 8;
const ::opencv_caffe::NetStateRule& include(int index) const;
::opencv_caffe::NetStateRule* mutable_include(int index);
::opencv_caffe::NetStateRule* add_include();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
mutable_include();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
include() const;
// repeated .opencv_caffe.NetStateRule exclude = 9;
int exclude_size() const;
void clear_exclude();
static const int kExcludeFieldNumber = 9;
const ::opencv_caffe::NetStateRule& exclude(int index) const;
::opencv_caffe::NetStateRule* mutable_exclude(int index);
::opencv_caffe::NetStateRule* add_exclude();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
mutable_exclude();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
exclude() const;
// repeated bool propagate_down = 11;
int propagate_down_size() const;
void clear_propagate_down();
static const int kPropagateDownFieldNumber = 11;
bool propagate_down(int index) const;
void set_propagate_down(int index, bool value);
void add_propagate_down(bool value);
const ::google::protobuf::RepeatedField< bool >&
propagate_down() const;
::google::protobuf::RepeatedField< bool >*
mutable_propagate_down();
// optional string name = 1;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string& name() const;
void set_name(const ::std::string& value);
#if LANG_CXX11
void set_name(::std::string&& value);
#endif
void set_name(const char* value);
void set_name(const char* value, size_t size);
::std::string* mutable_name();
::std::string* release_name();
void set_allocated_name(::std::string* name);
// optional string type = 2;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 2;
const ::std::string& type() const;
void set_type(const ::std::string& value);
#if LANG_CXX11
void set_type(::std::string&& value);
#endif
void set_type(const char* value);
void set_type(const char* value, size_t size);
::std::string* mutable_type();
::std::string* release_type();
void set_allocated_type(::std::string* type);
// optional .opencv_caffe.TransformationParameter transform_param = 100;
bool has_transform_param() const;
void clear_transform_param();
static const int kTransformParamFieldNumber = 100;
const ::opencv_caffe::TransformationParameter& transform_param() const;
::opencv_caffe::TransformationParameter* release_transform_param();
::opencv_caffe::TransformationParameter* mutable_transform_param();
void set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param);
// optional .opencv_caffe.LossParameter loss_param = 101;
bool has_loss_param() const;
void clear_loss_param();
static const int kLossParamFieldNumber = 101;
const ::opencv_caffe::LossParameter& loss_param() const;
::opencv_caffe::LossParameter* release_loss_param();
::opencv_caffe::LossParameter* mutable_loss_param();
void set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param);
// optional .opencv_caffe.AccuracyParameter accuracy_param = 102;
bool has_accuracy_param() const;
void clear_accuracy_param();
static const int kAccuracyParamFieldNumber = 102;
const ::opencv_caffe::AccuracyParameter& accuracy_param() const;
::opencv_caffe::AccuracyParameter* release_accuracy_param();
::opencv_caffe::AccuracyParameter* mutable_accuracy_param();
void set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param);
// optional .opencv_caffe.ArgMaxParameter argmax_param = 103;
bool has_argmax_param() const;
void clear_argmax_param();
static const int kArgmaxParamFieldNumber = 103;
const ::opencv_caffe::ArgMaxParameter& argmax_param() const;
::opencv_caffe::ArgMaxParameter* release_argmax_param();
::opencv_caffe::ArgMaxParameter* mutable_argmax_param();
void set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param);
// optional .opencv_caffe.ConcatParameter concat_param = 104;
bool has_concat_param() const;
void clear_concat_param();
static const int kConcatParamFieldNumber = 104;
const ::opencv_caffe::ConcatParameter& concat_param() const;
::opencv_caffe::ConcatParameter* release_concat_param();
::opencv_caffe::ConcatParameter* mutable_concat_param();
void set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param);
// optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105;
bool has_contrastive_loss_param() const;
void clear_contrastive_loss_param();
static const int kContrastiveLossParamFieldNumber = 105;
const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param() const;
::opencv_caffe::ContrastiveLossParameter* release_contrastive_loss_param();
::opencv_caffe::ContrastiveLossParameter* mutable_contrastive_loss_param();
void set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param);
// optional .opencv_caffe.ConvolutionParameter convolution_param = 106;
bool has_convolution_param() const;
void clear_convolution_param();
static const int kConvolutionParamFieldNumber = 106;
const ::opencv_caffe::ConvolutionParameter& convolution_param() const;
::opencv_caffe::ConvolutionParameter* release_convolution_param();
::opencv_caffe::ConvolutionParameter* mutable_convolution_param();
void set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param);
// optional .opencv_caffe.DataParameter data_param = 107;
bool has_data_param() const;
void clear_data_param();
static const int kDataParamFieldNumber = 107;
const ::opencv_caffe::DataParameter& data_param() const;
::opencv_caffe::DataParameter* release_data_param();
::opencv_caffe::DataParameter* mutable_data_param();
void set_allocated_data_param(::opencv_caffe::DataParameter* data_param);
// optional .opencv_caffe.DropoutParameter dropout_param = 108;
bool has_dropout_param() const;
void clear_dropout_param();
static const int kDropoutParamFieldNumber = 108;
const ::opencv_caffe::DropoutParameter& dropout_param() const;
::opencv_caffe::DropoutParameter* release_dropout_param();
::opencv_caffe::DropoutParameter* mutable_dropout_param();
void set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param);
// optional .opencv_caffe.DummyDataParameter dummy_data_param = 109;
bool has_dummy_data_param() const;
void clear_dummy_data_param();
static const int kDummyDataParamFieldNumber = 109;
const ::opencv_caffe::DummyDataParameter& dummy_data_param() const;
::opencv_caffe::DummyDataParameter* release_dummy_data_param();
::opencv_caffe::DummyDataParameter* mutable_dummy_data_param();
void set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param);
// optional .opencv_caffe.EltwiseParameter eltwise_param = 110;
bool has_eltwise_param() const;
void clear_eltwise_param();
static const int kEltwiseParamFieldNumber = 110;
const ::opencv_caffe::EltwiseParameter& eltwise_param() const;
::opencv_caffe::EltwiseParameter* release_eltwise_param();
::opencv_caffe::EltwiseParameter* mutable_eltwise_param();
void set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param);
// optional .opencv_caffe.ExpParameter exp_param = 111;
bool has_exp_param() const;
void clear_exp_param();
static const int kExpParamFieldNumber = 111;
const ::opencv_caffe::ExpParameter& exp_param() const;
::opencv_caffe::ExpParameter* release_exp_param();
::opencv_caffe::ExpParameter* mutable_exp_param();
void set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param);
// optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112;
bool has_hdf5_data_param() const;
void clear_hdf5_data_param();
static const int kHdf5DataParamFieldNumber = 112;
const ::opencv_caffe::HDF5DataParameter& hdf5_data_param() const;
::opencv_caffe::HDF5DataParameter* release_hdf5_data_param();
::opencv_caffe::HDF5DataParameter* mutable_hdf5_data_param();
void set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param);
// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113;
bool has_hdf5_output_param() const;
void clear_hdf5_output_param();
static const int kHdf5OutputParamFieldNumber = 113;
const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const;
::opencv_caffe::HDF5OutputParameter* release_hdf5_output_param();
::opencv_caffe::HDF5OutputParameter* mutable_hdf5_output_param();
void set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
// optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114;
bool has_hinge_loss_param() const;
void clear_hinge_loss_param();
static const int kHingeLossParamFieldNumber = 114;
const ::opencv_caffe::HingeLossParameter& hinge_loss_param() const;
::opencv_caffe::HingeLossParameter* release_hinge_loss_param();
::opencv_caffe::HingeLossParameter* mutable_hinge_loss_param();
void set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param);
// optional .opencv_caffe.ImageDataParameter image_data_param = 115;
bool has_image_data_param() const;
void clear_image_data_param();
static const int kImageDataParamFieldNumber = 115;
const ::opencv_caffe::ImageDataParameter& image_data_param() const;
::opencv_caffe::ImageDataParameter* release_image_data_param();
::opencv_caffe::ImageDataParameter* mutable_image_data_param();
void set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param);
// optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116;
bool has_infogain_loss_param() const;
void clear_infogain_loss_param();
static const int kInfogainLossParamFieldNumber = 116;
const ::opencv_caffe::InfogainLossParameter& infogain_loss_param() const;
::opencv_caffe::InfogainLossParameter* release_infogain_loss_param();
::opencv_caffe::InfogainLossParameter* mutable_infogain_loss_param();
void set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param);
// optional .opencv_caffe.InnerProductParameter inner_product_param = 117;
bool has_inner_product_param() const;
void clear_inner_product_param();
static const int kInnerProductParamFieldNumber = 117;
const ::opencv_caffe::InnerProductParameter& inner_product_param() const;
::opencv_caffe::InnerProductParameter* release_inner_product_param();
::opencv_caffe::InnerProductParameter* mutable_inner_product_param();
void set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param);
// optional .opencv_caffe.LRNParameter lrn_param = 118;
bool has_lrn_param() const;
void clear_lrn_param();
static const int kLrnParamFieldNumber = 118;
const ::opencv_caffe::LRNParameter& lrn_param() const;
::opencv_caffe::LRNParameter* release_lrn_param();
::opencv_caffe::LRNParameter* mutable_lrn_param();
void set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param);
// optional .opencv_caffe.MemoryDataParameter memory_data_param = 119;
bool has_memory_data_param() const;
void clear_memory_data_param();
static const int kMemoryDataParamFieldNumber = 119;
const ::opencv_caffe::MemoryDataParameter& memory_data_param() const;
::opencv_caffe::MemoryDataParameter* release_memory_data_param();
::opencv_caffe::MemoryDataParameter* mutable_memory_data_param();
void set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param);
// optional .opencv_caffe.MVNParameter mvn_param = 120;
bool has_mvn_param() const;
void clear_mvn_param();
static const int kMvnParamFieldNumber = 120;
const ::opencv_caffe::MVNParameter& mvn_param() const;
::opencv_caffe::MVNParameter* release_mvn_param();
::opencv_caffe::MVNParameter* mutable_mvn_param();
void set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param);
// optional .opencv_caffe.PoolingParameter pooling_param = 121;
bool has_pooling_param() const;
void clear_pooling_param();
static const int kPoolingParamFieldNumber = 121;
const ::opencv_caffe::PoolingParameter& pooling_param() const;
::opencv_caffe::PoolingParameter* release_pooling_param();
::opencv_caffe::PoolingParameter* mutable_pooling_param();
void set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param);
// optional .opencv_caffe.PowerParameter power_param = 122;
bool has_power_param() const;
void clear_power_param();
static const int kPowerParamFieldNumber = 122;
const ::opencv_caffe::PowerParameter& power_param() const;
::opencv_caffe::PowerParameter* release_power_param();
::opencv_caffe::PowerParameter* mutable_power_param();
void set_allocated_power_param(::opencv_caffe::PowerParameter* power_param);
// optional .opencv_caffe.ReLUParameter relu_param = 123;
bool has_relu_param() const;
void clear_relu_param();
static const int kReluParamFieldNumber = 123;
const ::opencv_caffe::ReLUParameter& relu_param() const;
::opencv_caffe::ReLUParameter* release_relu_param();
::opencv_caffe::ReLUParameter* mutable_relu_param();
void set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param);
// optional .opencv_caffe.SigmoidParameter sigmoid_param = 124;
bool has_sigmoid_param() const;
void clear_sigmoid_param();
static const int kSigmoidParamFieldNumber = 124;
const ::opencv_caffe::SigmoidParameter& sigmoid_param() const;
::opencv_caffe::SigmoidParameter* release_sigmoid_param();
::opencv_caffe::SigmoidParameter* mutable_sigmoid_param();
void set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param);
// optional .opencv_caffe.SoftmaxParameter softmax_param = 125;
bool has_softmax_param() const;
void clear_softmax_param();
static const int kSoftmaxParamFieldNumber = 125;
const ::opencv_caffe::SoftmaxParameter& softmax_param() const;
::opencv_caffe::SoftmaxParameter* release_softmax_param();
::opencv_caffe::SoftmaxParameter* mutable_softmax_param();
void set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param);
// optional .opencv_caffe.SliceParameter slice_param = 126;
bool has_slice_param() const;
void clear_slice_param();
static const int kSliceParamFieldNumber = 126;
const ::opencv_caffe::SliceParameter& slice_param() const;
::opencv_caffe::SliceParameter* release_slice_param();
::opencv_caffe::SliceParameter* mutable_slice_param();
void set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param);
// optional .opencv_caffe.TanHParameter tanh_param = 127;
bool has_tanh_param() const;
void clear_tanh_param();
static const int kTanhParamFieldNumber = 127;
const ::opencv_caffe::TanHParameter& tanh_param() const;
::opencv_caffe::TanHParameter* release_tanh_param();
::opencv_caffe::TanHParameter* mutable_tanh_param();
void set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param);
// optional .opencv_caffe.ThresholdParameter threshold_param = 128;
bool has_threshold_param() const;
void clear_threshold_param();
static const int kThresholdParamFieldNumber = 128;
const ::opencv_caffe::ThresholdParameter& threshold_param() const;
::opencv_caffe::ThresholdParameter* release_threshold_param();
::opencv_caffe::ThresholdParameter* mutable_threshold_param();
void set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param);
// optional .opencv_caffe.WindowDataParameter window_data_param = 129;
bool has_window_data_param() const;
void clear_window_data_param();
static const int kWindowDataParamFieldNumber = 129;
const ::opencv_caffe::WindowDataParameter& window_data_param() const;
::opencv_caffe::WindowDataParameter* release_window_data_param();
::opencv_caffe::WindowDataParameter* mutable_window_data_param();
void set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param);
// optional .opencv_caffe.PythonParameter python_param = 130;
bool has_python_param() const;
void clear_python_param();
static const int kPythonParamFieldNumber = 130;
const ::opencv_caffe::PythonParameter& python_param() const;
::opencv_caffe::PythonParameter* release_python_param();
::opencv_caffe::PythonParameter* mutable_python_param();
void set_allocated_python_param(::opencv_caffe::PythonParameter* python_param);
// optional .opencv_caffe.PReLUParameter prelu_param = 131;
bool has_prelu_param() const;
void clear_prelu_param();
static const int kPreluParamFieldNumber = 131;
const ::opencv_caffe::PReLUParameter& prelu_param() const;
::opencv_caffe::PReLUParameter* release_prelu_param();
::opencv_caffe::PReLUParameter* mutable_prelu_param();
void set_allocated_prelu_param(::opencv_caffe::PReLUParameter* prelu_param);
// optional .opencv_caffe.SPPParameter spp_param = 132;
bool has_spp_param() const;
void clear_spp_param();
static const int kSppParamFieldNumber = 132;
const ::opencv_caffe::SPPParameter& spp_param() const;
::opencv_caffe::SPPParameter* release_spp_param();
::opencv_caffe::SPPParameter* mutable_spp_param();
void set_allocated_spp_param(::opencv_caffe::SPPParameter* spp_param);
// optional .opencv_caffe.ReshapeParameter reshape_param = 133;
bool has_reshape_param() const;
void clear_reshape_param();
static const int kReshapeParamFieldNumber = 133;
const ::opencv_caffe::ReshapeParameter& reshape_param() const;
::opencv_caffe::ReshapeParameter* release_reshape_param();
::opencv_caffe::ReshapeParameter* mutable_reshape_param();
void set_allocated_reshape_param(::opencv_caffe::ReshapeParameter* reshape_param);
// optional .opencv_caffe.LogParameter log_param = 134;
bool has_log_param() const;
void clear_log_param();
static const int kLogParamFieldNumber = 134;
const ::opencv_caffe::LogParameter& log_param() const;
::opencv_caffe::LogParameter* release_log_param();
::opencv_caffe::LogParameter* mutable_log_param();
void set_allocated_log_param(::opencv_caffe::LogParameter* log_param);
// optional .opencv_caffe.FlattenParameter flatten_param = 135;
bool has_flatten_param() const;
void clear_flatten_param();
static const int kFlattenParamFieldNumber = 135;
const ::opencv_caffe::FlattenParameter& flatten_param() const;
::opencv_caffe::FlattenParameter* release_flatten_param();
::opencv_caffe::FlattenParameter* mutable_flatten_param();
void set_allocated_flatten_param(::opencv_caffe::FlattenParameter* flatten_param);
// optional .opencv_caffe.ReductionParameter reduction_param = 136;
bool has_reduction_param() const;
void clear_reduction_param();
static const int kReductionParamFieldNumber = 136;
const ::opencv_caffe::ReductionParameter& reduction_param() const;
::opencv_caffe::ReductionParameter* release_reduction_param();
::opencv_caffe::ReductionParameter* mutable_reduction_param();
void set_allocated_reduction_param(::opencv_caffe::ReductionParameter* reduction_param);
// optional .opencv_caffe.EmbedParameter embed_param = 137;
bool has_embed_param() const;
void clear_embed_param();
static const int kEmbedParamFieldNumber = 137;
const ::opencv_caffe::EmbedParameter& embed_param() const;
::opencv_caffe::EmbedParameter* release_embed_param();
::opencv_caffe::EmbedParameter* mutable_embed_param();
void set_allocated_embed_param(::opencv_caffe::EmbedParameter* embed_param);
// optional .opencv_caffe.TileParameter tile_param = 138;
bool has_tile_param() const;
void clear_tile_param();
static const int kTileParamFieldNumber = 138;
const ::opencv_caffe::TileParameter& tile_param() const;
::opencv_caffe::TileParameter* release_tile_param();
::opencv_caffe::TileParameter* mutable_tile_param();
void set_allocated_tile_param(::opencv_caffe::TileParameter* tile_param);
// optional .opencv_caffe.BatchNormParameter batch_norm_param = 139;
bool has_batch_norm_param() const;
void clear_batch_norm_param();
static const int kBatchNormParamFieldNumber = 139;
const ::opencv_caffe::BatchNormParameter& batch_norm_param() const;
::opencv_caffe::BatchNormParameter* release_batch_norm_param();
::opencv_caffe::BatchNormParameter* mutable_batch_norm_param();
void set_allocated_batch_norm_param(::opencv_caffe::BatchNormParameter* batch_norm_param);
// optional .opencv_caffe.ELUParameter elu_param = 140;
bool has_elu_param() const;
void clear_elu_param();
static const int kEluParamFieldNumber = 140;
const ::opencv_caffe::ELUParameter& elu_param() const;
::opencv_caffe::ELUParameter* release_elu_param();
::opencv_caffe::ELUParameter* mutable_elu_param();
void set_allocated_elu_param(::opencv_caffe::ELUParameter* elu_param);
// optional .opencv_caffe.BiasParameter bias_param = 141;
bool has_bias_param() const;
void clear_bias_param();
static const int kBiasParamFieldNumber = 141;
const ::opencv_caffe::BiasParameter& bias_param() const;
::opencv_caffe::BiasParameter* release_bias_param();
::opencv_caffe::BiasParameter* mutable_bias_param();
void set_allocated_bias_param(::opencv_caffe::BiasParameter* bias_param);
// optional .opencv_caffe.ScaleParameter scale_param = 142;
bool has_scale_param() const;
void clear_scale_param();
static const int kScaleParamFieldNumber = 142;
const ::opencv_caffe::ScaleParameter& scale_param() const;
::opencv_caffe::ScaleParameter* release_scale_param();
::opencv_caffe::ScaleParameter* mutable_scale_param();
void set_allocated_scale_param(::opencv_caffe::ScaleParameter* scale_param);
// optional .opencv_caffe.InputParameter input_param = 143;
bool has_input_param() const;
void clear_input_param();
static const int kInputParamFieldNumber = 143;
const ::opencv_caffe::InputParameter& input_param() const;
::opencv_caffe::InputParameter* release_input_param();
::opencv_caffe::InputParameter* mutable_input_param();
void set_allocated_input_param(::opencv_caffe::InputParameter* input_param);
// optional .opencv_caffe.CropParameter crop_param = 144;
bool has_crop_param() const;
void clear_crop_param();
static const int kCropParamFieldNumber = 144;
const ::opencv_caffe::CropParameter& crop_param() const;
::opencv_caffe::CropParameter* release_crop_param();
::opencv_caffe::CropParameter* mutable_crop_param();
void set_allocated_crop_param(::opencv_caffe::CropParameter* crop_param);
// optional .opencv_caffe.ParameterParameter parameter_param = 145;
bool has_parameter_param() const;
void clear_parameter_param();
static const int kParameterParamFieldNumber = 145;
const ::opencv_caffe::ParameterParameter& parameter_param() const;
::opencv_caffe::ParameterParameter* release_parameter_param();
::opencv_caffe::ParameterParameter* mutable_parameter_param();
void set_allocated_parameter_param(::opencv_caffe::ParameterParameter* parameter_param);
// optional .opencv_caffe.RecurrentParameter recurrent_param = 146;
bool has_recurrent_param() const;
void clear_recurrent_param();
static const int kRecurrentParamFieldNumber = 146;
const ::opencv_caffe::RecurrentParameter& recurrent_param() const;
::opencv_caffe::RecurrentParameter* release_recurrent_param();
::opencv_caffe::RecurrentParameter* mutable_recurrent_param();
void set_allocated_recurrent_param(::opencv_caffe::RecurrentParameter* recurrent_param);
// optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147;
bool has_detection_output_param() const;
void clear_detection_output_param();
static const int kDetectionOutputParamFieldNumber = 147;
const ::opencv_caffe::DetectionOutputParameter& detection_output_param() const;
::opencv_caffe::DetectionOutputParameter* release_detection_output_param();
::opencv_caffe::DetectionOutputParameter* mutable_detection_output_param();
void set_allocated_detection_output_param(::opencv_caffe::DetectionOutputParameter* detection_output_param);
// optional .opencv_caffe.PermuteParameter permute_param = 148;
bool has_permute_param() const;
void clear_permute_param();
static const int kPermuteParamFieldNumber = 148;
const ::opencv_caffe::PermuteParameter& permute_param() const;
::opencv_caffe::PermuteParameter* release_permute_param();
::opencv_caffe::PermuteParameter* mutable_permute_param();
void set_allocated_permute_param(::opencv_caffe::PermuteParameter* permute_param);
// optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149;
bool has_norm_param() const;
void clear_norm_param();
static const int kNormParamFieldNumber = 149;
const ::opencv_caffe::NormalizeBBoxParameter& norm_param() const;
::opencv_caffe::NormalizeBBoxParameter* release_norm_param();
::opencv_caffe::NormalizeBBoxParameter* mutable_norm_param();
void set_allocated_norm_param(::opencv_caffe::NormalizeBBoxParameter* norm_param);
// optional .opencv_caffe.PriorBoxParameter prior_box_param = 150;
bool has_prior_box_param() const;
void clear_prior_box_param();
static const int kPriorBoxParamFieldNumber = 150;
const ::opencv_caffe::PriorBoxParameter& prior_box_param() const;
::opencv_caffe::PriorBoxParameter* release_prior_box_param();
::opencv_caffe::PriorBoxParameter* mutable_prior_box_param();
void set_allocated_prior_box_param(::opencv_caffe::PriorBoxParameter* prior_box_param);
// optional .opencv_caffe.ProposalParameter proposal_param = 201;
bool has_proposal_param() const;
void clear_proposal_param();
static const int kProposalParamFieldNumber = 201;
const ::opencv_caffe::ProposalParameter& proposal_param() const;
::opencv_caffe::ProposalParameter* release_proposal_param();
::opencv_caffe::ProposalParameter* mutable_proposal_param();
void set_allocated_proposal_param(::opencv_caffe::ProposalParameter* proposal_param);
// optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002;
bool has_psroi_pooling_param() const;
void clear_psroi_pooling_param();
static const int kPsroiPoolingParamFieldNumber = 10002;
const ::opencv_caffe::PSROIPoolingParameter& psroi_pooling_param() const;
::opencv_caffe::PSROIPoolingParameter* release_psroi_pooling_param();
::opencv_caffe::PSROIPoolingParameter* mutable_psroi_pooling_param();
void set_allocated_psroi_pooling_param(::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param);
// optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711;
bool has_roi_pooling_param() const;
void clear_roi_pooling_param();
static const int kRoiPoolingParamFieldNumber = 8266711;
const ::opencv_caffe::ROIPoolingParameter& roi_pooling_param() const;
::opencv_caffe::ROIPoolingParameter* release_roi_pooling_param();
::opencv_caffe::ROIPoolingParameter* mutable_roi_pooling_param();
void set_allocated_roi_pooling_param(::opencv_caffe::ROIPoolingParameter* roi_pooling_param);
// optional .opencv_caffe.Phase phase = 10;
bool has_phase() const;
void clear_phase();
static const int kPhaseFieldNumber = 10;
::opencv_caffe::Phase phase() const;
void set_phase(::opencv_caffe::Phase value);
// @@protoc_insertion_point(class_scope:opencv_caffe.LayerParameter)
private:
void set_has_name();
void clear_has_name();
void set_has_type();
void clear_has_type();
void set_has_phase();
void clear_has_phase();
void set_has_transform_param();
void clear_has_transform_param();
void set_has_loss_param();
void clear_has_loss_param();
void set_has_accuracy_param();
void clear_has_accuracy_param();
void set_has_argmax_param();
void clear_has_argmax_param();
void set_has_batch_norm_param();
void clear_has_batch_norm_param();
void set_has_bias_param();
void clear_has_bias_param();
void set_has_concat_param();
void clear_has_concat_param();
void set_has_contrastive_loss_param();
void clear_has_contrastive_loss_param();
void set_has_convolution_param();
void clear_has_convolution_param();
void set_has_crop_param();
void clear_has_crop_param();
void set_has_data_param();
void clear_has_data_param();
void set_has_detection_output_param();
void clear_has_detection_output_param();
void set_has_dropout_param();
void clear_has_dropout_param();
void set_has_dummy_data_param();
void clear_has_dummy_data_param();
void set_has_eltwise_param();
void clear_has_eltwise_param();
void set_has_elu_param();
void clear_has_elu_param();
void set_has_embed_param();
void clear_has_embed_param();
void set_has_exp_param();
void clear_has_exp_param();
void set_has_flatten_param();
void clear_has_flatten_param();
void set_has_hdf5_data_param();
void clear_has_hdf5_data_param();
void set_has_hdf5_output_param();
void clear_has_hdf5_output_param();
void set_has_hinge_loss_param();
void clear_has_hinge_loss_param();
void set_has_image_data_param();
void clear_has_image_data_param();
void set_has_infogain_loss_param();
void clear_has_infogain_loss_param();
void set_has_inner_product_param();
void clear_has_inner_product_param();
void set_has_input_param();
void clear_has_input_param();
void set_has_log_param();
void clear_has_log_param();
void set_has_lrn_param();
void clear_has_lrn_param();
void set_has_memory_data_param();
void clear_has_memory_data_param();
void set_has_mvn_param();
void clear_has_mvn_param();
void set_has_norm_param();
void clear_has_norm_param();
void set_has_permute_param();
void clear_has_permute_param();
void set_has_parameter_param();
void clear_has_parameter_param();
void set_has_pooling_param();
void clear_has_pooling_param();
void set_has_power_param();
void clear_has_power_param();
void set_has_prelu_param();
void clear_has_prelu_param();
void set_has_prior_box_param();
void clear_has_prior_box_param();
void set_has_proposal_param();
void clear_has_proposal_param();
void set_has_psroi_pooling_param();
void clear_has_psroi_pooling_param();
void set_has_python_param();
void clear_has_python_param();
void set_has_recurrent_param();
void clear_has_recurrent_param();
void set_has_reduction_param();
void clear_has_reduction_param();
void set_has_relu_param();
void clear_has_relu_param();
void set_has_reshape_param();
void clear_has_reshape_param();
void set_has_roi_pooling_param();
void clear_has_roi_pooling_param();
void set_has_scale_param();
void clear_has_scale_param();
void set_has_sigmoid_param();
void clear_has_sigmoid_param();
void set_has_softmax_param();
void clear_has_softmax_param();
void set_has_spp_param();
void clear_has_spp_param();
void set_has_slice_param();
void clear_has_slice_param();
void set_has_tanh_param();
void clear_has_tanh_param();
void set_has_threshold_param();
void clear_has_threshold_param();
void set_has_tile_param();
void clear_has_tile_param();
void set_has_window_data_param();
void clear_has_window_data_param();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<2> _has_bits_;
::google::protobuf::RepeatedPtrField< ::std::string> bottom_;
::google::protobuf::RepeatedPtrField< ::std::string> top_;
::google::protobuf::RepeatedField< float > loss_weight_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::ParamSpec > param_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule > include_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule > exclude_;
::google::protobuf::RepeatedField< bool > propagate_down_;
::google::protobuf::internal::ArenaStringPtr name_;
::google::protobuf::internal::ArenaStringPtr type_;
::opencv_caffe::TransformationParameter* transform_param_;
::opencv_caffe::LossParameter* loss_param_;
::opencv_caffe::AccuracyParameter* accuracy_param_;
::opencv_caffe::ArgMaxParameter* argmax_param_;
::opencv_caffe::ConcatParameter* concat_param_;
::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param_;
::opencv_caffe::ConvolutionParameter* convolution_param_;
::opencv_caffe::DataParameter* data_param_;
::opencv_caffe::DropoutParameter* dropout_param_;
::opencv_caffe::DummyDataParameter* dummy_data_param_;
::opencv_caffe::EltwiseParameter* eltwise_param_;
::opencv_caffe::ExpParameter* exp_param_;
::opencv_caffe::HDF5DataParameter* hdf5_data_param_;
::opencv_caffe::HDF5OutputParameter* hdf5_output_param_;
::opencv_caffe::HingeLossParameter* hinge_loss_param_;
::opencv_caffe::ImageDataParameter* image_data_param_;
::opencv_caffe::InfogainLossParameter* infogain_loss_param_;
::opencv_caffe::InnerProductParameter* inner_product_param_;
::opencv_caffe::LRNParameter* lrn_param_;
::opencv_caffe::MemoryDataParameter* memory_data_param_;
::opencv_caffe::MVNParameter* mvn_param_;
::opencv_caffe::PoolingParameter* pooling_param_;
::opencv_caffe::PowerParameter* power_param_;
::opencv_caffe::ReLUParameter* relu_param_;
::opencv_caffe::SigmoidParameter* sigmoid_param_;
::opencv_caffe::SoftmaxParameter* softmax_param_;
::opencv_caffe::SliceParameter* slice_param_;
::opencv_caffe::TanHParameter* tanh_param_;
::opencv_caffe::ThresholdParameter* threshold_param_;
::opencv_caffe::WindowDataParameter* window_data_param_;
::opencv_caffe::PythonParameter* python_param_;
::opencv_caffe::PReLUParameter* prelu_param_;
::opencv_caffe::SPPParameter* spp_param_;
::opencv_caffe::ReshapeParameter* reshape_param_;
::opencv_caffe::LogParameter* log_param_;
::opencv_caffe::FlattenParameter* flatten_param_;
::opencv_caffe::ReductionParameter* reduction_param_;
::opencv_caffe::EmbedParameter* embed_param_;
::opencv_caffe::TileParameter* tile_param_;
::opencv_caffe::BatchNormParameter* batch_norm_param_;
::opencv_caffe::ELUParameter* elu_param_;
::opencv_caffe::BiasParameter* bias_param_;
::opencv_caffe::ScaleParameter* scale_param_;
::opencv_caffe::InputParameter* input_param_;
::opencv_caffe::CropParameter* crop_param_;
::opencv_caffe::ParameterParameter* parameter_param_;
::opencv_caffe::RecurrentParameter* recurrent_param_;
::opencv_caffe::DetectionOutputParameter* detection_output_param_;
::opencv_caffe::PermuteParameter* permute_param_;
::opencv_caffe::NormalizeBBoxParameter* norm_param_;
::opencv_caffe::PriorBoxParameter* prior_box_param_;
::opencv_caffe::ProposalParameter* proposal_param_;
::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param_;
::opencv_caffe::ROIPoolingParameter* roi_pooling_param_;
int phase_;
mutable int _cached_size_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLayerParameterImpl();
};
// -------------------------------------------------------------------
class TransformationParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TransformationParameter) */ {
public:
TransformationParameter();
virtual ~TransformationParameter();
TransformationParameter(const TransformationParameter& from);
inline TransformationParameter& operator=(const TransformationParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
TransformationParameter(TransformationParameter&& from) noexcept
: TransformationParameter() {
*this = ::std::move(from);
}
inline TransformationParameter& operator=(TransformationParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const TransformationParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const TransformationParameter* internal_default_instance() {
return reinterpret_cast<const TransformationParameter*>(
&_TransformationParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
16;
void Swap(TransformationParameter* other);
friend void swap(TransformationParameter& a, TransformationParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline TransformationParameter* New() const PROTOBUF_FINAL { return New(NULL); }
TransformationParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const TransformationParameter& from);
void MergeFrom(const TransformationParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(TransformationParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated float mean_value = 5;
int mean_value_size() const;
void clear_mean_value();
static const int kMeanValueFieldNumber = 5;
float mean_value(int index) const;
void set_mean_value(int index, float value);
void add_mean_value(float value);
const ::google::protobuf::RepeatedField< float >&
mean_value() const;
::google::protobuf::RepeatedField< float >*
mutable_mean_value();
// optional string mean_file = 4;
bool has_mean_file() const;
void clear_mean_file();
static const int kMeanFileFieldNumber = 4;
const ::std::string& mean_file() const;
void set_mean_file(const ::std::string& value);
#if LANG_CXX11
void set_mean_file(::std::string&& value);
#endif
void set_mean_file(const char* value);
void set_mean_file(const char* value, size_t size);
::std::string* mutable_mean_file();
::std::string* release_mean_file();
void set_allocated_mean_file(::std::string* mean_file);
// optional uint32 crop_size = 3 [default = 0];
bool has_crop_size() const;
void clear_crop_size();
static const int kCropSizeFieldNumber = 3;
::google::protobuf::uint32 crop_size() const;
void set_crop_size(::google::protobuf::uint32 value);
// optional bool mirror = 2 [default = false];
bool has_mirror() const;
void clear_mirror();
static const int kMirrorFieldNumber = 2;
bool mirror() const;
void set_mirror(bool value);
// optional bool force_color = 6 [default = false];
bool has_force_color() const;
void clear_force_color();
static const int kForceColorFieldNumber = 6;
bool force_color() const;
void set_force_color(bool value);
// optional bool force_gray = 7 [default = false];
bool has_force_gray() const;
void clear_force_gray();
static const int kForceGrayFieldNumber = 7;
bool force_gray() const;
void set_force_gray(bool value);
// optional float scale = 1 [default = 1];
bool has_scale() const;
void clear_scale();
static const int kScaleFieldNumber = 1;
float scale() const;
void set_scale(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.TransformationParameter)
private:
void set_has_scale();
void clear_has_scale();
void set_has_mirror();
void clear_has_mirror();
void set_has_crop_size();
void clear_has_crop_size();
void set_has_mean_file();
void clear_has_mean_file();
void set_has_force_color();
void clear_has_force_color();
void set_has_force_gray();
void clear_has_force_gray();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< float > mean_value_;
::google::protobuf::internal::ArenaStringPtr mean_file_;
::google::protobuf::uint32 crop_size_;
bool mirror_;
bool force_color_;
bool force_gray_;
float scale_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTransformationParameterImpl();
};
// -------------------------------------------------------------------
class LossParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LossParameter) */ {
public:
LossParameter();
virtual ~LossParameter();
LossParameter(const LossParameter& from);
inline LossParameter& operator=(const LossParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
LossParameter(LossParameter&& from) noexcept
: LossParameter() {
*this = ::std::move(from);
}
inline LossParameter& operator=(LossParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const LossParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const LossParameter* internal_default_instance() {
return reinterpret_cast<const LossParameter*>(
&_LossParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
17;
void Swap(LossParameter* other);
friend void swap(LossParameter& a, LossParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline LossParameter* New() const PROTOBUF_FINAL { return New(NULL); }
LossParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const LossParameter& from);
void MergeFrom(const LossParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(LossParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef LossParameter_NormalizationMode NormalizationMode;
static const NormalizationMode FULL =
LossParameter_NormalizationMode_FULL;
static const NormalizationMode VALID =
LossParameter_NormalizationMode_VALID;
static const NormalizationMode BATCH_SIZE =
LossParameter_NormalizationMode_BATCH_SIZE;
static const NormalizationMode NONE =
LossParameter_NormalizationMode_NONE;
static inline bool NormalizationMode_IsValid(int value) {
return LossParameter_NormalizationMode_IsValid(value);
}
static const NormalizationMode NormalizationMode_MIN =
LossParameter_NormalizationMode_NormalizationMode_MIN;
static const NormalizationMode NormalizationMode_MAX =
LossParameter_NormalizationMode_NormalizationMode_MAX;
static const int NormalizationMode_ARRAYSIZE =
LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
NormalizationMode_descriptor() {
return LossParameter_NormalizationMode_descriptor();
}
static inline const ::std::string& NormalizationMode_Name(NormalizationMode value) {
return LossParameter_NormalizationMode_Name(value);
}
static inline bool NormalizationMode_Parse(const ::std::string& name,
NormalizationMode* value) {
return LossParameter_NormalizationMode_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 ignore_label = 1;
bool has_ignore_label() const;
void clear_ignore_label();
static const int kIgnoreLabelFieldNumber = 1;
::google::protobuf::int32 ignore_label() const;
void set_ignore_label(::google::protobuf::int32 value);
// optional bool normalize = 2;
bool has_normalize() const;
void clear_normalize();
static const int kNormalizeFieldNumber = 2;
bool normalize() const;
void set_normalize(bool value);
// optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
bool has_normalization() const;
void clear_normalization();
static const int kNormalizationFieldNumber = 3;
::opencv_caffe::LossParameter_NormalizationMode normalization() const;
void set_normalization(::opencv_caffe::LossParameter_NormalizationMode value);
// @@protoc_insertion_point(class_scope:opencv_caffe.LossParameter)
private:
void set_has_ignore_label();
void clear_has_ignore_label();
void set_has_normalization();
void clear_has_normalization();
void set_has_normalize();
void clear_has_normalize();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::int32 ignore_label_;
bool normalize_;
int normalization_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLossParameterImpl();
};
// -------------------------------------------------------------------
class AccuracyParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.AccuracyParameter) */ {
public:
AccuracyParameter();
virtual ~AccuracyParameter();
AccuracyParameter(const AccuracyParameter& from);
inline AccuracyParameter& operator=(const AccuracyParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
AccuracyParameter(AccuracyParameter&& from) noexcept
: AccuracyParameter() {
*this = ::std::move(from);
}
inline AccuracyParameter& operator=(AccuracyParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const AccuracyParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const AccuracyParameter* internal_default_instance() {
return reinterpret_cast<const AccuracyParameter*>(
&_AccuracyParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
18;
void Swap(AccuracyParameter* other);
friend void swap(AccuracyParameter& a, AccuracyParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline AccuracyParameter* New() const PROTOBUF_FINAL { return New(NULL); }
AccuracyParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const AccuracyParameter& from);
void MergeFrom(const AccuracyParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(AccuracyParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional int32 ignore_label = 3;
bool has_ignore_label() const;
void clear_ignore_label();
static const int kIgnoreLabelFieldNumber = 3;
::google::protobuf::int32 ignore_label() const;
void set_ignore_label(::google::protobuf::int32 value);
// optional uint32 top_k = 1 [default = 1];
bool has_top_k() const;
void clear_top_k();
static const int kTopKFieldNumber = 1;
::google::protobuf::uint32 top_k() const;
void set_top_k(::google::protobuf::uint32 value);
// optional int32 axis = 2 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 2;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.AccuracyParameter)
private:
void set_has_top_k();
void clear_has_top_k();
void set_has_axis();
void clear_has_axis();
void set_has_ignore_label();
void clear_has_ignore_label();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::int32 ignore_label_;
::google::protobuf::uint32 top_k_;
::google::protobuf::int32 axis_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsAccuracyParameterImpl();
};
// -------------------------------------------------------------------
class ArgMaxParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ArgMaxParameter) */ {
public:
ArgMaxParameter();
virtual ~ArgMaxParameter();
ArgMaxParameter(const ArgMaxParameter& from);
inline ArgMaxParameter& operator=(const ArgMaxParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ArgMaxParameter(ArgMaxParameter&& from) noexcept
: ArgMaxParameter() {
*this = ::std::move(from);
}
inline ArgMaxParameter& operator=(ArgMaxParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ArgMaxParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ArgMaxParameter* internal_default_instance() {
return reinterpret_cast<const ArgMaxParameter*>(
&_ArgMaxParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
19;
void Swap(ArgMaxParameter* other);
friend void swap(ArgMaxParameter& a, ArgMaxParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ArgMaxParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ArgMaxParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ArgMaxParameter& from);
void MergeFrom(const ArgMaxParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ArgMaxParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional bool out_max_val = 1 [default = false];
bool has_out_max_val() const;
void clear_out_max_val();
static const int kOutMaxValFieldNumber = 1;
bool out_max_val() const;
void set_out_max_val(bool value);
// optional int32 axis = 3;
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 3;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// optional uint32 top_k = 2 [default = 1];
bool has_top_k() const;
void clear_top_k();
static const int kTopKFieldNumber = 2;
::google::protobuf::uint32 top_k() const;
void set_top_k(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ArgMaxParameter)
private:
void set_has_out_max_val();
void clear_has_out_max_val();
void set_has_top_k();
void clear_has_top_k();
void set_has_axis();
void clear_has_axis();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
bool out_max_val_;
::google::protobuf::int32 axis_;
::google::protobuf::uint32 top_k_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsArgMaxParameterImpl();
};
// -------------------------------------------------------------------
class ConcatParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ConcatParameter) */ {
public:
ConcatParameter();
virtual ~ConcatParameter();
ConcatParameter(const ConcatParameter& from);
inline ConcatParameter& operator=(const ConcatParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ConcatParameter(ConcatParameter&& from) noexcept
: ConcatParameter() {
*this = ::std::move(from);
}
inline ConcatParameter& operator=(ConcatParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ConcatParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ConcatParameter* internal_default_instance() {
return reinterpret_cast<const ConcatParameter*>(
&_ConcatParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
20;
void Swap(ConcatParameter* other);
friend void swap(ConcatParameter& a, ConcatParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ConcatParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ConcatParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ConcatParameter& from);
void MergeFrom(const ConcatParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ConcatParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional uint32 concat_dim = 1 [default = 1];
bool has_concat_dim() const;
void clear_concat_dim();
static const int kConcatDimFieldNumber = 1;
::google::protobuf::uint32 concat_dim() const;
void set_concat_dim(::google::protobuf::uint32 value);
// optional int32 axis = 2 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 2;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ConcatParameter)
private:
void set_has_axis();
void clear_has_axis();
void set_has_concat_dim();
void clear_has_concat_dim();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::uint32 concat_dim_;
::google::protobuf::int32 axis_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsConcatParameterImpl();
};
// -------------------------------------------------------------------
class BatchNormParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BatchNormParameter) */ {
public:
BatchNormParameter();
virtual ~BatchNormParameter();
BatchNormParameter(const BatchNormParameter& from);
inline BatchNormParameter& operator=(const BatchNormParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
BatchNormParameter(BatchNormParameter&& from) noexcept
: BatchNormParameter() {
*this = ::std::move(from);
}
inline BatchNormParameter& operator=(BatchNormParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const BatchNormParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const BatchNormParameter* internal_default_instance() {
return reinterpret_cast<const BatchNormParameter*>(
&_BatchNormParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
21;
void Swap(BatchNormParameter* other);
friend void swap(BatchNormParameter& a, BatchNormParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline BatchNormParameter* New() const PROTOBUF_FINAL { return New(NULL); }
BatchNormParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const BatchNormParameter& from);
void MergeFrom(const BatchNormParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(BatchNormParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional bool use_global_stats = 1;
bool has_use_global_stats() const;
void clear_use_global_stats();
static const int kUseGlobalStatsFieldNumber = 1;
bool use_global_stats() const;
void set_use_global_stats(bool value);
// optional bool scale_bias = 7 [default = false];
bool has_scale_bias() const;
void clear_scale_bias();
static const int kScaleBiasFieldNumber = 7;
bool scale_bias() const;
void set_scale_bias(bool value);
// optional float moving_average_fraction = 2 [default = 0.999];
bool has_moving_average_fraction() const;
void clear_moving_average_fraction();
static const int kMovingAverageFractionFieldNumber = 2;
float moving_average_fraction() const;
void set_moving_average_fraction(float value);
// optional float eps = 3 [default = 1e-05];
bool has_eps() const;
void clear_eps();
static const int kEpsFieldNumber = 3;
float eps() const;
void set_eps(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.BatchNormParameter)
private:
void set_has_use_global_stats();
void clear_has_use_global_stats();
void set_has_moving_average_fraction();
void clear_has_moving_average_fraction();
void set_has_eps();
void clear_has_eps();
void set_has_scale_bias();
void clear_has_scale_bias();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
bool use_global_stats_;
bool scale_bias_;
float moving_average_fraction_;
float eps_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBatchNormParameterImpl();
};
// -------------------------------------------------------------------
class BiasParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BiasParameter) */ {
public:
BiasParameter();
virtual ~BiasParameter();
BiasParameter(const BiasParameter& from);
inline BiasParameter& operator=(const BiasParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
BiasParameter(BiasParameter&& from) noexcept
: BiasParameter() {
*this = ::std::move(from);
}
inline BiasParameter& operator=(BiasParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const BiasParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const BiasParameter* internal_default_instance() {
return reinterpret_cast<const BiasParameter*>(
&_BiasParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
22;
void Swap(BiasParameter* other);
friend void swap(BiasParameter& a, BiasParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline BiasParameter* New() const PROTOBUF_FINAL { return New(NULL); }
BiasParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const BiasParameter& from);
void MergeFrom(const BiasParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(BiasParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.FillerParameter filler = 3;
bool has_filler() const;
void clear_filler();
static const int kFillerFieldNumber = 3;
const ::opencv_caffe::FillerParameter& filler() const;
::opencv_caffe::FillerParameter* release_filler();
::opencv_caffe::FillerParameter* mutable_filler();
void set_allocated_filler(::opencv_caffe::FillerParameter* filler);
// optional int32 axis = 1 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 1;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// optional int32 num_axes = 2 [default = 1];
bool has_num_axes() const;
void clear_num_axes();
static const int kNumAxesFieldNumber = 2;
::google::protobuf::int32 num_axes() const;
void set_num_axes(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.BiasParameter)
private:
void set_has_axis();
void clear_has_axis();
void set_has_num_axes();
void clear_has_num_axes();
void set_has_filler();
void clear_has_filler();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::FillerParameter* filler_;
::google::protobuf::int32 axis_;
::google::protobuf::int32 num_axes_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBiasParameterImpl();
};
// -------------------------------------------------------------------
class ContrastiveLossParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ContrastiveLossParameter) */ {
public:
ContrastiveLossParameter();
virtual ~ContrastiveLossParameter();
ContrastiveLossParameter(const ContrastiveLossParameter& from);
inline ContrastiveLossParameter& operator=(const ContrastiveLossParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ContrastiveLossParameter(ContrastiveLossParameter&& from) noexcept
: ContrastiveLossParameter() {
*this = ::std::move(from);
}
inline ContrastiveLossParameter& operator=(ContrastiveLossParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ContrastiveLossParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ContrastiveLossParameter* internal_default_instance() {
return reinterpret_cast<const ContrastiveLossParameter*>(
&_ContrastiveLossParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
23;
void Swap(ContrastiveLossParameter* other);
friend void swap(ContrastiveLossParameter& a, ContrastiveLossParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ContrastiveLossParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ContrastiveLossParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ContrastiveLossParameter& from);
void MergeFrom(const ContrastiveLossParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ContrastiveLossParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional bool legacy_version = 2 [default = false];
bool has_legacy_version() const;
void clear_legacy_version();
static const int kLegacyVersionFieldNumber = 2;
bool legacy_version() const;
void set_legacy_version(bool value);
// optional float margin = 1 [default = 1];
bool has_margin() const;
void clear_margin();
static const int kMarginFieldNumber = 1;
float margin() const;
void set_margin(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ContrastiveLossParameter)
private:
void set_has_margin();
void clear_has_margin();
void set_has_legacy_version();
void clear_has_legacy_version();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
bool legacy_version_;
float margin_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsContrastiveLossParameterImpl();
};
// -------------------------------------------------------------------
class ConvolutionParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ConvolutionParameter) */ {
public:
ConvolutionParameter();
virtual ~ConvolutionParameter();
ConvolutionParameter(const ConvolutionParameter& from);
inline ConvolutionParameter& operator=(const ConvolutionParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ConvolutionParameter(ConvolutionParameter&& from) noexcept
: ConvolutionParameter() {
*this = ::std::move(from);
}
inline ConvolutionParameter& operator=(ConvolutionParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ConvolutionParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ConvolutionParameter* internal_default_instance() {
return reinterpret_cast<const ConvolutionParameter*>(
&_ConvolutionParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
24;
void Swap(ConvolutionParameter* other);
friend void swap(ConvolutionParameter& a, ConvolutionParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ConvolutionParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ConvolutionParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ConvolutionParameter& from);
void MergeFrom(const ConvolutionParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ConvolutionParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef ConvolutionParameter_Engine Engine;
static const Engine DEFAULT =
ConvolutionParameter_Engine_DEFAULT;
static const Engine CAFFE =
ConvolutionParameter_Engine_CAFFE;
static const Engine CUDNN =
ConvolutionParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return ConvolutionParameter_Engine_IsValid(value);
}
static const Engine Engine_MIN =
ConvolutionParameter_Engine_Engine_MIN;
static const Engine Engine_MAX =
ConvolutionParameter_Engine_Engine_MAX;
static const int Engine_ARRAYSIZE =
ConvolutionParameter_Engine_Engine_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Engine_descriptor() {
return ConvolutionParameter_Engine_descriptor();
}
static inline const ::std::string& Engine_Name(Engine value) {
return ConvolutionParameter_Engine_Name(value);
}
static inline bool Engine_Parse(const ::std::string& name,
Engine* value) {
return ConvolutionParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
// repeated uint32 pad = 3;
int pad_size() const;
void clear_pad();
static const int kPadFieldNumber = 3;
::google::protobuf::uint32 pad(int index) const;
void set_pad(int index, ::google::protobuf::uint32 value);
void add_pad(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
pad() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_pad();
// repeated uint32 kernel_size = 4;
int kernel_size_size() const;
void clear_kernel_size();
static const int kKernelSizeFieldNumber = 4;
::google::protobuf::uint32 kernel_size(int index) const;
void set_kernel_size(int index, ::google::protobuf::uint32 value);
void add_kernel_size(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
kernel_size() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_kernel_size();
// repeated uint32 stride = 6;
int stride_size() const;
void clear_stride();
static const int kStrideFieldNumber = 6;
::google::protobuf::uint32 stride(int index) const;
void set_stride(int index, ::google::protobuf::uint32 value);
void add_stride(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
stride() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_stride();
// repeated uint32 dilation = 18;
int dilation_size() const;
void clear_dilation();
static const int kDilationFieldNumber = 18;
::google::protobuf::uint32 dilation(int index) const;
void set_dilation(int index, ::google::protobuf::uint32 value);
void add_dilation(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
dilation() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_dilation();
// optional .opencv_caffe.FillerParameter weight_filler = 7;
bool has_weight_filler() const;
void clear_weight_filler();
static const int kWeightFillerFieldNumber = 7;
const ::opencv_caffe::FillerParameter& weight_filler() const;
::opencv_caffe::FillerParameter* release_weight_filler();
::opencv_caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
// optional .opencv_caffe.FillerParameter bias_filler = 8;
bool has_bias_filler() const;
void clear_bias_filler();
static const int kBiasFillerFieldNumber = 8;
const ::opencv_caffe::FillerParameter& bias_filler() const;
::opencv_caffe::FillerParameter* release_bias_filler();
::opencv_caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
// optional uint32 num_output = 1;
bool has_num_output() const;
void clear_num_output();
static const int kNumOutputFieldNumber = 1;
::google::protobuf::uint32 num_output() const;
void set_num_output(::google::protobuf::uint32 value);
// optional uint32 pad_h = 9 [default = 0];
bool has_pad_h() const;
void clear_pad_h();
static const int kPadHFieldNumber = 9;
::google::protobuf::uint32 pad_h() const;
void set_pad_h(::google::protobuf::uint32 value);
// optional uint32 pad_w = 10 [default = 0];
bool has_pad_w() const;
void clear_pad_w();
static const int kPadWFieldNumber = 10;
::google::protobuf::uint32 pad_w() const;
void set_pad_w(::google::protobuf::uint32 value);
// optional uint32 kernel_h = 11;
bool has_kernel_h() const;
void clear_kernel_h();
static const int kKernelHFieldNumber = 11;
::google::protobuf::uint32 kernel_h() const;
void set_kernel_h(::google::protobuf::uint32 value);
// optional uint32 kernel_w = 12;
bool has_kernel_w() const;
void clear_kernel_w();
static const int kKernelWFieldNumber = 12;
::google::protobuf::uint32 kernel_w() const;
void set_kernel_w(::google::protobuf::uint32 value);
// optional uint32 stride_h = 13;
bool has_stride_h() const;
void clear_stride_h();
static const int kStrideHFieldNumber = 13;
::google::protobuf::uint32 stride_h() const;
void set_stride_h(::google::protobuf::uint32 value);
// optional uint32 stride_w = 14;
bool has_stride_w() const;
void clear_stride_w();
static const int kStrideWFieldNumber = 14;
::google::protobuf::uint32 stride_w() const;
void set_stride_w(::google::protobuf::uint32 value);
// optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
bool has_engine() const;
void clear_engine();
static const int kEngineFieldNumber = 15;
::opencv_caffe::ConvolutionParameter_Engine engine() const;
void set_engine(::opencv_caffe::ConvolutionParameter_Engine value);
// optional bool force_nd_im2col = 17 [default = false];
bool has_force_nd_im2col() const;
void clear_force_nd_im2col();
static const int kForceNdIm2ColFieldNumber = 17;
bool force_nd_im2col() const;
void set_force_nd_im2col(bool value);
// optional int32 axis = 16 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 16;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// optional bool bias_term = 2 [default = true];
bool has_bias_term() const;
void clear_bias_term();
static const int kBiasTermFieldNumber = 2;
bool bias_term() const;
void set_bias_term(bool value);
// optional uint32 group = 5 [default = 1];
bool has_group() const;
void clear_group();
static const int kGroupFieldNumber = 5;
::google::protobuf::uint32 group() const;
void set_group(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ConvolutionParameter)
private:
void set_has_num_output();
void clear_has_num_output();
void set_has_bias_term();
void clear_has_bias_term();
void set_has_pad_h();
void clear_has_pad_h();
void set_has_pad_w();
void clear_has_pad_w();
void set_has_kernel_h();
void clear_has_kernel_h();
void set_has_kernel_w();
void clear_has_kernel_w();
void set_has_stride_h();
void clear_has_stride_h();
void set_has_stride_w();
void clear_has_stride_w();
void set_has_group();
void clear_has_group();
void set_has_weight_filler();
void clear_has_weight_filler();
void set_has_bias_filler();
void clear_has_bias_filler();
void set_has_engine();
void clear_has_engine();
void set_has_axis();
void clear_has_axis();
void set_has_force_nd_im2col();
void clear_has_force_nd_im2col();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > pad_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > kernel_size_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > stride_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > dilation_;
::opencv_caffe::FillerParameter* weight_filler_;
::opencv_caffe::FillerParameter* bias_filler_;
::google::protobuf::uint32 num_output_;
::google::protobuf::uint32 pad_h_;
::google::protobuf::uint32 pad_w_;
::google::protobuf::uint32 kernel_h_;
::google::protobuf::uint32 kernel_w_;
::google::protobuf::uint32 stride_h_;
::google::protobuf::uint32 stride_w_;
int engine_;
bool force_nd_im2col_;
::google::protobuf::int32 axis_;
bool bias_term_;
::google::protobuf::uint32 group_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsConvolutionParameterImpl();
};
// -------------------------------------------------------------------
class CropParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.CropParameter) */ {
public:
CropParameter();
virtual ~CropParameter();
CropParameter(const CropParameter& from);
inline CropParameter& operator=(const CropParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
CropParameter(CropParameter&& from) noexcept
: CropParameter() {
*this = ::std::move(from);
}
inline CropParameter& operator=(CropParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const CropParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const CropParameter* internal_default_instance() {
return reinterpret_cast<const CropParameter*>(
&_CropParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
25;
void Swap(CropParameter* other);
friend void swap(CropParameter& a, CropParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline CropParameter* New() const PROTOBUF_FINAL { return New(NULL); }
CropParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const CropParameter& from);
void MergeFrom(const CropParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(CropParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated uint32 offset = 2;
int offset_size() const;
void clear_offset();
static const int kOffsetFieldNumber = 2;
::google::protobuf::uint32 offset(int index) const;
void set_offset(int index, ::google::protobuf::uint32 value);
void add_offset(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
offset() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_offset();
// optional int32 axis = 1 [default = 2];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 1;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.CropParameter)
private:
void set_has_axis();
void clear_has_axis();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > offset_;
::google::protobuf::int32 axis_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsCropParameterImpl();
};
// -------------------------------------------------------------------
class DataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DataParameter) */ {
public:
DataParameter();
virtual ~DataParameter();
DataParameter(const DataParameter& from);
inline DataParameter& operator=(const DataParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
DataParameter(DataParameter&& from) noexcept
: DataParameter() {
*this = ::std::move(from);
}
inline DataParameter& operator=(DataParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const DataParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DataParameter* internal_default_instance() {
return reinterpret_cast<const DataParameter*>(
&_DataParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
26;
void Swap(DataParameter* other);
friend void swap(DataParameter& a, DataParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline DataParameter* New() const PROTOBUF_FINAL { return New(NULL); }
DataParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const DataParameter& from);
void MergeFrom(const DataParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(DataParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef DataParameter_DB DB;
static const DB LEVELDB =
DataParameter_DB_LEVELDB;
static const DB LMDB =
DataParameter_DB_LMDB;
static inline bool DB_IsValid(int value) {
return DataParameter_DB_IsValid(value);
}
static const DB DB_MIN =
DataParameter_DB_DB_MIN;
static const DB DB_MAX =
DataParameter_DB_DB_MAX;
static const int DB_ARRAYSIZE =
DataParameter_DB_DB_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
DB_descriptor() {
return DataParameter_DB_descriptor();
}
static inline const ::std::string& DB_Name(DB value) {
return DataParameter_DB_Name(value);
}
static inline bool DB_Parse(const ::std::string& name,
DB* value) {
return DataParameter_DB_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional string source = 1;
bool has_source() const;
void clear_source();
static const int kSourceFieldNumber = 1;
const ::std::string& source() const;
void set_source(const ::std::string& value);
#if LANG_CXX11
void set_source(::std::string&& value);
#endif
void set_source(const char* value);
void set_source(const char* value, size_t size);
::std::string* mutable_source();
::std::string* release_source();
void set_allocated_source(::std::string* source);
// optional string mean_file = 3;
bool has_mean_file() const;
void clear_mean_file();
static const int kMeanFileFieldNumber = 3;
const ::std::string& mean_file() const;
void set_mean_file(const ::std::string& value);
#if LANG_CXX11
void set_mean_file(::std::string&& value);
#endif
void set_mean_file(const char* value);
void set_mean_file(const char* value, size_t size);
::std::string* mutable_mean_file();
::std::string* release_mean_file();
void set_allocated_mean_file(::std::string* mean_file);
// optional uint32 batch_size = 4;
bool has_batch_size() const;
void clear_batch_size();
static const int kBatchSizeFieldNumber = 4;
::google::protobuf::uint32 batch_size() const;
void set_batch_size(::google::protobuf::uint32 value);
// optional uint32 crop_size = 5 [default = 0];
bool has_crop_size() const;
void clear_crop_size();
static const int kCropSizeFieldNumber = 5;
::google::protobuf::uint32 crop_size() const;
void set_crop_size(::google::protobuf::uint32 value);
// optional uint32 rand_skip = 7 [default = 0];
bool has_rand_skip() const;
void clear_rand_skip();
static const int kRandSkipFieldNumber = 7;
::google::protobuf::uint32 rand_skip() const;
void set_rand_skip(::google::protobuf::uint32 value);
// optional bool mirror = 6 [default = false];
bool has_mirror() const;
void clear_mirror();
static const int kMirrorFieldNumber = 6;
bool mirror() const;
void set_mirror(bool value);
// optional bool force_encoded_color = 9 [default = false];
bool has_force_encoded_color() const;
void clear_force_encoded_color();
static const int kForceEncodedColorFieldNumber = 9;
bool force_encoded_color() const;
void set_force_encoded_color(bool value);
// optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB];
bool has_backend() const;
void clear_backend();
static const int kBackendFieldNumber = 8;
::opencv_caffe::DataParameter_DB backend() const;
void set_backend(::opencv_caffe::DataParameter_DB value);
// optional float scale = 2 [default = 1];
bool has_scale() const;
void clear_scale();
static const int kScaleFieldNumber = 2;
float scale() const;
void set_scale(float value);
// optional uint32 prefetch = 10 [default = 4];
bool has_prefetch() const;
void clear_prefetch();
static const int kPrefetchFieldNumber = 10;
::google::protobuf::uint32 prefetch() const;
void set_prefetch(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.DataParameter)
private:
void set_has_source();
void clear_has_source();
void set_has_batch_size();
void clear_has_batch_size();
void set_has_rand_skip();
void clear_has_rand_skip();
void set_has_backend();
void clear_has_backend();
void set_has_scale();
void clear_has_scale();
void set_has_mean_file();
void clear_has_mean_file();
void set_has_crop_size();
void clear_has_crop_size();
void set_has_mirror();
void clear_has_mirror();
void set_has_force_encoded_color();
void clear_has_force_encoded_color();
void set_has_prefetch();
void clear_has_prefetch();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr source_;
::google::protobuf::internal::ArenaStringPtr mean_file_;
::google::protobuf::uint32 batch_size_;
::google::protobuf::uint32 crop_size_;
::google::protobuf::uint32 rand_skip_;
bool mirror_;
bool force_encoded_color_;
int backend_;
float scale_;
::google::protobuf::uint32 prefetch_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDataParameterImpl();
};
// -------------------------------------------------------------------
class NonMaximumSuppressionParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NonMaximumSuppressionParameter) */ {
public:
NonMaximumSuppressionParameter();
virtual ~NonMaximumSuppressionParameter();
NonMaximumSuppressionParameter(const NonMaximumSuppressionParameter& from);
inline NonMaximumSuppressionParameter& operator=(const NonMaximumSuppressionParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
NonMaximumSuppressionParameter(NonMaximumSuppressionParameter&& from) noexcept
: NonMaximumSuppressionParameter() {
*this = ::std::move(from);
}
inline NonMaximumSuppressionParameter& operator=(NonMaximumSuppressionParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const NonMaximumSuppressionParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const NonMaximumSuppressionParameter* internal_default_instance() {
return reinterpret_cast<const NonMaximumSuppressionParameter*>(
&_NonMaximumSuppressionParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
27;
void Swap(NonMaximumSuppressionParameter* other);
friend void swap(NonMaximumSuppressionParameter& a, NonMaximumSuppressionParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline NonMaximumSuppressionParameter* New() const PROTOBUF_FINAL { return New(NULL); }
NonMaximumSuppressionParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const NonMaximumSuppressionParameter& from);
void MergeFrom(const NonMaximumSuppressionParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(NonMaximumSuppressionParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional int32 top_k = 2;
bool has_top_k() const;
void clear_top_k();
static const int kTopKFieldNumber = 2;
::google::protobuf::int32 top_k() const;
void set_top_k(::google::protobuf::int32 value);
// optional float nms_threshold = 1 [default = 0.3];
bool has_nms_threshold() const;
void clear_nms_threshold();
static const int kNmsThresholdFieldNumber = 1;
float nms_threshold() const;
void set_nms_threshold(float value);
// optional float eta = 3 [default = 1];
bool has_eta() const;
void clear_eta();
static const int kEtaFieldNumber = 3;
float eta() const;
void set_eta(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.NonMaximumSuppressionParameter)
private:
void set_has_nms_threshold();
void clear_has_nms_threshold();
void set_has_top_k();
void clear_has_top_k();
void set_has_eta();
void clear_has_eta();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::int32 top_k_;
float nms_threshold_;
float eta_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNonMaximumSuppressionParameterImpl();
};
// -------------------------------------------------------------------
class SaveOutputParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SaveOutputParameter) */ {
public:
SaveOutputParameter();
virtual ~SaveOutputParameter();
SaveOutputParameter(const SaveOutputParameter& from);
inline SaveOutputParameter& operator=(const SaveOutputParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
SaveOutputParameter(SaveOutputParameter&& from) noexcept
: SaveOutputParameter() {
*this = ::std::move(from);
}
inline SaveOutputParameter& operator=(SaveOutputParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const SaveOutputParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const SaveOutputParameter* internal_default_instance() {
return reinterpret_cast<const SaveOutputParameter*>(
&_SaveOutputParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
28;
void Swap(SaveOutputParameter* other);
friend void swap(SaveOutputParameter& a, SaveOutputParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline SaveOutputParameter* New() const PROTOBUF_FINAL { return New(NULL); }
SaveOutputParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const SaveOutputParameter& from);
void MergeFrom(const SaveOutputParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(SaveOutputParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional string output_directory = 1;
bool has_output_directory() const;
void clear_output_directory();
static const int kOutputDirectoryFieldNumber = 1;
const ::std::string& output_directory() const;
void set_output_directory(const ::std::string& value);
#if LANG_CXX11
void set_output_directory(::std::string&& value);
#endif
void set_output_directory(const char* value);
void set_output_directory(const char* value, size_t size);
::std::string* mutable_output_directory();
::std::string* release_output_directory();
void set_allocated_output_directory(::std::string* output_directory);
// optional string output_name_prefix = 2;
bool has_output_name_prefix() const;
void clear_output_name_prefix();
static const int kOutputNamePrefixFieldNumber = 2;
const ::std::string& output_name_prefix() const;
void set_output_name_prefix(const ::std::string& value);
#if LANG_CXX11
void set_output_name_prefix(::std::string&& value);
#endif
void set_output_name_prefix(const char* value);
void set_output_name_prefix(const char* value, size_t size);
::std::string* mutable_output_name_prefix();
::std::string* release_output_name_prefix();
void set_allocated_output_name_prefix(::std::string* output_name_prefix);
// optional string output_format = 3;
bool has_output_format() const;
void clear_output_format();
static const int kOutputFormatFieldNumber = 3;
const ::std::string& output_format() const;
void set_output_format(const ::std::string& value);
#if LANG_CXX11
void set_output_format(::std::string&& value);
#endif
void set_output_format(const char* value);
void set_output_format(const char* value, size_t size);
::std::string* mutable_output_format();
::std::string* release_output_format();
void set_allocated_output_format(::std::string* output_format);
// optional string label_map_file = 4;
bool has_label_map_file() const;
void clear_label_map_file();
static const int kLabelMapFileFieldNumber = 4;
const ::std::string& label_map_file() const;
void set_label_map_file(const ::std::string& value);
#if LANG_CXX11
void set_label_map_file(::std::string&& value);
#endif
void set_label_map_file(const char* value);
void set_label_map_file(const char* value, size_t size);
::std::string* mutable_label_map_file();
::std::string* release_label_map_file();
void set_allocated_label_map_file(::std::string* label_map_file);
// optional string name_size_file = 5;
bool has_name_size_file() const;
void clear_name_size_file();
static const int kNameSizeFileFieldNumber = 5;
const ::std::string& name_size_file() const;
void set_name_size_file(const ::std::string& value);
#if LANG_CXX11
void set_name_size_file(::std::string&& value);
#endif
void set_name_size_file(const char* value);
void set_name_size_file(const char* value, size_t size);
::std::string* mutable_name_size_file();
::std::string* release_name_size_file();
void set_allocated_name_size_file(::std::string* name_size_file);
// optional uint32 num_test_image = 6;
bool has_num_test_image() const;
void clear_num_test_image();
static const int kNumTestImageFieldNumber = 6;
::google::protobuf::uint32 num_test_image() const;
void set_num_test_image(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.SaveOutputParameter)
private:
void set_has_output_directory();
void clear_has_output_directory();
void set_has_output_name_prefix();
void clear_has_output_name_prefix();
void set_has_output_format();
void clear_has_output_format();
void set_has_label_map_file();
void clear_has_label_map_file();
void set_has_name_size_file();
void clear_has_name_size_file();
void set_has_num_test_image();
void clear_has_num_test_image();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr output_directory_;
::google::protobuf::internal::ArenaStringPtr output_name_prefix_;
::google::protobuf::internal::ArenaStringPtr output_format_;
::google::protobuf::internal::ArenaStringPtr label_map_file_;
::google::protobuf::internal::ArenaStringPtr name_size_file_;
::google::protobuf::uint32 num_test_image_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSaveOutputParameterImpl();
};
// -------------------------------------------------------------------
class DropoutParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DropoutParameter) */ {
public:
DropoutParameter();
virtual ~DropoutParameter();
DropoutParameter(const DropoutParameter& from);
inline DropoutParameter& operator=(const DropoutParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
DropoutParameter(DropoutParameter&& from) noexcept
: DropoutParameter() {
*this = ::std::move(from);
}
inline DropoutParameter& operator=(DropoutParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const DropoutParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DropoutParameter* internal_default_instance() {
return reinterpret_cast<const DropoutParameter*>(
&_DropoutParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
29;
void Swap(DropoutParameter* other);
friend void swap(DropoutParameter& a, DropoutParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline DropoutParameter* New() const PROTOBUF_FINAL { return New(NULL); }
DropoutParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const DropoutParameter& from);
void MergeFrom(const DropoutParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(DropoutParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional float dropout_ratio = 1 [default = 0.5];
bool has_dropout_ratio() const;
void clear_dropout_ratio();
static const int kDropoutRatioFieldNumber = 1;
float dropout_ratio() const;
void set_dropout_ratio(float value);
// optional bool scale_train = 2 [default = true];
bool has_scale_train() const;
void clear_scale_train();
static const int kScaleTrainFieldNumber = 2;
bool scale_train() const;
void set_scale_train(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.DropoutParameter)
private:
void set_has_dropout_ratio();
void clear_has_dropout_ratio();
void set_has_scale_train();
void clear_has_scale_train();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float dropout_ratio_;
bool scale_train_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDropoutParameterImpl();
};
// -------------------------------------------------------------------
class DummyDataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DummyDataParameter) */ {
public:
DummyDataParameter();
virtual ~DummyDataParameter();
DummyDataParameter(const DummyDataParameter& from);
inline DummyDataParameter& operator=(const DummyDataParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
DummyDataParameter(DummyDataParameter&& from) noexcept
: DummyDataParameter() {
*this = ::std::move(from);
}
inline DummyDataParameter& operator=(DummyDataParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const DummyDataParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DummyDataParameter* internal_default_instance() {
return reinterpret_cast<const DummyDataParameter*>(
&_DummyDataParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
30;
void Swap(DummyDataParameter* other);
friend void swap(DummyDataParameter& a, DummyDataParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline DummyDataParameter* New() const PROTOBUF_FINAL { return New(NULL); }
DummyDataParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const DummyDataParameter& from);
void MergeFrom(const DummyDataParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(DummyDataParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated .opencv_caffe.FillerParameter data_filler = 1;
int data_filler_size() const;
void clear_data_filler();
static const int kDataFillerFieldNumber = 1;
const ::opencv_caffe::FillerParameter& data_filler(int index) const;
::opencv_caffe::FillerParameter* mutable_data_filler(int index);
::opencv_caffe::FillerParameter* add_data_filler();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::FillerParameter >*
mutable_data_filler();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::FillerParameter >&
data_filler() const;
// repeated uint32 num = 2;
int num_size() const;
void clear_num();
static const int kNumFieldNumber = 2;
::google::protobuf::uint32 num(int index) const;
void set_num(int index, ::google::protobuf::uint32 value);
void add_num(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
num() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_num();
// repeated uint32 channels = 3;
int channels_size() const;
void clear_channels();
static const int kChannelsFieldNumber = 3;
::google::protobuf::uint32 channels(int index) const;
void set_channels(int index, ::google::protobuf::uint32 value);
void add_channels(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
channels() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_channels();
// repeated uint32 height = 4;
int height_size() const;
void clear_height();
static const int kHeightFieldNumber = 4;
::google::protobuf::uint32 height(int index) const;
void set_height(int index, ::google::protobuf::uint32 value);
void add_height(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
height() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_height();
// repeated uint32 width = 5;
int width_size() const;
void clear_width();
static const int kWidthFieldNumber = 5;
::google::protobuf::uint32 width(int index) const;
void set_width(int index, ::google::protobuf::uint32 value);
void add_width(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
width() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_width();
// repeated .opencv_caffe.BlobShape shape = 6;
int shape_size() const;
void clear_shape();
static const int kShapeFieldNumber = 6;
const ::opencv_caffe::BlobShape& shape(int index) const;
::opencv_caffe::BlobShape* mutable_shape(int index);
::opencv_caffe::BlobShape* add_shape();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >*
mutable_shape();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >&
shape() const;
// @@protoc_insertion_point(class_scope:opencv_caffe.DummyDataParameter)
private:
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::FillerParameter > data_filler_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > num_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > channels_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > height_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > width_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape > shape_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDummyDataParameterImpl();
};
// -------------------------------------------------------------------
class EltwiseParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.EltwiseParameter) */ {
public:
EltwiseParameter();
virtual ~EltwiseParameter();
EltwiseParameter(const EltwiseParameter& from);
inline EltwiseParameter& operator=(const EltwiseParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
EltwiseParameter(EltwiseParameter&& from) noexcept
: EltwiseParameter() {
*this = ::std::move(from);
}
inline EltwiseParameter& operator=(EltwiseParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const EltwiseParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const EltwiseParameter* internal_default_instance() {
return reinterpret_cast<const EltwiseParameter*>(
&_EltwiseParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
31;
void Swap(EltwiseParameter* other);
friend void swap(EltwiseParameter& a, EltwiseParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline EltwiseParameter* New() const PROTOBUF_FINAL { return New(NULL); }
EltwiseParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const EltwiseParameter& from);
void MergeFrom(const EltwiseParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(EltwiseParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef EltwiseParameter_EltwiseOp EltwiseOp;
static const EltwiseOp PROD =
EltwiseParameter_EltwiseOp_PROD;
static const EltwiseOp SUM =
EltwiseParameter_EltwiseOp_SUM;
static const EltwiseOp MAX =
EltwiseParameter_EltwiseOp_MAX;
static inline bool EltwiseOp_IsValid(int value) {
return EltwiseParameter_EltwiseOp_IsValid(value);
}
static const EltwiseOp EltwiseOp_MIN =
EltwiseParameter_EltwiseOp_EltwiseOp_MIN;
static const EltwiseOp EltwiseOp_MAX =
EltwiseParameter_EltwiseOp_EltwiseOp_MAX;
static const int EltwiseOp_ARRAYSIZE =
EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
EltwiseOp_descriptor() {
return EltwiseParameter_EltwiseOp_descriptor();
}
static inline const ::std::string& EltwiseOp_Name(EltwiseOp value) {
return EltwiseParameter_EltwiseOp_Name(value);
}
static inline bool EltwiseOp_Parse(const ::std::string& name,
EltwiseOp* value) {
return EltwiseParameter_EltwiseOp_Parse(name, value);
}
// accessors -------------------------------------------------------
// repeated float coeff = 2;
int coeff_size() const;
void clear_coeff();
static const int kCoeffFieldNumber = 2;
float coeff(int index) const;
void set_coeff(int index, float value);
void add_coeff(float value);
const ::google::protobuf::RepeatedField< float >&
coeff() const;
::google::protobuf::RepeatedField< float >*
mutable_coeff();
// optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
bool has_operation() const;
void clear_operation();
static const int kOperationFieldNumber = 1;
::opencv_caffe::EltwiseParameter_EltwiseOp operation() const;
void set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value);
// optional bool stable_prod_grad = 3 [default = true];
bool has_stable_prod_grad() const;
void clear_stable_prod_grad();
static const int kStableProdGradFieldNumber = 3;
bool stable_prod_grad() const;
void set_stable_prod_grad(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.EltwiseParameter)
private:
void set_has_operation();
void clear_has_operation();
void set_has_stable_prod_grad();
void clear_has_stable_prod_grad();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< float > coeff_;
int operation_;
bool stable_prod_grad_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsEltwiseParameterImpl();
};
// -------------------------------------------------------------------
class ELUParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ELUParameter) */ {
public:
ELUParameter();
virtual ~ELUParameter();
ELUParameter(const ELUParameter& from);
inline ELUParameter& operator=(const ELUParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ELUParameter(ELUParameter&& from) noexcept
: ELUParameter() {
*this = ::std::move(from);
}
inline ELUParameter& operator=(ELUParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ELUParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ELUParameter* internal_default_instance() {
return reinterpret_cast<const ELUParameter*>(
&_ELUParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
32;
void Swap(ELUParameter* other);
friend void swap(ELUParameter& a, ELUParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ELUParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ELUParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ELUParameter& from);
void MergeFrom(const ELUParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ELUParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional float alpha = 1 [default = 1];
bool has_alpha() const;
void clear_alpha();
static const int kAlphaFieldNumber = 1;
float alpha() const;
void set_alpha(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ELUParameter)
private:
void set_has_alpha();
void clear_has_alpha();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float alpha_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsELUParameterImpl();
};
// -------------------------------------------------------------------
class EmbedParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.EmbedParameter) */ {
public:
EmbedParameter();
virtual ~EmbedParameter();
EmbedParameter(const EmbedParameter& from);
inline EmbedParameter& operator=(const EmbedParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
EmbedParameter(EmbedParameter&& from) noexcept
: EmbedParameter() {
*this = ::std::move(from);
}
inline EmbedParameter& operator=(EmbedParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const EmbedParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const EmbedParameter* internal_default_instance() {
return reinterpret_cast<const EmbedParameter*>(
&_EmbedParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
33;
void Swap(EmbedParameter* other);
friend void swap(EmbedParameter& a, EmbedParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline EmbedParameter* New() const PROTOBUF_FINAL { return New(NULL); }
EmbedParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const EmbedParameter& from);
void MergeFrom(const EmbedParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(EmbedParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.FillerParameter weight_filler = 4;
bool has_weight_filler() const;
void clear_weight_filler();
static const int kWeightFillerFieldNumber = 4;
const ::opencv_caffe::FillerParameter& weight_filler() const;
::opencv_caffe::FillerParameter* release_weight_filler();
::opencv_caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
// optional .opencv_caffe.FillerParameter bias_filler = 5;
bool has_bias_filler() const;
void clear_bias_filler();
static const int kBiasFillerFieldNumber = 5;
const ::opencv_caffe::FillerParameter& bias_filler() const;
::opencv_caffe::FillerParameter* release_bias_filler();
::opencv_caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
// optional uint32 num_output = 1;
bool has_num_output() const;
void clear_num_output();
static const int kNumOutputFieldNumber = 1;
::google::protobuf::uint32 num_output() const;
void set_num_output(::google::protobuf::uint32 value);
// optional uint32 input_dim = 2;
bool has_input_dim() const;
void clear_input_dim();
static const int kInputDimFieldNumber = 2;
::google::protobuf::uint32 input_dim() const;
void set_input_dim(::google::protobuf::uint32 value);
// optional bool bias_term = 3 [default = true];
bool has_bias_term() const;
void clear_bias_term();
static const int kBiasTermFieldNumber = 3;
bool bias_term() const;
void set_bias_term(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.EmbedParameter)
private:
void set_has_num_output();
void clear_has_num_output();
void set_has_input_dim();
void clear_has_input_dim();
void set_has_bias_term();
void clear_has_bias_term();
void set_has_weight_filler();
void clear_has_weight_filler();
void set_has_bias_filler();
void clear_has_bias_filler();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::FillerParameter* weight_filler_;
::opencv_caffe::FillerParameter* bias_filler_;
::google::protobuf::uint32 num_output_;
::google::protobuf::uint32 input_dim_;
bool bias_term_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsEmbedParameterImpl();
};
// -------------------------------------------------------------------
class ExpParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ExpParameter) */ {
public:
ExpParameter();
virtual ~ExpParameter();
ExpParameter(const ExpParameter& from);
inline ExpParameter& operator=(const ExpParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ExpParameter(ExpParameter&& from) noexcept
: ExpParameter() {
*this = ::std::move(from);
}
inline ExpParameter& operator=(ExpParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ExpParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ExpParameter* internal_default_instance() {
return reinterpret_cast<const ExpParameter*>(
&_ExpParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
34;
void Swap(ExpParameter* other);
friend void swap(ExpParameter& a, ExpParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ExpParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ExpParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ExpParameter& from);
void MergeFrom(const ExpParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ExpParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional float shift = 3 [default = 0];
bool has_shift() const;
void clear_shift();
static const int kShiftFieldNumber = 3;
float shift() const;
void set_shift(float value);
// optional float base = 1 [default = -1];
bool has_base() const;
void clear_base();
static const int kBaseFieldNumber = 1;
float base() const;
void set_base(float value);
// optional float scale = 2 [default = 1];
bool has_scale() const;
void clear_scale();
static const int kScaleFieldNumber = 2;
float scale() const;
void set_scale(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ExpParameter)
private:
void set_has_base();
void clear_has_base();
void set_has_scale();
void clear_has_scale();
void set_has_shift();
void clear_has_shift();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float shift_;
float base_;
float scale_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsExpParameterImpl();
};
// -------------------------------------------------------------------
class FlattenParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.FlattenParameter) */ {
public:
FlattenParameter();
virtual ~FlattenParameter();
FlattenParameter(const FlattenParameter& from);
inline FlattenParameter& operator=(const FlattenParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
FlattenParameter(FlattenParameter&& from) noexcept
: FlattenParameter() {
*this = ::std::move(from);
}
inline FlattenParameter& operator=(FlattenParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const FlattenParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const FlattenParameter* internal_default_instance() {
return reinterpret_cast<const FlattenParameter*>(
&_FlattenParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
35;
void Swap(FlattenParameter* other);
friend void swap(FlattenParameter& a, FlattenParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline FlattenParameter* New() const PROTOBUF_FINAL { return New(NULL); }
FlattenParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const FlattenParameter& from);
void MergeFrom(const FlattenParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(FlattenParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional int32 axis = 1 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 1;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// optional int32 end_axis = 2 [default = -1];
bool has_end_axis() const;
void clear_end_axis();
static const int kEndAxisFieldNumber = 2;
::google::protobuf::int32 end_axis() const;
void set_end_axis(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.FlattenParameter)
private:
void set_has_axis();
void clear_has_axis();
void set_has_end_axis();
void clear_has_end_axis();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::int32 axis_;
::google::protobuf::int32 end_axis_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsFlattenParameterImpl();
};
// -------------------------------------------------------------------
class HDF5DataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HDF5DataParameter) */ {
public:
HDF5DataParameter();
virtual ~HDF5DataParameter();
HDF5DataParameter(const HDF5DataParameter& from);
inline HDF5DataParameter& operator=(const HDF5DataParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
HDF5DataParameter(HDF5DataParameter&& from) noexcept
: HDF5DataParameter() {
*this = ::std::move(from);
}
inline HDF5DataParameter& operator=(HDF5DataParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const HDF5DataParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const HDF5DataParameter* internal_default_instance() {
return reinterpret_cast<const HDF5DataParameter*>(
&_HDF5DataParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
36;
void Swap(HDF5DataParameter* other);
friend void swap(HDF5DataParameter& a, HDF5DataParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline HDF5DataParameter* New() const PROTOBUF_FINAL { return New(NULL); }
HDF5DataParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const HDF5DataParameter& from);
void MergeFrom(const HDF5DataParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(HDF5DataParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional string source = 1;
bool has_source() const;
void clear_source();
static const int kSourceFieldNumber = 1;
const ::std::string& source() const;
void set_source(const ::std::string& value);
#if LANG_CXX11
void set_source(::std::string&& value);
#endif
void set_source(const char* value);
void set_source(const char* value, size_t size);
::std::string* mutable_source();
::std::string* release_source();
void set_allocated_source(::std::string* source);
// optional uint32 batch_size = 2;
bool has_batch_size() const;
void clear_batch_size();
static const int kBatchSizeFieldNumber = 2;
::google::protobuf::uint32 batch_size() const;
void set_batch_size(::google::protobuf::uint32 value);
// optional bool shuffle = 3 [default = false];
bool has_shuffle() const;
void clear_shuffle();
static const int kShuffleFieldNumber = 3;
bool shuffle() const;
void set_shuffle(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.HDF5DataParameter)
private:
void set_has_source();
void clear_has_source();
void set_has_batch_size();
void clear_has_batch_size();
void set_has_shuffle();
void clear_has_shuffle();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr source_;
::google::protobuf::uint32 batch_size_;
bool shuffle_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5DataParameterImpl();
};
// -------------------------------------------------------------------
class HDF5OutputParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HDF5OutputParameter) */ {
public:
HDF5OutputParameter();
virtual ~HDF5OutputParameter();
HDF5OutputParameter(const HDF5OutputParameter& from);
inline HDF5OutputParameter& operator=(const HDF5OutputParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
HDF5OutputParameter(HDF5OutputParameter&& from) noexcept
: HDF5OutputParameter() {
*this = ::std::move(from);
}
inline HDF5OutputParameter& operator=(HDF5OutputParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const HDF5OutputParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const HDF5OutputParameter* internal_default_instance() {
return reinterpret_cast<const HDF5OutputParameter*>(
&_HDF5OutputParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
37;
void Swap(HDF5OutputParameter* other);
friend void swap(HDF5OutputParameter& a, HDF5OutputParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline HDF5OutputParameter* New() const PROTOBUF_FINAL { return New(NULL); }
HDF5OutputParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const HDF5OutputParameter& from);
void MergeFrom(const HDF5OutputParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(HDF5OutputParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional string file_name = 1;
bool has_file_name() const;
void clear_file_name();
static const int kFileNameFieldNumber = 1;
const ::std::string& file_name() const;
void set_file_name(const ::std::string& value);
#if LANG_CXX11
void set_file_name(::std::string&& value);
#endif
void set_file_name(const char* value);
void set_file_name(const char* value, size_t size);
::std::string* mutable_file_name();
::std::string* release_file_name();
void set_allocated_file_name(::std::string* file_name);
// @@protoc_insertion_point(class_scope:opencv_caffe.HDF5OutputParameter)
private:
void set_has_file_name();
void clear_has_file_name();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr file_name_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5OutputParameterImpl();
};
// -------------------------------------------------------------------
class HingeLossParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HingeLossParameter) */ {
public:
HingeLossParameter();
virtual ~HingeLossParameter();
HingeLossParameter(const HingeLossParameter& from);
inline HingeLossParameter& operator=(const HingeLossParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
HingeLossParameter(HingeLossParameter&& from) noexcept
: HingeLossParameter() {
*this = ::std::move(from);
}
inline HingeLossParameter& operator=(HingeLossParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const HingeLossParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const HingeLossParameter* internal_default_instance() {
return reinterpret_cast<const HingeLossParameter*>(
&_HingeLossParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
38;
void Swap(HingeLossParameter* other);
friend void swap(HingeLossParameter& a, HingeLossParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline HingeLossParameter* New() const PROTOBUF_FINAL { return New(NULL); }
HingeLossParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const HingeLossParameter& from);
void MergeFrom(const HingeLossParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(HingeLossParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef HingeLossParameter_Norm Norm;
static const Norm L1 =
HingeLossParameter_Norm_L1;
static const Norm L2 =
HingeLossParameter_Norm_L2;
static inline bool Norm_IsValid(int value) {
return HingeLossParameter_Norm_IsValid(value);
}
static const Norm Norm_MIN =
HingeLossParameter_Norm_Norm_MIN;
static const Norm Norm_MAX =
HingeLossParameter_Norm_Norm_MAX;
static const int Norm_ARRAYSIZE =
HingeLossParameter_Norm_Norm_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Norm_descriptor() {
return HingeLossParameter_Norm_descriptor();
}
static inline const ::std::string& Norm_Name(Norm value) {
return HingeLossParameter_Norm_Name(value);
}
static inline bool Norm_Parse(const ::std::string& name,
Norm* value) {
return HingeLossParameter_Norm_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1];
bool has_norm() const;
void clear_norm();
static const int kNormFieldNumber = 1;
::opencv_caffe::HingeLossParameter_Norm norm() const;
void set_norm(::opencv_caffe::HingeLossParameter_Norm value);
// @@protoc_insertion_point(class_scope:opencv_caffe.HingeLossParameter)
private:
void set_has_norm();
void clear_has_norm();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
int norm_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHingeLossParameterImpl();
};
// -------------------------------------------------------------------
class ImageDataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ImageDataParameter) */ {
public:
ImageDataParameter();
virtual ~ImageDataParameter();
ImageDataParameter(const ImageDataParameter& from);
inline ImageDataParameter& operator=(const ImageDataParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ImageDataParameter(ImageDataParameter&& from) noexcept
: ImageDataParameter() {
*this = ::std::move(from);
}
inline ImageDataParameter& operator=(ImageDataParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ImageDataParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ImageDataParameter* internal_default_instance() {
return reinterpret_cast<const ImageDataParameter*>(
&_ImageDataParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
39;
void Swap(ImageDataParameter* other);
friend void swap(ImageDataParameter& a, ImageDataParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ImageDataParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ImageDataParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ImageDataParameter& from);
void MergeFrom(const ImageDataParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ImageDataParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional string source = 1;
bool has_source() const;
void clear_source();
static const int kSourceFieldNumber = 1;
const ::std::string& source() const;
void set_source(const ::std::string& value);
#if LANG_CXX11
void set_source(::std::string&& value);
#endif
void set_source(const char* value);
void set_source(const char* value, size_t size);
::std::string* mutable_source();
::std::string* release_source();
void set_allocated_source(::std::string* source);
// optional string mean_file = 3;
bool has_mean_file() const;
void clear_mean_file();
static const int kMeanFileFieldNumber = 3;
const ::std::string& mean_file() const;
void set_mean_file(const ::std::string& value);
#if LANG_CXX11
void set_mean_file(::std::string&& value);
#endif
void set_mean_file(const char* value);
void set_mean_file(const char* value, size_t size);
::std::string* mutable_mean_file();
::std::string* release_mean_file();
void set_allocated_mean_file(::std::string* mean_file);
// optional string root_folder = 12 [default = ""];
bool has_root_folder() const;
void clear_root_folder();
static const int kRootFolderFieldNumber = 12;
const ::std::string& root_folder() const;
void set_root_folder(const ::std::string& value);
#if LANG_CXX11
void set_root_folder(::std::string&& value);
#endif
void set_root_folder(const char* value);
void set_root_folder(const char* value, size_t size);
::std::string* mutable_root_folder();
::std::string* release_root_folder();
void set_allocated_root_folder(::std::string* root_folder);
// optional uint32 crop_size = 5 [default = 0];
bool has_crop_size() const;
void clear_crop_size();
static const int kCropSizeFieldNumber = 5;
::google::protobuf::uint32 crop_size() const;
void set_crop_size(::google::protobuf::uint32 value);
// optional uint32 rand_skip = 7 [default = 0];
bool has_rand_skip() const;
void clear_rand_skip();
static const int kRandSkipFieldNumber = 7;
::google::protobuf::uint32 rand_skip() const;
void set_rand_skip(::google::protobuf::uint32 value);
// optional bool shuffle = 8 [default = false];
bool has_shuffle() const;
void clear_shuffle();
static const int kShuffleFieldNumber = 8;
bool shuffle() const;
void set_shuffle(bool value);
// optional bool mirror = 6 [default = false];
bool has_mirror() const;
void clear_mirror();
static const int kMirrorFieldNumber = 6;
bool mirror() const;
void set_mirror(bool value);
// optional uint32 new_height = 9 [default = 0];
bool has_new_height() const;
void clear_new_height();
static const int kNewHeightFieldNumber = 9;
::google::protobuf::uint32 new_height() const;
void set_new_height(::google::protobuf::uint32 value);
// optional uint32 new_width = 10 [default = 0];
bool has_new_width() const;
void clear_new_width();
static const int kNewWidthFieldNumber = 10;
::google::protobuf::uint32 new_width() const;
void set_new_width(::google::protobuf::uint32 value);
// optional bool is_color = 11 [default = true];
bool has_is_color() const;
void clear_is_color();
static const int kIsColorFieldNumber = 11;
bool is_color() const;
void set_is_color(bool value);
// optional float scale = 2 [default = 1];
bool has_scale() const;
void clear_scale();
static const int kScaleFieldNumber = 2;
float scale() const;
void set_scale(float value);
// optional uint32 batch_size = 4 [default = 1];
bool has_batch_size() const;
void clear_batch_size();
static const int kBatchSizeFieldNumber = 4;
::google::protobuf::uint32 batch_size() const;
void set_batch_size(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ImageDataParameter)
private:
void set_has_source();
void clear_has_source();
void set_has_batch_size();
void clear_has_batch_size();
void set_has_rand_skip();
void clear_has_rand_skip();
void set_has_shuffle();
void clear_has_shuffle();
void set_has_new_height();
void clear_has_new_height();
void set_has_new_width();
void clear_has_new_width();
void set_has_is_color();
void clear_has_is_color();
void set_has_scale();
void clear_has_scale();
void set_has_mean_file();
void clear_has_mean_file();
void set_has_crop_size();
void clear_has_crop_size();
void set_has_mirror();
void clear_has_mirror();
void set_has_root_folder();
void clear_has_root_folder();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr source_;
::google::protobuf::internal::ArenaStringPtr mean_file_;
::google::protobuf::internal::ArenaStringPtr root_folder_;
::google::protobuf::uint32 crop_size_;
::google::protobuf::uint32 rand_skip_;
bool shuffle_;
bool mirror_;
::google::protobuf::uint32 new_height_;
::google::protobuf::uint32 new_width_;
bool is_color_;
float scale_;
::google::protobuf::uint32 batch_size_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsImageDataParameterImpl();
};
// -------------------------------------------------------------------
class InfogainLossParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InfogainLossParameter) */ {
public:
InfogainLossParameter();
virtual ~InfogainLossParameter();
InfogainLossParameter(const InfogainLossParameter& from);
inline InfogainLossParameter& operator=(const InfogainLossParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
InfogainLossParameter(InfogainLossParameter&& from) noexcept
: InfogainLossParameter() {
*this = ::std::move(from);
}
inline InfogainLossParameter& operator=(InfogainLossParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const InfogainLossParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const InfogainLossParameter* internal_default_instance() {
return reinterpret_cast<const InfogainLossParameter*>(
&_InfogainLossParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
40;
void Swap(InfogainLossParameter* other);
friend void swap(InfogainLossParameter& a, InfogainLossParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline InfogainLossParameter* New() const PROTOBUF_FINAL { return New(NULL); }
InfogainLossParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const InfogainLossParameter& from);
void MergeFrom(const InfogainLossParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(InfogainLossParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional string source = 1;
bool has_source() const;
void clear_source();
static const int kSourceFieldNumber = 1;
const ::std::string& source() const;
void set_source(const ::std::string& value);
#if LANG_CXX11
void set_source(::std::string&& value);
#endif
void set_source(const char* value);
void set_source(const char* value, size_t size);
::std::string* mutable_source();
::std::string* release_source();
void set_allocated_source(::std::string* source);
// @@protoc_insertion_point(class_scope:opencv_caffe.InfogainLossParameter)
private:
void set_has_source();
void clear_has_source();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr source_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInfogainLossParameterImpl();
};
// -------------------------------------------------------------------
class InnerProductParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InnerProductParameter) */ {
public:
InnerProductParameter();
virtual ~InnerProductParameter();
InnerProductParameter(const InnerProductParameter& from);
inline InnerProductParameter& operator=(const InnerProductParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
InnerProductParameter(InnerProductParameter&& from) noexcept
: InnerProductParameter() {
*this = ::std::move(from);
}
inline InnerProductParameter& operator=(InnerProductParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const InnerProductParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const InnerProductParameter* internal_default_instance() {
return reinterpret_cast<const InnerProductParameter*>(
&_InnerProductParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
41;
void Swap(InnerProductParameter* other);
friend void swap(InnerProductParameter& a, InnerProductParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline InnerProductParameter* New() const PROTOBUF_FINAL { return New(NULL); }
InnerProductParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const InnerProductParameter& from);
void MergeFrom(const InnerProductParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(InnerProductParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.FillerParameter weight_filler = 3;
bool has_weight_filler() const;
void clear_weight_filler();
static const int kWeightFillerFieldNumber = 3;
const ::opencv_caffe::FillerParameter& weight_filler() const;
::opencv_caffe::FillerParameter* release_weight_filler();
::opencv_caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
// optional .opencv_caffe.FillerParameter bias_filler = 4;
bool has_bias_filler() const;
void clear_bias_filler();
static const int kBiasFillerFieldNumber = 4;
const ::opencv_caffe::FillerParameter& bias_filler() const;
::opencv_caffe::FillerParameter* release_bias_filler();
::opencv_caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
// optional uint32 num_output = 1;
bool has_num_output() const;
void clear_num_output();
static const int kNumOutputFieldNumber = 1;
::google::protobuf::uint32 num_output() const;
void set_num_output(::google::protobuf::uint32 value);
// optional bool transpose = 6 [default = false];
bool has_transpose() const;
void clear_transpose();
static const int kTransposeFieldNumber = 6;
bool transpose() const;
void set_transpose(bool value);
// optional bool bias_term = 2 [default = true];
bool has_bias_term() const;
void clear_bias_term();
static const int kBiasTermFieldNumber = 2;
bool bias_term() const;
void set_bias_term(bool value);
// optional int32 axis = 5 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 5;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.InnerProductParameter)
private:
void set_has_num_output();
void clear_has_num_output();
void set_has_bias_term();
void clear_has_bias_term();
void set_has_weight_filler();
void clear_has_weight_filler();
void set_has_bias_filler();
void clear_has_bias_filler();
void set_has_axis();
void clear_has_axis();
void set_has_transpose();
void clear_has_transpose();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::FillerParameter* weight_filler_;
::opencv_caffe::FillerParameter* bias_filler_;
::google::protobuf::uint32 num_output_;
bool transpose_;
bool bias_term_;
::google::protobuf::int32 axis_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInnerProductParameterImpl();
};
// -------------------------------------------------------------------
class InputParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InputParameter) */ {
public:
InputParameter();
virtual ~InputParameter();
InputParameter(const InputParameter& from);
inline InputParameter& operator=(const InputParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
InputParameter(InputParameter&& from) noexcept
: InputParameter() {
*this = ::std::move(from);
}
inline InputParameter& operator=(InputParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const InputParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const InputParameter* internal_default_instance() {
return reinterpret_cast<const InputParameter*>(
&_InputParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
42;
void Swap(InputParameter* other);
friend void swap(InputParameter& a, InputParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline InputParameter* New() const PROTOBUF_FINAL { return New(NULL); }
InputParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const InputParameter& from);
void MergeFrom(const InputParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(InputParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated .opencv_caffe.BlobShape shape = 1;
int shape_size() const;
void clear_shape();
static const int kShapeFieldNumber = 1;
const ::opencv_caffe::BlobShape& shape(int index) const;
::opencv_caffe::BlobShape* mutable_shape(int index);
::opencv_caffe::BlobShape* add_shape();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >*
mutable_shape();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >&
shape() const;
// @@protoc_insertion_point(class_scope:opencv_caffe.InputParameter)
private:
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape > shape_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInputParameterImpl();
};
// -------------------------------------------------------------------
class LogParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LogParameter) */ {
public:
LogParameter();
virtual ~LogParameter();
LogParameter(const LogParameter& from);
inline LogParameter& operator=(const LogParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
LogParameter(LogParameter&& from) noexcept
: LogParameter() {
*this = ::std::move(from);
}
inline LogParameter& operator=(LogParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const LogParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const LogParameter* internal_default_instance() {
return reinterpret_cast<const LogParameter*>(
&_LogParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
43;
void Swap(LogParameter* other);
friend void swap(LogParameter& a, LogParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline LogParameter* New() const PROTOBUF_FINAL { return New(NULL); }
LogParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const LogParameter& from);
void MergeFrom(const LogParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(LogParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional float shift = 3 [default = 0];
bool has_shift() const;
void clear_shift();
static const int kShiftFieldNumber = 3;
float shift() const;
void set_shift(float value);
// optional float base = 1 [default = -1];
bool has_base() const;
void clear_base();
static const int kBaseFieldNumber = 1;
float base() const;
void set_base(float value);
// optional float scale = 2 [default = 1];
bool has_scale() const;
void clear_scale();
static const int kScaleFieldNumber = 2;
float scale() const;
void set_scale(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.LogParameter)
private:
void set_has_base();
void clear_has_base();
void set_has_scale();
void clear_has_scale();
void set_has_shift();
void clear_has_shift();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float shift_;
float base_;
float scale_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLogParameterImpl();
};
// -------------------------------------------------------------------
class LRNParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LRNParameter) */ {
public:
LRNParameter();
virtual ~LRNParameter();
LRNParameter(const LRNParameter& from);
inline LRNParameter& operator=(const LRNParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
LRNParameter(LRNParameter&& from) noexcept
: LRNParameter() {
*this = ::std::move(from);
}
inline LRNParameter& operator=(LRNParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const LRNParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const LRNParameter* internal_default_instance() {
return reinterpret_cast<const LRNParameter*>(
&_LRNParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
44;
void Swap(LRNParameter* other);
friend void swap(LRNParameter& a, LRNParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline LRNParameter* New() const PROTOBUF_FINAL { return New(NULL); }
LRNParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const LRNParameter& from);
void MergeFrom(const LRNParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(LRNParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef LRNParameter_NormRegion NormRegion;
static const NormRegion ACROSS_CHANNELS =
LRNParameter_NormRegion_ACROSS_CHANNELS;
static const NormRegion WITHIN_CHANNEL =
LRNParameter_NormRegion_WITHIN_CHANNEL;
static inline bool NormRegion_IsValid(int value) {
return LRNParameter_NormRegion_IsValid(value);
}
static const NormRegion NormRegion_MIN =
LRNParameter_NormRegion_NormRegion_MIN;
static const NormRegion NormRegion_MAX =
LRNParameter_NormRegion_NormRegion_MAX;
static const int NormRegion_ARRAYSIZE =
LRNParameter_NormRegion_NormRegion_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
NormRegion_descriptor() {
return LRNParameter_NormRegion_descriptor();
}
static inline const ::std::string& NormRegion_Name(NormRegion value) {
return LRNParameter_NormRegion_Name(value);
}
static inline bool NormRegion_Parse(const ::std::string& name,
NormRegion* value) {
return LRNParameter_NormRegion_Parse(name, value);
}
typedef LRNParameter_Engine Engine;
static const Engine DEFAULT =
LRNParameter_Engine_DEFAULT;
static const Engine CAFFE =
LRNParameter_Engine_CAFFE;
static const Engine CUDNN =
LRNParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return LRNParameter_Engine_IsValid(value);
}
static const Engine Engine_MIN =
LRNParameter_Engine_Engine_MIN;
static const Engine Engine_MAX =
LRNParameter_Engine_Engine_MAX;
static const int Engine_ARRAYSIZE =
LRNParameter_Engine_Engine_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Engine_descriptor() {
return LRNParameter_Engine_descriptor();
}
static inline const ::std::string& Engine_Name(Engine value) {
return LRNParameter_Engine_Name(value);
}
static inline bool Engine_Parse(const ::std::string& name,
Engine* value) {
return LRNParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
bool has_norm_region() const;
void clear_norm_region();
static const int kNormRegionFieldNumber = 4;
::opencv_caffe::LRNParameter_NormRegion norm_region() const;
void set_norm_region(::opencv_caffe::LRNParameter_NormRegion value);
// optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
bool has_engine() const;
void clear_engine();
static const int kEngineFieldNumber = 6;
::opencv_caffe::LRNParameter_Engine engine() const;
void set_engine(::opencv_caffe::LRNParameter_Engine value);
// optional uint32 local_size = 1 [default = 5];
bool has_local_size() const;
void clear_local_size();
static const int kLocalSizeFieldNumber = 1;
::google::protobuf::uint32 local_size() const;
void set_local_size(::google::protobuf::uint32 value);
// optional float alpha = 2 [default = 1];
bool has_alpha() const;
void clear_alpha();
static const int kAlphaFieldNumber = 2;
float alpha() const;
void set_alpha(float value);
// optional float beta = 3 [default = 0.75];
bool has_beta() const;
void clear_beta();
static const int kBetaFieldNumber = 3;
float beta() const;
void set_beta(float value);
// optional float k = 5 [default = 1];
bool has_k() const;
void clear_k();
static const int kKFieldNumber = 5;
float k() const;
void set_k(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.LRNParameter)
private:
void set_has_local_size();
void clear_has_local_size();
void set_has_alpha();
void clear_has_alpha();
void set_has_beta();
void clear_has_beta();
void set_has_norm_region();
void clear_has_norm_region();
void set_has_k();
void clear_has_k();
void set_has_engine();
void clear_has_engine();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
int norm_region_;
int engine_;
::google::protobuf::uint32 local_size_;
float alpha_;
float beta_;
float k_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLRNParameterImpl();
};
// -------------------------------------------------------------------
class MemoryDataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.MemoryDataParameter) */ {
public:
MemoryDataParameter();
virtual ~MemoryDataParameter();
MemoryDataParameter(const MemoryDataParameter& from);
inline MemoryDataParameter& operator=(const MemoryDataParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
MemoryDataParameter(MemoryDataParameter&& from) noexcept
: MemoryDataParameter() {
*this = ::std::move(from);
}
inline MemoryDataParameter& operator=(MemoryDataParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const MemoryDataParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const MemoryDataParameter* internal_default_instance() {
return reinterpret_cast<const MemoryDataParameter*>(
&_MemoryDataParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
45;
void Swap(MemoryDataParameter* other);
friend void swap(MemoryDataParameter& a, MemoryDataParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline MemoryDataParameter* New() const PROTOBUF_FINAL { return New(NULL); }
MemoryDataParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const MemoryDataParameter& from);
void MergeFrom(const MemoryDataParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(MemoryDataParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional uint32 batch_size = 1;
bool has_batch_size() const;
void clear_batch_size();
static const int kBatchSizeFieldNumber = 1;
::google::protobuf::uint32 batch_size() const;
void set_batch_size(::google::protobuf::uint32 value);
// optional uint32 channels = 2;
bool has_channels() const;
void clear_channels();
static const int kChannelsFieldNumber = 2;
::google::protobuf::uint32 channels() const;
void set_channels(::google::protobuf::uint32 value);
// optional uint32 height = 3;
bool has_height() const;
void clear_height();
static const int kHeightFieldNumber = 3;
::google::protobuf::uint32 height() const;
void set_height(::google::protobuf::uint32 value);
// optional uint32 width = 4;
bool has_width() const;
void clear_width();
static const int kWidthFieldNumber = 4;
::google::protobuf::uint32 width() const;
void set_width(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.MemoryDataParameter)
private:
void set_has_batch_size();
void clear_has_batch_size();
void set_has_channels();
void clear_has_channels();
void set_has_height();
void clear_has_height();
void set_has_width();
void clear_has_width();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::uint32 batch_size_;
::google::protobuf::uint32 channels_;
::google::protobuf::uint32 height_;
::google::protobuf::uint32 width_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsMemoryDataParameterImpl();
};
// -------------------------------------------------------------------
class MVNParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.MVNParameter) */ {
public:
MVNParameter();
virtual ~MVNParameter();
MVNParameter(const MVNParameter& from);
inline MVNParameter& operator=(const MVNParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
MVNParameter(MVNParameter&& from) noexcept
: MVNParameter() {
*this = ::std::move(from);
}
inline MVNParameter& operator=(MVNParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const MVNParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const MVNParameter* internal_default_instance() {
return reinterpret_cast<const MVNParameter*>(
&_MVNParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
46;
void Swap(MVNParameter* other);
friend void swap(MVNParameter& a, MVNParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline MVNParameter* New() const PROTOBUF_FINAL { return New(NULL); }
MVNParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const MVNParameter& from);
void MergeFrom(const MVNParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(MVNParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional bool across_channels = 2 [default = false];
bool has_across_channels() const;
void clear_across_channels();
static const int kAcrossChannelsFieldNumber = 2;
bool across_channels() const;
void set_across_channels(bool value);
// optional bool normalize_variance = 1 [default = true];
bool has_normalize_variance() const;
void clear_normalize_variance();
static const int kNormalizeVarianceFieldNumber = 1;
bool normalize_variance() const;
void set_normalize_variance(bool value);
// optional float eps = 3 [default = 1e-09];
bool has_eps() const;
void clear_eps();
static const int kEpsFieldNumber = 3;
float eps() const;
void set_eps(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.MVNParameter)
private:
void set_has_normalize_variance();
void clear_has_normalize_variance();
void set_has_across_channels();
void clear_has_across_channels();
void set_has_eps();
void clear_has_eps();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
bool across_channels_;
bool normalize_variance_;
float eps_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsMVNParameterImpl();
};
// -------------------------------------------------------------------
class ParameterParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ParameterParameter) */ {
public:
ParameterParameter();
virtual ~ParameterParameter();
ParameterParameter(const ParameterParameter& from);
inline ParameterParameter& operator=(const ParameterParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ParameterParameter(ParameterParameter&& from) noexcept
: ParameterParameter() {
*this = ::std::move(from);
}
inline ParameterParameter& operator=(ParameterParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ParameterParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ParameterParameter* internal_default_instance() {
return reinterpret_cast<const ParameterParameter*>(
&_ParameterParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
47;
void Swap(ParameterParameter* other);
friend void swap(ParameterParameter& a, ParameterParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ParameterParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ParameterParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ParameterParameter& from);
void MergeFrom(const ParameterParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ParameterParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.BlobShape shape = 1;
bool has_shape() const;
void clear_shape();
static const int kShapeFieldNumber = 1;
const ::opencv_caffe::BlobShape& shape() const;
::opencv_caffe::BlobShape* release_shape();
::opencv_caffe::BlobShape* mutable_shape();
void set_allocated_shape(::opencv_caffe::BlobShape* shape);
// @@protoc_insertion_point(class_scope:opencv_caffe.ParameterParameter)
private:
void set_has_shape();
void clear_has_shape();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::BlobShape* shape_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsParameterParameterImpl();
};
// -------------------------------------------------------------------
class PoolingParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PoolingParameter) */ {
public:
PoolingParameter();
virtual ~PoolingParameter();
PoolingParameter(const PoolingParameter& from);
inline PoolingParameter& operator=(const PoolingParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
PoolingParameter(PoolingParameter&& from) noexcept
: PoolingParameter() {
*this = ::std::move(from);
}
inline PoolingParameter& operator=(PoolingParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const PoolingParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PoolingParameter* internal_default_instance() {
return reinterpret_cast<const PoolingParameter*>(
&_PoolingParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
48;
void Swap(PoolingParameter* other);
friend void swap(PoolingParameter& a, PoolingParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline PoolingParameter* New() const PROTOBUF_FINAL { return New(NULL); }
PoolingParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const PoolingParameter& from);
void MergeFrom(const PoolingParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(PoolingParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef PoolingParameter_PoolMethod PoolMethod;
static const PoolMethod MAX =
PoolingParameter_PoolMethod_MAX;
static const PoolMethod AVE =
PoolingParameter_PoolMethod_AVE;
static const PoolMethod STOCHASTIC =
PoolingParameter_PoolMethod_STOCHASTIC;
static inline bool PoolMethod_IsValid(int value) {
return PoolingParameter_PoolMethod_IsValid(value);
}
static const PoolMethod PoolMethod_MIN =
PoolingParameter_PoolMethod_PoolMethod_MIN;
static const PoolMethod PoolMethod_MAX =
PoolingParameter_PoolMethod_PoolMethod_MAX;
static const int PoolMethod_ARRAYSIZE =
PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
PoolMethod_descriptor() {
return PoolingParameter_PoolMethod_descriptor();
}
static inline const ::std::string& PoolMethod_Name(PoolMethod value) {
return PoolingParameter_PoolMethod_Name(value);
}
static inline bool PoolMethod_Parse(const ::std::string& name,
PoolMethod* value) {
return PoolingParameter_PoolMethod_Parse(name, value);
}
typedef PoolingParameter_Engine Engine;
static const Engine DEFAULT =
PoolingParameter_Engine_DEFAULT;
static const Engine CAFFE =
PoolingParameter_Engine_CAFFE;
static const Engine CUDNN =
PoolingParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return PoolingParameter_Engine_IsValid(value);
}
static const Engine Engine_MIN =
PoolingParameter_Engine_Engine_MIN;
static const Engine Engine_MAX =
PoolingParameter_Engine_Engine_MAX;
static const int Engine_ARRAYSIZE =
PoolingParameter_Engine_Engine_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Engine_descriptor() {
return PoolingParameter_Engine_descriptor();
}
static inline const ::std::string& Engine_Name(Engine value) {
return PoolingParameter_Engine_Name(value);
}
static inline bool Engine_Parse(const ::std::string& name,
Engine* value) {
return PoolingParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
bool has_pool() const;
void clear_pool();
static const int kPoolFieldNumber = 1;
::opencv_caffe::PoolingParameter_PoolMethod pool() const;
void set_pool(::opencv_caffe::PoolingParameter_PoolMethod value);
// optional uint32 kernel_size = 2;
bool has_kernel_size() const;
void clear_kernel_size();
static const int kKernelSizeFieldNumber = 2;
::google::protobuf::uint32 kernel_size() const;
void set_kernel_size(::google::protobuf::uint32 value);
// optional uint32 pad = 4 [default = 0];
bool has_pad() const;
void clear_pad();
static const int kPadFieldNumber = 4;
::google::protobuf::uint32 pad() const;
void set_pad(::google::protobuf::uint32 value);
// optional uint32 kernel_h = 5;
bool has_kernel_h() const;
void clear_kernel_h();
static const int kKernelHFieldNumber = 5;
::google::protobuf::uint32 kernel_h() const;
void set_kernel_h(::google::protobuf::uint32 value);
// optional uint32 kernel_w = 6;
bool has_kernel_w() const;
void clear_kernel_w();
static const int kKernelWFieldNumber = 6;
::google::protobuf::uint32 kernel_w() const;
void set_kernel_w(::google::protobuf::uint32 value);
// optional uint32 stride_h = 7;
bool has_stride_h() const;
void clear_stride_h();
static const int kStrideHFieldNumber = 7;
::google::protobuf::uint32 stride_h() const;
void set_stride_h(::google::protobuf::uint32 value);
// optional uint32 stride_w = 8;
bool has_stride_w() const;
void clear_stride_w();
static const int kStrideWFieldNumber = 8;
::google::protobuf::uint32 stride_w() const;
void set_stride_w(::google::protobuf::uint32 value);
// optional uint32 pad_h = 9 [default = 0];
bool has_pad_h() const;
void clear_pad_h();
static const int kPadHFieldNumber = 9;
::google::protobuf::uint32 pad_h() const;
void set_pad_h(::google::protobuf::uint32 value);
// optional uint32 pad_w = 10 [default = 0];
bool has_pad_w() const;
void clear_pad_w();
static const int kPadWFieldNumber = 10;
::google::protobuf::uint32 pad_w() const;
void set_pad_w(::google::protobuf::uint32 value);
// optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
bool has_engine() const;
void clear_engine();
static const int kEngineFieldNumber = 11;
::opencv_caffe::PoolingParameter_Engine engine() const;
void set_engine(::opencv_caffe::PoolingParameter_Engine value);
// optional bool global_pooling = 12 [default = false];
bool has_global_pooling() const;
void clear_global_pooling();
static const int kGlobalPoolingFieldNumber = 12;
bool global_pooling() const;
void set_global_pooling(bool value);
// optional uint32 stride = 3 [default = 1];
bool has_stride() const;
void clear_stride();
static const int kStrideFieldNumber = 3;
::google::protobuf::uint32 stride() const;
void set_stride(::google::protobuf::uint32 value);
// optional bool ceil_mode = 13 [default = true];
bool has_ceil_mode() const;
void clear_ceil_mode();
static const int kCeilModeFieldNumber = 13;
bool ceil_mode() const;
void set_ceil_mode(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.PoolingParameter)
private:
void set_has_pool();
void clear_has_pool();
void set_has_pad();
void clear_has_pad();
void set_has_pad_h();
void clear_has_pad_h();
void set_has_pad_w();
void clear_has_pad_w();
void set_has_kernel_size();
void clear_has_kernel_size();
void set_has_kernel_h();
void clear_has_kernel_h();
void set_has_kernel_w();
void clear_has_kernel_w();
void set_has_stride();
void clear_has_stride();
void set_has_stride_h();
void clear_has_stride_h();
void set_has_stride_w();
void clear_has_stride_w();
void set_has_engine();
void clear_has_engine();
void set_has_global_pooling();
void clear_has_global_pooling();
void set_has_ceil_mode();
void clear_has_ceil_mode();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
int pool_;
::google::protobuf::uint32 kernel_size_;
::google::protobuf::uint32 pad_;
::google::protobuf::uint32 kernel_h_;
::google::protobuf::uint32 kernel_w_;
::google::protobuf::uint32 stride_h_;
::google::protobuf::uint32 stride_w_;
::google::protobuf::uint32 pad_h_;
::google::protobuf::uint32 pad_w_;
int engine_;
bool global_pooling_;
::google::protobuf::uint32 stride_;
bool ceil_mode_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPoolingParameterImpl();
};
// -------------------------------------------------------------------
class PowerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PowerParameter) */ {
public:
PowerParameter();
virtual ~PowerParameter();
PowerParameter(const PowerParameter& from);
inline PowerParameter& operator=(const PowerParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
PowerParameter(PowerParameter&& from) noexcept
: PowerParameter() {
*this = ::std::move(from);
}
inline PowerParameter& operator=(PowerParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const PowerParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PowerParameter* internal_default_instance() {
return reinterpret_cast<const PowerParameter*>(
&_PowerParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
49;
void Swap(PowerParameter* other);
friend void swap(PowerParameter& a, PowerParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline PowerParameter* New() const PROTOBUF_FINAL { return New(NULL); }
PowerParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const PowerParameter& from);
void MergeFrom(const PowerParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(PowerParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional float shift = 3 [default = 0];
bool has_shift() const;
void clear_shift();
static const int kShiftFieldNumber = 3;
float shift() const;
void set_shift(float value);
// optional float power = 1 [default = 1];
bool has_power() const;
void clear_power();
static const int kPowerFieldNumber = 1;
float power() const;
void set_power(float value);
// optional float scale = 2 [default = 1];
bool has_scale() const;
void clear_scale();
static const int kScaleFieldNumber = 2;
float scale() const;
void set_scale(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.PowerParameter)
private:
void set_has_power();
void clear_has_power();
void set_has_scale();
void clear_has_scale();
void set_has_shift();
void clear_has_shift();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float shift_;
float power_;
float scale_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPowerParameterImpl();
};
// -------------------------------------------------------------------
class PythonParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PythonParameter) */ {
public:
PythonParameter();
virtual ~PythonParameter();
PythonParameter(const PythonParameter& from);
inline PythonParameter& operator=(const PythonParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
PythonParameter(PythonParameter&& from) noexcept
: PythonParameter() {
*this = ::std::move(from);
}
inline PythonParameter& operator=(PythonParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const PythonParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PythonParameter* internal_default_instance() {
return reinterpret_cast<const PythonParameter*>(
&_PythonParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
50;
void Swap(PythonParameter* other);
friend void swap(PythonParameter& a, PythonParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline PythonParameter* New() const PROTOBUF_FINAL { return New(NULL); }
PythonParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const PythonParameter& from);
void MergeFrom(const PythonParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(PythonParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional string module = 1;
bool has_module() const;
void clear_module();
static const int kModuleFieldNumber = 1;
const ::std::string& module() const;
void set_module(const ::std::string& value);
#if LANG_CXX11
void set_module(::std::string&& value);
#endif
void set_module(const char* value);
void set_module(const char* value, size_t size);
::std::string* mutable_module();
::std::string* release_module();
void set_allocated_module(::std::string* module);
// optional string layer = 2;
bool has_layer() const;
void clear_layer();
static const int kLayerFieldNumber = 2;
const ::std::string& layer() const;
void set_layer(const ::std::string& value);
#if LANG_CXX11
void set_layer(::std::string&& value);
#endif
void set_layer(const char* value);
void set_layer(const char* value, size_t size);
::std::string* mutable_layer();
::std::string* release_layer();
void set_allocated_layer(::std::string* layer);
// optional string param_str = 3 [default = ""];
bool has_param_str() const;
void clear_param_str();
static const int kParamStrFieldNumber = 3;
const ::std::string& param_str() const;
void set_param_str(const ::std::string& value);
#if LANG_CXX11
void set_param_str(::std::string&& value);
#endif
void set_param_str(const char* value);
void set_param_str(const char* value, size_t size);
::std::string* mutable_param_str();
::std::string* release_param_str();
void set_allocated_param_str(::std::string* param_str);
// optional bool share_in_parallel = 4 [default = false];
bool has_share_in_parallel() const;
void clear_share_in_parallel();
static const int kShareInParallelFieldNumber = 4;
bool share_in_parallel() const;
void set_share_in_parallel(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.PythonParameter)
private:
void set_has_module();
void clear_has_module();
void set_has_layer();
void clear_has_layer();
void set_has_param_str();
void clear_has_param_str();
void set_has_share_in_parallel();
void clear_has_share_in_parallel();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr module_;
::google::protobuf::internal::ArenaStringPtr layer_;
::google::protobuf::internal::ArenaStringPtr param_str_;
bool share_in_parallel_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPythonParameterImpl();
};
// -------------------------------------------------------------------
class RecurrentParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.RecurrentParameter) */ {
public:
RecurrentParameter();
virtual ~RecurrentParameter();
RecurrentParameter(const RecurrentParameter& from);
inline RecurrentParameter& operator=(const RecurrentParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
RecurrentParameter(RecurrentParameter&& from) noexcept
: RecurrentParameter() {
*this = ::std::move(from);
}
inline RecurrentParameter& operator=(RecurrentParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const RecurrentParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const RecurrentParameter* internal_default_instance() {
return reinterpret_cast<const RecurrentParameter*>(
&_RecurrentParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
51;
void Swap(RecurrentParameter* other);
friend void swap(RecurrentParameter& a, RecurrentParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline RecurrentParameter* New() const PROTOBUF_FINAL { return New(NULL); }
RecurrentParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const RecurrentParameter& from);
void MergeFrom(const RecurrentParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(RecurrentParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.FillerParameter weight_filler = 2;
bool has_weight_filler() const;
void clear_weight_filler();
static const int kWeightFillerFieldNumber = 2;
const ::opencv_caffe::FillerParameter& weight_filler() const;
::opencv_caffe::FillerParameter* release_weight_filler();
::opencv_caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
// optional .opencv_caffe.FillerParameter bias_filler = 3;
bool has_bias_filler() const;
void clear_bias_filler();
static const int kBiasFillerFieldNumber = 3;
const ::opencv_caffe::FillerParameter& bias_filler() const;
::opencv_caffe::FillerParameter* release_bias_filler();
::opencv_caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
// optional uint32 num_output = 1 [default = 0];
bool has_num_output() const;
void clear_num_output();
static const int kNumOutputFieldNumber = 1;
::google::protobuf::uint32 num_output() const;
void set_num_output(::google::protobuf::uint32 value);
// optional bool debug_info = 4 [default = false];
bool has_debug_info() const;
void clear_debug_info();
static const int kDebugInfoFieldNumber = 4;
bool debug_info() const;
void set_debug_info(bool value);
// optional bool expose_hidden = 5 [default = false];
bool has_expose_hidden() const;
void clear_expose_hidden();
static const int kExposeHiddenFieldNumber = 5;
bool expose_hidden() const;
void set_expose_hidden(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.RecurrentParameter)
private:
void set_has_num_output();
void clear_has_num_output();
void set_has_weight_filler();
void clear_has_weight_filler();
void set_has_bias_filler();
void clear_has_bias_filler();
void set_has_debug_info();
void clear_has_debug_info();
void set_has_expose_hidden();
void clear_has_expose_hidden();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::FillerParameter* weight_filler_;
::opencv_caffe::FillerParameter* bias_filler_;
::google::protobuf::uint32 num_output_;
bool debug_info_;
bool expose_hidden_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsRecurrentParameterImpl();
};
// -------------------------------------------------------------------
class ReductionParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReductionParameter) */ {
public:
ReductionParameter();
virtual ~ReductionParameter();
ReductionParameter(const ReductionParameter& from);
inline ReductionParameter& operator=(const ReductionParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ReductionParameter(ReductionParameter&& from) noexcept
: ReductionParameter() {
*this = ::std::move(from);
}
inline ReductionParameter& operator=(ReductionParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ReductionParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ReductionParameter* internal_default_instance() {
return reinterpret_cast<const ReductionParameter*>(
&_ReductionParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
52;
void Swap(ReductionParameter* other);
friend void swap(ReductionParameter& a, ReductionParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ReductionParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ReductionParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ReductionParameter& from);
void MergeFrom(const ReductionParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ReductionParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef ReductionParameter_ReductionOp ReductionOp;
static const ReductionOp SUM =
ReductionParameter_ReductionOp_SUM;
static const ReductionOp ASUM =
ReductionParameter_ReductionOp_ASUM;
static const ReductionOp SUMSQ =
ReductionParameter_ReductionOp_SUMSQ;
static const ReductionOp MEAN =
ReductionParameter_ReductionOp_MEAN;
static inline bool ReductionOp_IsValid(int value) {
return ReductionParameter_ReductionOp_IsValid(value);
}
static const ReductionOp ReductionOp_MIN =
ReductionParameter_ReductionOp_ReductionOp_MIN;
static const ReductionOp ReductionOp_MAX =
ReductionParameter_ReductionOp_ReductionOp_MAX;
static const int ReductionOp_ARRAYSIZE =
ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
ReductionOp_descriptor() {
return ReductionParameter_ReductionOp_descriptor();
}
static inline const ::std::string& ReductionOp_Name(ReductionOp value) {
return ReductionParameter_ReductionOp_Name(value);
}
static inline bool ReductionOp_Parse(const ::std::string& name,
ReductionOp* value) {
return ReductionParameter_ReductionOp_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 axis = 2 [default = 0];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 2;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
bool has_operation() const;
void clear_operation();
static const int kOperationFieldNumber = 1;
::opencv_caffe::ReductionParameter_ReductionOp operation() const;
void set_operation(::opencv_caffe::ReductionParameter_ReductionOp value);
// optional float coeff = 3 [default = 1];
bool has_coeff() const;
void clear_coeff();
static const int kCoeffFieldNumber = 3;
float coeff() const;
void set_coeff(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ReductionParameter)
private:
void set_has_operation();
void clear_has_operation();
void set_has_axis();
void clear_has_axis();
void set_has_coeff();
void clear_has_coeff();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::int32 axis_;
int operation_;
float coeff_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReductionParameterImpl();
};
// -------------------------------------------------------------------
class ReLUParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReLUParameter) */ {
public:
ReLUParameter();
virtual ~ReLUParameter();
ReLUParameter(const ReLUParameter& from);
inline ReLUParameter& operator=(const ReLUParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ReLUParameter(ReLUParameter&& from) noexcept
: ReLUParameter() {
*this = ::std::move(from);
}
inline ReLUParameter& operator=(ReLUParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ReLUParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ReLUParameter* internal_default_instance() {
return reinterpret_cast<const ReLUParameter*>(
&_ReLUParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
53;
void Swap(ReLUParameter* other);
friend void swap(ReLUParameter& a, ReLUParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ReLUParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ReLUParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ReLUParameter& from);
void MergeFrom(const ReLUParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ReLUParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef ReLUParameter_Engine Engine;
static const Engine DEFAULT =
ReLUParameter_Engine_DEFAULT;
static const Engine CAFFE =
ReLUParameter_Engine_CAFFE;
static const Engine CUDNN =
ReLUParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return ReLUParameter_Engine_IsValid(value);
}
static const Engine Engine_MIN =
ReLUParameter_Engine_Engine_MIN;
static const Engine Engine_MAX =
ReLUParameter_Engine_Engine_MAX;
static const int Engine_ARRAYSIZE =
ReLUParameter_Engine_Engine_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Engine_descriptor() {
return ReLUParameter_Engine_descriptor();
}
static inline const ::std::string& Engine_Name(Engine value) {
return ReLUParameter_Engine_Name(value);
}
static inline bool Engine_Parse(const ::std::string& name,
Engine* value) {
return ReLUParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional float negative_slope = 1 [default = 0];
bool has_negative_slope() const;
void clear_negative_slope();
static const int kNegativeSlopeFieldNumber = 1;
float negative_slope() const;
void set_negative_slope(float value);
// optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
bool has_engine() const;
void clear_engine();
static const int kEngineFieldNumber = 2;
::opencv_caffe::ReLUParameter_Engine engine() const;
void set_engine(::opencv_caffe::ReLUParameter_Engine value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ReLUParameter)
private:
void set_has_negative_slope();
void clear_has_negative_slope();
void set_has_engine();
void clear_has_engine();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float negative_slope_;
int engine_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReLUParameterImpl();
};
// -------------------------------------------------------------------
class ReshapeParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReshapeParameter) */ {
public:
ReshapeParameter();
virtual ~ReshapeParameter();
ReshapeParameter(const ReshapeParameter& from);
inline ReshapeParameter& operator=(const ReshapeParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ReshapeParameter(ReshapeParameter&& from) noexcept
: ReshapeParameter() {
*this = ::std::move(from);
}
inline ReshapeParameter& operator=(ReshapeParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ReshapeParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ReshapeParameter* internal_default_instance() {
return reinterpret_cast<const ReshapeParameter*>(
&_ReshapeParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
54;
void Swap(ReshapeParameter* other);
friend void swap(ReshapeParameter& a, ReshapeParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ReshapeParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ReshapeParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ReshapeParameter& from);
void MergeFrom(const ReshapeParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ReshapeParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.BlobShape shape = 1;
bool has_shape() const;
void clear_shape();
static const int kShapeFieldNumber = 1;
const ::opencv_caffe::BlobShape& shape() const;
::opencv_caffe::BlobShape* release_shape();
::opencv_caffe::BlobShape* mutable_shape();
void set_allocated_shape(::opencv_caffe::BlobShape* shape);
// optional int32 axis = 2 [default = 0];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 2;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// optional int32 num_axes = 3 [default = -1];
bool has_num_axes() const;
void clear_num_axes();
static const int kNumAxesFieldNumber = 3;
::google::protobuf::int32 num_axes() const;
void set_num_axes(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ReshapeParameter)
private:
void set_has_shape();
void clear_has_shape();
void set_has_axis();
void clear_has_axis();
void set_has_num_axes();
void clear_has_num_axes();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::BlobShape* shape_;
::google::protobuf::int32 axis_;
::google::protobuf::int32 num_axes_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReshapeParameterImpl();
};
// -------------------------------------------------------------------
class ScaleParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ScaleParameter) */ {
public:
ScaleParameter();
virtual ~ScaleParameter();
ScaleParameter(const ScaleParameter& from);
inline ScaleParameter& operator=(const ScaleParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ScaleParameter(ScaleParameter&& from) noexcept
: ScaleParameter() {
*this = ::std::move(from);
}
inline ScaleParameter& operator=(ScaleParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ScaleParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ScaleParameter* internal_default_instance() {
return reinterpret_cast<const ScaleParameter*>(
&_ScaleParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
55;
void Swap(ScaleParameter* other);
friend void swap(ScaleParameter& a, ScaleParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ScaleParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ScaleParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ScaleParameter& from);
void MergeFrom(const ScaleParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ScaleParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.FillerParameter filler = 3;
bool has_filler() const;
void clear_filler();
static const int kFillerFieldNumber = 3;
const ::opencv_caffe::FillerParameter& filler() const;
::opencv_caffe::FillerParameter* release_filler();
::opencv_caffe::FillerParameter* mutable_filler();
void set_allocated_filler(::opencv_caffe::FillerParameter* filler);
// optional .opencv_caffe.FillerParameter bias_filler = 5;
bool has_bias_filler() const;
void clear_bias_filler();
static const int kBiasFillerFieldNumber = 5;
const ::opencv_caffe::FillerParameter& bias_filler() const;
::opencv_caffe::FillerParameter* release_bias_filler();
::opencv_caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
// optional bool bias_term = 4 [default = false];
bool has_bias_term() const;
void clear_bias_term();
static const int kBiasTermFieldNumber = 4;
bool bias_term() const;
void set_bias_term(bool value);
// optional int32 axis = 1 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 1;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// optional int32 num_axes = 2 [default = 1];
bool has_num_axes() const;
void clear_num_axes();
static const int kNumAxesFieldNumber = 2;
::google::protobuf::int32 num_axes() const;
void set_num_axes(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ScaleParameter)
private:
void set_has_axis();
void clear_has_axis();
void set_has_num_axes();
void clear_has_num_axes();
void set_has_filler();
void clear_has_filler();
void set_has_bias_term();
void clear_has_bias_term();
void set_has_bias_filler();
void clear_has_bias_filler();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::FillerParameter* filler_;
::opencv_caffe::FillerParameter* bias_filler_;
bool bias_term_;
::google::protobuf::int32 axis_;
::google::protobuf::int32 num_axes_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsScaleParameterImpl();
};
// -------------------------------------------------------------------
class SigmoidParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SigmoidParameter) */ {
public:
SigmoidParameter();
virtual ~SigmoidParameter();
SigmoidParameter(const SigmoidParameter& from);
inline SigmoidParameter& operator=(const SigmoidParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
SigmoidParameter(SigmoidParameter&& from) noexcept
: SigmoidParameter() {
*this = ::std::move(from);
}
inline SigmoidParameter& operator=(SigmoidParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const SigmoidParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const SigmoidParameter* internal_default_instance() {
return reinterpret_cast<const SigmoidParameter*>(
&_SigmoidParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
56;
void Swap(SigmoidParameter* other);
friend void swap(SigmoidParameter& a, SigmoidParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline SigmoidParameter* New() const PROTOBUF_FINAL { return New(NULL); }
SigmoidParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const SigmoidParameter& from);
void MergeFrom(const SigmoidParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(SigmoidParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef SigmoidParameter_Engine Engine;
static const Engine DEFAULT =
SigmoidParameter_Engine_DEFAULT;
static const Engine CAFFE =
SigmoidParameter_Engine_CAFFE;
static const Engine CUDNN =
SigmoidParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return SigmoidParameter_Engine_IsValid(value);
}
static const Engine Engine_MIN =
SigmoidParameter_Engine_Engine_MIN;
static const Engine Engine_MAX =
SigmoidParameter_Engine_Engine_MAX;
static const int Engine_ARRAYSIZE =
SigmoidParameter_Engine_Engine_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Engine_descriptor() {
return SigmoidParameter_Engine_descriptor();
}
static inline const ::std::string& Engine_Name(Engine value) {
return SigmoidParameter_Engine_Name(value);
}
static inline bool Engine_Parse(const ::std::string& name,
Engine* value) {
return SigmoidParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
bool has_engine() const;
void clear_engine();
static const int kEngineFieldNumber = 1;
::opencv_caffe::SigmoidParameter_Engine engine() const;
void set_engine(::opencv_caffe::SigmoidParameter_Engine value);
// @@protoc_insertion_point(class_scope:opencv_caffe.SigmoidParameter)
private:
void set_has_engine();
void clear_has_engine();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
int engine_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSigmoidParameterImpl();
};
// -------------------------------------------------------------------
class SliceParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SliceParameter) */ {
public:
SliceParameter();
virtual ~SliceParameter();
SliceParameter(const SliceParameter& from);
inline SliceParameter& operator=(const SliceParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
SliceParameter(SliceParameter&& from) noexcept
: SliceParameter() {
*this = ::std::move(from);
}
inline SliceParameter& operator=(SliceParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const SliceParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const SliceParameter* internal_default_instance() {
return reinterpret_cast<const SliceParameter*>(
&_SliceParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
57;
void Swap(SliceParameter* other);
friend void swap(SliceParameter& a, SliceParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline SliceParameter* New() const PROTOBUF_FINAL { return New(NULL); }
SliceParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const SliceParameter& from);
void MergeFrom(const SliceParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(SliceParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated uint32 slice_point = 2;
int slice_point_size() const;
void clear_slice_point();
static const int kSlicePointFieldNumber = 2;
::google::protobuf::uint32 slice_point(int index) const;
void set_slice_point(int index, ::google::protobuf::uint32 value);
void add_slice_point(::google::protobuf::uint32 value);
const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
slice_point() const;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
mutable_slice_point();
// optional uint32 slice_dim = 1 [default = 1];
bool has_slice_dim() const;
void clear_slice_dim();
static const int kSliceDimFieldNumber = 1;
::google::protobuf::uint32 slice_dim() const;
void set_slice_dim(::google::protobuf::uint32 value);
// optional int32 axis = 3 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 3;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.SliceParameter)
private:
void set_has_axis();
void clear_has_axis();
void set_has_slice_dim();
void clear_has_slice_dim();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< ::google::protobuf::uint32 > slice_point_;
::google::protobuf::uint32 slice_dim_;
::google::protobuf::int32 axis_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSliceParameterImpl();
};
// -------------------------------------------------------------------
class SoftmaxParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SoftmaxParameter) */ {
public:
SoftmaxParameter();
virtual ~SoftmaxParameter();
SoftmaxParameter(const SoftmaxParameter& from);
inline SoftmaxParameter& operator=(const SoftmaxParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
SoftmaxParameter(SoftmaxParameter&& from) noexcept
: SoftmaxParameter() {
*this = ::std::move(from);
}
inline SoftmaxParameter& operator=(SoftmaxParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const SoftmaxParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const SoftmaxParameter* internal_default_instance() {
return reinterpret_cast<const SoftmaxParameter*>(
&_SoftmaxParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
58;
void Swap(SoftmaxParameter* other);
friend void swap(SoftmaxParameter& a, SoftmaxParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline SoftmaxParameter* New() const PROTOBUF_FINAL { return New(NULL); }
SoftmaxParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const SoftmaxParameter& from);
void MergeFrom(const SoftmaxParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(SoftmaxParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef SoftmaxParameter_Engine Engine;
static const Engine DEFAULT =
SoftmaxParameter_Engine_DEFAULT;
static const Engine CAFFE =
SoftmaxParameter_Engine_CAFFE;
static const Engine CUDNN =
SoftmaxParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return SoftmaxParameter_Engine_IsValid(value);
}
static const Engine Engine_MIN =
SoftmaxParameter_Engine_Engine_MIN;
static const Engine Engine_MAX =
SoftmaxParameter_Engine_Engine_MAX;
static const int Engine_ARRAYSIZE =
SoftmaxParameter_Engine_Engine_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Engine_descriptor() {
return SoftmaxParameter_Engine_descriptor();
}
static inline const ::std::string& Engine_Name(Engine value) {
return SoftmaxParameter_Engine_Name(value);
}
static inline bool Engine_Parse(const ::std::string& name,
Engine* value) {
return SoftmaxParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
bool has_engine() const;
void clear_engine();
static const int kEngineFieldNumber = 1;
::opencv_caffe::SoftmaxParameter_Engine engine() const;
void set_engine(::opencv_caffe::SoftmaxParameter_Engine value);
// optional int32 axis = 2 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 2;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.SoftmaxParameter)
private:
void set_has_engine();
void clear_has_engine();
void set_has_axis();
void clear_has_axis();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
int engine_;
::google::protobuf::int32 axis_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSoftmaxParameterImpl();
};
// -------------------------------------------------------------------
class TanHParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TanHParameter) */ {
public:
TanHParameter();
virtual ~TanHParameter();
TanHParameter(const TanHParameter& from);
inline TanHParameter& operator=(const TanHParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
TanHParameter(TanHParameter&& from) noexcept
: TanHParameter() {
*this = ::std::move(from);
}
inline TanHParameter& operator=(TanHParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const TanHParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const TanHParameter* internal_default_instance() {
return reinterpret_cast<const TanHParameter*>(
&_TanHParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
59;
void Swap(TanHParameter* other);
friend void swap(TanHParameter& a, TanHParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline TanHParameter* New() const PROTOBUF_FINAL { return New(NULL); }
TanHParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const TanHParameter& from);
void MergeFrom(const TanHParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(TanHParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef TanHParameter_Engine Engine;
static const Engine DEFAULT =
TanHParameter_Engine_DEFAULT;
static const Engine CAFFE =
TanHParameter_Engine_CAFFE;
static const Engine CUDNN =
TanHParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return TanHParameter_Engine_IsValid(value);
}
static const Engine Engine_MIN =
TanHParameter_Engine_Engine_MIN;
static const Engine Engine_MAX =
TanHParameter_Engine_Engine_MAX;
static const int Engine_ARRAYSIZE =
TanHParameter_Engine_Engine_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Engine_descriptor() {
return TanHParameter_Engine_descriptor();
}
static inline const ::std::string& Engine_Name(Engine value) {
return TanHParameter_Engine_Name(value);
}
static inline bool Engine_Parse(const ::std::string& name,
Engine* value) {
return TanHParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
bool has_engine() const;
void clear_engine();
static const int kEngineFieldNumber = 1;
::opencv_caffe::TanHParameter_Engine engine() const;
void set_engine(::opencv_caffe::TanHParameter_Engine value);
// @@protoc_insertion_point(class_scope:opencv_caffe.TanHParameter)
private:
void set_has_engine();
void clear_has_engine();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
int engine_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTanHParameterImpl();
};
// -------------------------------------------------------------------
class TileParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TileParameter) */ {
public:
TileParameter();
virtual ~TileParameter();
TileParameter(const TileParameter& from);
inline TileParameter& operator=(const TileParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
TileParameter(TileParameter&& from) noexcept
: TileParameter() {
*this = ::std::move(from);
}
inline TileParameter& operator=(TileParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const TileParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const TileParameter* internal_default_instance() {
return reinterpret_cast<const TileParameter*>(
&_TileParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
60;
void Swap(TileParameter* other);
friend void swap(TileParameter& a, TileParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline TileParameter* New() const PROTOBUF_FINAL { return New(NULL); }
TileParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const TileParameter& from);
void MergeFrom(const TileParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(TileParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional int32 tiles = 2;
bool has_tiles() const;
void clear_tiles();
static const int kTilesFieldNumber = 2;
::google::protobuf::int32 tiles() const;
void set_tiles(::google::protobuf::int32 value);
// optional int32 axis = 1 [default = 1];
bool has_axis() const;
void clear_axis();
static const int kAxisFieldNumber = 1;
::google::protobuf::int32 axis() const;
void set_axis(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.TileParameter)
private:
void set_has_axis();
void clear_has_axis();
void set_has_tiles();
void clear_has_tiles();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::int32 tiles_;
::google::protobuf::int32 axis_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTileParameterImpl();
};
// -------------------------------------------------------------------
class ThresholdParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ThresholdParameter) */ {
public:
ThresholdParameter();
virtual ~ThresholdParameter();
ThresholdParameter(const ThresholdParameter& from);
inline ThresholdParameter& operator=(const ThresholdParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ThresholdParameter(ThresholdParameter&& from) noexcept
: ThresholdParameter() {
*this = ::std::move(from);
}
inline ThresholdParameter& operator=(ThresholdParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ThresholdParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ThresholdParameter* internal_default_instance() {
return reinterpret_cast<const ThresholdParameter*>(
&_ThresholdParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
61;
void Swap(ThresholdParameter* other);
friend void swap(ThresholdParameter& a, ThresholdParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ThresholdParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ThresholdParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ThresholdParameter& from);
void MergeFrom(const ThresholdParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ThresholdParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional float threshold = 1 [default = 0];
bool has_threshold() const;
void clear_threshold();
static const int kThresholdFieldNumber = 1;
float threshold() const;
void set_threshold(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ThresholdParameter)
private:
void set_has_threshold();
void clear_has_threshold();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float threshold_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsThresholdParameterImpl();
};
// -------------------------------------------------------------------
class WindowDataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.WindowDataParameter) */ {
public:
WindowDataParameter();
virtual ~WindowDataParameter();
WindowDataParameter(const WindowDataParameter& from);
inline WindowDataParameter& operator=(const WindowDataParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
WindowDataParameter(WindowDataParameter&& from) noexcept
: WindowDataParameter() {
*this = ::std::move(from);
}
inline WindowDataParameter& operator=(WindowDataParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const WindowDataParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const WindowDataParameter* internal_default_instance() {
return reinterpret_cast<const WindowDataParameter*>(
&_WindowDataParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
62;
void Swap(WindowDataParameter* other);
friend void swap(WindowDataParameter& a, WindowDataParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline WindowDataParameter* New() const PROTOBUF_FINAL { return New(NULL); }
WindowDataParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const WindowDataParameter& from);
void MergeFrom(const WindowDataParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(WindowDataParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional string source = 1;
bool has_source() const;
void clear_source();
static const int kSourceFieldNumber = 1;
const ::std::string& source() const;
void set_source(const ::std::string& value);
#if LANG_CXX11
void set_source(::std::string&& value);
#endif
void set_source(const char* value);
void set_source(const char* value, size_t size);
::std::string* mutable_source();
::std::string* release_source();
void set_allocated_source(::std::string* source);
// optional string mean_file = 3;
bool has_mean_file() const;
void clear_mean_file();
static const int kMeanFileFieldNumber = 3;
const ::std::string& mean_file() const;
void set_mean_file(const ::std::string& value);
#if LANG_CXX11
void set_mean_file(::std::string&& value);
#endif
void set_mean_file(const char* value);
void set_mean_file(const char* value, size_t size);
::std::string* mutable_mean_file();
::std::string* release_mean_file();
void set_allocated_mean_file(::std::string* mean_file);
// optional string crop_mode = 11 [default = "warp"];
bool has_crop_mode() const;
void clear_crop_mode();
static const int kCropModeFieldNumber = 11;
const ::std::string& crop_mode() const;
void set_crop_mode(const ::std::string& value);
#if LANG_CXX11
void set_crop_mode(::std::string&& value);
#endif
void set_crop_mode(const char* value);
void set_crop_mode(const char* value, size_t size);
::std::string* mutable_crop_mode();
::std::string* release_crop_mode();
void set_allocated_crop_mode(::std::string* crop_mode);
// optional string root_folder = 13 [default = ""];
bool has_root_folder() const;
void clear_root_folder();
static const int kRootFolderFieldNumber = 13;
const ::std::string& root_folder() const;
void set_root_folder(const ::std::string& value);
#if LANG_CXX11
void set_root_folder(::std::string&& value);
#endif
void set_root_folder(const char* value);
void set_root_folder(const char* value, size_t size);
::std::string* mutable_root_folder();
::std::string* release_root_folder();
void set_allocated_root_folder(::std::string* root_folder);
// optional uint32 batch_size = 4;
bool has_batch_size() const;
void clear_batch_size();
static const int kBatchSizeFieldNumber = 4;
::google::protobuf::uint32 batch_size() const;
void set_batch_size(::google::protobuf::uint32 value);
// optional uint32 crop_size = 5 [default = 0];
bool has_crop_size() const;
void clear_crop_size();
static const int kCropSizeFieldNumber = 5;
::google::protobuf::uint32 crop_size() const;
void set_crop_size(::google::protobuf::uint32 value);
// optional bool mirror = 6 [default = false];
bool has_mirror() const;
void clear_mirror();
static const int kMirrorFieldNumber = 6;
bool mirror() const;
void set_mirror(bool value);
// optional bool cache_images = 12 [default = false];
bool has_cache_images() const;
void clear_cache_images();
static const int kCacheImagesFieldNumber = 12;
bool cache_images() const;
void set_cache_images(bool value);
// optional uint32 context_pad = 10 [default = 0];
bool has_context_pad() const;
void clear_context_pad();
static const int kContextPadFieldNumber = 10;
::google::protobuf::uint32 context_pad() const;
void set_context_pad(::google::protobuf::uint32 value);
// optional float scale = 2 [default = 1];
bool has_scale() const;
void clear_scale();
static const int kScaleFieldNumber = 2;
float scale() const;
void set_scale(float value);
// optional float fg_threshold = 7 [default = 0.5];
bool has_fg_threshold() const;
void clear_fg_threshold();
static const int kFgThresholdFieldNumber = 7;
float fg_threshold() const;
void set_fg_threshold(float value);
// optional float bg_threshold = 8 [default = 0.5];
bool has_bg_threshold() const;
void clear_bg_threshold();
static const int kBgThresholdFieldNumber = 8;
float bg_threshold() const;
void set_bg_threshold(float value);
// optional float fg_fraction = 9 [default = 0.25];
bool has_fg_fraction() const;
void clear_fg_fraction();
static const int kFgFractionFieldNumber = 9;
float fg_fraction() const;
void set_fg_fraction(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.WindowDataParameter)
private:
void set_has_source();
void clear_has_source();
void set_has_scale();
void clear_has_scale();
void set_has_mean_file();
void clear_has_mean_file();
void set_has_batch_size();
void clear_has_batch_size();
void set_has_crop_size();
void clear_has_crop_size();
void set_has_mirror();
void clear_has_mirror();
void set_has_fg_threshold();
void clear_has_fg_threshold();
void set_has_bg_threshold();
void clear_has_bg_threshold();
void set_has_fg_fraction();
void clear_has_fg_fraction();
void set_has_context_pad();
void clear_has_context_pad();
void set_has_crop_mode();
void clear_has_crop_mode();
void set_has_cache_images();
void clear_has_cache_images();
void set_has_root_folder();
void clear_has_root_folder();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr source_;
::google::protobuf::internal::ArenaStringPtr mean_file_;
static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _default_crop_mode_;
::google::protobuf::internal::ArenaStringPtr crop_mode_;
::google::protobuf::internal::ArenaStringPtr root_folder_;
::google::protobuf::uint32 batch_size_;
::google::protobuf::uint32 crop_size_;
bool mirror_;
bool cache_images_;
::google::protobuf::uint32 context_pad_;
float scale_;
float fg_threshold_;
float bg_threshold_;
float fg_fraction_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsWindowDataParameterImpl();
};
// -------------------------------------------------------------------
class SPPParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SPPParameter) */ {
public:
SPPParameter();
virtual ~SPPParameter();
SPPParameter(const SPPParameter& from);
inline SPPParameter& operator=(const SPPParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
SPPParameter(SPPParameter&& from) noexcept
: SPPParameter() {
*this = ::std::move(from);
}
inline SPPParameter& operator=(SPPParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const SPPParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const SPPParameter* internal_default_instance() {
return reinterpret_cast<const SPPParameter*>(
&_SPPParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
63;
void Swap(SPPParameter* other);
friend void swap(SPPParameter& a, SPPParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline SPPParameter* New() const PROTOBUF_FINAL { return New(NULL); }
SPPParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const SPPParameter& from);
void MergeFrom(const SPPParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(SPPParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef SPPParameter_PoolMethod PoolMethod;
static const PoolMethod MAX =
SPPParameter_PoolMethod_MAX;
static const PoolMethod AVE =
SPPParameter_PoolMethod_AVE;
static const PoolMethod STOCHASTIC =
SPPParameter_PoolMethod_STOCHASTIC;
static inline bool PoolMethod_IsValid(int value) {
return SPPParameter_PoolMethod_IsValid(value);
}
static const PoolMethod PoolMethod_MIN =
SPPParameter_PoolMethod_PoolMethod_MIN;
static const PoolMethod PoolMethod_MAX =
SPPParameter_PoolMethod_PoolMethod_MAX;
static const int PoolMethod_ARRAYSIZE =
SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
PoolMethod_descriptor() {
return SPPParameter_PoolMethod_descriptor();
}
static inline const ::std::string& PoolMethod_Name(PoolMethod value) {
return SPPParameter_PoolMethod_Name(value);
}
static inline bool PoolMethod_Parse(const ::std::string& name,
PoolMethod* value) {
return SPPParameter_PoolMethod_Parse(name, value);
}
typedef SPPParameter_Engine Engine;
static const Engine DEFAULT =
SPPParameter_Engine_DEFAULT;
static const Engine CAFFE =
SPPParameter_Engine_CAFFE;
static const Engine CUDNN =
SPPParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return SPPParameter_Engine_IsValid(value);
}
static const Engine Engine_MIN =
SPPParameter_Engine_Engine_MIN;
static const Engine Engine_MAX =
SPPParameter_Engine_Engine_MAX;
static const int Engine_ARRAYSIZE =
SPPParameter_Engine_Engine_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
Engine_descriptor() {
return SPPParameter_Engine_descriptor();
}
static inline const ::std::string& Engine_Name(Engine value) {
return SPPParameter_Engine_Name(value);
}
static inline bool Engine_Parse(const ::std::string& name,
Engine* value) {
return SPPParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional uint32 pyramid_height = 1;
bool has_pyramid_height() const;
void clear_pyramid_height();
static const int kPyramidHeightFieldNumber = 1;
::google::protobuf::uint32 pyramid_height() const;
void set_pyramid_height(::google::protobuf::uint32 value);
// optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
bool has_pool() const;
void clear_pool();
static const int kPoolFieldNumber = 2;
::opencv_caffe::SPPParameter_PoolMethod pool() const;
void set_pool(::opencv_caffe::SPPParameter_PoolMethod value);
// optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
bool has_engine() const;
void clear_engine();
static const int kEngineFieldNumber = 6;
::opencv_caffe::SPPParameter_Engine engine() const;
void set_engine(::opencv_caffe::SPPParameter_Engine value);
// @@protoc_insertion_point(class_scope:opencv_caffe.SPPParameter)
private:
void set_has_pyramid_height();
void clear_has_pyramid_height();
void set_has_pool();
void clear_has_pool();
void set_has_engine();
void clear_has_engine();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::uint32 pyramid_height_;
int pool_;
int engine_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSPPParameterImpl();
};
// -------------------------------------------------------------------
class V1LayerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.V1LayerParameter) */ {
public:
V1LayerParameter();
virtual ~V1LayerParameter();
V1LayerParameter(const V1LayerParameter& from);
inline V1LayerParameter& operator=(const V1LayerParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
V1LayerParameter(V1LayerParameter&& from) noexcept
: V1LayerParameter() {
*this = ::std::move(from);
}
inline V1LayerParameter& operator=(V1LayerParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const V1LayerParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const V1LayerParameter* internal_default_instance() {
return reinterpret_cast<const V1LayerParameter*>(
&_V1LayerParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
64;
void Swap(V1LayerParameter* other);
friend void swap(V1LayerParameter& a, V1LayerParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline V1LayerParameter* New() const PROTOBUF_FINAL { return New(NULL); }
V1LayerParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const V1LayerParameter& from);
void MergeFrom(const V1LayerParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(V1LayerParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef V1LayerParameter_LayerType LayerType;
static const LayerType NONE =
V1LayerParameter_LayerType_NONE;
static const LayerType ABSVAL =
V1LayerParameter_LayerType_ABSVAL;
static const LayerType ACCURACY =
V1LayerParameter_LayerType_ACCURACY;
static const LayerType ARGMAX =
V1LayerParameter_LayerType_ARGMAX;
static const LayerType BNLL =
V1LayerParameter_LayerType_BNLL;
static const LayerType CONCAT =
V1LayerParameter_LayerType_CONCAT;
static const LayerType CONTRASTIVE_LOSS =
V1LayerParameter_LayerType_CONTRASTIVE_LOSS;
static const LayerType CONVOLUTION =
V1LayerParameter_LayerType_CONVOLUTION;
static const LayerType DATA =
V1LayerParameter_LayerType_DATA;
static const LayerType DECONVOLUTION =
V1LayerParameter_LayerType_DECONVOLUTION;
static const LayerType DROPOUT =
V1LayerParameter_LayerType_DROPOUT;
static const LayerType DUMMY_DATA =
V1LayerParameter_LayerType_DUMMY_DATA;
static const LayerType EUCLIDEAN_LOSS =
V1LayerParameter_LayerType_EUCLIDEAN_LOSS;
static const LayerType ELTWISE =
V1LayerParameter_LayerType_ELTWISE;
static const LayerType EXP =
V1LayerParameter_LayerType_EXP;
static const LayerType FLATTEN =
V1LayerParameter_LayerType_FLATTEN;
static const LayerType HDF5_DATA =
V1LayerParameter_LayerType_HDF5_DATA;
static const LayerType HDF5_OUTPUT =
V1LayerParameter_LayerType_HDF5_OUTPUT;
static const LayerType HINGE_LOSS =
V1LayerParameter_LayerType_HINGE_LOSS;
static const LayerType IM2COL =
V1LayerParameter_LayerType_IM2COL;
static const LayerType IMAGE_DATA =
V1LayerParameter_LayerType_IMAGE_DATA;
static const LayerType INFOGAIN_LOSS =
V1LayerParameter_LayerType_INFOGAIN_LOSS;
static const LayerType INNER_PRODUCT =
V1LayerParameter_LayerType_INNER_PRODUCT;
static const LayerType LRN =
V1LayerParameter_LayerType_LRN;
static const LayerType MEMORY_DATA =
V1LayerParameter_LayerType_MEMORY_DATA;
static const LayerType MULTINOMIAL_LOGISTIC_LOSS =
V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS;
static const LayerType MVN =
V1LayerParameter_LayerType_MVN;
static const LayerType POOLING =
V1LayerParameter_LayerType_POOLING;
static const LayerType POWER =
V1LayerParameter_LayerType_POWER;
static const LayerType RELU =
V1LayerParameter_LayerType_RELU;
static const LayerType SIGMOID =
V1LayerParameter_LayerType_SIGMOID;
static const LayerType SIGMOID_CROSS_ENTROPY_LOSS =
V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS;
static const LayerType SILENCE =
V1LayerParameter_LayerType_SILENCE;
static const LayerType SOFTMAX =
V1LayerParameter_LayerType_SOFTMAX;
static const LayerType SOFTMAX_LOSS =
V1LayerParameter_LayerType_SOFTMAX_LOSS;
static const LayerType SPLIT =
V1LayerParameter_LayerType_SPLIT;
static const LayerType SLICE =
V1LayerParameter_LayerType_SLICE;
static const LayerType TANH =
V1LayerParameter_LayerType_TANH;
static const LayerType WINDOW_DATA =
V1LayerParameter_LayerType_WINDOW_DATA;
static const LayerType THRESHOLD =
V1LayerParameter_LayerType_THRESHOLD;
static inline bool LayerType_IsValid(int value) {
return V1LayerParameter_LayerType_IsValid(value);
}
static const LayerType LayerType_MIN =
V1LayerParameter_LayerType_LayerType_MIN;
static const LayerType LayerType_MAX =
V1LayerParameter_LayerType_LayerType_MAX;
static const int LayerType_ARRAYSIZE =
V1LayerParameter_LayerType_LayerType_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
LayerType_descriptor() {
return V1LayerParameter_LayerType_descriptor();
}
static inline const ::std::string& LayerType_Name(LayerType value) {
return V1LayerParameter_LayerType_Name(value);
}
static inline bool LayerType_Parse(const ::std::string& name,
LayerType* value) {
return V1LayerParameter_LayerType_Parse(name, value);
}
typedef V1LayerParameter_DimCheckMode DimCheckMode;
static const DimCheckMode STRICT =
V1LayerParameter_DimCheckMode_STRICT;
static const DimCheckMode PERMISSIVE =
V1LayerParameter_DimCheckMode_PERMISSIVE;
static inline bool DimCheckMode_IsValid(int value) {
return V1LayerParameter_DimCheckMode_IsValid(value);
}
static const DimCheckMode DimCheckMode_MIN =
V1LayerParameter_DimCheckMode_DimCheckMode_MIN;
static const DimCheckMode DimCheckMode_MAX =
V1LayerParameter_DimCheckMode_DimCheckMode_MAX;
static const int DimCheckMode_ARRAYSIZE =
V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
DimCheckMode_descriptor() {
return V1LayerParameter_DimCheckMode_descriptor();
}
static inline const ::std::string& DimCheckMode_Name(DimCheckMode value) {
return V1LayerParameter_DimCheckMode_Name(value);
}
static inline bool DimCheckMode_Parse(const ::std::string& name,
DimCheckMode* value) {
return V1LayerParameter_DimCheckMode_Parse(name, value);
}
// accessors -------------------------------------------------------
// repeated string bottom = 2;
int bottom_size() const;
void clear_bottom();
static const int kBottomFieldNumber = 2;
const ::std::string& bottom(int index) const;
::std::string* mutable_bottom(int index);
void set_bottom(int index, const ::std::string& value);
#if LANG_CXX11
void set_bottom(int index, ::std::string&& value);
#endif
void set_bottom(int index, const char* value);
void set_bottom(int index, const char* value, size_t size);
::std::string* add_bottom();
void add_bottom(const ::std::string& value);
#if LANG_CXX11
void add_bottom(::std::string&& value);
#endif
void add_bottom(const char* value);
void add_bottom(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& bottom() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_bottom();
// repeated string top = 3;
int top_size() const;
void clear_top();
static const int kTopFieldNumber = 3;
const ::std::string& top(int index) const;
::std::string* mutable_top(int index);
void set_top(int index, const ::std::string& value);
#if LANG_CXX11
void set_top(int index, ::std::string&& value);
#endif
void set_top(int index, const char* value);
void set_top(int index, const char* value, size_t size);
::std::string* add_top();
void add_top(const ::std::string& value);
#if LANG_CXX11
void add_top(::std::string&& value);
#endif
void add_top(const char* value);
void add_top(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& top() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_top();
// repeated .opencv_caffe.BlobProto blobs = 6;
int blobs_size() const;
void clear_blobs();
static const int kBlobsFieldNumber = 6;
const ::opencv_caffe::BlobProto& blobs(int index) const;
::opencv_caffe::BlobProto* mutable_blobs(int index);
::opencv_caffe::BlobProto* add_blobs();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
mutable_blobs();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
blobs() const;
// repeated float blobs_lr = 7;
int blobs_lr_size() const;
void clear_blobs_lr();
static const int kBlobsLrFieldNumber = 7;
float blobs_lr(int index) const;
void set_blobs_lr(int index, float value);
void add_blobs_lr(float value);
const ::google::protobuf::RepeatedField< float >&
blobs_lr() const;
::google::protobuf::RepeatedField< float >*
mutable_blobs_lr();
// repeated float weight_decay = 8;
int weight_decay_size() const;
void clear_weight_decay();
static const int kWeightDecayFieldNumber = 8;
float weight_decay(int index) const;
void set_weight_decay(int index, float value);
void add_weight_decay(float value);
const ::google::protobuf::RepeatedField< float >&
weight_decay() const;
::google::protobuf::RepeatedField< float >*
mutable_weight_decay();
// repeated .opencv_caffe.NetStateRule include = 32;
int include_size() const;
void clear_include();
static const int kIncludeFieldNumber = 32;
const ::opencv_caffe::NetStateRule& include(int index) const;
::opencv_caffe::NetStateRule* mutable_include(int index);
::opencv_caffe::NetStateRule* add_include();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
mutable_include();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
include() const;
// repeated .opencv_caffe.NetStateRule exclude = 33;
int exclude_size() const;
void clear_exclude();
static const int kExcludeFieldNumber = 33;
const ::opencv_caffe::NetStateRule& exclude(int index) const;
::opencv_caffe::NetStateRule* mutable_exclude(int index);
::opencv_caffe::NetStateRule* add_exclude();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
mutable_exclude();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
exclude() const;
// repeated float loss_weight = 35;
int loss_weight_size() const;
void clear_loss_weight();
static const int kLossWeightFieldNumber = 35;
float loss_weight(int index) const;
void set_loss_weight(int index, float value);
void add_loss_weight(float value);
const ::google::protobuf::RepeatedField< float >&
loss_weight() const;
::google::protobuf::RepeatedField< float >*
mutable_loss_weight();
// repeated string param = 1001;
int param_size() const;
void clear_param();
static const int kParamFieldNumber = 1001;
const ::std::string& param(int index) const;
::std::string* mutable_param(int index);
void set_param(int index, const ::std::string& value);
#if LANG_CXX11
void set_param(int index, ::std::string&& value);
#endif
void set_param(int index, const char* value);
void set_param(int index, const char* value, size_t size);
::std::string* add_param();
void add_param(const ::std::string& value);
#if LANG_CXX11
void add_param(::std::string&& value);
#endif
void add_param(const char* value);
void add_param(const char* value, size_t size);
const ::google::protobuf::RepeatedPtrField< ::std::string>& param() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_param();
// repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
int blob_share_mode_size() const;
void clear_blob_share_mode();
static const int kBlobShareModeFieldNumber = 1002;
::opencv_caffe::V1LayerParameter_DimCheckMode blob_share_mode(int index) const;
void set_blob_share_mode(int index, ::opencv_caffe::V1LayerParameter_DimCheckMode value);
void add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value);
const ::google::protobuf::RepeatedField<int>& blob_share_mode() const;
::google::protobuf::RepeatedField<int>* mutable_blob_share_mode();
// optional string name = 4;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 4;
const ::std::string& name() const;
void set_name(const ::std::string& value);
#if LANG_CXX11
void set_name(::std::string&& value);
#endif
void set_name(const char* value);
void set_name(const char* value, size_t size);
::std::string* mutable_name();
::std::string* release_name();
void set_allocated_name(::std::string* name);
// optional .opencv_caffe.V0LayerParameter layer = 1;
bool has_layer() const;
void clear_layer();
static const int kLayerFieldNumber = 1;
const ::opencv_caffe::V0LayerParameter& layer() const;
::opencv_caffe::V0LayerParameter* release_layer();
::opencv_caffe::V0LayerParameter* mutable_layer();
void set_allocated_layer(::opencv_caffe::V0LayerParameter* layer);
// optional .opencv_caffe.ConcatParameter concat_param = 9;
bool has_concat_param() const;
void clear_concat_param();
static const int kConcatParamFieldNumber = 9;
const ::opencv_caffe::ConcatParameter& concat_param() const;
::opencv_caffe::ConcatParameter* release_concat_param();
::opencv_caffe::ConcatParameter* mutable_concat_param();
void set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param);
// optional .opencv_caffe.ConvolutionParameter convolution_param = 10;
bool has_convolution_param() const;
void clear_convolution_param();
static const int kConvolutionParamFieldNumber = 10;
const ::opencv_caffe::ConvolutionParameter& convolution_param() const;
::opencv_caffe::ConvolutionParameter* release_convolution_param();
::opencv_caffe::ConvolutionParameter* mutable_convolution_param();
void set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param);
// optional .opencv_caffe.DataParameter data_param = 11;
bool has_data_param() const;
void clear_data_param();
static const int kDataParamFieldNumber = 11;
const ::opencv_caffe::DataParameter& data_param() const;
::opencv_caffe::DataParameter* release_data_param();
::opencv_caffe::DataParameter* mutable_data_param();
void set_allocated_data_param(::opencv_caffe::DataParameter* data_param);
// optional .opencv_caffe.DropoutParameter dropout_param = 12;
bool has_dropout_param() const;
void clear_dropout_param();
static const int kDropoutParamFieldNumber = 12;
const ::opencv_caffe::DropoutParameter& dropout_param() const;
::opencv_caffe::DropoutParameter* release_dropout_param();
::opencv_caffe::DropoutParameter* mutable_dropout_param();
void set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param);
// optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13;
bool has_hdf5_data_param() const;
void clear_hdf5_data_param();
static const int kHdf5DataParamFieldNumber = 13;
const ::opencv_caffe::HDF5DataParameter& hdf5_data_param() const;
::opencv_caffe::HDF5DataParameter* release_hdf5_data_param();
::opencv_caffe::HDF5DataParameter* mutable_hdf5_data_param();
void set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param);
// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14;
bool has_hdf5_output_param() const;
void clear_hdf5_output_param();
static const int kHdf5OutputParamFieldNumber = 14;
const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const;
::opencv_caffe::HDF5OutputParameter* release_hdf5_output_param();
::opencv_caffe::HDF5OutputParameter* mutable_hdf5_output_param();
void set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
// optional .opencv_caffe.ImageDataParameter image_data_param = 15;
bool has_image_data_param() const;
void clear_image_data_param();
static const int kImageDataParamFieldNumber = 15;
const ::opencv_caffe::ImageDataParameter& image_data_param() const;
::opencv_caffe::ImageDataParameter* release_image_data_param();
::opencv_caffe::ImageDataParameter* mutable_image_data_param();
void set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param);
// optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16;
bool has_infogain_loss_param() const;
void clear_infogain_loss_param();
static const int kInfogainLossParamFieldNumber = 16;
const ::opencv_caffe::InfogainLossParameter& infogain_loss_param() const;
::opencv_caffe::InfogainLossParameter* release_infogain_loss_param();
::opencv_caffe::InfogainLossParameter* mutable_infogain_loss_param();
void set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param);
// optional .opencv_caffe.InnerProductParameter inner_product_param = 17;
bool has_inner_product_param() const;
void clear_inner_product_param();
static const int kInnerProductParamFieldNumber = 17;
const ::opencv_caffe::InnerProductParameter& inner_product_param() const;
::opencv_caffe::InnerProductParameter* release_inner_product_param();
::opencv_caffe::InnerProductParameter* mutable_inner_product_param();
void set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param);
// optional .opencv_caffe.LRNParameter lrn_param = 18;
bool has_lrn_param() const;
void clear_lrn_param();
static const int kLrnParamFieldNumber = 18;
const ::opencv_caffe::LRNParameter& lrn_param() const;
::opencv_caffe::LRNParameter* release_lrn_param();
::opencv_caffe::LRNParameter* mutable_lrn_param();
void set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param);
// optional .opencv_caffe.PoolingParameter pooling_param = 19;
bool has_pooling_param() const;
void clear_pooling_param();
static const int kPoolingParamFieldNumber = 19;
const ::opencv_caffe::PoolingParameter& pooling_param() const;
::opencv_caffe::PoolingParameter* release_pooling_param();
::opencv_caffe::PoolingParameter* mutable_pooling_param();
void set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param);
// optional .opencv_caffe.WindowDataParameter window_data_param = 20;
bool has_window_data_param() const;
void clear_window_data_param();
static const int kWindowDataParamFieldNumber = 20;
const ::opencv_caffe::WindowDataParameter& window_data_param() const;
::opencv_caffe::WindowDataParameter* release_window_data_param();
::opencv_caffe::WindowDataParameter* mutable_window_data_param();
void set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param);
// optional .opencv_caffe.PowerParameter power_param = 21;
bool has_power_param() const;
void clear_power_param();
static const int kPowerParamFieldNumber = 21;
const ::opencv_caffe::PowerParameter& power_param() const;
::opencv_caffe::PowerParameter* release_power_param();
::opencv_caffe::PowerParameter* mutable_power_param();
void set_allocated_power_param(::opencv_caffe::PowerParameter* power_param);
// optional .opencv_caffe.MemoryDataParameter memory_data_param = 22;
bool has_memory_data_param() const;
void clear_memory_data_param();
static const int kMemoryDataParamFieldNumber = 22;
const ::opencv_caffe::MemoryDataParameter& memory_data_param() const;
::opencv_caffe::MemoryDataParameter* release_memory_data_param();
::opencv_caffe::MemoryDataParameter* mutable_memory_data_param();
void set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param);
// optional .opencv_caffe.ArgMaxParameter argmax_param = 23;
bool has_argmax_param() const;
void clear_argmax_param();
static const int kArgmaxParamFieldNumber = 23;
const ::opencv_caffe::ArgMaxParameter& argmax_param() const;
::opencv_caffe::ArgMaxParameter* release_argmax_param();
::opencv_caffe::ArgMaxParameter* mutable_argmax_param();
void set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param);
// optional .opencv_caffe.EltwiseParameter eltwise_param = 24;
bool has_eltwise_param() const;
void clear_eltwise_param();
static const int kEltwiseParamFieldNumber = 24;
const ::opencv_caffe::EltwiseParameter& eltwise_param() const;
::opencv_caffe::EltwiseParameter* release_eltwise_param();
::opencv_caffe::EltwiseParameter* mutable_eltwise_param();
void set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param);
// optional .opencv_caffe.ThresholdParameter threshold_param = 25;
bool has_threshold_param() const;
void clear_threshold_param();
static const int kThresholdParamFieldNumber = 25;
const ::opencv_caffe::ThresholdParameter& threshold_param() const;
::opencv_caffe::ThresholdParameter* release_threshold_param();
::opencv_caffe::ThresholdParameter* mutable_threshold_param();
void set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param);
// optional .opencv_caffe.DummyDataParameter dummy_data_param = 26;
bool has_dummy_data_param() const;
void clear_dummy_data_param();
static const int kDummyDataParamFieldNumber = 26;
const ::opencv_caffe::DummyDataParameter& dummy_data_param() const;
::opencv_caffe::DummyDataParameter* release_dummy_data_param();
::opencv_caffe::DummyDataParameter* mutable_dummy_data_param();
void set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param);
// optional .opencv_caffe.AccuracyParameter accuracy_param = 27;
bool has_accuracy_param() const;
void clear_accuracy_param();
static const int kAccuracyParamFieldNumber = 27;
const ::opencv_caffe::AccuracyParameter& accuracy_param() const;
::opencv_caffe::AccuracyParameter* release_accuracy_param();
::opencv_caffe::AccuracyParameter* mutable_accuracy_param();
void set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param);
// optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29;
bool has_hinge_loss_param() const;
void clear_hinge_loss_param();
static const int kHingeLossParamFieldNumber = 29;
const ::opencv_caffe::HingeLossParameter& hinge_loss_param() const;
::opencv_caffe::HingeLossParameter* release_hinge_loss_param();
::opencv_caffe::HingeLossParameter* mutable_hinge_loss_param();
void set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param);
// optional .opencv_caffe.ReLUParameter relu_param = 30;
bool has_relu_param() const;
void clear_relu_param();
static const int kReluParamFieldNumber = 30;
const ::opencv_caffe::ReLUParameter& relu_param() const;
::opencv_caffe::ReLUParameter* release_relu_param();
::opencv_caffe::ReLUParameter* mutable_relu_param();
void set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param);
// optional .opencv_caffe.SliceParameter slice_param = 31;
bool has_slice_param() const;
void clear_slice_param();
static const int kSliceParamFieldNumber = 31;
const ::opencv_caffe::SliceParameter& slice_param() const;
::opencv_caffe::SliceParameter* release_slice_param();
::opencv_caffe::SliceParameter* mutable_slice_param();
void set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param);
// optional .opencv_caffe.MVNParameter mvn_param = 34;
bool has_mvn_param() const;
void clear_mvn_param();
static const int kMvnParamFieldNumber = 34;
const ::opencv_caffe::MVNParameter& mvn_param() const;
::opencv_caffe::MVNParameter* release_mvn_param();
::opencv_caffe::MVNParameter* mutable_mvn_param();
void set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param);
// optional .opencv_caffe.TransformationParameter transform_param = 36;
bool has_transform_param() const;
void clear_transform_param();
static const int kTransformParamFieldNumber = 36;
const ::opencv_caffe::TransformationParameter& transform_param() const;
::opencv_caffe::TransformationParameter* release_transform_param();
::opencv_caffe::TransformationParameter* mutable_transform_param();
void set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param);
// optional .opencv_caffe.TanHParameter tanh_param = 37;
bool has_tanh_param() const;
void clear_tanh_param();
static const int kTanhParamFieldNumber = 37;
const ::opencv_caffe::TanHParameter& tanh_param() const;
::opencv_caffe::TanHParameter* release_tanh_param();
::opencv_caffe::TanHParameter* mutable_tanh_param();
void set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param);
// optional .opencv_caffe.SigmoidParameter sigmoid_param = 38;
bool has_sigmoid_param() const;
void clear_sigmoid_param();
static const int kSigmoidParamFieldNumber = 38;
const ::opencv_caffe::SigmoidParameter& sigmoid_param() const;
::opencv_caffe::SigmoidParameter* release_sigmoid_param();
::opencv_caffe::SigmoidParameter* mutable_sigmoid_param();
void set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param);
// optional .opencv_caffe.SoftmaxParameter softmax_param = 39;
bool has_softmax_param() const;
void clear_softmax_param();
static const int kSoftmaxParamFieldNumber = 39;
const ::opencv_caffe::SoftmaxParameter& softmax_param() const;
::opencv_caffe::SoftmaxParameter* release_softmax_param();
::opencv_caffe::SoftmaxParameter* mutable_softmax_param();
void set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param);
// optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40;
bool has_contrastive_loss_param() const;
void clear_contrastive_loss_param();
static const int kContrastiveLossParamFieldNumber = 40;
const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param() const;
::opencv_caffe::ContrastiveLossParameter* release_contrastive_loss_param();
::opencv_caffe::ContrastiveLossParameter* mutable_contrastive_loss_param();
void set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param);
// optional .opencv_caffe.ExpParameter exp_param = 41;
bool has_exp_param() const;
void clear_exp_param();
static const int kExpParamFieldNumber = 41;
const ::opencv_caffe::ExpParameter& exp_param() const;
::opencv_caffe::ExpParameter* release_exp_param();
::opencv_caffe::ExpParameter* mutable_exp_param();
void set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param);
// optional .opencv_caffe.LossParameter loss_param = 42;
bool has_loss_param() const;
void clear_loss_param();
static const int kLossParamFieldNumber = 42;
const ::opencv_caffe::LossParameter& loss_param() const;
::opencv_caffe::LossParameter* release_loss_param();
::opencv_caffe::LossParameter* mutable_loss_param();
void set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param);
// optional .opencv_caffe.V1LayerParameter.LayerType type = 5;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 5;
::opencv_caffe::V1LayerParameter_LayerType type() const;
void set_type(::opencv_caffe::V1LayerParameter_LayerType value);
// @@protoc_insertion_point(class_scope:opencv_caffe.V1LayerParameter)
private:
void set_has_name();
void clear_has_name();
void set_has_type();
void clear_has_type();
void set_has_accuracy_param();
void clear_has_accuracy_param();
void set_has_argmax_param();
void clear_has_argmax_param();
void set_has_concat_param();
void clear_has_concat_param();
void set_has_contrastive_loss_param();
void clear_has_contrastive_loss_param();
void set_has_convolution_param();
void clear_has_convolution_param();
void set_has_data_param();
void clear_has_data_param();
void set_has_dropout_param();
void clear_has_dropout_param();
void set_has_dummy_data_param();
void clear_has_dummy_data_param();
void set_has_eltwise_param();
void clear_has_eltwise_param();
void set_has_exp_param();
void clear_has_exp_param();
void set_has_hdf5_data_param();
void clear_has_hdf5_data_param();
void set_has_hdf5_output_param();
void clear_has_hdf5_output_param();
void set_has_hinge_loss_param();
void clear_has_hinge_loss_param();
void set_has_image_data_param();
void clear_has_image_data_param();
void set_has_infogain_loss_param();
void clear_has_infogain_loss_param();
void set_has_inner_product_param();
void clear_has_inner_product_param();
void set_has_lrn_param();
void clear_has_lrn_param();
void set_has_memory_data_param();
void clear_has_memory_data_param();
void set_has_mvn_param();
void clear_has_mvn_param();
void set_has_pooling_param();
void clear_has_pooling_param();
void set_has_power_param();
void clear_has_power_param();
void set_has_relu_param();
void clear_has_relu_param();
void set_has_sigmoid_param();
void clear_has_sigmoid_param();
void set_has_softmax_param();
void clear_has_softmax_param();
void set_has_slice_param();
void clear_has_slice_param();
void set_has_tanh_param();
void clear_has_tanh_param();
void set_has_threshold_param();
void clear_has_threshold_param();
void set_has_window_data_param();
void clear_has_window_data_param();
void set_has_transform_param();
void clear_has_transform_param();
void set_has_loss_param();
void clear_has_loss_param();
void set_has_layer();
void clear_has_layer();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<2> _has_bits_;
::google::protobuf::RepeatedPtrField< ::std::string> bottom_;
::google::protobuf::RepeatedPtrField< ::std::string> top_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_;
::google::protobuf::RepeatedField< float > blobs_lr_;
::google::protobuf::RepeatedField< float > weight_decay_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule > include_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule > exclude_;
::google::protobuf::RepeatedField< float > loss_weight_;
::google::protobuf::RepeatedPtrField< ::std::string> param_;
::google::protobuf::RepeatedField<int> blob_share_mode_;
::google::protobuf::internal::ArenaStringPtr name_;
::opencv_caffe::V0LayerParameter* layer_;
::opencv_caffe::ConcatParameter* concat_param_;
::opencv_caffe::ConvolutionParameter* convolution_param_;
::opencv_caffe::DataParameter* data_param_;
::opencv_caffe::DropoutParameter* dropout_param_;
::opencv_caffe::HDF5DataParameter* hdf5_data_param_;
::opencv_caffe::HDF5OutputParameter* hdf5_output_param_;
::opencv_caffe::ImageDataParameter* image_data_param_;
::opencv_caffe::InfogainLossParameter* infogain_loss_param_;
::opencv_caffe::InnerProductParameter* inner_product_param_;
::opencv_caffe::LRNParameter* lrn_param_;
::opencv_caffe::PoolingParameter* pooling_param_;
::opencv_caffe::WindowDataParameter* window_data_param_;
::opencv_caffe::PowerParameter* power_param_;
::opencv_caffe::MemoryDataParameter* memory_data_param_;
::opencv_caffe::ArgMaxParameter* argmax_param_;
::opencv_caffe::EltwiseParameter* eltwise_param_;
::opencv_caffe::ThresholdParameter* threshold_param_;
::opencv_caffe::DummyDataParameter* dummy_data_param_;
::opencv_caffe::AccuracyParameter* accuracy_param_;
::opencv_caffe::HingeLossParameter* hinge_loss_param_;
::opencv_caffe::ReLUParameter* relu_param_;
::opencv_caffe::SliceParameter* slice_param_;
::opencv_caffe::MVNParameter* mvn_param_;
::opencv_caffe::TransformationParameter* transform_param_;
::opencv_caffe::TanHParameter* tanh_param_;
::opencv_caffe::SigmoidParameter* sigmoid_param_;
::opencv_caffe::SoftmaxParameter* softmax_param_;
::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param_;
::opencv_caffe::ExpParameter* exp_param_;
::opencv_caffe::LossParameter* loss_param_;
int type_;
mutable int _cached_size_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsV1LayerParameterImpl();
};
// -------------------------------------------------------------------
class V0LayerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.V0LayerParameter) */ {
public:
V0LayerParameter();
virtual ~V0LayerParameter();
V0LayerParameter(const V0LayerParameter& from);
inline V0LayerParameter& operator=(const V0LayerParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
V0LayerParameter(V0LayerParameter&& from) noexcept
: V0LayerParameter() {
*this = ::std::move(from);
}
inline V0LayerParameter& operator=(V0LayerParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const V0LayerParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const V0LayerParameter* internal_default_instance() {
return reinterpret_cast<const V0LayerParameter*>(
&_V0LayerParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
65;
void Swap(V0LayerParameter* other);
friend void swap(V0LayerParameter& a, V0LayerParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline V0LayerParameter* New() const PROTOBUF_FINAL { return New(NULL); }
V0LayerParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const V0LayerParameter& from);
void MergeFrom(const V0LayerParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(V0LayerParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
typedef V0LayerParameter_PoolMethod PoolMethod;
static const PoolMethod MAX =
V0LayerParameter_PoolMethod_MAX;
static const PoolMethod AVE =
V0LayerParameter_PoolMethod_AVE;
static const PoolMethod STOCHASTIC =
V0LayerParameter_PoolMethod_STOCHASTIC;
static inline bool PoolMethod_IsValid(int value) {
return V0LayerParameter_PoolMethod_IsValid(value);
}
static const PoolMethod PoolMethod_MIN =
V0LayerParameter_PoolMethod_PoolMethod_MIN;
static const PoolMethod PoolMethod_MAX =
V0LayerParameter_PoolMethod_PoolMethod_MAX;
static const int PoolMethod_ARRAYSIZE =
V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
PoolMethod_descriptor() {
return V0LayerParameter_PoolMethod_descriptor();
}
static inline const ::std::string& PoolMethod_Name(PoolMethod value) {
return V0LayerParameter_PoolMethod_Name(value);
}
static inline bool PoolMethod_Parse(const ::std::string& name,
PoolMethod* value) {
return V0LayerParameter_PoolMethod_Parse(name, value);
}
// accessors -------------------------------------------------------
// repeated .opencv_caffe.BlobProto blobs = 50;
int blobs_size() const;
void clear_blobs();
static const int kBlobsFieldNumber = 50;
const ::opencv_caffe::BlobProto& blobs(int index) const;
::opencv_caffe::BlobProto* mutable_blobs(int index);
::opencv_caffe::BlobProto* add_blobs();
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
mutable_blobs();
const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
blobs() const;
// repeated float blobs_lr = 51;
int blobs_lr_size() const;
void clear_blobs_lr();
static const int kBlobsLrFieldNumber = 51;
float blobs_lr(int index) const;
void set_blobs_lr(int index, float value);
void add_blobs_lr(float value);
const ::google::protobuf::RepeatedField< float >&
blobs_lr() const;
::google::protobuf::RepeatedField< float >*
mutable_blobs_lr();
// repeated float weight_decay = 52;
int weight_decay_size() const;
void clear_weight_decay();
static const int kWeightDecayFieldNumber = 52;
float weight_decay(int index) const;
void set_weight_decay(int index, float value);
void add_weight_decay(float value);
const ::google::protobuf::RepeatedField< float >&
weight_decay() const;
::google::protobuf::RepeatedField< float >*
mutable_weight_decay();
// optional string name = 1;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string& name() const;
void set_name(const ::std::string& value);
#if LANG_CXX11
void set_name(::std::string&& value);
#endif
void set_name(const char* value);
void set_name(const char* value, size_t size);
::std::string* mutable_name();
::std::string* release_name();
void set_allocated_name(::std::string* name);
// optional string type = 2;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 2;
const ::std::string& type() const;
void set_type(const ::std::string& value);
#if LANG_CXX11
void set_type(::std::string&& value);
#endif
void set_type(const char* value);
void set_type(const char* value, size_t size);
::std::string* mutable_type();
::std::string* release_type();
void set_allocated_type(::std::string* type);
// optional string source = 16;
bool has_source() const;
void clear_source();
static const int kSourceFieldNumber = 16;
const ::std::string& source() const;
void set_source(const ::std::string& value);
#if LANG_CXX11
void set_source(::std::string&& value);
#endif
void set_source(const char* value);
void set_source(const char* value, size_t size);
::std::string* mutable_source();
::std::string* release_source();
void set_allocated_source(::std::string* source);
// optional string meanfile = 18;
bool has_meanfile() const;
void clear_meanfile();
static const int kMeanfileFieldNumber = 18;
const ::std::string& meanfile() const;
void set_meanfile(const ::std::string& value);
#if LANG_CXX11
void set_meanfile(::std::string&& value);
#endif
void set_meanfile(const char* value);
void set_meanfile(const char* value, size_t size);
::std::string* mutable_meanfile();
::std::string* release_meanfile();
void set_allocated_meanfile(::std::string* meanfile);
// optional string det_crop_mode = 59 [default = "warp"];
bool has_det_crop_mode() const;
void clear_det_crop_mode();
static const int kDetCropModeFieldNumber = 59;
const ::std::string& det_crop_mode() const;
void set_det_crop_mode(const ::std::string& value);
#if LANG_CXX11
void set_det_crop_mode(::std::string&& value);
#endif
void set_det_crop_mode(const char* value);
void set_det_crop_mode(const char* value, size_t size);
::std::string* mutable_det_crop_mode();
::std::string* release_det_crop_mode();
void set_allocated_det_crop_mode(::std::string* det_crop_mode);
// optional .opencv_caffe.FillerParameter weight_filler = 5;
bool has_weight_filler() const;
void clear_weight_filler();
static const int kWeightFillerFieldNumber = 5;
const ::opencv_caffe::FillerParameter& weight_filler() const;
::opencv_caffe::FillerParameter* release_weight_filler();
::opencv_caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
// optional .opencv_caffe.FillerParameter bias_filler = 6;
bool has_bias_filler() const;
void clear_bias_filler();
static const int kBiasFillerFieldNumber = 6;
const ::opencv_caffe::FillerParameter& bias_filler() const;
::opencv_caffe::FillerParameter* release_bias_filler();
::opencv_caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001;
bool has_hdf5_output_param() const;
void clear_hdf5_output_param();
static const int kHdf5OutputParamFieldNumber = 1001;
const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const;
::opencv_caffe::HDF5OutputParameter* release_hdf5_output_param();
::opencv_caffe::HDF5OutputParameter* mutable_hdf5_output_param();
void set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
// optional uint32 num_output = 3;
bool has_num_output() const;
void clear_num_output();
static const int kNumOutputFieldNumber = 3;
::google::protobuf::uint32 num_output() const;
void set_num_output(::google::protobuf::uint32 value);
// optional uint32 pad = 7 [default = 0];
bool has_pad() const;
void clear_pad();
static const int kPadFieldNumber = 7;
::google::protobuf::uint32 pad() const;
void set_pad(::google::protobuf::uint32 value);
// optional uint32 kernelsize = 8;
bool has_kernelsize() const;
void clear_kernelsize();
static const int kKernelsizeFieldNumber = 8;
::google::protobuf::uint32 kernelsize() const;
void set_kernelsize(::google::protobuf::uint32 value);
// optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
bool has_pool() const;
void clear_pool();
static const int kPoolFieldNumber = 11;
::opencv_caffe::V0LayerParameter_PoolMethod pool() const;
void set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value);
// optional uint32 batchsize = 19;
bool has_batchsize() const;
void clear_batchsize();
static const int kBatchsizeFieldNumber = 19;
::google::protobuf::uint32 batchsize() const;
void set_batchsize(::google::protobuf::uint32 value);
// optional uint32 cropsize = 20 [default = 0];
bool has_cropsize() const;
void clear_cropsize();
static const int kCropsizeFieldNumber = 20;
::google::protobuf::uint32 cropsize() const;
void set_cropsize(::google::protobuf::uint32 value);
// optional int32 new_width = 63 [default = 0];
bool has_new_width() const;
void clear_new_width();
static const int kNewWidthFieldNumber = 63;
::google::protobuf::int32 new_width() const;
void set_new_width(::google::protobuf::int32 value);
// optional bool mirror = 21 [default = false];
bool has_mirror() const;
void clear_mirror();
static const int kMirrorFieldNumber = 21;
bool mirror() const;
void set_mirror(bool value);
// optional bool shuffle_images = 64 [default = false];
bool has_shuffle_images() const;
void clear_shuffle_images();
static const int kShuffleImagesFieldNumber = 64;
bool shuffle_images() const;
void set_shuffle_images(bool value);
// optional uint32 rand_skip = 53 [default = 0];
bool has_rand_skip() const;
void clear_rand_skip();
static const int kRandSkipFieldNumber = 53;
::google::protobuf::uint32 rand_skip() const;
void set_rand_skip(::google::protobuf::uint32 value);
// optional uint32 det_context_pad = 58 [default = 0];
bool has_det_context_pad() const;
void clear_det_context_pad();
static const int kDetContextPadFieldNumber = 58;
::google::protobuf::uint32 det_context_pad() const;
void set_det_context_pad(::google::protobuf::uint32 value);
// optional int32 new_num = 60 [default = 0];
bool has_new_num() const;
void clear_new_num();
static const int kNewNumFieldNumber = 60;
::google::protobuf::int32 new_num() const;
void set_new_num(::google::protobuf::int32 value);
// optional int32 new_channels = 61 [default = 0];
bool has_new_channels() const;
void clear_new_channels();
static const int kNewChannelsFieldNumber = 61;
::google::protobuf::int32 new_channels() const;
void set_new_channels(::google::protobuf::int32 value);
// optional int32 new_height = 62 [default = 0];
bool has_new_height() const;
void clear_new_height();
static const int kNewHeightFieldNumber = 62;
::google::protobuf::int32 new_height() const;
void set_new_height(::google::protobuf::int32 value);
// optional uint32 concat_dim = 65 [default = 1];
bool has_concat_dim() const;
void clear_concat_dim();
static const int kConcatDimFieldNumber = 65;
::google::protobuf::uint32 concat_dim() const;
void set_concat_dim(::google::protobuf::uint32 value);
// optional bool biasterm = 4 [default = true];
bool has_biasterm() const;
void clear_biasterm();
static const int kBiastermFieldNumber = 4;
bool biasterm() const;
void set_biasterm(bool value);
// optional uint32 group = 9 [default = 1];
bool has_group() const;
void clear_group();
static const int kGroupFieldNumber = 9;
::google::protobuf::uint32 group() const;
void set_group(::google::protobuf::uint32 value);
// optional uint32 stride = 10 [default = 1];
bool has_stride() const;
void clear_stride();
static const int kStrideFieldNumber = 10;
::google::protobuf::uint32 stride() const;
void set_stride(::google::protobuf::uint32 value);
// optional float dropout_ratio = 12 [default = 0.5];
bool has_dropout_ratio() const;
void clear_dropout_ratio();
static const int kDropoutRatioFieldNumber = 12;
float dropout_ratio() const;
void set_dropout_ratio(float value);
// optional uint32 local_size = 13 [default = 5];
bool has_local_size() const;
void clear_local_size();
static const int kLocalSizeFieldNumber = 13;
::google::protobuf::uint32 local_size() const;
void set_local_size(::google::protobuf::uint32 value);
// optional float alpha = 14 [default = 1];
bool has_alpha() const;
void clear_alpha();
static const int kAlphaFieldNumber = 14;
float alpha() const;
void set_alpha(float value);
// optional float beta = 15 [default = 0.75];
bool has_beta() const;
void clear_beta();
static const int kBetaFieldNumber = 15;
float beta() const;
void set_beta(float value);
// optional float scale = 17 [default = 1];
bool has_scale() const;
void clear_scale();
static const int kScaleFieldNumber = 17;
float scale() const;
void set_scale(float value);
// optional float k = 22 [default = 1];
bool has_k() const;
void clear_k();
static const int kKFieldNumber = 22;
float k() const;
void set_k(float value);
// optional float det_fg_threshold = 54 [default = 0.5];
bool has_det_fg_threshold() const;
void clear_det_fg_threshold();
static const int kDetFgThresholdFieldNumber = 54;
float det_fg_threshold() const;
void set_det_fg_threshold(float value);
// optional float det_bg_threshold = 55 [default = 0.5];
bool has_det_bg_threshold() const;
void clear_det_bg_threshold();
static const int kDetBgThresholdFieldNumber = 55;
float det_bg_threshold() const;
void set_det_bg_threshold(float value);
// optional float det_fg_fraction = 56 [default = 0.25];
bool has_det_fg_fraction() const;
void clear_det_fg_fraction();
static const int kDetFgFractionFieldNumber = 56;
float det_fg_fraction() const;
void set_det_fg_fraction(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.V0LayerParameter)
private:
void set_has_name();
void clear_has_name();
void set_has_type();
void clear_has_type();
void set_has_num_output();
void clear_has_num_output();
void set_has_biasterm();
void clear_has_biasterm();
void set_has_weight_filler();
void clear_has_weight_filler();
void set_has_bias_filler();
void clear_has_bias_filler();
void set_has_pad();
void clear_has_pad();
void set_has_kernelsize();
void clear_has_kernelsize();
void set_has_group();
void clear_has_group();
void set_has_stride();
void clear_has_stride();
void set_has_pool();
void clear_has_pool();
void set_has_dropout_ratio();
void clear_has_dropout_ratio();
void set_has_local_size();
void clear_has_local_size();
void set_has_alpha();
void clear_has_alpha();
void set_has_beta();
void clear_has_beta();
void set_has_k();
void clear_has_k();
void set_has_source();
void clear_has_source();
void set_has_scale();
void clear_has_scale();
void set_has_meanfile();
void clear_has_meanfile();
void set_has_batchsize();
void clear_has_batchsize();
void set_has_cropsize();
void clear_has_cropsize();
void set_has_mirror();
void clear_has_mirror();
void set_has_rand_skip();
void clear_has_rand_skip();
void set_has_det_fg_threshold();
void clear_has_det_fg_threshold();
void set_has_det_bg_threshold();
void clear_has_det_bg_threshold();
void set_has_det_fg_fraction();
void clear_has_det_fg_fraction();
void set_has_det_context_pad();
void clear_has_det_context_pad();
void set_has_det_crop_mode();
void clear_has_det_crop_mode();
void set_has_new_num();
void clear_has_new_num();
void set_has_new_channels();
void clear_has_new_channels();
void set_has_new_height();
void clear_has_new_height();
void set_has_new_width();
void clear_has_new_width();
void set_has_shuffle_images();
void clear_has_shuffle_images();
void set_has_concat_dim();
void clear_has_concat_dim();
void set_has_hdf5_output_param();
void clear_has_hdf5_output_param();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<2> _has_bits_;
::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_;
::google::protobuf::RepeatedField< float > blobs_lr_;
::google::protobuf::RepeatedField< float > weight_decay_;
::google::protobuf::internal::ArenaStringPtr name_;
::google::protobuf::internal::ArenaStringPtr type_;
::google::protobuf::internal::ArenaStringPtr source_;
::google::protobuf::internal::ArenaStringPtr meanfile_;
static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _default_det_crop_mode_;
::google::protobuf::internal::ArenaStringPtr det_crop_mode_;
::opencv_caffe::FillerParameter* weight_filler_;
::opencv_caffe::FillerParameter* bias_filler_;
::opencv_caffe::HDF5OutputParameter* hdf5_output_param_;
::google::protobuf::uint32 num_output_;
::google::protobuf::uint32 pad_;
::google::protobuf::uint32 kernelsize_;
int pool_;
::google::protobuf::uint32 batchsize_;
::google::protobuf::uint32 cropsize_;
::google::protobuf::int32 new_width_;
bool mirror_;
bool shuffle_images_;
::google::protobuf::uint32 rand_skip_;
::google::protobuf::uint32 det_context_pad_;
::google::protobuf::int32 new_num_;
::google::protobuf::int32 new_channels_;
::google::protobuf::int32 new_height_;
::google::protobuf::uint32 concat_dim_;
bool biasterm_;
::google::protobuf::uint32 group_;
::google::protobuf::uint32 stride_;
float dropout_ratio_;
::google::protobuf::uint32 local_size_;
float alpha_;
float beta_;
float scale_;
float k_;
float det_fg_threshold_;
float det_bg_threshold_;
float det_fg_fraction_;
mutable int _cached_size_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsV0LayerParameterImpl();
};
// -------------------------------------------------------------------
class PReLUParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PReLUParameter) */ {
public:
PReLUParameter();
virtual ~PReLUParameter();
PReLUParameter(const PReLUParameter& from);
inline PReLUParameter& operator=(const PReLUParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
PReLUParameter(PReLUParameter&& from) noexcept
: PReLUParameter() {
*this = ::std::move(from);
}
inline PReLUParameter& operator=(PReLUParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const PReLUParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PReLUParameter* internal_default_instance() {
return reinterpret_cast<const PReLUParameter*>(
&_PReLUParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
66;
void Swap(PReLUParameter* other);
friend void swap(PReLUParameter& a, PReLUParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline PReLUParameter* New() const PROTOBUF_FINAL { return New(NULL); }
PReLUParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const PReLUParameter& from);
void MergeFrom(const PReLUParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(PReLUParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .opencv_caffe.FillerParameter filler = 1;
bool has_filler() const;
void clear_filler();
static const int kFillerFieldNumber = 1;
const ::opencv_caffe::FillerParameter& filler() const;
::opencv_caffe::FillerParameter* release_filler();
::opencv_caffe::FillerParameter* mutable_filler();
void set_allocated_filler(::opencv_caffe::FillerParameter* filler);
// optional bool channel_shared = 2 [default = false];
bool has_channel_shared() const;
void clear_channel_shared();
static const int kChannelSharedFieldNumber = 2;
bool channel_shared() const;
void set_channel_shared(bool value);
// @@protoc_insertion_point(class_scope:opencv_caffe.PReLUParameter)
private:
void set_has_filler();
void clear_has_filler();
void set_has_channel_shared();
void clear_has_channel_shared();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::opencv_caffe::FillerParameter* filler_;
bool channel_shared_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPReLUParameterImpl();
};
// -------------------------------------------------------------------
class NormalizedBBox : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NormalizedBBox) */ {
public:
NormalizedBBox();
virtual ~NormalizedBBox();
NormalizedBBox(const NormalizedBBox& from);
inline NormalizedBBox& operator=(const NormalizedBBox& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
NormalizedBBox(NormalizedBBox&& from) noexcept
: NormalizedBBox() {
*this = ::std::move(from);
}
inline NormalizedBBox& operator=(NormalizedBBox&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const NormalizedBBox& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const NormalizedBBox* internal_default_instance() {
return reinterpret_cast<const NormalizedBBox*>(
&_NormalizedBBox_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
67;
void Swap(NormalizedBBox* other);
friend void swap(NormalizedBBox& a, NormalizedBBox& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline NormalizedBBox* New() const PROTOBUF_FINAL { return New(NULL); }
NormalizedBBox* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const NormalizedBBox& from);
void MergeFrom(const NormalizedBBox& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(NormalizedBBox* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional float xmin = 1;
bool has_xmin() const;
void clear_xmin();
static const int kXminFieldNumber = 1;
float xmin() const;
void set_xmin(float value);
// optional float ymin = 2;
bool has_ymin() const;
void clear_ymin();
static const int kYminFieldNumber = 2;
float ymin() const;
void set_ymin(float value);
// optional float xmax = 3;
bool has_xmax() const;
void clear_xmax();
static const int kXmaxFieldNumber = 3;
float xmax() const;
void set_xmax(float value);
// optional float ymax = 4;
bool has_ymax() const;
void clear_ymax();
static const int kYmaxFieldNumber = 4;
float ymax() const;
void set_ymax(float value);
// optional int32 label = 5;
bool has_label() const;
void clear_label();
static const int kLabelFieldNumber = 5;
::google::protobuf::int32 label() const;
void set_label(::google::protobuf::int32 value);
// optional bool difficult = 6;
bool has_difficult() const;
void clear_difficult();
static const int kDifficultFieldNumber = 6;
bool difficult() const;
void set_difficult(bool value);
// optional float score = 7;
bool has_score() const;
void clear_score();
static const int kScoreFieldNumber = 7;
float score() const;
void set_score(float value);
// optional float size = 8;
bool has_size() const;
void clear_size();
static const int kSizeFieldNumber = 8;
float size() const;
void set_size(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.NormalizedBBox)
private:
void set_has_xmin();
void clear_has_xmin();
void set_has_ymin();
void clear_has_ymin();
void set_has_xmax();
void clear_has_xmax();
void set_has_ymax();
void clear_has_ymax();
void set_has_label();
void clear_has_label();
void set_has_difficult();
void clear_has_difficult();
void set_has_score();
void clear_has_score();
void set_has_size();
void clear_has_size();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float xmin_;
float ymin_;
float xmax_;
float ymax_;
::google::protobuf::int32 label_;
bool difficult_;
float score_;
float size_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNormalizedBBoxImpl();
};
// -------------------------------------------------------------------
class ROIPoolingParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ROIPoolingParameter) */ {
public:
ROIPoolingParameter();
virtual ~ROIPoolingParameter();
ROIPoolingParameter(const ROIPoolingParameter& from);
inline ROIPoolingParameter& operator=(const ROIPoolingParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ROIPoolingParameter(ROIPoolingParameter&& from) noexcept
: ROIPoolingParameter() {
*this = ::std::move(from);
}
inline ROIPoolingParameter& operator=(ROIPoolingParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ROIPoolingParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ROIPoolingParameter* internal_default_instance() {
return reinterpret_cast<const ROIPoolingParameter*>(
&_ROIPoolingParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
68;
void Swap(ROIPoolingParameter* other);
friend void swap(ROIPoolingParameter& a, ROIPoolingParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ROIPoolingParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ROIPoolingParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ROIPoolingParameter& from);
void MergeFrom(const ROIPoolingParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ROIPoolingParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional uint32 pooled_h = 1 [default = 0];
bool has_pooled_h() const;
void clear_pooled_h();
static const int kPooledHFieldNumber = 1;
::google::protobuf::uint32 pooled_h() const;
void set_pooled_h(::google::protobuf::uint32 value);
// optional uint32 pooled_w = 2 [default = 0];
bool has_pooled_w() const;
void clear_pooled_w();
static const int kPooledWFieldNumber = 2;
::google::protobuf::uint32 pooled_w() const;
void set_pooled_w(::google::protobuf::uint32 value);
// optional float spatial_scale = 3 [default = 1];
bool has_spatial_scale() const;
void clear_spatial_scale();
static const int kSpatialScaleFieldNumber = 3;
float spatial_scale() const;
void set_spatial_scale(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ROIPoolingParameter)
private:
void set_has_pooled_h();
void clear_has_pooled_h();
void set_has_pooled_w();
void clear_has_pooled_w();
void set_has_spatial_scale();
void clear_has_spatial_scale();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::uint32 pooled_h_;
::google::protobuf::uint32 pooled_w_;
float spatial_scale_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsROIPoolingParameterImpl();
};
// -------------------------------------------------------------------
class ProposalParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ProposalParameter) */ {
public:
ProposalParameter();
virtual ~ProposalParameter();
ProposalParameter(const ProposalParameter& from);
inline ProposalParameter& operator=(const ProposalParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ProposalParameter(ProposalParameter&& from) noexcept
: ProposalParameter() {
*this = ::std::move(from);
}
inline ProposalParameter& operator=(ProposalParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const ProposalParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ProposalParameter* internal_default_instance() {
return reinterpret_cast<const ProposalParameter*>(
&_ProposalParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
69;
void Swap(ProposalParameter* other);
friend void swap(ProposalParameter& a, ProposalParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline ProposalParameter* New() const PROTOBUF_FINAL { return New(NULL); }
ProposalParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const ProposalParameter& from);
void MergeFrom(const ProposalParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(ProposalParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated float ratio = 4;
int ratio_size() const;
void clear_ratio();
static const int kRatioFieldNumber = 4;
float ratio(int index) const;
void set_ratio(int index, float value);
void add_ratio(float value);
const ::google::protobuf::RepeatedField< float >&
ratio() const;
::google::protobuf::RepeatedField< float >*
mutable_ratio();
// repeated float scale = 5;
int scale_size() const;
void clear_scale();
static const int kScaleFieldNumber = 5;
float scale(int index) const;
void set_scale(int index, float value);
void add_scale(float value);
const ::google::protobuf::RepeatedField< float >&
scale() const;
::google::protobuf::RepeatedField< float >*
mutable_scale();
// optional uint32 feat_stride = 1 [default = 16];
bool has_feat_stride() const;
void clear_feat_stride();
static const int kFeatStrideFieldNumber = 1;
::google::protobuf::uint32 feat_stride() const;
void set_feat_stride(::google::protobuf::uint32 value);
// optional uint32 base_size = 2 [default = 16];
bool has_base_size() const;
void clear_base_size();
static const int kBaseSizeFieldNumber = 2;
::google::protobuf::uint32 base_size() const;
void set_base_size(::google::protobuf::uint32 value);
// optional uint32 min_size = 3 [default = 16];
bool has_min_size() const;
void clear_min_size();
static const int kMinSizeFieldNumber = 3;
::google::protobuf::uint32 min_size() const;
void set_min_size(::google::protobuf::uint32 value);
// optional uint32 pre_nms_topn = 6 [default = 6000];
bool has_pre_nms_topn() const;
void clear_pre_nms_topn();
static const int kPreNmsTopnFieldNumber = 6;
::google::protobuf::uint32 pre_nms_topn() const;
void set_pre_nms_topn(::google::protobuf::uint32 value);
// optional uint32 post_nms_topn = 7 [default = 300];
bool has_post_nms_topn() const;
void clear_post_nms_topn();
static const int kPostNmsTopnFieldNumber = 7;
::google::protobuf::uint32 post_nms_topn() const;
void set_post_nms_topn(::google::protobuf::uint32 value);
// optional float nms_thresh = 8 [default = 0.7];
bool has_nms_thresh() const;
void clear_nms_thresh();
static const int kNmsThreshFieldNumber = 8;
float nms_thresh() const;
void set_nms_thresh(float value);
// @@protoc_insertion_point(class_scope:opencv_caffe.ProposalParameter)
private:
void set_has_feat_stride();
void clear_has_feat_stride();
void set_has_base_size();
void clear_has_base_size();
void set_has_min_size();
void clear_has_min_size();
void set_has_pre_nms_topn();
void clear_has_pre_nms_topn();
void set_has_post_nms_topn();
void clear_has_post_nms_topn();
void set_has_nms_thresh();
void clear_has_nms_thresh();
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField< float > ratio_;
::google::protobuf::RepeatedField< float > scale_;
::google::protobuf::uint32 feat_stride_;
::google::protobuf::uint32 base_size_;
::google::protobuf::uint32 min_size_;
::google::protobuf::uint32 pre_nms_topn_;
::google::protobuf::uint32 post_nms_topn_;
float nms_thresh_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsProposalParameterImpl();
};
// -------------------------------------------------------------------
class PSROIPoolingParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PSROIPoolingParameter) */ {
public:
PSROIPoolingParameter();
virtual ~PSROIPoolingParameter();
PSROIPoolingParameter(const PSROIPoolingParameter& from);
inline PSROIPoolingParameter& operator=(const PSROIPoolingParameter& from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
PSROIPoolingParameter(PSROIPoolingParameter&& from) noexcept
: PSROIPoolingParameter() {
*this = ::std::move(from);
}
inline PSROIPoolingParameter& operator=(PSROIPoolingParameter&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ::google::protobuf::Descriptor* descriptor();
static const PSROIPoolingParameter& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PSROIPoolingParameter* internal_default_instance() {
return reinterpret_cast<const PSROIPoolingParameter*>(
&_PSROIPoolingParameter_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
70;
void Swap(PSROIPoolingParameter* other);
friend void swap(PSROIPoolingParameter& a, PSROIPoolingParameter& b) {
a.Swap(&b);
}
// implements Message ----------------------------------------------
inline PSROIPoolingParameter* New() const PROTOBUF_FINAL { return New(NULL); }
PSROIPoolingParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
void CopyFrom(const PSROIPoolingParameter& from);
void MergeFrom(const PSROIPoolingParameter& from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const PROTOBUF_FINAL;
void InternalSwap(PSROIPoolingParameter* other);
private:
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
return NULL;
}
inline void* MaybeArenaPtr() const {
return NULL;
}
public:
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// required float spatial_scale = 1;
bool has_spatial_scale() const;
void clear_spatial_scale();
static const int kSpatialScaleFieldNumber = 1;
float spatial_scale() const;
void set_spatial_scale(float value);
// required int32 output_dim = 2;
bool has_output_dim() const;
void clear_output_dim();
static const int kOutputDimFieldNumber = 2;
::google::protobuf::int32 output_dim() const;
void set_output_dim(::google::protobuf::int32 value);
// required int32 group_size = 3;
bool has_group_size() const;
void clear_group_size();
static const int kGroupSizeFieldNumber = 3;
::google::protobuf::int32 group_size() const;
void set_group_size(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:opencv_caffe.PSROIPoolingParameter)
private:
void set_has_spatial_scale();
void clear_has_spatial_scale();
void set_has_output_dim();
void clear_has_output_dim();
void set_has_group_size();
void clear_has_group_size();
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
float spatial_scale_;
::google::protobuf::int32 output_dim_;
::google::protobuf::int32 group_size_;
friend struct ::protobuf_opencv_2dcaffe_2eproto::TableStruct;
friend void ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPSROIPoolingParameterImpl();
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// BlobShape
// repeated int64 dim = 1 [packed = true];
inline int BlobShape::dim_size() const {
return dim_.size();
}
inline void BlobShape::clear_dim() {
dim_.Clear();
}
inline ::google::protobuf::int64 BlobShape::dim(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobShape.dim)
return dim_.Get(index);
}
inline void BlobShape::set_dim(int index, ::google::protobuf::int64 value) {
dim_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.BlobShape.dim)
}
inline void BlobShape::add_dim(::google::protobuf::int64 value) {
dim_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.BlobShape.dim)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
BlobShape::dim() const {
// @@protoc_insertion_point(field_list:opencv_caffe.BlobShape.dim)
return dim_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
BlobShape::mutable_dim() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobShape.dim)
return &dim_;
}
// -------------------------------------------------------------------
// BlobProto
// optional .opencv_caffe.BlobShape shape = 7;
inline bool BlobProto::has_shape() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BlobProto::set_has_shape() {
_has_bits_[0] |= 0x00000002u;
}
inline void BlobProto::clear_has_shape() {
_has_bits_[0] &= ~0x00000002u;
}
inline void BlobProto::clear_shape() {
if (shape_ != NULL) shape_->Clear();
clear_has_shape();
}
inline const ::opencv_caffe::BlobShape& BlobProto::shape() const {
const ::opencv_caffe::BlobShape* p = shape_;
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.shape)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::BlobShape*>(
&::opencv_caffe::_BlobShape_default_instance_);
}
inline ::opencv_caffe::BlobShape* BlobProto::release_shape() {
// @@protoc_insertion_point(field_release:opencv_caffe.BlobProto.shape)
clear_has_shape();
::opencv_caffe::BlobShape* temp = shape_;
shape_ = NULL;
return temp;
}
inline ::opencv_caffe::BlobShape* BlobProto::mutable_shape() {
set_has_shape();
if (shape_ == NULL) {
shape_ = new ::opencv_caffe::BlobShape;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProto.shape)
return shape_;
}
inline void BlobProto::set_allocated_shape(::opencv_caffe::BlobShape* shape) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete shape_;
}
if (shape) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
shape = ::google::protobuf::internal::GetOwnedMessage(
message_arena, shape, submessage_arena);
}
set_has_shape();
} else {
clear_has_shape();
}
shape_ = shape;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.BlobProto.shape)
}
// repeated float data = 5 [packed = true];
inline int BlobProto::data_size() const {
return data_.size();
}
inline void BlobProto::clear_data() {
data_.Clear();
}
inline float BlobProto::data(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.data)
return data_.Get(index);
}
inline void BlobProto::set_data(int index, float value) {
data_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.data)
}
inline void BlobProto::add_data(float value) {
data_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.data)
}
inline const ::google::protobuf::RepeatedField< float >&
BlobProto::data() const {
// @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.data)
return data_;
}
inline ::google::protobuf::RepeatedField< float >*
BlobProto::mutable_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.data)
return &data_;
}
// repeated float diff = 6 [packed = true];
inline int BlobProto::diff_size() const {
return diff_.size();
}
inline void BlobProto::clear_diff() {
diff_.Clear();
}
inline float BlobProto::diff(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.diff)
return diff_.Get(index);
}
inline void BlobProto::set_diff(int index, float value) {
diff_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.diff)
}
inline void BlobProto::add_diff(float value) {
diff_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.diff)
}
inline const ::google::protobuf::RepeatedField< float >&
BlobProto::diff() const {
// @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.diff)
return diff_;
}
inline ::google::protobuf::RepeatedField< float >*
BlobProto::mutable_diff() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.diff)
return &diff_;
}
// repeated double double_data = 8 [packed = true];
inline int BlobProto::double_data_size() const {
return double_data_.size();
}
inline void BlobProto::clear_double_data() {
double_data_.Clear();
}
inline double BlobProto::double_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.double_data)
return double_data_.Get(index);
}
inline void BlobProto::set_double_data(int index, double value) {
double_data_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.double_data)
}
inline void BlobProto::add_double_data(double value) {
double_data_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.double_data)
}
inline const ::google::protobuf::RepeatedField< double >&
BlobProto::double_data() const {
// @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.double_data)
return double_data_;
}
inline ::google::protobuf::RepeatedField< double >*
BlobProto::mutable_double_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.double_data)
return &double_data_;
}
// repeated double double_diff = 9 [packed = true];
inline int BlobProto::double_diff_size() const {
return double_diff_.size();
}
inline void BlobProto::clear_double_diff() {
double_diff_.Clear();
}
inline double BlobProto::double_diff(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.double_diff)
return double_diff_.Get(index);
}
inline void BlobProto::set_double_diff(int index, double value) {
double_diff_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.double_diff)
}
inline void BlobProto::add_double_diff(double value) {
double_diff_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.double_diff)
}
inline const ::google::protobuf::RepeatedField< double >&
BlobProto::double_diff() const {
// @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.double_diff)
return double_diff_;
}
inline ::google::protobuf::RepeatedField< double >*
BlobProto::mutable_double_diff() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.double_diff)
return &double_diff_;
}
// optional .opencv_caffe.Type raw_data_type = 10;
inline bool BlobProto::has_raw_data_type() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void BlobProto::set_has_raw_data_type() {
_has_bits_[0] |= 0x00000040u;
}
inline void BlobProto::clear_has_raw_data_type() {
_has_bits_[0] &= ~0x00000040u;
}
inline void BlobProto::clear_raw_data_type() {
raw_data_type_ = 0;
clear_has_raw_data_type();
}
inline ::opencv_caffe::Type BlobProto::raw_data_type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.raw_data_type)
return static_cast< ::opencv_caffe::Type >(raw_data_type_);
}
inline void BlobProto::set_raw_data_type(::opencv_caffe::Type value) {
assert(::opencv_caffe::Type_IsValid(value));
set_has_raw_data_type();
raw_data_type_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.raw_data_type)
}
// optional bytes raw_data = 12 [packed = false];
inline bool BlobProto::has_raw_data() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlobProto::set_has_raw_data() {
_has_bits_[0] |= 0x00000001u;
}
inline void BlobProto::clear_has_raw_data() {
_has_bits_[0] &= ~0x00000001u;
}
inline void BlobProto::clear_raw_data() {
raw_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_raw_data();
}
inline const ::std::string& BlobProto::raw_data() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.raw_data)
return raw_data_.GetNoArena();
}
inline void BlobProto::set_raw_data(const ::std::string& value) {
set_has_raw_data();
raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.raw_data)
}
#if LANG_CXX11
inline void BlobProto::set_raw_data(::std::string&& value) {
set_has_raw_data();
raw_data_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.BlobProto.raw_data)
}
#endif
inline void BlobProto::set_raw_data(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_raw_data();
raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.BlobProto.raw_data)
}
inline void BlobProto::set_raw_data(const void* value, size_t size) {
set_has_raw_data();
raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.BlobProto.raw_data)
}
inline ::std::string* BlobProto::mutable_raw_data() {
set_has_raw_data();
// @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProto.raw_data)
return raw_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* BlobProto::release_raw_data() {
// @@protoc_insertion_point(field_release:opencv_caffe.BlobProto.raw_data)
clear_has_raw_data();
return raw_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BlobProto::set_allocated_raw_data(::std::string* raw_data) {
if (raw_data != NULL) {
set_has_raw_data();
} else {
clear_has_raw_data();
}
raw_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), raw_data);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.BlobProto.raw_data)
}
// optional int32 num = 1 [default = 0];
inline bool BlobProto::has_num() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BlobProto::set_has_num() {
_has_bits_[0] |= 0x00000004u;
}
inline void BlobProto::clear_has_num() {
_has_bits_[0] &= ~0x00000004u;
}
inline void BlobProto::clear_num() {
num_ = 0;
clear_has_num();
}
inline ::google::protobuf::int32 BlobProto::num() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.num)
return num_;
}
inline void BlobProto::set_num(::google::protobuf::int32 value) {
set_has_num();
num_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.num)
}
// optional int32 channels = 2 [default = 0];
inline bool BlobProto::has_channels() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BlobProto::set_has_channels() {
_has_bits_[0] |= 0x00000008u;
}
inline void BlobProto::clear_has_channels() {
_has_bits_[0] &= ~0x00000008u;
}
inline void BlobProto::clear_channels() {
channels_ = 0;
clear_has_channels();
}
inline ::google::protobuf::int32 BlobProto::channels() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.channels)
return channels_;
}
inline void BlobProto::set_channels(::google::protobuf::int32 value) {
set_has_channels();
channels_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.channels)
}
// optional int32 height = 3 [default = 0];
inline bool BlobProto::has_height() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BlobProto::set_has_height() {
_has_bits_[0] |= 0x00000010u;
}
inline void BlobProto::clear_has_height() {
_has_bits_[0] &= ~0x00000010u;
}
inline void BlobProto::clear_height() {
height_ = 0;
clear_has_height();
}
inline ::google::protobuf::int32 BlobProto::height() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.height)
return height_;
}
inline void BlobProto::set_height(::google::protobuf::int32 value) {
set_has_height();
height_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.height)
}
// optional int32 width = 4 [default = 0];
inline bool BlobProto::has_width() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void BlobProto::set_has_width() {
_has_bits_[0] |= 0x00000020u;
}
inline void BlobProto::clear_has_width() {
_has_bits_[0] &= ~0x00000020u;
}
inline void BlobProto::clear_width() {
width_ = 0;
clear_has_width();
}
inline ::google::protobuf::int32 BlobProto::width() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.width)
return width_;
}
inline void BlobProto::set_width(::google::protobuf::int32 value) {
set_has_width();
width_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.width)
}
// -------------------------------------------------------------------
// BlobProtoVector
// repeated .opencv_caffe.BlobProto blobs = 1;
inline int BlobProtoVector::blobs_size() const {
return blobs_.size();
}
inline void BlobProtoVector::clear_blobs() {
blobs_.Clear();
}
inline const ::opencv_caffe::BlobProto& BlobProtoVector::blobs(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.BlobProtoVector.blobs)
return blobs_.Get(index);
}
inline ::opencv_caffe::BlobProto* BlobProtoVector::mutable_blobs(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProtoVector.blobs)
return blobs_.Mutable(index);
}
inline ::opencv_caffe::BlobProto* BlobProtoVector::add_blobs() {
// @@protoc_insertion_point(field_add:opencv_caffe.BlobProtoVector.blobs)
return blobs_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
BlobProtoVector::mutable_blobs() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProtoVector.blobs)
return &blobs_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
BlobProtoVector::blobs() const {
// @@protoc_insertion_point(field_list:opencv_caffe.BlobProtoVector.blobs)
return blobs_;
}
// -------------------------------------------------------------------
// PermuteParameter
// repeated uint32 order = 1;
inline int PermuteParameter::order_size() const {
return order_.size();
}
inline void PermuteParameter::clear_order() {
order_.Clear();
}
inline ::google::protobuf::uint32 PermuteParameter::order(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PermuteParameter.order)
return order_.Get(index);
}
inline void PermuteParameter::set_order(int index, ::google::protobuf::uint32 value) {
order_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PermuteParameter.order)
}
inline void PermuteParameter::add_order(::google::protobuf::uint32 value) {
order_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PermuteParameter.order)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
PermuteParameter::order() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PermuteParameter.order)
return order_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
PermuteParameter::mutable_order() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PermuteParameter.order)
return &order_;
}
// -------------------------------------------------------------------
// NormalizeBBoxParameter
// optional bool across_spatial = 1 [default = true];
inline bool NormalizeBBoxParameter::has_across_spatial() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NormalizeBBoxParameter::set_has_across_spatial() {
_has_bits_[0] |= 0x00000002u;
}
inline void NormalizeBBoxParameter::clear_has_across_spatial() {
_has_bits_[0] &= ~0x00000002u;
}
inline void NormalizeBBoxParameter::clear_across_spatial() {
across_spatial_ = true;
clear_has_across_spatial();
}
inline bool NormalizeBBoxParameter::across_spatial() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.across_spatial)
return across_spatial_;
}
inline void NormalizeBBoxParameter::set_across_spatial(bool value) {
set_has_across_spatial();
across_spatial_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.across_spatial)
}
// optional .opencv_caffe.FillerParameter scale_filler = 2;
inline bool NormalizeBBoxParameter::has_scale_filler() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NormalizeBBoxParameter::set_has_scale_filler() {
_has_bits_[0] |= 0x00000001u;
}
inline void NormalizeBBoxParameter::clear_has_scale_filler() {
_has_bits_[0] &= ~0x00000001u;
}
inline void NormalizeBBoxParameter::clear_scale_filler() {
if (scale_filler_ != NULL) scale_filler_->Clear();
clear_has_scale_filler();
}
inline const ::opencv_caffe::FillerParameter& NormalizeBBoxParameter::scale_filler() const {
const ::opencv_caffe::FillerParameter* p = scale_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.scale_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::release_scale_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.NormalizeBBoxParameter.scale_filler)
clear_has_scale_filler();
::opencv_caffe::FillerParameter* temp = scale_filler_;
scale_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::mutable_scale_filler() {
set_has_scale_filler();
if (scale_filler_ == NULL) {
scale_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.NormalizeBBoxParameter.scale_filler)
return scale_filler_;
}
inline void NormalizeBBoxParameter::set_allocated_scale_filler(::opencv_caffe::FillerParameter* scale_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete scale_filler_;
}
if (scale_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
scale_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, scale_filler, submessage_arena);
}
set_has_scale_filler();
} else {
clear_has_scale_filler();
}
scale_filler_ = scale_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.NormalizeBBoxParameter.scale_filler)
}
// optional bool channel_shared = 3 [default = true];
inline bool NormalizeBBoxParameter::has_channel_shared() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NormalizeBBoxParameter::set_has_channel_shared() {
_has_bits_[0] |= 0x00000004u;
}
inline void NormalizeBBoxParameter::clear_has_channel_shared() {
_has_bits_[0] &= ~0x00000004u;
}
inline void NormalizeBBoxParameter::clear_channel_shared() {
channel_shared_ = true;
clear_has_channel_shared();
}
inline bool NormalizeBBoxParameter::channel_shared() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.channel_shared)
return channel_shared_;
}
inline void NormalizeBBoxParameter::set_channel_shared(bool value) {
set_has_channel_shared();
channel_shared_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.channel_shared)
}
// optional float eps = 4 [default = 1e-10];
inline bool NormalizeBBoxParameter::has_eps() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NormalizeBBoxParameter::set_has_eps() {
_has_bits_[0] |= 0x00000008u;
}
inline void NormalizeBBoxParameter::clear_has_eps() {
_has_bits_[0] &= ~0x00000008u;
}
inline void NormalizeBBoxParameter::clear_eps() {
eps_ = 1e-10f;
clear_has_eps();
}
inline float NormalizeBBoxParameter::eps() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.eps)
return eps_;
}
inline void NormalizeBBoxParameter::set_eps(float value) {
set_has_eps();
eps_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.eps)
}
// -------------------------------------------------------------------
// PriorBoxParameter
// repeated float min_size = 1;
inline int PriorBoxParameter::min_size_size() const {
return min_size_.size();
}
inline void PriorBoxParameter::clear_min_size() {
min_size_.Clear();
}
inline float PriorBoxParameter::min_size(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.min_size)
return min_size_.Get(index);
}
inline void PriorBoxParameter::set_min_size(int index, float value) {
min_size_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.min_size)
}
inline void PriorBoxParameter::add_min_size(float value) {
min_size_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.min_size)
}
inline const ::google::protobuf::RepeatedField< float >&
PriorBoxParameter::min_size() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.min_size)
return min_size_;
}
inline ::google::protobuf::RepeatedField< float >*
PriorBoxParameter::mutable_min_size() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.min_size)
return &min_size_;
}
// repeated float max_size = 2;
inline int PriorBoxParameter::max_size_size() const {
return max_size_.size();
}
inline void PriorBoxParameter::clear_max_size() {
max_size_.Clear();
}
inline float PriorBoxParameter::max_size(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.max_size)
return max_size_.Get(index);
}
inline void PriorBoxParameter::set_max_size(int index, float value) {
max_size_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.max_size)
}
inline void PriorBoxParameter::add_max_size(float value) {
max_size_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.max_size)
}
inline const ::google::protobuf::RepeatedField< float >&
PriorBoxParameter::max_size() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.max_size)
return max_size_;
}
inline ::google::protobuf::RepeatedField< float >*
PriorBoxParameter::mutable_max_size() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.max_size)
return &max_size_;
}
// repeated float aspect_ratio = 3;
inline int PriorBoxParameter::aspect_ratio_size() const {
return aspect_ratio_.size();
}
inline void PriorBoxParameter::clear_aspect_ratio() {
aspect_ratio_.Clear();
}
inline float PriorBoxParameter::aspect_ratio(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.aspect_ratio)
return aspect_ratio_.Get(index);
}
inline void PriorBoxParameter::set_aspect_ratio(int index, float value) {
aspect_ratio_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.aspect_ratio)
}
inline void PriorBoxParameter::add_aspect_ratio(float value) {
aspect_ratio_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.aspect_ratio)
}
inline const ::google::protobuf::RepeatedField< float >&
PriorBoxParameter::aspect_ratio() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.aspect_ratio)
return aspect_ratio_;
}
inline ::google::protobuf::RepeatedField< float >*
PriorBoxParameter::mutable_aspect_ratio() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.aspect_ratio)
return &aspect_ratio_;
}
// optional bool flip = 4 [default = true];
inline bool PriorBoxParameter::has_flip() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void PriorBoxParameter::set_has_flip() {
_has_bits_[0] |= 0x00000040u;
}
inline void PriorBoxParameter::clear_has_flip() {
_has_bits_[0] &= ~0x00000040u;
}
inline void PriorBoxParameter::clear_flip() {
flip_ = true;
clear_has_flip();
}
inline bool PriorBoxParameter::flip() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.flip)
return flip_;
}
inline void PriorBoxParameter::set_flip(bool value) {
set_has_flip();
flip_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.flip)
}
// optional bool clip = 5 [default = true];
inline bool PriorBoxParameter::has_clip() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void PriorBoxParameter::set_has_clip() {
_has_bits_[0] |= 0x00000080u;
}
inline void PriorBoxParameter::clear_has_clip() {
_has_bits_[0] &= ~0x00000080u;
}
inline void PriorBoxParameter::clear_clip() {
clip_ = true;
clear_has_clip();
}
inline bool PriorBoxParameter::clip() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.clip)
return clip_;
}
inline void PriorBoxParameter::set_clip(bool value) {
set_has_clip();
clip_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.clip)
}
// repeated float variance = 6;
inline int PriorBoxParameter::variance_size() const {
return variance_.size();
}
inline void PriorBoxParameter::clear_variance() {
variance_.Clear();
}
inline float PriorBoxParameter::variance(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.variance)
return variance_.Get(index);
}
inline void PriorBoxParameter::set_variance(int index, float value) {
variance_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.variance)
}
inline void PriorBoxParameter::add_variance(float value) {
variance_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.variance)
}
inline const ::google::protobuf::RepeatedField< float >&
PriorBoxParameter::variance() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.variance)
return variance_;
}
inline ::google::protobuf::RepeatedField< float >*
PriorBoxParameter::mutable_variance() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.variance)
return &variance_;
}
// optional uint32 img_size = 7;
inline bool PriorBoxParameter::has_img_size() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PriorBoxParameter::set_has_img_size() {
_has_bits_[0] |= 0x00000001u;
}
inline void PriorBoxParameter::clear_has_img_size() {
_has_bits_[0] &= ~0x00000001u;
}
inline void PriorBoxParameter::clear_img_size() {
img_size_ = 0u;
clear_has_img_size();
}
inline ::google::protobuf::uint32 PriorBoxParameter::img_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_size)
return img_size_;
}
inline void PriorBoxParameter::set_img_size(::google::protobuf::uint32 value) {
set_has_img_size();
img_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_size)
}
// optional uint32 img_h = 8;
inline bool PriorBoxParameter::has_img_h() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PriorBoxParameter::set_has_img_h() {
_has_bits_[0] |= 0x00000002u;
}
inline void PriorBoxParameter::clear_has_img_h() {
_has_bits_[0] &= ~0x00000002u;
}
inline void PriorBoxParameter::clear_img_h() {
img_h_ = 0u;
clear_has_img_h();
}
inline ::google::protobuf::uint32 PriorBoxParameter::img_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_h)
return img_h_;
}
inline void PriorBoxParameter::set_img_h(::google::protobuf::uint32 value) {
set_has_img_h();
img_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_h)
}
// optional uint32 img_w = 9;
inline bool PriorBoxParameter::has_img_w() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PriorBoxParameter::set_has_img_w() {
_has_bits_[0] |= 0x00000004u;
}
inline void PriorBoxParameter::clear_has_img_w() {
_has_bits_[0] &= ~0x00000004u;
}
inline void PriorBoxParameter::clear_img_w() {
img_w_ = 0u;
clear_has_img_w();
}
inline ::google::protobuf::uint32 PriorBoxParameter::img_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_w)
return img_w_;
}
inline void PriorBoxParameter::set_img_w(::google::protobuf::uint32 value) {
set_has_img_w();
img_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_w)
}
// optional float step = 10;
inline bool PriorBoxParameter::has_step() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PriorBoxParameter::set_has_step() {
_has_bits_[0] |= 0x00000008u;
}
inline void PriorBoxParameter::clear_has_step() {
_has_bits_[0] &= ~0x00000008u;
}
inline void PriorBoxParameter::clear_step() {
step_ = 0;
clear_has_step();
}
inline float PriorBoxParameter::step() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step)
return step_;
}
inline void PriorBoxParameter::set_step(float value) {
set_has_step();
step_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step)
}
// optional float step_h = 11;
inline bool PriorBoxParameter::has_step_h() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PriorBoxParameter::set_has_step_h() {
_has_bits_[0] |= 0x00000010u;
}
inline void PriorBoxParameter::clear_has_step_h() {
_has_bits_[0] &= ~0x00000010u;
}
inline void PriorBoxParameter::clear_step_h() {
step_h_ = 0;
clear_has_step_h();
}
inline float PriorBoxParameter::step_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step_h)
return step_h_;
}
inline void PriorBoxParameter::set_step_h(float value) {
set_has_step_h();
step_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step_h)
}
// optional float step_w = 12;
inline bool PriorBoxParameter::has_step_w() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void PriorBoxParameter::set_has_step_w() {
_has_bits_[0] |= 0x00000020u;
}
inline void PriorBoxParameter::clear_has_step_w() {
_has_bits_[0] &= ~0x00000020u;
}
inline void PriorBoxParameter::clear_step_w() {
step_w_ = 0;
clear_has_step_w();
}
inline float PriorBoxParameter::step_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step_w)
return step_w_;
}
inline void PriorBoxParameter::set_step_w(float value) {
set_has_step_w();
step_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step_w)
}
// optional float offset = 13 [default = 0.5];
inline bool PriorBoxParameter::has_offset() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void PriorBoxParameter::set_has_offset() {
_has_bits_[0] |= 0x00000100u;
}
inline void PriorBoxParameter::clear_has_offset() {
_has_bits_[0] &= ~0x00000100u;
}
inline void PriorBoxParameter::clear_offset() {
offset_ = 0.5f;
clear_has_offset();
}
inline float PriorBoxParameter::offset() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset)
return offset_;
}
inline void PriorBoxParameter::set_offset(float value) {
set_has_offset();
offset_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.offset)
}
// repeated float offset_h = 14;
inline int PriorBoxParameter::offset_h_size() const {
return offset_h_.size();
}
inline void PriorBoxParameter::clear_offset_h() {
offset_h_.Clear();
}
inline float PriorBoxParameter::offset_h(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset_h)
return offset_h_.Get(index);
}
inline void PriorBoxParameter::set_offset_h(int index, float value) {
offset_h_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.offset_h)
}
inline void PriorBoxParameter::add_offset_h(float value) {
offset_h_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.offset_h)
}
inline const ::google::protobuf::RepeatedField< float >&
PriorBoxParameter::offset_h() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.offset_h)
return offset_h_;
}
inline ::google::protobuf::RepeatedField< float >*
PriorBoxParameter::mutable_offset_h() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.offset_h)
return &offset_h_;
}
// repeated float offset_w = 15;
inline int PriorBoxParameter::offset_w_size() const {
return offset_w_.size();
}
inline void PriorBoxParameter::clear_offset_w() {
offset_w_.Clear();
}
inline float PriorBoxParameter::offset_w(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset_w)
return offset_w_.Get(index);
}
inline void PriorBoxParameter::set_offset_w(int index, float value) {
offset_w_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.offset_w)
}
inline void PriorBoxParameter::add_offset_w(float value) {
offset_w_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.offset_w)
}
inline const ::google::protobuf::RepeatedField< float >&
PriorBoxParameter::offset_w() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.offset_w)
return offset_w_;
}
inline ::google::protobuf::RepeatedField< float >*
PriorBoxParameter::mutable_offset_w() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.offset_w)
return &offset_w_;
}
// repeated float width = 16;
inline int PriorBoxParameter::width_size() const {
return width_.size();
}
inline void PriorBoxParameter::clear_width() {
width_.Clear();
}
inline float PriorBoxParameter::width(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.width)
return width_.Get(index);
}
inline void PriorBoxParameter::set_width(int index, float value) {
width_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.width)
}
inline void PriorBoxParameter::add_width(float value) {
width_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.width)
}
inline const ::google::protobuf::RepeatedField< float >&
PriorBoxParameter::width() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.width)
return width_;
}
inline ::google::protobuf::RepeatedField< float >*
PriorBoxParameter::mutable_width() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.width)
return &width_;
}
// repeated float height = 17;
inline int PriorBoxParameter::height_size() const {
return height_.size();
}
inline void PriorBoxParameter::clear_height() {
height_.Clear();
}
inline float PriorBoxParameter::height(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.height)
return height_.Get(index);
}
inline void PriorBoxParameter::set_height(int index, float value) {
height_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.height)
}
inline void PriorBoxParameter::add_height(float value) {
height_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.height)
}
inline const ::google::protobuf::RepeatedField< float >&
PriorBoxParameter::height() const {
// @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.height)
return height_;
}
inline ::google::protobuf::RepeatedField< float >*
PriorBoxParameter::mutable_height() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.height)
return &height_;
}
// -------------------------------------------------------------------
// DetectionOutputParameter
// optional uint32 num_classes = 1;
inline bool DetectionOutputParameter::has_num_classes() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DetectionOutputParameter::set_has_num_classes() {
_has_bits_[0] |= 0x00000004u;
}
inline void DetectionOutputParameter::clear_has_num_classes() {
_has_bits_[0] &= ~0x00000004u;
}
inline void DetectionOutputParameter::clear_num_classes() {
num_classes_ = 0u;
clear_has_num_classes();
}
inline ::google::protobuf::uint32 DetectionOutputParameter::num_classes() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.num_classes)
return num_classes_;
}
inline void DetectionOutputParameter::set_num_classes(::google::protobuf::uint32 value) {
set_has_num_classes();
num_classes_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.num_classes)
}
// optional bool share_location = 2 [default = true];
inline bool DetectionOutputParameter::has_share_location() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void DetectionOutputParameter::set_has_share_location() {
_has_bits_[0] |= 0x00000100u;
}
inline void DetectionOutputParameter::clear_has_share_location() {
_has_bits_[0] &= ~0x00000100u;
}
inline void DetectionOutputParameter::clear_share_location() {
share_location_ = true;
clear_has_share_location();
}
inline bool DetectionOutputParameter::share_location() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.share_location)
return share_location_;
}
inline void DetectionOutputParameter::set_share_location(bool value) {
set_has_share_location();
share_location_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.share_location)
}
// optional int32 background_label_id = 3 [default = 0];
inline bool DetectionOutputParameter::has_background_label_id() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DetectionOutputParameter::set_has_background_label_id() {
_has_bits_[0] |= 0x00000008u;
}
inline void DetectionOutputParameter::clear_has_background_label_id() {
_has_bits_[0] &= ~0x00000008u;
}
inline void DetectionOutputParameter::clear_background_label_id() {
background_label_id_ = 0;
clear_has_background_label_id();
}
inline ::google::protobuf::int32 DetectionOutputParameter::background_label_id() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.background_label_id)
return background_label_id_;
}
inline void DetectionOutputParameter::set_background_label_id(::google::protobuf::int32 value) {
set_has_background_label_id();
background_label_id_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.background_label_id)
}
// optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4;
inline bool DetectionOutputParameter::has_nms_param() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DetectionOutputParameter::set_has_nms_param() {
_has_bits_[0] |= 0x00000001u;
}
inline void DetectionOutputParameter::clear_has_nms_param() {
_has_bits_[0] &= ~0x00000001u;
}
inline void DetectionOutputParameter::clear_nms_param() {
if (nms_param_ != NULL) nms_param_->Clear();
clear_has_nms_param();
}
inline const ::opencv_caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::nms_param() const {
const ::opencv_caffe::NonMaximumSuppressionParameter* p = nms_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.nms_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::NonMaximumSuppressionParameter*>(
&::opencv_caffe::_NonMaximumSuppressionParameter_default_instance_);
}
inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::release_nms_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.DetectionOutputParameter.nms_param)
clear_has_nms_param();
::opencv_caffe::NonMaximumSuppressionParameter* temp = nms_param_;
nms_param_ = NULL;
return temp;
}
inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::mutable_nms_param() {
set_has_nms_param();
if (nms_param_ == NULL) {
nms_param_ = new ::opencv_caffe::NonMaximumSuppressionParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.DetectionOutputParameter.nms_param)
return nms_param_;
}
inline void DetectionOutputParameter::set_allocated_nms_param(::opencv_caffe::NonMaximumSuppressionParameter* nms_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete nms_param_;
}
if (nms_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
nms_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, nms_param, submessage_arena);
}
set_has_nms_param();
} else {
clear_has_nms_param();
}
nms_param_ = nms_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.DetectionOutputParameter.nms_param)
}
// optional .opencv_caffe.SaveOutputParameter save_output_param = 5;
inline bool DetectionOutputParameter::has_save_output_param() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DetectionOutputParameter::set_has_save_output_param() {
_has_bits_[0] |= 0x00000002u;
}
inline void DetectionOutputParameter::clear_has_save_output_param() {
_has_bits_[0] &= ~0x00000002u;
}
inline void DetectionOutputParameter::clear_save_output_param() {
if (save_output_param_ != NULL) save_output_param_->Clear();
clear_has_save_output_param();
}
inline const ::opencv_caffe::SaveOutputParameter& DetectionOutputParameter::save_output_param() const {
const ::opencv_caffe::SaveOutputParameter* p = save_output_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.save_output_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::SaveOutputParameter*>(
&::opencv_caffe::_SaveOutputParameter_default_instance_);
}
inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::release_save_output_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.DetectionOutputParameter.save_output_param)
clear_has_save_output_param();
::opencv_caffe::SaveOutputParameter* temp = save_output_param_;
save_output_param_ = NULL;
return temp;
}
inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::mutable_save_output_param() {
set_has_save_output_param();
if (save_output_param_ == NULL) {
save_output_param_ = new ::opencv_caffe::SaveOutputParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.DetectionOutputParameter.save_output_param)
return save_output_param_;
}
inline void DetectionOutputParameter::set_allocated_save_output_param(::opencv_caffe::SaveOutputParameter* save_output_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete save_output_param_;
}
if (save_output_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
save_output_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, save_output_param, submessage_arena);
}
set_has_save_output_param();
} else {
clear_has_save_output_param();
}
save_output_param_ = save_output_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.DetectionOutputParameter.save_output_param)
}
// optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
inline bool DetectionOutputParameter::has_code_type() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void DetectionOutputParameter::set_has_code_type() {
_has_bits_[0] |= 0x00000080u;
}
inline void DetectionOutputParameter::clear_has_code_type() {
_has_bits_[0] &= ~0x00000080u;
}
inline void DetectionOutputParameter::clear_code_type() {
code_type_ = 1;
clear_has_code_type();
}
inline ::opencv_caffe::PriorBoxParameter_CodeType DetectionOutputParameter::code_type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.code_type)
return static_cast< ::opencv_caffe::PriorBoxParameter_CodeType >(code_type_);
}
inline void DetectionOutputParameter::set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value) {
assert(::opencv_caffe::PriorBoxParameter_CodeType_IsValid(value));
set_has_code_type();
code_type_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.code_type)
}
// optional bool variance_encoded_in_target = 8 [default = false];
inline bool DetectionOutputParameter::has_variance_encoded_in_target() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DetectionOutputParameter::set_has_variance_encoded_in_target() {
_has_bits_[0] |= 0x00000010u;
}
inline void DetectionOutputParameter::clear_has_variance_encoded_in_target() {
_has_bits_[0] &= ~0x00000010u;
}
inline void DetectionOutputParameter::clear_variance_encoded_in_target() {
variance_encoded_in_target_ = false;
clear_has_variance_encoded_in_target();
}
inline bool DetectionOutputParameter::variance_encoded_in_target() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.variance_encoded_in_target)
return variance_encoded_in_target_;
}
inline void DetectionOutputParameter::set_variance_encoded_in_target(bool value) {
set_has_variance_encoded_in_target();
variance_encoded_in_target_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.variance_encoded_in_target)
}
// optional int32 keep_top_k = 7 [default = -1];
inline bool DetectionOutputParameter::has_keep_top_k() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void DetectionOutputParameter::set_has_keep_top_k() {
_has_bits_[0] |= 0x00000040u;
}
inline void DetectionOutputParameter::clear_has_keep_top_k() {
_has_bits_[0] &= ~0x00000040u;
}
inline void DetectionOutputParameter::clear_keep_top_k() {
keep_top_k_ = -1;
clear_has_keep_top_k();
}
inline ::google::protobuf::int32 DetectionOutputParameter::keep_top_k() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.keep_top_k)
return keep_top_k_;
}
inline void DetectionOutputParameter::set_keep_top_k(::google::protobuf::int32 value) {
set_has_keep_top_k();
keep_top_k_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.keep_top_k)
}
// optional float confidence_threshold = 9;
inline bool DetectionOutputParameter::has_confidence_threshold() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void DetectionOutputParameter::set_has_confidence_threshold() {
_has_bits_[0] |= 0x00000020u;
}
inline void DetectionOutputParameter::clear_has_confidence_threshold() {
_has_bits_[0] &= ~0x00000020u;
}
inline void DetectionOutputParameter::clear_confidence_threshold() {
confidence_threshold_ = 0;
clear_has_confidence_threshold();
}
inline float DetectionOutputParameter::confidence_threshold() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.confidence_threshold)
return confidence_threshold_;
}
inline void DetectionOutputParameter::set_confidence_threshold(float value) {
set_has_confidence_threshold();
confidence_threshold_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.confidence_threshold)
}
// optional bool normalized_bbox = 10 [default = true];
inline bool DetectionOutputParameter::has_normalized_bbox() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void DetectionOutputParameter::set_has_normalized_bbox() {
_has_bits_[0] |= 0x00000200u;
}
inline void DetectionOutputParameter::clear_has_normalized_bbox() {
_has_bits_[0] &= ~0x00000200u;
}
inline void DetectionOutputParameter::clear_normalized_bbox() {
normalized_bbox_ = true;
clear_has_normalized_bbox();
}
inline bool DetectionOutputParameter::normalized_bbox() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.normalized_bbox)
return normalized_bbox_;
}
inline void DetectionOutputParameter::set_normalized_bbox(bool value) {
set_has_normalized_bbox();
normalized_bbox_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.normalized_bbox)
}
// -------------------------------------------------------------------
// Datum
// optional int32 channels = 1;
inline bool Datum::has_channels() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Datum::set_has_channels() {
_has_bits_[0] |= 0x00000002u;
}
inline void Datum::clear_has_channels() {
_has_bits_[0] &= ~0x00000002u;
}
inline void Datum::clear_channels() {
channels_ = 0;
clear_has_channels();
}
inline ::google::protobuf::int32 Datum::channels() const {
// @@protoc_insertion_point(field_get:opencv_caffe.Datum.channels)
return channels_;
}
inline void Datum::set_channels(::google::protobuf::int32 value) {
set_has_channels();
channels_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.Datum.channels)
}
// optional int32 height = 2;
inline bool Datum::has_height() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Datum::set_has_height() {
_has_bits_[0] |= 0x00000004u;
}
inline void Datum::clear_has_height() {
_has_bits_[0] &= ~0x00000004u;
}
inline void Datum::clear_height() {
height_ = 0;
clear_has_height();
}
inline ::google::protobuf::int32 Datum::height() const {
// @@protoc_insertion_point(field_get:opencv_caffe.Datum.height)
return height_;
}
inline void Datum::set_height(::google::protobuf::int32 value) {
set_has_height();
height_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.Datum.height)
}
// optional int32 width = 3;
inline bool Datum::has_width() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Datum::set_has_width() {
_has_bits_[0] |= 0x00000008u;
}
inline void Datum::clear_has_width() {
_has_bits_[0] &= ~0x00000008u;
}
inline void Datum::clear_width() {
width_ = 0;
clear_has_width();
}
inline ::google::protobuf::int32 Datum::width() const {
// @@protoc_insertion_point(field_get:opencv_caffe.Datum.width)
return width_;
}
inline void Datum::set_width(::google::protobuf::int32 value) {
set_has_width();
width_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.Datum.width)
}
// optional bytes data = 4;
inline bool Datum::has_data() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Datum::set_has_data() {
_has_bits_[0] |= 0x00000001u;
}
inline void Datum::clear_has_data() {
_has_bits_[0] &= ~0x00000001u;
}
inline void Datum::clear_data() {
data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_data();
}
inline const ::std::string& Datum::data() const {
// @@protoc_insertion_point(field_get:opencv_caffe.Datum.data)
return data_.GetNoArena();
}
inline void Datum::set_data(const ::std::string& value) {
set_has_data();
data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.Datum.data)
}
#if LANG_CXX11
inline void Datum::set_data(::std::string&& value) {
set_has_data();
data_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.Datum.data)
}
#endif
inline void Datum::set_data(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_data();
data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.Datum.data)
}
inline void Datum::set_data(const void* value, size_t size) {
set_has_data();
data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.Datum.data)
}
inline ::std::string* Datum::mutable_data() {
set_has_data();
// @@protoc_insertion_point(field_mutable:opencv_caffe.Datum.data)
return data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Datum::release_data() {
// @@protoc_insertion_point(field_release:opencv_caffe.Datum.data)
clear_has_data();
return data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Datum::set_allocated_data(::std::string* data) {
if (data != NULL) {
set_has_data();
} else {
clear_has_data();
}
data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.Datum.data)
}
// optional int32 label = 5;
inline bool Datum::has_label() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Datum::set_has_label() {
_has_bits_[0] |= 0x00000010u;
}
inline void Datum::clear_has_label() {
_has_bits_[0] &= ~0x00000010u;
}
inline void Datum::clear_label() {
label_ = 0;
clear_has_label();
}
inline ::google::protobuf::int32 Datum::label() const {
// @@protoc_insertion_point(field_get:opencv_caffe.Datum.label)
return label_;
}
inline void Datum::set_label(::google::protobuf::int32 value) {
set_has_label();
label_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.Datum.label)
}
// repeated float float_data = 6;
inline int Datum::float_data_size() const {
return float_data_.size();
}
inline void Datum::clear_float_data() {
float_data_.Clear();
}
inline float Datum::float_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.Datum.float_data)
return float_data_.Get(index);
}
inline void Datum::set_float_data(int index, float value) {
float_data_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.Datum.float_data)
}
inline void Datum::add_float_data(float value) {
float_data_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.Datum.float_data)
}
inline const ::google::protobuf::RepeatedField< float >&
Datum::float_data() const {
// @@protoc_insertion_point(field_list:opencv_caffe.Datum.float_data)
return float_data_;
}
inline ::google::protobuf::RepeatedField< float >*
Datum::mutable_float_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.Datum.float_data)
return &float_data_;
}
// optional bool encoded = 7 [default = false];
inline bool Datum::has_encoded() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Datum::set_has_encoded() {
_has_bits_[0] |= 0x00000020u;
}
inline void Datum::clear_has_encoded() {
_has_bits_[0] &= ~0x00000020u;
}
inline void Datum::clear_encoded() {
encoded_ = false;
clear_has_encoded();
}
inline bool Datum::encoded() const {
// @@protoc_insertion_point(field_get:opencv_caffe.Datum.encoded)
return encoded_;
}
inline void Datum::set_encoded(bool value) {
set_has_encoded();
encoded_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.Datum.encoded)
}
// -------------------------------------------------------------------
// FillerParameter
// optional string type = 1 [default = "constant"];
inline bool FillerParameter::has_type() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FillerParameter::set_has_type() {
_has_bits_[0] |= 0x00000001u;
}
inline void FillerParameter::clear_has_type() {
_has_bits_[0] &= ~0x00000001u;
}
inline void FillerParameter::clear_type() {
type_.ClearToDefaultNoArena(&::opencv_caffe::FillerParameter::_default_type_.get());
clear_has_type();
}
inline const ::std::string& FillerParameter::type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.type)
return type_.GetNoArena();
}
inline void FillerParameter::set_type(const ::std::string& value) {
set_has_type();
type_.SetNoArena(&::opencv_caffe::FillerParameter::_default_type_.get(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.type)
}
#if LANG_CXX11
inline void FillerParameter::set_type(::std::string&& value) {
set_has_type();
type_.SetNoArena(
&::opencv_caffe::FillerParameter::_default_type_.get(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.FillerParameter.type)
}
#endif
inline void FillerParameter::set_type(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_type();
type_.SetNoArena(&::opencv_caffe::FillerParameter::_default_type_.get(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.FillerParameter.type)
}
inline void FillerParameter::set_type(const char* value, size_t size) {
set_has_type();
type_.SetNoArena(&::opencv_caffe::FillerParameter::_default_type_.get(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.FillerParameter.type)
}
inline ::std::string* FillerParameter::mutable_type() {
set_has_type();
// @@protoc_insertion_point(field_mutable:opencv_caffe.FillerParameter.type)
return type_.MutableNoArena(&::opencv_caffe::FillerParameter::_default_type_.get());
}
inline ::std::string* FillerParameter::release_type() {
// @@protoc_insertion_point(field_release:opencv_caffe.FillerParameter.type)
clear_has_type();
return type_.ReleaseNoArena(&::opencv_caffe::FillerParameter::_default_type_.get());
}
inline void FillerParameter::set_allocated_type(::std::string* type) {
if (type != NULL) {
set_has_type();
} else {
clear_has_type();
}
type_.SetAllocatedNoArena(&::opencv_caffe::FillerParameter::_default_type_.get(), type);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.FillerParameter.type)
}
// optional float value = 2 [default = 0];
inline bool FillerParameter::has_value() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FillerParameter::set_has_value() {
_has_bits_[0] |= 0x00000002u;
}
inline void FillerParameter::clear_has_value() {
_has_bits_[0] &= ~0x00000002u;
}
inline void FillerParameter::clear_value() {
value_ = 0;
clear_has_value();
}
inline float FillerParameter::value() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.value)
return value_;
}
inline void FillerParameter::set_value(float value) {
set_has_value();
value_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.value)
}
// optional float min = 3 [default = 0];
inline bool FillerParameter::has_min() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FillerParameter::set_has_min() {
_has_bits_[0] |= 0x00000004u;
}
inline void FillerParameter::clear_has_min() {
_has_bits_[0] &= ~0x00000004u;
}
inline void FillerParameter::clear_min() {
min_ = 0;
clear_has_min();
}
inline float FillerParameter::min() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.min)
return min_;
}
inline void FillerParameter::set_min(float value) {
set_has_min();
min_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.min)
}
// optional float max = 4 [default = 1];
inline bool FillerParameter::has_max() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void FillerParameter::set_has_max() {
_has_bits_[0] |= 0x00000040u;
}
inline void FillerParameter::clear_has_max() {
_has_bits_[0] &= ~0x00000040u;
}
inline void FillerParameter::clear_max() {
max_ = 1;
clear_has_max();
}
inline float FillerParameter::max() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.max)
return max_;
}
inline void FillerParameter::set_max(float value) {
set_has_max();
max_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.max)
}
// optional float mean = 5 [default = 0];
inline bool FillerParameter::has_mean() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FillerParameter::set_has_mean() {
_has_bits_[0] |= 0x00000008u;
}
inline void FillerParameter::clear_has_mean() {
_has_bits_[0] &= ~0x00000008u;
}
inline void FillerParameter::clear_mean() {
mean_ = 0;
clear_has_mean();
}
inline float FillerParameter::mean() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.mean)
return mean_;
}
inline void FillerParameter::set_mean(float value) {
set_has_mean();
mean_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.mean)
}
// optional float std = 6 [default = 1];
inline bool FillerParameter::has_std() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void FillerParameter::set_has_std() {
_has_bits_[0] |= 0x00000080u;
}
inline void FillerParameter::clear_has_std() {
_has_bits_[0] &= ~0x00000080u;
}
inline void FillerParameter::clear_std() {
std_ = 1;
clear_has_std();
}
inline float FillerParameter::std() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.std)
return std_;
}
inline void FillerParameter::set_std(float value) {
set_has_std();
std_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.std)
}
// optional int32 sparse = 7 [default = -1];
inline bool FillerParameter::has_sparse() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void FillerParameter::set_has_sparse() {
_has_bits_[0] |= 0x00000020u;
}
inline void FillerParameter::clear_has_sparse() {
_has_bits_[0] &= ~0x00000020u;
}
inline void FillerParameter::clear_sparse() {
sparse_ = -1;
clear_has_sparse();
}
inline ::google::protobuf::int32 FillerParameter::sparse() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.sparse)
return sparse_;
}
inline void FillerParameter::set_sparse(::google::protobuf::int32 value) {
set_has_sparse();
sparse_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.sparse)
}
// optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
inline bool FillerParameter::has_variance_norm() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void FillerParameter::set_has_variance_norm() {
_has_bits_[0] |= 0x00000010u;
}
inline void FillerParameter::clear_has_variance_norm() {
_has_bits_[0] &= ~0x00000010u;
}
inline void FillerParameter::clear_variance_norm() {
variance_norm_ = 0;
clear_has_variance_norm();
}
inline ::opencv_caffe::FillerParameter_VarianceNorm FillerParameter::variance_norm() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.variance_norm)
return static_cast< ::opencv_caffe::FillerParameter_VarianceNorm >(variance_norm_);
}
inline void FillerParameter::set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value) {
assert(::opencv_caffe::FillerParameter_VarianceNorm_IsValid(value));
set_has_variance_norm();
variance_norm_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.variance_norm)
}
// -------------------------------------------------------------------
// NetParameter
// optional string name = 1;
inline bool NetParameter::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NetParameter::set_has_name() {
_has_bits_[0] |= 0x00000001u;
}
inline void NetParameter::clear_has_name() {
_has_bits_[0] &= ~0x00000001u;
}
inline void NetParameter::clear_name() {
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string& NetParameter::name() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.name)
return name_.GetNoArena();
}
inline void NetParameter::set_name(const ::std::string& value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.name)
}
#if LANG_CXX11
inline void NetParameter::set_name(::std::string&& value) {
set_has_name();
name_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.NetParameter.name)
}
#endif
inline void NetParameter::set_name(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.NetParameter.name)
}
inline void NetParameter::set_name(const char* value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetParameter.name)
}
inline ::std::string* NetParameter::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.name)
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NetParameter::release_name() {
// @@protoc_insertion_point(field_release:opencv_caffe.NetParameter.name)
clear_has_name();
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NetParameter::set_allocated_name(::std::string* name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.NetParameter.name)
}
// repeated string input = 3;
inline int NetParameter::input_size() const {
return input_.size();
}
inline void NetParameter::clear_input() {
input_.Clear();
}
inline const ::std::string& NetParameter::input(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input)
return input_.Get(index);
}
inline ::std::string* NetParameter::mutable_input(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.input)
return input_.Mutable(index);
}
inline void NetParameter::set_input(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input)
input_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void NetParameter::set_input(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input)
input_.Mutable(index)->assign(std::move(value));
}
#endif
inline void NetParameter::set_input(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
input_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.NetParameter.input)
}
inline void NetParameter::set_input(int index, const char* value, size_t size) {
input_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetParameter.input)
}
inline ::std::string* NetParameter::add_input() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetParameter.input)
return input_.Add();
}
inline void NetParameter::add_input(const ::std::string& value) {
input_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input)
}
#if LANG_CXX11
inline void NetParameter::add_input(::std::string&& value) {
input_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input)
}
#endif
inline void NetParameter::add_input(const char* value) {
GOOGLE_DCHECK(value != NULL);
input_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.NetParameter.input)
}
inline void NetParameter::add_input(const char* value, size_t size) {
input_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetParameter.input)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NetParameter::input() const {
// @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input)
return input_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NetParameter::mutable_input() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input)
return &input_;
}
// repeated .opencv_caffe.BlobShape input_shape = 8;
inline int NetParameter::input_shape_size() const {
return input_shape_.size();
}
inline void NetParameter::clear_input_shape() {
input_shape_.Clear();
}
inline const ::opencv_caffe::BlobShape& NetParameter::input_shape(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input_shape)
return input_shape_.Get(index);
}
inline ::opencv_caffe::BlobShape* NetParameter::mutable_input_shape(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.input_shape)
return input_shape_.Mutable(index);
}
inline ::opencv_caffe::BlobShape* NetParameter::add_input_shape() {
// @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input_shape)
return input_shape_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >*
NetParameter::mutable_input_shape() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input_shape)
return &input_shape_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >&
NetParameter::input_shape() const {
// @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input_shape)
return input_shape_;
}
// repeated int32 input_dim = 4;
inline int NetParameter::input_dim_size() const {
return input_dim_.size();
}
inline void NetParameter::clear_input_dim() {
input_dim_.Clear();
}
inline ::google::protobuf::int32 NetParameter::input_dim(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input_dim)
return input_dim_.Get(index);
}
inline void NetParameter::set_input_dim(int index, ::google::protobuf::int32 value) {
input_dim_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input_dim)
}
inline void NetParameter::add_input_dim(::google::protobuf::int32 value) {
input_dim_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input_dim)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
NetParameter::input_dim() const {
// @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input_dim)
return input_dim_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
NetParameter::mutable_input_dim() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input_dim)
return &input_dim_;
}
// optional bool force_backward = 5 [default = false];
inline bool NetParameter::has_force_backward() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NetParameter::set_has_force_backward() {
_has_bits_[0] |= 0x00000004u;
}
inline void NetParameter::clear_has_force_backward() {
_has_bits_[0] &= ~0x00000004u;
}
inline void NetParameter::clear_force_backward() {
force_backward_ = false;
clear_has_force_backward();
}
inline bool NetParameter::force_backward() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.force_backward)
return force_backward_;
}
inline void NetParameter::set_force_backward(bool value) {
set_has_force_backward();
force_backward_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.force_backward)
}
// optional .opencv_caffe.NetState state = 6;
inline bool NetParameter::has_state() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NetParameter::set_has_state() {
_has_bits_[0] |= 0x00000002u;
}
inline void NetParameter::clear_has_state() {
_has_bits_[0] &= ~0x00000002u;
}
inline void NetParameter::clear_state() {
if (state_ != NULL) state_->Clear();
clear_has_state();
}
inline const ::opencv_caffe::NetState& NetParameter::state() const {
const ::opencv_caffe::NetState* p = state_;
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.state)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::NetState*>(
&::opencv_caffe::_NetState_default_instance_);
}
inline ::opencv_caffe::NetState* NetParameter::release_state() {
// @@protoc_insertion_point(field_release:opencv_caffe.NetParameter.state)
clear_has_state();
::opencv_caffe::NetState* temp = state_;
state_ = NULL;
return temp;
}
inline ::opencv_caffe::NetState* NetParameter::mutable_state() {
set_has_state();
if (state_ == NULL) {
state_ = new ::opencv_caffe::NetState;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.state)
return state_;
}
inline void NetParameter::set_allocated_state(::opencv_caffe::NetState* state) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete state_;
}
if (state) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
state = ::google::protobuf::internal::GetOwnedMessage(
message_arena, state, submessage_arena);
}
set_has_state();
} else {
clear_has_state();
}
state_ = state;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.NetParameter.state)
}
// optional bool debug_info = 7 [default = false];
inline bool NetParameter::has_debug_info() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NetParameter::set_has_debug_info() {
_has_bits_[0] |= 0x00000008u;
}
inline void NetParameter::clear_has_debug_info() {
_has_bits_[0] &= ~0x00000008u;
}
inline void NetParameter::clear_debug_info() {
debug_info_ = false;
clear_has_debug_info();
}
inline bool NetParameter::debug_info() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.debug_info)
return debug_info_;
}
inline void NetParameter::set_debug_info(bool value) {
set_has_debug_info();
debug_info_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.debug_info)
}
// repeated .opencv_caffe.LayerParameter layer = 100;
inline int NetParameter::layer_size() const {
return layer_.size();
}
inline void NetParameter::clear_layer() {
layer_.Clear();
}
inline const ::opencv_caffe::LayerParameter& NetParameter::layer(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.layer)
return layer_.Get(index);
}
inline ::opencv_caffe::LayerParameter* NetParameter::mutable_layer(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.layer)
return layer_.Mutable(index);
}
inline ::opencv_caffe::LayerParameter* NetParameter::add_layer() {
// @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.layer)
return layer_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::LayerParameter >*
NetParameter::mutable_layer() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.layer)
return &layer_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::LayerParameter >&
NetParameter::layer() const {
// @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.layer)
return layer_;
}
// repeated .opencv_caffe.V1LayerParameter layers = 2;
inline int NetParameter::layers_size() const {
return layers_.size();
}
inline void NetParameter::clear_layers() {
layers_.Clear();
}
inline const ::opencv_caffe::V1LayerParameter& NetParameter::layers(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.layers)
return layers_.Get(index);
}
inline ::opencv_caffe::V1LayerParameter* NetParameter::mutable_layers(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.layers)
return layers_.Mutable(index);
}
inline ::opencv_caffe::V1LayerParameter* NetParameter::add_layers() {
// @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.layers)
return layers_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >*
NetParameter::mutable_layers() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.layers)
return &layers_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >&
NetParameter::layers() const {
// @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.layers)
return layers_;
}
// -------------------------------------------------------------------
// SolverParameter
// optional string net = 24;
inline bool SolverParameter::has_net() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SolverParameter::set_has_net() {
_has_bits_[0] |= 0x00000008u;
}
inline void SolverParameter::clear_has_net() {
_has_bits_[0] &= ~0x00000008u;
}
inline void SolverParameter::clear_net() {
net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_net();
}
inline const ::std::string& SolverParameter::net() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.net)
return net_.GetNoArena();
}
inline void SolverParameter::set_net(const ::std::string& value) {
set_has_net();
net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.net)
}
#if LANG_CXX11
inline void SolverParameter::set_net(::std::string&& value) {
set_has_net();
net_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SolverParameter.net)
}
#endif
inline void SolverParameter::set_net(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_net();
net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SolverParameter.net)
}
inline void SolverParameter::set_net(const char* value, size_t size) {
set_has_net();
net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.net)
}
inline ::std::string* SolverParameter::mutable_net() {
set_has_net();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.net)
return net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SolverParameter::release_net() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.net)
clear_has_net();
return net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SolverParameter::set_allocated_net(::std::string* net) {
if (net != NULL) {
set_has_net();
} else {
clear_has_net();
}
net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), net);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.net)
}
// optional .opencv_caffe.NetParameter net_param = 25;
inline bool SolverParameter::has_net_param() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void SolverParameter::set_has_net_param() {
_has_bits_[0] |= 0x00000080u;
}
inline void SolverParameter::clear_has_net_param() {
_has_bits_[0] &= ~0x00000080u;
}
inline void SolverParameter::clear_net_param() {
if (net_param_ != NULL) net_param_->Clear();
clear_has_net_param();
}
inline const ::opencv_caffe::NetParameter& SolverParameter::net_param() const {
const ::opencv_caffe::NetParameter* p = net_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.net_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::NetParameter*>(
&::opencv_caffe::_NetParameter_default_instance_);
}
inline ::opencv_caffe::NetParameter* SolverParameter::release_net_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.net_param)
clear_has_net_param();
::opencv_caffe::NetParameter* temp = net_param_;
net_param_ = NULL;
return temp;
}
inline ::opencv_caffe::NetParameter* SolverParameter::mutable_net_param() {
set_has_net_param();
if (net_param_ == NULL) {
net_param_ = new ::opencv_caffe::NetParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.net_param)
return net_param_;
}
inline void SolverParameter::set_allocated_net_param(::opencv_caffe::NetParameter* net_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete net_param_;
}
if (net_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
net_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, net_param, submessage_arena);
}
set_has_net_param();
} else {
clear_has_net_param();
}
net_param_ = net_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.net_param)
}
// optional string train_net = 1;
inline bool SolverParameter::has_train_net() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SolverParameter::set_has_train_net() {
_has_bits_[0] |= 0x00000001u;
}
inline void SolverParameter::clear_has_train_net() {
_has_bits_[0] &= ~0x00000001u;
}
inline void SolverParameter::clear_train_net() {
train_net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_train_net();
}
inline const ::std::string& SolverParameter::train_net() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_net)
return train_net_.GetNoArena();
}
inline void SolverParameter::set_train_net(const ::std::string& value) {
set_has_train_net();
train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.train_net)
}
#if LANG_CXX11
inline void SolverParameter::set_train_net(::std::string&& value) {
set_has_train_net();
train_net_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SolverParameter.train_net)
}
#endif
inline void SolverParameter::set_train_net(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_train_net();
train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SolverParameter.train_net)
}
inline void SolverParameter::set_train_net(const char* value, size_t size) {
set_has_train_net();
train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.train_net)
}
inline ::std::string* SolverParameter::mutable_train_net() {
set_has_train_net();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_net)
return train_net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SolverParameter::release_train_net() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_net)
clear_has_train_net();
return train_net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SolverParameter::set_allocated_train_net(::std::string* train_net) {
if (train_net != NULL) {
set_has_train_net();
} else {
clear_has_train_net();
}
train_net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), train_net);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.train_net)
}
// repeated string test_net = 2;
inline int SolverParameter::test_net_size() const {
return test_net_.size();
}
inline void SolverParameter::clear_test_net() {
test_net_.Clear();
}
inline const ::std::string& SolverParameter::test_net(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_net)
return test_net_.Get(index);
}
inline ::std::string* SolverParameter::mutable_test_net(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.test_net)
return test_net_.Mutable(index);
}
inline void SolverParameter::set_test_net(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_net)
test_net_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void SolverParameter::set_test_net(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_net)
test_net_.Mutable(index)->assign(std::move(value));
}
#endif
inline void SolverParameter::set_test_net(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
test_net_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.SolverParameter.test_net)
}
inline void SolverParameter::set_test_net(int index, const char* value, size_t size) {
test_net_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.test_net)
}
inline ::std::string* SolverParameter::add_test_net() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.SolverParameter.test_net)
return test_net_.Add();
}
inline void SolverParameter::add_test_net(const ::std::string& value) {
test_net_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_net)
}
#if LANG_CXX11
inline void SolverParameter::add_test_net(::std::string&& value) {
test_net_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_net)
}
#endif
inline void SolverParameter::add_test_net(const char* value) {
GOOGLE_DCHECK(value != NULL);
test_net_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.SolverParameter.test_net)
}
inline void SolverParameter::add_test_net(const char* value, size_t size) {
test_net_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.SolverParameter.test_net)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
SolverParameter::test_net() const {
// @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_net)
return test_net_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
SolverParameter::mutable_test_net() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_net)
return &test_net_;
}
// optional .opencv_caffe.NetParameter train_net_param = 21;
inline bool SolverParameter::has_train_net_param() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void SolverParameter::set_has_train_net_param() {
_has_bits_[0] |= 0x00000040u;
}
inline void SolverParameter::clear_has_train_net_param() {
_has_bits_[0] &= ~0x00000040u;
}
inline void SolverParameter::clear_train_net_param() {
if (train_net_param_ != NULL) train_net_param_->Clear();
clear_has_train_net_param();
}
inline const ::opencv_caffe::NetParameter& SolverParameter::train_net_param() const {
const ::opencv_caffe::NetParameter* p = train_net_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_net_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::NetParameter*>(
&::opencv_caffe::_NetParameter_default_instance_);
}
inline ::opencv_caffe::NetParameter* SolverParameter::release_train_net_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_net_param)
clear_has_train_net_param();
::opencv_caffe::NetParameter* temp = train_net_param_;
train_net_param_ = NULL;
return temp;
}
inline ::opencv_caffe::NetParameter* SolverParameter::mutable_train_net_param() {
set_has_train_net_param();
if (train_net_param_ == NULL) {
train_net_param_ = new ::opencv_caffe::NetParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_net_param)
return train_net_param_;
}
inline void SolverParameter::set_allocated_train_net_param(::opencv_caffe::NetParameter* train_net_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete train_net_param_;
}
if (train_net_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
train_net_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, train_net_param, submessage_arena);
}
set_has_train_net_param();
} else {
clear_has_train_net_param();
}
train_net_param_ = train_net_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.train_net_param)
}
// repeated .opencv_caffe.NetParameter test_net_param = 22;
inline int SolverParameter::test_net_param_size() const {
return test_net_param_.size();
}
inline void SolverParameter::clear_test_net_param() {
test_net_param_.Clear();
}
inline const ::opencv_caffe::NetParameter& SolverParameter::test_net_param(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_net_param)
return test_net_param_.Get(index);
}
inline ::opencv_caffe::NetParameter* SolverParameter::mutable_test_net_param(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.test_net_param)
return test_net_param_.Mutable(index);
}
inline ::opencv_caffe::NetParameter* SolverParameter::add_test_net_param() {
// @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_net_param)
return test_net_param_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetParameter >*
SolverParameter::mutable_test_net_param() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_net_param)
return &test_net_param_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetParameter >&
SolverParameter::test_net_param() const {
// @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_net_param)
return test_net_param_;
}
// optional .opencv_caffe.NetState train_state = 26;
inline bool SolverParameter::has_train_state() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void SolverParameter::set_has_train_state() {
_has_bits_[0] |= 0x00000100u;
}
inline void SolverParameter::clear_has_train_state() {
_has_bits_[0] &= ~0x00000100u;
}
inline void SolverParameter::clear_train_state() {
if (train_state_ != NULL) train_state_->Clear();
clear_has_train_state();
}
inline const ::opencv_caffe::NetState& SolverParameter::train_state() const {
const ::opencv_caffe::NetState* p = train_state_;
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_state)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::NetState*>(
&::opencv_caffe::_NetState_default_instance_);
}
inline ::opencv_caffe::NetState* SolverParameter::release_train_state() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_state)
clear_has_train_state();
::opencv_caffe::NetState* temp = train_state_;
train_state_ = NULL;
return temp;
}
inline ::opencv_caffe::NetState* SolverParameter::mutable_train_state() {
set_has_train_state();
if (train_state_ == NULL) {
train_state_ = new ::opencv_caffe::NetState;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_state)
return train_state_;
}
inline void SolverParameter::set_allocated_train_state(::opencv_caffe::NetState* train_state) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete train_state_;
}
if (train_state) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
train_state = ::google::protobuf::internal::GetOwnedMessage(
message_arena, train_state, submessage_arena);
}
set_has_train_state();
} else {
clear_has_train_state();
}
train_state_ = train_state;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.train_state)
}
// repeated .opencv_caffe.NetState test_state = 27;
inline int SolverParameter::test_state_size() const {
return test_state_.size();
}
inline void SolverParameter::clear_test_state() {
test_state_.Clear();
}
inline const ::opencv_caffe::NetState& SolverParameter::test_state(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_state)
return test_state_.Get(index);
}
inline ::opencv_caffe::NetState* SolverParameter::mutable_test_state(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.test_state)
return test_state_.Mutable(index);
}
inline ::opencv_caffe::NetState* SolverParameter::add_test_state() {
// @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_state)
return test_state_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetState >*
SolverParameter::mutable_test_state() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_state)
return &test_state_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetState >&
SolverParameter::test_state() const {
// @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_state)
return test_state_;
}
// repeated int32 test_iter = 3;
inline int SolverParameter::test_iter_size() const {
return test_iter_.size();
}
inline void SolverParameter::clear_test_iter() {
test_iter_.Clear();
}
inline ::google::protobuf::int32 SolverParameter::test_iter(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_iter)
return test_iter_.Get(index);
}
inline void SolverParameter::set_test_iter(int index, ::google::protobuf::int32 value) {
test_iter_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_iter)
}
inline void SolverParameter::add_test_iter(::google::protobuf::int32 value) {
test_iter_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_iter)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SolverParameter::test_iter() const {
// @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_iter)
return test_iter_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SolverParameter::mutable_test_iter() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_iter)
return &test_iter_;
}
// optional int32 test_interval = 4 [default = 0];
inline bool SolverParameter::has_test_interval() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void SolverParameter::set_has_test_interval() {
_has_bits_[0] |= 0x00000200u;
}
inline void SolverParameter::clear_has_test_interval() {
_has_bits_[0] &= ~0x00000200u;
}
inline void SolverParameter::clear_test_interval() {
test_interval_ = 0;
clear_has_test_interval();
}
inline ::google::protobuf::int32 SolverParameter::test_interval() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_interval)
return test_interval_;
}
inline void SolverParameter::set_test_interval(::google::protobuf::int32 value) {
set_has_test_interval();
test_interval_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_interval)
}
// optional bool test_compute_loss = 19 [default = false];
inline bool SolverParameter::has_test_compute_loss() const {
return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void SolverParameter::set_has_test_compute_loss() {
_has_bits_[0] |= 0x00100000u;
}
inline void SolverParameter::clear_has_test_compute_loss() {
_has_bits_[0] &= ~0x00100000u;
}
inline void SolverParameter::clear_test_compute_loss() {
test_compute_loss_ = false;
clear_has_test_compute_loss();
}
inline bool SolverParameter::test_compute_loss() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_compute_loss)
return test_compute_loss_;
}
inline void SolverParameter::set_test_compute_loss(bool value) {
set_has_test_compute_loss();
test_compute_loss_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_compute_loss)
}
// optional bool test_initialization = 32 [default = true];
inline bool SolverParameter::has_test_initialization() const {
return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void SolverParameter::set_has_test_initialization() {
_has_bits_[0] |= 0x08000000u;
}
inline void SolverParameter::clear_has_test_initialization() {
_has_bits_[0] &= ~0x08000000u;
}
inline void SolverParameter::clear_test_initialization() {
test_initialization_ = true;
clear_has_test_initialization();
}
inline bool SolverParameter::test_initialization() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_initialization)
return test_initialization_;
}
inline void SolverParameter::set_test_initialization(bool value) {
set_has_test_initialization();
test_initialization_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_initialization)
}
// optional float base_lr = 5;
inline bool SolverParameter::has_base_lr() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void SolverParameter::set_has_base_lr() {
_has_bits_[0] |= 0x00000400u;
}
inline void SolverParameter::clear_has_base_lr() {
_has_bits_[0] &= ~0x00000400u;
}
inline void SolverParameter::clear_base_lr() {
base_lr_ = 0;
clear_has_base_lr();
}
inline float SolverParameter::base_lr() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.base_lr)
return base_lr_;
}
inline void SolverParameter::set_base_lr(float value) {
set_has_base_lr();
base_lr_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.base_lr)
}
// optional int32 display = 6;
inline bool SolverParameter::has_display() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void SolverParameter::set_has_display() {
_has_bits_[0] |= 0x00000800u;
}
inline void SolverParameter::clear_has_display() {
_has_bits_[0] &= ~0x00000800u;
}
inline void SolverParameter::clear_display() {
display_ = 0;
clear_has_display();
}
inline ::google::protobuf::int32 SolverParameter::display() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.display)
return display_;
}
inline void SolverParameter::set_display(::google::protobuf::int32 value) {
set_has_display();
display_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.display)
}
// optional int32 average_loss = 33 [default = 1];
inline bool SolverParameter::has_average_loss() const {
return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void SolverParameter::set_has_average_loss() {
_has_bits_[0] |= 0x40000000u;
}
inline void SolverParameter::clear_has_average_loss() {
_has_bits_[0] &= ~0x40000000u;
}
inline void SolverParameter::clear_average_loss() {
average_loss_ = 1;
clear_has_average_loss();
}
inline ::google::protobuf::int32 SolverParameter::average_loss() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.average_loss)
return average_loss_;
}
inline void SolverParameter::set_average_loss(::google::protobuf::int32 value) {
set_has_average_loss();
average_loss_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.average_loss)
}
// optional int32 max_iter = 7;
inline bool SolverParameter::has_max_iter() const {
return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void SolverParameter::set_has_max_iter() {
_has_bits_[0] |= 0x00001000u;
}
inline void SolverParameter::clear_has_max_iter() {
_has_bits_[0] &= ~0x00001000u;
}
inline void SolverParameter::clear_max_iter() {
max_iter_ = 0;
clear_has_max_iter();
}
inline ::google::protobuf::int32 SolverParameter::max_iter() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.max_iter)
return max_iter_;
}
inline void SolverParameter::set_max_iter(::google::protobuf::int32 value) {
set_has_max_iter();
max_iter_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.max_iter)
}
// optional int32 iter_size = 36 [default = 1];
inline bool SolverParameter::has_iter_size() const {
return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void SolverParameter::set_has_iter_size() {
_has_bits_[1] |= 0x00000001u;
}
inline void SolverParameter::clear_has_iter_size() {
_has_bits_[1] &= ~0x00000001u;
}
inline void SolverParameter::clear_iter_size() {
iter_size_ = 1;
clear_has_iter_size();
}
inline ::google::protobuf::int32 SolverParameter::iter_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.iter_size)
return iter_size_;
}
inline void SolverParameter::set_iter_size(::google::protobuf::int32 value) {
set_has_iter_size();
iter_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.iter_size)
}
// optional string lr_policy = 8;
inline bool SolverParameter::has_lr_policy() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SolverParameter::set_has_lr_policy() {
_has_bits_[0] |= 0x00000002u;
}
inline void SolverParameter::clear_has_lr_policy() {
_has_bits_[0] &= ~0x00000002u;
}
inline void SolverParameter::clear_lr_policy() {
lr_policy_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_lr_policy();
}
inline const ::std::string& SolverParameter::lr_policy() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.lr_policy)
return lr_policy_.GetNoArena();
}
inline void SolverParameter::set_lr_policy(const ::std::string& value) {
set_has_lr_policy();
lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.lr_policy)
}
#if LANG_CXX11
inline void SolverParameter::set_lr_policy(::std::string&& value) {
set_has_lr_policy();
lr_policy_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SolverParameter.lr_policy)
}
#endif
inline void SolverParameter::set_lr_policy(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_lr_policy();
lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SolverParameter.lr_policy)
}
inline void SolverParameter::set_lr_policy(const char* value, size_t size) {
set_has_lr_policy();
lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.lr_policy)
}
inline ::std::string* SolverParameter::mutable_lr_policy() {
set_has_lr_policy();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.lr_policy)
return lr_policy_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SolverParameter::release_lr_policy() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.lr_policy)
clear_has_lr_policy();
return lr_policy_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SolverParameter::set_allocated_lr_policy(::std::string* lr_policy) {
if (lr_policy != NULL) {
set_has_lr_policy();
} else {
clear_has_lr_policy();
}
lr_policy_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), lr_policy);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.lr_policy)
}
// optional float gamma = 9;
inline bool SolverParameter::has_gamma() const {
return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void SolverParameter::set_has_gamma() {
_has_bits_[0] |= 0x00002000u;
}
inline void SolverParameter::clear_has_gamma() {
_has_bits_[0] &= ~0x00002000u;
}
inline void SolverParameter::clear_gamma() {
gamma_ = 0;
clear_has_gamma();
}
inline float SolverParameter::gamma() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.gamma)
return gamma_;
}
inline void SolverParameter::set_gamma(float value) {
set_has_gamma();
gamma_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.gamma)
}
// optional float power = 10;
inline bool SolverParameter::has_power() const {
return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void SolverParameter::set_has_power() {
_has_bits_[0] |= 0x00004000u;
}
inline void SolverParameter::clear_has_power() {
_has_bits_[0] &= ~0x00004000u;
}
inline void SolverParameter::clear_power() {
power_ = 0;
clear_has_power();
}
inline float SolverParameter::power() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.power)
return power_;
}
inline void SolverParameter::set_power(float value) {
set_has_power();
power_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.power)
}
// optional float momentum = 11;
inline bool SolverParameter::has_momentum() const {
return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void SolverParameter::set_has_momentum() {
_has_bits_[0] |= 0x00008000u;
}
inline void SolverParameter::clear_has_momentum() {
_has_bits_[0] &= ~0x00008000u;
}
inline void SolverParameter::clear_momentum() {
momentum_ = 0;
clear_has_momentum();
}
inline float SolverParameter::momentum() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.momentum)
return momentum_;
}
inline void SolverParameter::set_momentum(float value) {
set_has_momentum();
momentum_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.momentum)
}
// optional float weight_decay = 12;
inline bool SolverParameter::has_weight_decay() const {
return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void SolverParameter::set_has_weight_decay() {
_has_bits_[0] |= 0x00010000u;
}
inline void SolverParameter::clear_has_weight_decay() {
_has_bits_[0] &= ~0x00010000u;
}
inline void SolverParameter::clear_weight_decay() {
weight_decay_ = 0;
clear_has_weight_decay();
}
inline float SolverParameter::weight_decay() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.weight_decay)
return weight_decay_;
}
inline void SolverParameter::set_weight_decay(float value) {
set_has_weight_decay();
weight_decay_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.weight_decay)
}
// optional string regularization_type = 29 [default = "L2"];
inline bool SolverParameter::has_regularization_type() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SolverParameter::set_has_regularization_type() {
_has_bits_[0] |= 0x00000010u;
}
inline void SolverParameter::clear_has_regularization_type() {
_has_bits_[0] &= ~0x00000010u;
}
inline void SolverParameter::clear_regularization_type() {
regularization_type_.ClearToDefaultNoArena(&::opencv_caffe::SolverParameter::_default_regularization_type_.get());
clear_has_regularization_type();
}
inline const ::std::string& SolverParameter::regularization_type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.regularization_type)
return regularization_type_.GetNoArena();
}
inline void SolverParameter::set_regularization_type(const ::std::string& value) {
set_has_regularization_type();
regularization_type_.SetNoArena(&::opencv_caffe::SolverParameter::_default_regularization_type_.get(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.regularization_type)
}
#if LANG_CXX11
inline void SolverParameter::set_regularization_type(::std::string&& value) {
set_has_regularization_type();
regularization_type_.SetNoArena(
&::opencv_caffe::SolverParameter::_default_regularization_type_.get(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SolverParameter.regularization_type)
}
#endif
inline void SolverParameter::set_regularization_type(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_regularization_type();
regularization_type_.SetNoArena(&::opencv_caffe::SolverParameter::_default_regularization_type_.get(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SolverParameter.regularization_type)
}
inline void SolverParameter::set_regularization_type(const char* value, size_t size) {
set_has_regularization_type();
regularization_type_.SetNoArena(&::opencv_caffe::SolverParameter::_default_regularization_type_.get(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.regularization_type)
}
inline ::std::string* SolverParameter::mutable_regularization_type() {
set_has_regularization_type();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.regularization_type)
return regularization_type_.MutableNoArena(&::opencv_caffe::SolverParameter::_default_regularization_type_.get());
}
inline ::std::string* SolverParameter::release_regularization_type() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.regularization_type)
clear_has_regularization_type();
return regularization_type_.ReleaseNoArena(&::opencv_caffe::SolverParameter::_default_regularization_type_.get());
}
inline void SolverParameter::set_allocated_regularization_type(::std::string* regularization_type) {
if (regularization_type != NULL) {
set_has_regularization_type();
} else {
clear_has_regularization_type();
}
regularization_type_.SetAllocatedNoArena(&::opencv_caffe::SolverParameter::_default_regularization_type_.get(), regularization_type);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.regularization_type)
}
// optional int32 stepsize = 13;
inline bool SolverParameter::has_stepsize() const {
return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void SolverParameter::set_has_stepsize() {
_has_bits_[0] |= 0x00020000u;
}
inline void SolverParameter::clear_has_stepsize() {
_has_bits_[0] &= ~0x00020000u;
}
inline void SolverParameter::clear_stepsize() {
stepsize_ = 0;
clear_has_stepsize();
}
inline ::google::protobuf::int32 SolverParameter::stepsize() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.stepsize)
return stepsize_;
}
inline void SolverParameter::set_stepsize(::google::protobuf::int32 value) {
set_has_stepsize();
stepsize_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.stepsize)
}
// repeated int32 stepvalue = 34;
inline int SolverParameter::stepvalue_size() const {
return stepvalue_.size();
}
inline void SolverParameter::clear_stepvalue() {
stepvalue_.Clear();
}
inline ::google::protobuf::int32 SolverParameter::stepvalue(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.stepvalue)
return stepvalue_.Get(index);
}
inline void SolverParameter::set_stepvalue(int index, ::google::protobuf::int32 value) {
stepvalue_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.stepvalue)
}
inline void SolverParameter::add_stepvalue(::google::protobuf::int32 value) {
stepvalue_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.stepvalue)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SolverParameter::stepvalue() const {
// @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.stepvalue)
return stepvalue_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SolverParameter::mutable_stepvalue() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.stepvalue)
return &stepvalue_;
}
// optional float clip_gradients = 35 [default = -1];
inline bool SolverParameter::has_clip_gradients() const {
return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void SolverParameter::set_has_clip_gradients() {
_has_bits_[0] |= 0x80000000u;
}
inline void SolverParameter::clear_has_clip_gradients() {
_has_bits_[0] &= ~0x80000000u;
}
inline void SolverParameter::clear_clip_gradients() {
clip_gradients_ = -1;
clear_has_clip_gradients();
}
inline float SolverParameter::clip_gradients() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.clip_gradients)
return clip_gradients_;
}
inline void SolverParameter::set_clip_gradients(float value) {
set_has_clip_gradients();
clip_gradients_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.clip_gradients)
}
// optional int32 snapshot = 14 [default = 0];
inline bool SolverParameter::has_snapshot() const {
return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void SolverParameter::set_has_snapshot() {
_has_bits_[0] |= 0x00040000u;
}
inline void SolverParameter::clear_has_snapshot() {
_has_bits_[0] &= ~0x00040000u;
}
inline void SolverParameter::clear_snapshot() {
snapshot_ = 0;
clear_has_snapshot();
}
inline ::google::protobuf::int32 SolverParameter::snapshot() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot)
return snapshot_;
}
inline void SolverParameter::set_snapshot(::google::protobuf::int32 value) {
set_has_snapshot();
snapshot_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot)
}
// optional string snapshot_prefix = 15;
inline bool SolverParameter::has_snapshot_prefix() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SolverParameter::set_has_snapshot_prefix() {
_has_bits_[0] |= 0x00000004u;
}
inline void SolverParameter::clear_has_snapshot_prefix() {
_has_bits_[0] &= ~0x00000004u;
}
inline void SolverParameter::clear_snapshot_prefix() {
snapshot_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_snapshot_prefix();
}
inline const ::std::string& SolverParameter::snapshot_prefix() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_prefix)
return snapshot_prefix_.GetNoArena();
}
inline void SolverParameter::set_snapshot_prefix(const ::std::string& value) {
set_has_snapshot_prefix();
snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_prefix)
}
#if LANG_CXX11
inline void SolverParameter::set_snapshot_prefix(::std::string&& value) {
set_has_snapshot_prefix();
snapshot_prefix_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SolverParameter.snapshot_prefix)
}
#endif
inline void SolverParameter::set_snapshot_prefix(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_snapshot_prefix();
snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SolverParameter.snapshot_prefix)
}
inline void SolverParameter::set_snapshot_prefix(const char* value, size_t size) {
set_has_snapshot_prefix();
snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.snapshot_prefix)
}
inline ::std::string* SolverParameter::mutable_snapshot_prefix() {
set_has_snapshot_prefix();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.snapshot_prefix)
return snapshot_prefix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SolverParameter::release_snapshot_prefix() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.snapshot_prefix)
clear_has_snapshot_prefix();
return snapshot_prefix_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SolverParameter::set_allocated_snapshot_prefix(::std::string* snapshot_prefix) {
if (snapshot_prefix != NULL) {
set_has_snapshot_prefix();
} else {
clear_has_snapshot_prefix();
}
snapshot_prefix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshot_prefix);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.snapshot_prefix)
}
// optional bool snapshot_diff = 16 [default = false];
inline bool SolverParameter::has_snapshot_diff() const {
return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void SolverParameter::set_has_snapshot_diff() {
_has_bits_[0] |= 0x00200000u;
}
inline void SolverParameter::clear_has_snapshot_diff() {
_has_bits_[0] &= ~0x00200000u;
}
inline void SolverParameter::clear_snapshot_diff() {
snapshot_diff_ = false;
clear_has_snapshot_diff();
}
inline bool SolverParameter::snapshot_diff() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_diff)
return snapshot_diff_;
}
inline void SolverParameter::set_snapshot_diff(bool value) {
set_has_snapshot_diff();
snapshot_diff_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_diff)
}
// optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
inline bool SolverParameter::has_snapshot_format() const {
return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void SolverParameter::set_has_snapshot_format() {
_has_bits_[1] |= 0x00000002u;
}
inline void SolverParameter::clear_has_snapshot_format() {
_has_bits_[1] &= ~0x00000002u;
}
inline void SolverParameter::clear_snapshot_format() {
snapshot_format_ = 1;
clear_has_snapshot_format();
}
inline ::opencv_caffe::SolverParameter_SnapshotFormat SolverParameter::snapshot_format() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_format)
return static_cast< ::opencv_caffe::SolverParameter_SnapshotFormat >(snapshot_format_);
}
inline void SolverParameter::set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value) {
assert(::opencv_caffe::SolverParameter_SnapshotFormat_IsValid(value));
set_has_snapshot_format();
snapshot_format_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_format)
}
// optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
inline bool SolverParameter::has_solver_mode() const {
return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void SolverParameter::set_has_solver_mode() {
_has_bits_[0] |= 0x04000000u;
}
inline void SolverParameter::clear_has_solver_mode() {
_has_bits_[0] &= ~0x04000000u;
}
inline void SolverParameter::clear_solver_mode() {
solver_mode_ = 1;
clear_has_solver_mode();
}
inline ::opencv_caffe::SolverParameter_SolverMode SolverParameter::solver_mode() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.solver_mode)
return static_cast< ::opencv_caffe::SolverParameter_SolverMode >(solver_mode_);
}
inline void SolverParameter::set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value) {
assert(::opencv_caffe::SolverParameter_SolverMode_IsValid(value));
set_has_solver_mode();
solver_mode_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.solver_mode)
}
// optional int32 device_id = 18 [default = 0];
inline bool SolverParameter::has_device_id() const {
return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void SolverParameter::set_has_device_id() {
_has_bits_[0] |= 0x00080000u;
}
inline void SolverParameter::clear_has_device_id() {
_has_bits_[0] &= ~0x00080000u;
}
inline void SolverParameter::clear_device_id() {
device_id_ = 0;
clear_has_device_id();
}
inline ::google::protobuf::int32 SolverParameter::device_id() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.device_id)
return device_id_;
}
inline void SolverParameter::set_device_id(::google::protobuf::int32 value) {
set_has_device_id();
device_id_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.device_id)
}
// optional int64 random_seed = 20 [default = -1];
inline bool SolverParameter::has_random_seed() const {
return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void SolverParameter::set_has_random_seed() {
_has_bits_[0] |= 0x02000000u;
}
inline void SolverParameter::clear_has_random_seed() {
_has_bits_[0] &= ~0x02000000u;
}
inline void SolverParameter::clear_random_seed() {
random_seed_ = GOOGLE_LONGLONG(-1);
clear_has_random_seed();
}
inline ::google::protobuf::int64 SolverParameter::random_seed() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.random_seed)
return random_seed_;
}
inline void SolverParameter::set_random_seed(::google::protobuf::int64 value) {
set_has_random_seed();
random_seed_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.random_seed)
}
// optional string type = 40 [default = "SGD"];
inline bool SolverParameter::has_type() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void SolverParameter::set_has_type() {
_has_bits_[0] |= 0x00000020u;
}
inline void SolverParameter::clear_has_type() {
_has_bits_[0] &= ~0x00000020u;
}
inline void SolverParameter::clear_type() {
type_.ClearToDefaultNoArena(&::opencv_caffe::SolverParameter::_default_type_.get());
clear_has_type();
}
inline const ::std::string& SolverParameter::type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.type)
return type_.GetNoArena();
}
inline void SolverParameter::set_type(const ::std::string& value) {
set_has_type();
type_.SetNoArena(&::opencv_caffe::SolverParameter::_default_type_.get(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.type)
}
#if LANG_CXX11
inline void SolverParameter::set_type(::std::string&& value) {
set_has_type();
type_.SetNoArena(
&::opencv_caffe::SolverParameter::_default_type_.get(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SolverParameter.type)
}
#endif
inline void SolverParameter::set_type(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_type();
type_.SetNoArena(&::opencv_caffe::SolverParameter::_default_type_.get(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SolverParameter.type)
}
inline void SolverParameter::set_type(const char* value, size_t size) {
set_has_type();
type_.SetNoArena(&::opencv_caffe::SolverParameter::_default_type_.get(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.type)
}
inline ::std::string* SolverParameter::mutable_type() {
set_has_type();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.type)
return type_.MutableNoArena(&::opencv_caffe::SolverParameter::_default_type_.get());
}
inline ::std::string* SolverParameter::release_type() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.type)
clear_has_type();
return type_.ReleaseNoArena(&::opencv_caffe::SolverParameter::_default_type_.get());
}
inline void SolverParameter::set_allocated_type(::std::string* type) {
if (type != NULL) {
set_has_type();
} else {
clear_has_type();
}
type_.SetAllocatedNoArena(&::opencv_caffe::SolverParameter::_default_type_.get(), type);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.type)
}
// optional float delta = 31 [default = 1e-08];
inline bool SolverParameter::has_delta() const {
return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void SolverParameter::set_has_delta() {
_has_bits_[0] |= 0x20000000u;
}
inline void SolverParameter::clear_has_delta() {
_has_bits_[0] &= ~0x20000000u;
}
inline void SolverParameter::clear_delta() {
delta_ = 1e-08f;
clear_has_delta();
}
inline float SolverParameter::delta() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.delta)
return delta_;
}
inline void SolverParameter::set_delta(float value) {
set_has_delta();
delta_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.delta)
}
// optional float momentum2 = 39 [default = 0.999];
inline bool SolverParameter::has_momentum2() const {
return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void SolverParameter::set_has_momentum2() {
_has_bits_[0] |= 0x01000000u;
}
inline void SolverParameter::clear_has_momentum2() {
_has_bits_[0] &= ~0x01000000u;
}
inline void SolverParameter::clear_momentum2() {
momentum2_ = 0.999f;
clear_has_momentum2();
}
inline float SolverParameter::momentum2() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.momentum2)
return momentum2_;
}
inline void SolverParameter::set_momentum2(float value) {
set_has_momentum2();
momentum2_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.momentum2)
}
// optional float rms_decay = 38 [default = 0.99];
inline bool SolverParameter::has_rms_decay() const {
return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void SolverParameter::set_has_rms_decay() {
_has_bits_[1] |= 0x00000004u;
}
inline void SolverParameter::clear_has_rms_decay() {
_has_bits_[1] &= ~0x00000004u;
}
inline void SolverParameter::clear_rms_decay() {
rms_decay_ = 0.99f;
clear_has_rms_decay();
}
inline float SolverParameter::rms_decay() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.rms_decay)
return rms_decay_;
}
inline void SolverParameter::set_rms_decay(float value) {
set_has_rms_decay();
rms_decay_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.rms_decay)
}
// optional bool debug_info = 23 [default = false];
inline bool SolverParameter::has_debug_info() const {
return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void SolverParameter::set_has_debug_info() {
_has_bits_[0] |= 0x00400000u;
}
inline void SolverParameter::clear_has_debug_info() {
_has_bits_[0] &= ~0x00400000u;
}
inline void SolverParameter::clear_debug_info() {
debug_info_ = false;
clear_has_debug_info();
}
inline bool SolverParameter::debug_info() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.debug_info)
return debug_info_;
}
inline void SolverParameter::set_debug_info(bool value) {
set_has_debug_info();
debug_info_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.debug_info)
}
// optional bool snapshot_after_train = 28 [default = true];
inline bool SolverParameter::has_snapshot_after_train() const {
return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void SolverParameter::set_has_snapshot_after_train() {
_has_bits_[0] |= 0x10000000u;
}
inline void SolverParameter::clear_has_snapshot_after_train() {
_has_bits_[0] &= ~0x10000000u;
}
inline void SolverParameter::clear_snapshot_after_train() {
snapshot_after_train_ = true;
clear_has_snapshot_after_train();
}
inline bool SolverParameter::snapshot_after_train() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_after_train)
return snapshot_after_train_;
}
inline void SolverParameter::set_snapshot_after_train(bool value) {
set_has_snapshot_after_train();
snapshot_after_train_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_after_train)
}
// optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
inline bool SolverParameter::has_solver_type() const {
return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void SolverParameter::set_has_solver_type() {
_has_bits_[0] |= 0x00800000u;
}
inline void SolverParameter::clear_has_solver_type() {
_has_bits_[0] &= ~0x00800000u;
}
inline void SolverParameter::clear_solver_type() {
solver_type_ = 0;
clear_has_solver_type();
}
inline ::opencv_caffe::SolverParameter_SolverType SolverParameter::solver_type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.solver_type)
return static_cast< ::opencv_caffe::SolverParameter_SolverType >(solver_type_);
}
inline void SolverParameter::set_solver_type(::opencv_caffe::SolverParameter_SolverType value) {
assert(::opencv_caffe::SolverParameter_SolverType_IsValid(value));
set_has_solver_type();
solver_type_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.solver_type)
}
// -------------------------------------------------------------------
// SolverState
// optional int32 iter = 1;
inline bool SolverState::has_iter() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SolverState::set_has_iter() {
_has_bits_[0] |= 0x00000002u;
}
inline void SolverState::clear_has_iter() {
_has_bits_[0] &= ~0x00000002u;
}
inline void SolverState::clear_iter() {
iter_ = 0;
clear_has_iter();
}
inline ::google::protobuf::int32 SolverState::iter() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverState.iter)
return iter_;
}
inline void SolverState::set_iter(::google::protobuf::int32 value) {
set_has_iter();
iter_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverState.iter)
}
// optional string learned_net = 2;
inline bool SolverState::has_learned_net() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SolverState::set_has_learned_net() {
_has_bits_[0] |= 0x00000001u;
}
inline void SolverState::clear_has_learned_net() {
_has_bits_[0] &= ~0x00000001u;
}
inline void SolverState::clear_learned_net() {
learned_net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_learned_net();
}
inline const ::std::string& SolverState::learned_net() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverState.learned_net)
return learned_net_.GetNoArena();
}
inline void SolverState::set_learned_net(const ::std::string& value) {
set_has_learned_net();
learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SolverState.learned_net)
}
#if LANG_CXX11
inline void SolverState::set_learned_net(::std::string&& value) {
set_has_learned_net();
learned_net_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SolverState.learned_net)
}
#endif
inline void SolverState::set_learned_net(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_learned_net();
learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SolverState.learned_net)
}
inline void SolverState::set_learned_net(const char* value, size_t size) {
set_has_learned_net();
learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverState.learned_net)
}
inline ::std::string* SolverState::mutable_learned_net() {
set_has_learned_net();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverState.learned_net)
return learned_net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SolverState::release_learned_net() {
// @@protoc_insertion_point(field_release:opencv_caffe.SolverState.learned_net)
clear_has_learned_net();
return learned_net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SolverState::set_allocated_learned_net(::std::string* learned_net) {
if (learned_net != NULL) {
set_has_learned_net();
} else {
clear_has_learned_net();
}
learned_net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), learned_net);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverState.learned_net)
}
// repeated .opencv_caffe.BlobProto history = 3;
inline int SolverState::history_size() const {
return history_.size();
}
inline void SolverState::clear_history() {
history_.Clear();
}
inline const ::opencv_caffe::BlobProto& SolverState::history(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverState.history)
return history_.Get(index);
}
inline ::opencv_caffe::BlobProto* SolverState::mutable_history(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.SolverState.history)
return history_.Mutable(index);
}
inline ::opencv_caffe::BlobProto* SolverState::add_history() {
// @@protoc_insertion_point(field_add:opencv_caffe.SolverState.history)
return history_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
SolverState::mutable_history() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverState.history)
return &history_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
SolverState::history() const {
// @@protoc_insertion_point(field_list:opencv_caffe.SolverState.history)
return history_;
}
// optional int32 current_step = 4 [default = 0];
inline bool SolverState::has_current_step() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SolverState::set_has_current_step() {
_has_bits_[0] |= 0x00000004u;
}
inline void SolverState::clear_has_current_step() {
_has_bits_[0] &= ~0x00000004u;
}
inline void SolverState::clear_current_step() {
current_step_ = 0;
clear_has_current_step();
}
inline ::google::protobuf::int32 SolverState::current_step() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SolverState.current_step)
return current_step_;
}
inline void SolverState::set_current_step(::google::protobuf::int32 value) {
set_has_current_step();
current_step_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SolverState.current_step)
}
// -------------------------------------------------------------------
// NetState
// optional .opencv_caffe.Phase phase = 1 [default = TEST];
inline bool NetState::has_phase() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NetState::set_has_phase() {
_has_bits_[0] |= 0x00000002u;
}
inline void NetState::clear_has_phase() {
_has_bits_[0] &= ~0x00000002u;
}
inline void NetState::clear_phase() {
phase_ = 1;
clear_has_phase();
}
inline ::opencv_caffe::Phase NetState::phase() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetState.phase)
return static_cast< ::opencv_caffe::Phase >(phase_);
}
inline void NetState::set_phase(::opencv_caffe::Phase value) {
assert(::opencv_caffe::Phase_IsValid(value));
set_has_phase();
phase_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NetState.phase)
}
// optional int32 level = 2 [default = 0];
inline bool NetState::has_level() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NetState::set_has_level() {
_has_bits_[0] |= 0x00000001u;
}
inline void NetState::clear_has_level() {
_has_bits_[0] &= ~0x00000001u;
}
inline void NetState::clear_level() {
level_ = 0;
clear_has_level();
}
inline ::google::protobuf::int32 NetState::level() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetState.level)
return level_;
}
inline void NetState::set_level(::google::protobuf::int32 value) {
set_has_level();
level_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NetState.level)
}
// repeated string stage = 3;
inline int NetState::stage_size() const {
return stage_.size();
}
inline void NetState::clear_stage() {
stage_.Clear();
}
inline const ::std::string& NetState::stage(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetState.stage)
return stage_.Get(index);
}
inline ::std::string* NetState::mutable_stage(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetState.stage)
return stage_.Mutable(index);
}
inline void NetState::set_stage(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.NetState.stage)
stage_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void NetState::set_stage(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.NetState.stage)
stage_.Mutable(index)->assign(std::move(value));
}
#endif
inline void NetState::set_stage(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.NetState.stage)
}
inline void NetState::set_stage(int index, const char* value, size_t size) {
stage_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetState.stage)
}
inline ::std::string* NetState::add_stage() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetState.stage)
return stage_.Add();
}
inline void NetState::add_stage(const ::std::string& value) {
stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.NetState.stage)
}
#if LANG_CXX11
inline void NetState::add_stage(::std::string&& value) {
stage_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.NetState.stage)
}
#endif
inline void NetState::add_stage(const char* value) {
GOOGLE_DCHECK(value != NULL);
stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.NetState.stage)
}
inline void NetState::add_stage(const char* value, size_t size) {
stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetState.stage)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NetState::stage() const {
// @@protoc_insertion_point(field_list:opencv_caffe.NetState.stage)
return stage_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NetState::mutable_stage() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetState.stage)
return &stage_;
}
// -------------------------------------------------------------------
// NetStateRule
// optional .opencv_caffe.Phase phase = 1;
inline bool NetStateRule::has_phase() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NetStateRule::set_has_phase() {
_has_bits_[0] |= 0x00000001u;
}
inline void NetStateRule::clear_has_phase() {
_has_bits_[0] &= ~0x00000001u;
}
inline void NetStateRule::clear_phase() {
phase_ = 0;
clear_has_phase();
}
inline ::opencv_caffe::Phase NetStateRule::phase() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.phase)
return static_cast< ::opencv_caffe::Phase >(phase_);
}
inline void NetStateRule::set_phase(::opencv_caffe::Phase value) {
assert(::opencv_caffe::Phase_IsValid(value));
set_has_phase();
phase_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.phase)
}
// optional int32 min_level = 2;
inline bool NetStateRule::has_min_level() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NetStateRule::set_has_min_level() {
_has_bits_[0] |= 0x00000002u;
}
inline void NetStateRule::clear_has_min_level() {
_has_bits_[0] &= ~0x00000002u;
}
inline void NetStateRule::clear_min_level() {
min_level_ = 0;
clear_has_min_level();
}
inline ::google::protobuf::int32 NetStateRule::min_level() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.min_level)
return min_level_;
}
inline void NetStateRule::set_min_level(::google::protobuf::int32 value) {
set_has_min_level();
min_level_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.min_level)
}
// optional int32 max_level = 3;
inline bool NetStateRule::has_max_level() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NetStateRule::set_has_max_level() {
_has_bits_[0] |= 0x00000004u;
}
inline void NetStateRule::clear_has_max_level() {
_has_bits_[0] &= ~0x00000004u;
}
inline void NetStateRule::clear_max_level() {
max_level_ = 0;
clear_has_max_level();
}
inline ::google::protobuf::int32 NetStateRule::max_level() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.max_level)
return max_level_;
}
inline void NetStateRule::set_max_level(::google::protobuf::int32 value) {
set_has_max_level();
max_level_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.max_level)
}
// repeated string stage = 4;
inline int NetStateRule::stage_size() const {
return stage_.size();
}
inline void NetStateRule::clear_stage() {
stage_.Clear();
}
inline const ::std::string& NetStateRule::stage(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.stage)
return stage_.Get(index);
}
inline ::std::string* NetStateRule::mutable_stage(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetStateRule.stage)
return stage_.Mutable(index);
}
inline void NetStateRule::set_stage(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.stage)
stage_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void NetStateRule::set_stage(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.stage)
stage_.Mutable(index)->assign(std::move(value));
}
#endif
inline void NetStateRule::set_stage(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.NetStateRule.stage)
}
inline void NetStateRule::set_stage(int index, const char* value, size_t size) {
stage_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetStateRule.stage)
}
inline ::std::string* NetStateRule::add_stage() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetStateRule.stage)
return stage_.Add();
}
inline void NetStateRule::add_stage(const ::std::string& value) {
stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.stage)
}
#if LANG_CXX11
inline void NetStateRule::add_stage(::std::string&& value) {
stage_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.stage)
}
#endif
inline void NetStateRule::add_stage(const char* value) {
GOOGLE_DCHECK(value != NULL);
stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.NetStateRule.stage)
}
inline void NetStateRule::add_stage(const char* value, size_t size) {
stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetStateRule.stage)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NetStateRule::stage() const {
// @@protoc_insertion_point(field_list:opencv_caffe.NetStateRule.stage)
return stage_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NetStateRule::mutable_stage() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetStateRule.stage)
return &stage_;
}
// repeated string not_stage = 5;
inline int NetStateRule::not_stage_size() const {
return not_stage_.size();
}
inline void NetStateRule::clear_not_stage() {
not_stage_.Clear();
}
inline const ::std::string& NetStateRule::not_stage(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.not_stage)
return not_stage_.Get(index);
}
inline ::std::string* NetStateRule::mutable_not_stage(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.NetStateRule.not_stage)
return not_stage_.Mutable(index);
}
inline void NetStateRule::set_not_stage(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.not_stage)
not_stage_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void NetStateRule::set_not_stage(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.not_stage)
not_stage_.Mutable(index)->assign(std::move(value));
}
#endif
inline void NetStateRule::set_not_stage(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
not_stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.NetStateRule.not_stage)
}
inline void NetStateRule::set_not_stage(int index, const char* value, size_t size) {
not_stage_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetStateRule.not_stage)
}
inline ::std::string* NetStateRule::add_not_stage() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetStateRule.not_stage)
return not_stage_.Add();
}
inline void NetStateRule::add_not_stage(const ::std::string& value) {
not_stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.not_stage)
}
#if LANG_CXX11
inline void NetStateRule::add_not_stage(::std::string&& value) {
not_stage_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.not_stage)
}
#endif
inline void NetStateRule::add_not_stage(const char* value) {
GOOGLE_DCHECK(value != NULL);
not_stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.NetStateRule.not_stage)
}
inline void NetStateRule::add_not_stage(const char* value, size_t size) {
not_stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetStateRule.not_stage)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NetStateRule::not_stage() const {
// @@protoc_insertion_point(field_list:opencv_caffe.NetStateRule.not_stage)
return not_stage_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NetStateRule::mutable_not_stage() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetStateRule.not_stage)
return &not_stage_;
}
// -------------------------------------------------------------------
// ParamSpec
// optional string name = 1;
inline bool ParamSpec::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ParamSpec::set_has_name() {
_has_bits_[0] |= 0x00000001u;
}
inline void ParamSpec::clear_has_name() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ParamSpec::clear_name() {
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string& ParamSpec::name() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.name)
return name_.GetNoArena();
}
inline void ParamSpec::set_name(const ::std::string& value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.name)
}
#if LANG_CXX11
inline void ParamSpec::set_name(::std::string&& value) {
set_has_name();
name_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.ParamSpec.name)
}
#endif
inline void ParamSpec::set_name(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.ParamSpec.name)
}
inline void ParamSpec::set_name(const char* value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.ParamSpec.name)
}
inline ::std::string* ParamSpec::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:opencv_caffe.ParamSpec.name)
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ParamSpec::release_name() {
// @@protoc_insertion_point(field_release:opencv_caffe.ParamSpec.name)
clear_has_name();
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ParamSpec::set_allocated_name(::std::string* name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ParamSpec.name)
}
// optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2;
inline bool ParamSpec::has_share_mode() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ParamSpec::set_has_share_mode() {
_has_bits_[0] |= 0x00000002u;
}
inline void ParamSpec::clear_has_share_mode() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ParamSpec::clear_share_mode() {
share_mode_ = 0;
clear_has_share_mode();
}
inline ::opencv_caffe::ParamSpec_DimCheckMode ParamSpec::share_mode() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.share_mode)
return static_cast< ::opencv_caffe::ParamSpec_DimCheckMode >(share_mode_);
}
inline void ParamSpec::set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value) {
assert(::opencv_caffe::ParamSpec_DimCheckMode_IsValid(value));
set_has_share_mode();
share_mode_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.share_mode)
}
// optional float lr_mult = 3 [default = 1];
inline bool ParamSpec::has_lr_mult() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ParamSpec::set_has_lr_mult() {
_has_bits_[0] |= 0x00000004u;
}
inline void ParamSpec::clear_has_lr_mult() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ParamSpec::clear_lr_mult() {
lr_mult_ = 1;
clear_has_lr_mult();
}
inline float ParamSpec::lr_mult() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.lr_mult)
return lr_mult_;
}
inline void ParamSpec::set_lr_mult(float value) {
set_has_lr_mult();
lr_mult_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.lr_mult)
}
// optional float decay_mult = 4 [default = 1];
inline bool ParamSpec::has_decay_mult() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ParamSpec::set_has_decay_mult() {
_has_bits_[0] |= 0x00000008u;
}
inline void ParamSpec::clear_has_decay_mult() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ParamSpec::clear_decay_mult() {
decay_mult_ = 1;
clear_has_decay_mult();
}
inline float ParamSpec::decay_mult() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.decay_mult)
return decay_mult_;
}
inline void ParamSpec::set_decay_mult(float value) {
set_has_decay_mult();
decay_mult_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.decay_mult)
}
// -------------------------------------------------------------------
// LayerParameter
// optional string name = 1;
inline bool LayerParameter::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LayerParameter::set_has_name() {
_has_bits_[0] |= 0x00000001u;
}
inline void LayerParameter::clear_has_name() {
_has_bits_[0] &= ~0x00000001u;
}
inline void LayerParameter::clear_name() {
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string& LayerParameter::name() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.name)
return name_.GetNoArena();
}
inline void LayerParameter::set_name(const ::std::string& value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.name)
}
#if LANG_CXX11
inline void LayerParameter::set_name(::std::string&& value) {
set_has_name();
name_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.LayerParameter.name)
}
#endif
inline void LayerParameter::set_name(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.LayerParameter.name)
}
inline void LayerParameter::set_name(const char* value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.LayerParameter.name)
}
inline ::std::string* LayerParameter::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.name)
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LayerParameter::release_name() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.name)
clear_has_name();
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LayerParameter::set_allocated_name(::std::string* name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.name)
}
// optional string type = 2;
inline bool LayerParameter::has_type() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LayerParameter::set_has_type() {
_has_bits_[0] |= 0x00000002u;
}
inline void LayerParameter::clear_has_type() {
_has_bits_[0] &= ~0x00000002u;
}
inline void LayerParameter::clear_type() {
type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_type();
}
inline const ::std::string& LayerParameter::type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.type)
return type_.GetNoArena();
}
inline void LayerParameter::set_type(const ::std::string& value) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.type)
}
#if LANG_CXX11
inline void LayerParameter::set_type(::std::string&& value) {
set_has_type();
type_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.LayerParameter.type)
}
#endif
inline void LayerParameter::set_type(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.LayerParameter.type)
}
inline void LayerParameter::set_type(const char* value, size_t size) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.LayerParameter.type)
}
inline ::std::string* LayerParameter::mutable_type() {
set_has_type();
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.type)
return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LayerParameter::release_type() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.type)
clear_has_type();
return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LayerParameter::set_allocated_type(::std::string* type) {
if (type != NULL) {
set_has_type();
} else {
clear_has_type();
}
type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.type)
}
// repeated string bottom = 3;
inline int LayerParameter::bottom_size() const {
return bottom_.size();
}
inline void LayerParameter::clear_bottom() {
bottom_.Clear();
}
inline const ::std::string& LayerParameter::bottom(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.bottom)
return bottom_.Get(index);
}
inline ::std::string* LayerParameter::mutable_bottom(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.bottom)
return bottom_.Mutable(index);
}
inline void LayerParameter::set_bottom(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.bottom)
bottom_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void LayerParameter::set_bottom(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.bottom)
bottom_.Mutable(index)->assign(std::move(value));
}
#endif
inline void LayerParameter::set_bottom(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
bottom_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.LayerParameter.bottom)
}
inline void LayerParameter::set_bottom(int index, const char* value, size_t size) {
bottom_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.LayerParameter.bottom)
}
inline ::std::string* LayerParameter::add_bottom() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.LayerParameter.bottom)
return bottom_.Add();
}
inline void LayerParameter::add_bottom(const ::std::string& value) {
bottom_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.bottom)
}
#if LANG_CXX11
inline void LayerParameter::add_bottom(::std::string&& value) {
bottom_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.bottom)
}
#endif
inline void LayerParameter::add_bottom(const char* value) {
GOOGLE_DCHECK(value != NULL);
bottom_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.LayerParameter.bottom)
}
inline void LayerParameter::add_bottom(const char* value, size_t size) {
bottom_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.LayerParameter.bottom)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LayerParameter::bottom() const {
// @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.bottom)
return bottom_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LayerParameter::mutable_bottom() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.bottom)
return &bottom_;
}
// repeated string top = 4;
inline int LayerParameter::top_size() const {
return top_.size();
}
inline void LayerParameter::clear_top() {
top_.Clear();
}
inline const ::std::string& LayerParameter::top(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.top)
return top_.Get(index);
}
inline ::std::string* LayerParameter::mutable_top(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.top)
return top_.Mutable(index);
}
inline void LayerParameter::set_top(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.top)
top_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void LayerParameter::set_top(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.top)
top_.Mutable(index)->assign(std::move(value));
}
#endif
inline void LayerParameter::set_top(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
top_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.LayerParameter.top)
}
inline void LayerParameter::set_top(int index, const char* value, size_t size) {
top_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.LayerParameter.top)
}
inline ::std::string* LayerParameter::add_top() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.LayerParameter.top)
return top_.Add();
}
inline void LayerParameter::add_top(const ::std::string& value) {
top_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.top)
}
#if LANG_CXX11
inline void LayerParameter::add_top(::std::string&& value) {
top_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.top)
}
#endif
inline void LayerParameter::add_top(const char* value) {
GOOGLE_DCHECK(value != NULL);
top_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.LayerParameter.top)
}
inline void LayerParameter::add_top(const char* value, size_t size) {
top_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.LayerParameter.top)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LayerParameter::top() const {
// @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.top)
return top_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LayerParameter::mutable_top() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.top)
return &top_;
}
// optional .opencv_caffe.Phase phase = 10;
inline bool LayerParameter::has_phase() const {
return (_has_bits_[1] & 0x01000000u) != 0;
}
inline void LayerParameter::set_has_phase() {
_has_bits_[1] |= 0x01000000u;
}
inline void LayerParameter::clear_has_phase() {
_has_bits_[1] &= ~0x01000000u;
}
inline void LayerParameter::clear_phase() {
phase_ = 0;
clear_has_phase();
}
inline ::opencv_caffe::Phase LayerParameter::phase() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.phase)
return static_cast< ::opencv_caffe::Phase >(phase_);
}
inline void LayerParameter::set_phase(::opencv_caffe::Phase value) {
assert(::opencv_caffe::Phase_IsValid(value));
set_has_phase();
phase_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.phase)
}
// repeated float loss_weight = 5;
inline int LayerParameter::loss_weight_size() const {
return loss_weight_.size();
}
inline void LayerParameter::clear_loss_weight() {
loss_weight_.Clear();
}
inline float LayerParameter::loss_weight(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.loss_weight)
return loss_weight_.Get(index);
}
inline void LayerParameter::set_loss_weight(int index, float value) {
loss_weight_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.loss_weight)
}
inline void LayerParameter::add_loss_weight(float value) {
loss_weight_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.loss_weight)
}
inline const ::google::protobuf::RepeatedField< float >&
LayerParameter::loss_weight() const {
// @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.loss_weight)
return loss_weight_;
}
inline ::google::protobuf::RepeatedField< float >*
LayerParameter::mutable_loss_weight() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.loss_weight)
return &loss_weight_;
}
// repeated .opencv_caffe.ParamSpec param = 6;
inline int LayerParameter::param_size() const {
return param_.size();
}
inline void LayerParameter::clear_param() {
param_.Clear();
}
inline const ::opencv_caffe::ParamSpec& LayerParameter::param(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.param)
return param_.Get(index);
}
inline ::opencv_caffe::ParamSpec* LayerParameter::mutable_param(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.param)
return param_.Mutable(index);
}
inline ::opencv_caffe::ParamSpec* LayerParameter::add_param() {
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.param)
return param_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::ParamSpec >*
LayerParameter::mutable_param() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.param)
return &param_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::ParamSpec >&
LayerParameter::param() const {
// @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.param)
return param_;
}
// repeated .opencv_caffe.BlobProto blobs = 7;
inline int LayerParameter::blobs_size() const {
return blobs_.size();
}
inline void LayerParameter::clear_blobs() {
blobs_.Clear();
}
inline const ::opencv_caffe::BlobProto& LayerParameter::blobs(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.blobs)
return blobs_.Get(index);
}
inline ::opencv_caffe::BlobProto* LayerParameter::mutable_blobs(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.blobs)
return blobs_.Mutable(index);
}
inline ::opencv_caffe::BlobProto* LayerParameter::add_blobs() {
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.blobs)
return blobs_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
LayerParameter::mutable_blobs() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.blobs)
return &blobs_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
LayerParameter::blobs() const {
// @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.blobs)
return blobs_;
}
// repeated bool propagate_down = 11;
inline int LayerParameter::propagate_down_size() const {
return propagate_down_.size();
}
inline void LayerParameter::clear_propagate_down() {
propagate_down_.Clear();
}
inline bool LayerParameter::propagate_down(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.propagate_down)
return propagate_down_.Get(index);
}
inline void LayerParameter::set_propagate_down(int index, bool value) {
propagate_down_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.propagate_down)
}
inline void LayerParameter::add_propagate_down(bool value) {
propagate_down_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.propagate_down)
}
inline const ::google::protobuf::RepeatedField< bool >&
LayerParameter::propagate_down() const {
// @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.propagate_down)
return propagate_down_;
}
inline ::google::protobuf::RepeatedField< bool >*
LayerParameter::mutable_propagate_down() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.propagate_down)
return &propagate_down_;
}
// repeated .opencv_caffe.NetStateRule include = 8;
inline int LayerParameter::include_size() const {
return include_.size();
}
inline void LayerParameter::clear_include() {
include_.Clear();
}
inline const ::opencv_caffe::NetStateRule& LayerParameter::include(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.include)
return include_.Get(index);
}
inline ::opencv_caffe::NetStateRule* LayerParameter::mutable_include(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.include)
return include_.Mutable(index);
}
inline ::opencv_caffe::NetStateRule* LayerParameter::add_include() {
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.include)
return include_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
LayerParameter::mutable_include() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.include)
return &include_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
LayerParameter::include() const {
// @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.include)
return include_;
}
// repeated .opencv_caffe.NetStateRule exclude = 9;
inline int LayerParameter::exclude_size() const {
return exclude_.size();
}
inline void LayerParameter::clear_exclude() {
exclude_.Clear();
}
inline const ::opencv_caffe::NetStateRule& LayerParameter::exclude(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.exclude)
return exclude_.Get(index);
}
inline ::opencv_caffe::NetStateRule* LayerParameter::mutable_exclude(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.exclude)
return exclude_.Mutable(index);
}
inline ::opencv_caffe::NetStateRule* LayerParameter::add_exclude() {
// @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.exclude)
return exclude_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
LayerParameter::mutable_exclude() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.exclude)
return &exclude_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
LayerParameter::exclude() const {
// @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.exclude)
return exclude_;
}
// optional .opencv_caffe.TransformationParameter transform_param = 100;
inline bool LayerParameter::has_transform_param() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LayerParameter::set_has_transform_param() {
_has_bits_[0] |= 0x00000004u;
}
inline void LayerParameter::clear_has_transform_param() {
_has_bits_[0] &= ~0x00000004u;
}
inline void LayerParameter::clear_transform_param() {
if (transform_param_ != NULL) transform_param_->Clear();
clear_has_transform_param();
}
inline const ::opencv_caffe::TransformationParameter& LayerParameter::transform_param() const {
const ::opencv_caffe::TransformationParameter* p = transform_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.transform_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::TransformationParameter*>(
&::opencv_caffe::_TransformationParameter_default_instance_);
}
inline ::opencv_caffe::TransformationParameter* LayerParameter::release_transform_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.transform_param)
clear_has_transform_param();
::opencv_caffe::TransformationParameter* temp = transform_param_;
transform_param_ = NULL;
return temp;
}
inline ::opencv_caffe::TransformationParameter* LayerParameter::mutable_transform_param() {
set_has_transform_param();
if (transform_param_ == NULL) {
transform_param_ = new ::opencv_caffe::TransformationParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.transform_param)
return transform_param_;
}
inline void LayerParameter::set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete transform_param_;
}
if (transform_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
transform_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, transform_param, submessage_arena);
}
set_has_transform_param();
} else {
clear_has_transform_param();
}
transform_param_ = transform_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.transform_param)
}
// optional .opencv_caffe.LossParameter loss_param = 101;
inline bool LayerParameter::has_loss_param() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LayerParameter::set_has_loss_param() {
_has_bits_[0] |= 0x00000008u;
}
inline void LayerParameter::clear_has_loss_param() {
_has_bits_[0] &= ~0x00000008u;
}
inline void LayerParameter::clear_loss_param() {
if (loss_param_ != NULL) loss_param_->Clear();
clear_has_loss_param();
}
inline const ::opencv_caffe::LossParameter& LayerParameter::loss_param() const {
const ::opencv_caffe::LossParameter* p = loss_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.loss_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::LossParameter*>(
&::opencv_caffe::_LossParameter_default_instance_);
}
inline ::opencv_caffe::LossParameter* LayerParameter::release_loss_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.loss_param)
clear_has_loss_param();
::opencv_caffe::LossParameter* temp = loss_param_;
loss_param_ = NULL;
return temp;
}
inline ::opencv_caffe::LossParameter* LayerParameter::mutable_loss_param() {
set_has_loss_param();
if (loss_param_ == NULL) {
loss_param_ = new ::opencv_caffe::LossParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.loss_param)
return loss_param_;
}
inline void LayerParameter::set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete loss_param_;
}
if (loss_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
loss_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, loss_param, submessage_arena);
}
set_has_loss_param();
} else {
clear_has_loss_param();
}
loss_param_ = loss_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.loss_param)
}
// optional .opencv_caffe.AccuracyParameter accuracy_param = 102;
inline bool LayerParameter::has_accuracy_param() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LayerParameter::set_has_accuracy_param() {
_has_bits_[0] |= 0x00000010u;
}
inline void LayerParameter::clear_has_accuracy_param() {
_has_bits_[0] &= ~0x00000010u;
}
inline void LayerParameter::clear_accuracy_param() {
if (accuracy_param_ != NULL) accuracy_param_->Clear();
clear_has_accuracy_param();
}
inline const ::opencv_caffe::AccuracyParameter& LayerParameter::accuracy_param() const {
const ::opencv_caffe::AccuracyParameter* p = accuracy_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.accuracy_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::AccuracyParameter*>(
&::opencv_caffe::_AccuracyParameter_default_instance_);
}
inline ::opencv_caffe::AccuracyParameter* LayerParameter::release_accuracy_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.accuracy_param)
clear_has_accuracy_param();
::opencv_caffe::AccuracyParameter* temp = accuracy_param_;
accuracy_param_ = NULL;
return temp;
}
inline ::opencv_caffe::AccuracyParameter* LayerParameter::mutable_accuracy_param() {
set_has_accuracy_param();
if (accuracy_param_ == NULL) {
accuracy_param_ = new ::opencv_caffe::AccuracyParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.accuracy_param)
return accuracy_param_;
}
inline void LayerParameter::set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete accuracy_param_;
}
if (accuracy_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
accuracy_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, accuracy_param, submessage_arena);
}
set_has_accuracy_param();
} else {
clear_has_accuracy_param();
}
accuracy_param_ = accuracy_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.accuracy_param)
}
// optional .opencv_caffe.ArgMaxParameter argmax_param = 103;
inline bool LayerParameter::has_argmax_param() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void LayerParameter::set_has_argmax_param() {
_has_bits_[0] |= 0x00000020u;
}
inline void LayerParameter::clear_has_argmax_param() {
_has_bits_[0] &= ~0x00000020u;
}
inline void LayerParameter::clear_argmax_param() {
if (argmax_param_ != NULL) argmax_param_->Clear();
clear_has_argmax_param();
}
inline const ::opencv_caffe::ArgMaxParameter& LayerParameter::argmax_param() const {
const ::opencv_caffe::ArgMaxParameter* p = argmax_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.argmax_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ArgMaxParameter*>(
&::opencv_caffe::_ArgMaxParameter_default_instance_);
}
inline ::opencv_caffe::ArgMaxParameter* LayerParameter::release_argmax_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.argmax_param)
clear_has_argmax_param();
::opencv_caffe::ArgMaxParameter* temp = argmax_param_;
argmax_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ArgMaxParameter* LayerParameter::mutable_argmax_param() {
set_has_argmax_param();
if (argmax_param_ == NULL) {
argmax_param_ = new ::opencv_caffe::ArgMaxParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.argmax_param)
return argmax_param_;
}
inline void LayerParameter::set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete argmax_param_;
}
if (argmax_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
argmax_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, argmax_param, submessage_arena);
}
set_has_argmax_param();
} else {
clear_has_argmax_param();
}
argmax_param_ = argmax_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.argmax_param)
}
// optional .opencv_caffe.BatchNormParameter batch_norm_param = 139;
inline bool LayerParameter::has_batch_norm_param() const {
return (_has_bits_[1] & 0x00000200u) != 0;
}
inline void LayerParameter::set_has_batch_norm_param() {
_has_bits_[1] |= 0x00000200u;
}
inline void LayerParameter::clear_has_batch_norm_param() {
_has_bits_[1] &= ~0x00000200u;
}
inline void LayerParameter::clear_batch_norm_param() {
if (batch_norm_param_ != NULL) batch_norm_param_->Clear();
clear_has_batch_norm_param();
}
inline const ::opencv_caffe::BatchNormParameter& LayerParameter::batch_norm_param() const {
const ::opencv_caffe::BatchNormParameter* p = batch_norm_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.batch_norm_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::BatchNormParameter*>(
&::opencv_caffe::_BatchNormParameter_default_instance_);
}
inline ::opencv_caffe::BatchNormParameter* LayerParameter::release_batch_norm_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.batch_norm_param)
clear_has_batch_norm_param();
::opencv_caffe::BatchNormParameter* temp = batch_norm_param_;
batch_norm_param_ = NULL;
return temp;
}
inline ::opencv_caffe::BatchNormParameter* LayerParameter::mutable_batch_norm_param() {
set_has_batch_norm_param();
if (batch_norm_param_ == NULL) {
batch_norm_param_ = new ::opencv_caffe::BatchNormParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.batch_norm_param)
return batch_norm_param_;
}
inline void LayerParameter::set_allocated_batch_norm_param(::opencv_caffe::BatchNormParameter* batch_norm_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete batch_norm_param_;
}
if (batch_norm_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
batch_norm_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, batch_norm_param, submessage_arena);
}
set_has_batch_norm_param();
} else {
clear_has_batch_norm_param();
}
batch_norm_param_ = batch_norm_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.batch_norm_param)
}
// optional .opencv_caffe.BiasParameter bias_param = 141;
inline bool LayerParameter::has_bias_param() const {
return (_has_bits_[1] & 0x00000800u) != 0;
}
inline void LayerParameter::set_has_bias_param() {
_has_bits_[1] |= 0x00000800u;
}
inline void LayerParameter::clear_has_bias_param() {
_has_bits_[1] &= ~0x00000800u;
}
inline void LayerParameter::clear_bias_param() {
if (bias_param_ != NULL) bias_param_->Clear();
clear_has_bias_param();
}
inline const ::opencv_caffe::BiasParameter& LayerParameter::bias_param() const {
const ::opencv_caffe::BiasParameter* p = bias_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.bias_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::BiasParameter*>(
&::opencv_caffe::_BiasParameter_default_instance_);
}
inline ::opencv_caffe::BiasParameter* LayerParameter::release_bias_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.bias_param)
clear_has_bias_param();
::opencv_caffe::BiasParameter* temp = bias_param_;
bias_param_ = NULL;
return temp;
}
inline ::opencv_caffe::BiasParameter* LayerParameter::mutable_bias_param() {
set_has_bias_param();
if (bias_param_ == NULL) {
bias_param_ = new ::opencv_caffe::BiasParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.bias_param)
return bias_param_;
}
inline void LayerParameter::set_allocated_bias_param(::opencv_caffe::BiasParameter* bias_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete bias_param_;
}
if (bias_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
bias_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, bias_param, submessage_arena);
}
set_has_bias_param();
} else {
clear_has_bias_param();
}
bias_param_ = bias_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.bias_param)
}
// optional .opencv_caffe.ConcatParameter concat_param = 104;
inline bool LayerParameter::has_concat_param() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void LayerParameter::set_has_concat_param() {
_has_bits_[0] |= 0x00000040u;
}
inline void LayerParameter::clear_has_concat_param() {
_has_bits_[0] &= ~0x00000040u;
}
inline void LayerParameter::clear_concat_param() {
if (concat_param_ != NULL) concat_param_->Clear();
clear_has_concat_param();
}
inline const ::opencv_caffe::ConcatParameter& LayerParameter::concat_param() const {
const ::opencv_caffe::ConcatParameter* p = concat_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.concat_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ConcatParameter*>(
&::opencv_caffe::_ConcatParameter_default_instance_);
}
inline ::opencv_caffe::ConcatParameter* LayerParameter::release_concat_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.concat_param)
clear_has_concat_param();
::opencv_caffe::ConcatParameter* temp = concat_param_;
concat_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ConcatParameter* LayerParameter::mutable_concat_param() {
set_has_concat_param();
if (concat_param_ == NULL) {
concat_param_ = new ::opencv_caffe::ConcatParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.concat_param)
return concat_param_;
}
inline void LayerParameter::set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete concat_param_;
}
if (concat_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
concat_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, concat_param, submessage_arena);
}
set_has_concat_param();
} else {
clear_has_concat_param();
}
concat_param_ = concat_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.concat_param)
}
// optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105;
inline bool LayerParameter::has_contrastive_loss_param() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void LayerParameter::set_has_contrastive_loss_param() {
_has_bits_[0] |= 0x00000080u;
}
inline void LayerParameter::clear_has_contrastive_loss_param() {
_has_bits_[0] &= ~0x00000080u;
}
inline void LayerParameter::clear_contrastive_loss_param() {
if (contrastive_loss_param_ != NULL) contrastive_loss_param_->Clear();
clear_has_contrastive_loss_param();
}
inline const ::opencv_caffe::ContrastiveLossParameter& LayerParameter::contrastive_loss_param() const {
const ::opencv_caffe::ContrastiveLossParameter* p = contrastive_loss_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.contrastive_loss_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ContrastiveLossParameter*>(
&::opencv_caffe::_ContrastiveLossParameter_default_instance_);
}
inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::release_contrastive_loss_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.contrastive_loss_param)
clear_has_contrastive_loss_param();
::opencv_caffe::ContrastiveLossParameter* temp = contrastive_loss_param_;
contrastive_loss_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::mutable_contrastive_loss_param() {
set_has_contrastive_loss_param();
if (contrastive_loss_param_ == NULL) {
contrastive_loss_param_ = new ::opencv_caffe::ContrastiveLossParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.contrastive_loss_param)
return contrastive_loss_param_;
}
inline void LayerParameter::set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete contrastive_loss_param_;
}
if (contrastive_loss_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
contrastive_loss_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, contrastive_loss_param, submessage_arena);
}
set_has_contrastive_loss_param();
} else {
clear_has_contrastive_loss_param();
}
contrastive_loss_param_ = contrastive_loss_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.contrastive_loss_param)
}
// optional .opencv_caffe.ConvolutionParameter convolution_param = 106;
inline bool LayerParameter::has_convolution_param() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void LayerParameter::set_has_convolution_param() {
_has_bits_[0] |= 0x00000100u;
}
inline void LayerParameter::clear_has_convolution_param() {
_has_bits_[0] &= ~0x00000100u;
}
inline void LayerParameter::clear_convolution_param() {
if (convolution_param_ != NULL) convolution_param_->Clear();
clear_has_convolution_param();
}
inline const ::opencv_caffe::ConvolutionParameter& LayerParameter::convolution_param() const {
const ::opencv_caffe::ConvolutionParameter* p = convolution_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.convolution_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ConvolutionParameter*>(
&::opencv_caffe::_ConvolutionParameter_default_instance_);
}
inline ::opencv_caffe::ConvolutionParameter* LayerParameter::release_convolution_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.convolution_param)
clear_has_convolution_param();
::opencv_caffe::ConvolutionParameter* temp = convolution_param_;
convolution_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ConvolutionParameter* LayerParameter::mutable_convolution_param() {
set_has_convolution_param();
if (convolution_param_ == NULL) {
convolution_param_ = new ::opencv_caffe::ConvolutionParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.convolution_param)
return convolution_param_;
}
inline void LayerParameter::set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete convolution_param_;
}
if (convolution_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
convolution_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, convolution_param, submessage_arena);
}
set_has_convolution_param();
} else {
clear_has_convolution_param();
}
convolution_param_ = convolution_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.convolution_param)
}
// optional .opencv_caffe.CropParameter crop_param = 144;
inline bool LayerParameter::has_crop_param() const {
return (_has_bits_[1] & 0x00004000u) != 0;
}
inline void LayerParameter::set_has_crop_param() {
_has_bits_[1] |= 0x00004000u;
}
inline void LayerParameter::clear_has_crop_param() {
_has_bits_[1] &= ~0x00004000u;
}
inline void LayerParameter::clear_crop_param() {
if (crop_param_ != NULL) crop_param_->Clear();
clear_has_crop_param();
}
inline const ::opencv_caffe::CropParameter& LayerParameter::crop_param() const {
const ::opencv_caffe::CropParameter* p = crop_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.crop_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::CropParameter*>(
&::opencv_caffe::_CropParameter_default_instance_);
}
inline ::opencv_caffe::CropParameter* LayerParameter::release_crop_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.crop_param)
clear_has_crop_param();
::opencv_caffe::CropParameter* temp = crop_param_;
crop_param_ = NULL;
return temp;
}
inline ::opencv_caffe::CropParameter* LayerParameter::mutable_crop_param() {
set_has_crop_param();
if (crop_param_ == NULL) {
crop_param_ = new ::opencv_caffe::CropParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.crop_param)
return crop_param_;
}
inline void LayerParameter::set_allocated_crop_param(::opencv_caffe::CropParameter* crop_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete crop_param_;
}
if (crop_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
crop_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, crop_param, submessage_arena);
}
set_has_crop_param();
} else {
clear_has_crop_param();
}
crop_param_ = crop_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.crop_param)
}
// optional .opencv_caffe.DataParameter data_param = 107;
inline bool LayerParameter::has_data_param() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void LayerParameter::set_has_data_param() {
_has_bits_[0] |= 0x00000200u;
}
inline void LayerParameter::clear_has_data_param() {
_has_bits_[0] &= ~0x00000200u;
}
inline void LayerParameter::clear_data_param() {
if (data_param_ != NULL) data_param_->Clear();
clear_has_data_param();
}
inline const ::opencv_caffe::DataParameter& LayerParameter::data_param() const {
const ::opencv_caffe::DataParameter* p = data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::DataParameter*>(
&::opencv_caffe::_DataParameter_default_instance_);
}
inline ::opencv_caffe::DataParameter* LayerParameter::release_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.data_param)
clear_has_data_param();
::opencv_caffe::DataParameter* temp = data_param_;
data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::DataParameter* LayerParameter::mutable_data_param() {
set_has_data_param();
if (data_param_ == NULL) {
data_param_ = new ::opencv_caffe::DataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.data_param)
return data_param_;
}
inline void LayerParameter::set_allocated_data_param(::opencv_caffe::DataParameter* data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete data_param_;
}
if (data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, data_param, submessage_arena);
}
set_has_data_param();
} else {
clear_has_data_param();
}
data_param_ = data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.data_param)
}
// optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147;
inline bool LayerParameter::has_detection_output_param() const {
return (_has_bits_[1] & 0x00020000u) != 0;
}
inline void LayerParameter::set_has_detection_output_param() {
_has_bits_[1] |= 0x00020000u;
}
inline void LayerParameter::clear_has_detection_output_param() {
_has_bits_[1] &= ~0x00020000u;
}
inline void LayerParameter::clear_detection_output_param() {
if (detection_output_param_ != NULL) detection_output_param_->Clear();
clear_has_detection_output_param();
}
inline const ::opencv_caffe::DetectionOutputParameter& LayerParameter::detection_output_param() const {
const ::opencv_caffe::DetectionOutputParameter* p = detection_output_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.detection_output_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::DetectionOutputParameter*>(
&::opencv_caffe::_DetectionOutputParameter_default_instance_);
}
inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::release_detection_output_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.detection_output_param)
clear_has_detection_output_param();
::opencv_caffe::DetectionOutputParameter* temp = detection_output_param_;
detection_output_param_ = NULL;
return temp;
}
inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::mutable_detection_output_param() {
set_has_detection_output_param();
if (detection_output_param_ == NULL) {
detection_output_param_ = new ::opencv_caffe::DetectionOutputParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.detection_output_param)
return detection_output_param_;
}
inline void LayerParameter::set_allocated_detection_output_param(::opencv_caffe::DetectionOutputParameter* detection_output_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete detection_output_param_;
}
if (detection_output_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
detection_output_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, detection_output_param, submessage_arena);
}
set_has_detection_output_param();
} else {
clear_has_detection_output_param();
}
detection_output_param_ = detection_output_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.detection_output_param)
}
// optional .opencv_caffe.DropoutParameter dropout_param = 108;
inline bool LayerParameter::has_dropout_param() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void LayerParameter::set_has_dropout_param() {
_has_bits_[0] |= 0x00000400u;
}
inline void LayerParameter::clear_has_dropout_param() {
_has_bits_[0] &= ~0x00000400u;
}
inline void LayerParameter::clear_dropout_param() {
if (dropout_param_ != NULL) dropout_param_->Clear();
clear_has_dropout_param();
}
inline const ::opencv_caffe::DropoutParameter& LayerParameter::dropout_param() const {
const ::opencv_caffe::DropoutParameter* p = dropout_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.dropout_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::DropoutParameter*>(
&::opencv_caffe::_DropoutParameter_default_instance_);
}
inline ::opencv_caffe::DropoutParameter* LayerParameter::release_dropout_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.dropout_param)
clear_has_dropout_param();
::opencv_caffe::DropoutParameter* temp = dropout_param_;
dropout_param_ = NULL;
return temp;
}
inline ::opencv_caffe::DropoutParameter* LayerParameter::mutable_dropout_param() {
set_has_dropout_param();
if (dropout_param_ == NULL) {
dropout_param_ = new ::opencv_caffe::DropoutParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.dropout_param)
return dropout_param_;
}
inline void LayerParameter::set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete dropout_param_;
}
if (dropout_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
dropout_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, dropout_param, submessage_arena);
}
set_has_dropout_param();
} else {
clear_has_dropout_param();
}
dropout_param_ = dropout_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.dropout_param)
}
// optional .opencv_caffe.DummyDataParameter dummy_data_param = 109;
inline bool LayerParameter::has_dummy_data_param() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void LayerParameter::set_has_dummy_data_param() {
_has_bits_[0] |= 0x00000800u;
}
inline void LayerParameter::clear_has_dummy_data_param() {
_has_bits_[0] &= ~0x00000800u;
}
inline void LayerParameter::clear_dummy_data_param() {
if (dummy_data_param_ != NULL) dummy_data_param_->Clear();
clear_has_dummy_data_param();
}
inline const ::opencv_caffe::DummyDataParameter& LayerParameter::dummy_data_param() const {
const ::opencv_caffe::DummyDataParameter* p = dummy_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.dummy_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::DummyDataParameter*>(
&::opencv_caffe::_DummyDataParameter_default_instance_);
}
inline ::opencv_caffe::DummyDataParameter* LayerParameter::release_dummy_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.dummy_data_param)
clear_has_dummy_data_param();
::opencv_caffe::DummyDataParameter* temp = dummy_data_param_;
dummy_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::DummyDataParameter* LayerParameter::mutable_dummy_data_param() {
set_has_dummy_data_param();
if (dummy_data_param_ == NULL) {
dummy_data_param_ = new ::opencv_caffe::DummyDataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.dummy_data_param)
return dummy_data_param_;
}
inline void LayerParameter::set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete dummy_data_param_;
}
if (dummy_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
dummy_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, dummy_data_param, submessage_arena);
}
set_has_dummy_data_param();
} else {
clear_has_dummy_data_param();
}
dummy_data_param_ = dummy_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.dummy_data_param)
}
// optional .opencv_caffe.EltwiseParameter eltwise_param = 110;
inline bool LayerParameter::has_eltwise_param() const {
return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void LayerParameter::set_has_eltwise_param() {
_has_bits_[0] |= 0x00001000u;
}
inline void LayerParameter::clear_has_eltwise_param() {
_has_bits_[0] &= ~0x00001000u;
}
inline void LayerParameter::clear_eltwise_param() {
if (eltwise_param_ != NULL) eltwise_param_->Clear();
clear_has_eltwise_param();
}
inline const ::opencv_caffe::EltwiseParameter& LayerParameter::eltwise_param() const {
const ::opencv_caffe::EltwiseParameter* p = eltwise_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.eltwise_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::EltwiseParameter*>(
&::opencv_caffe::_EltwiseParameter_default_instance_);
}
inline ::opencv_caffe::EltwiseParameter* LayerParameter::release_eltwise_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.eltwise_param)
clear_has_eltwise_param();
::opencv_caffe::EltwiseParameter* temp = eltwise_param_;
eltwise_param_ = NULL;
return temp;
}
inline ::opencv_caffe::EltwiseParameter* LayerParameter::mutable_eltwise_param() {
set_has_eltwise_param();
if (eltwise_param_ == NULL) {
eltwise_param_ = new ::opencv_caffe::EltwiseParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.eltwise_param)
return eltwise_param_;
}
inline void LayerParameter::set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete eltwise_param_;
}
if (eltwise_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
eltwise_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, eltwise_param, submessage_arena);
}
set_has_eltwise_param();
} else {
clear_has_eltwise_param();
}
eltwise_param_ = eltwise_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.eltwise_param)
}
// optional .opencv_caffe.ELUParameter elu_param = 140;
inline bool LayerParameter::has_elu_param() const {
return (_has_bits_[1] & 0x00000400u) != 0;
}
inline void LayerParameter::set_has_elu_param() {
_has_bits_[1] |= 0x00000400u;
}
inline void LayerParameter::clear_has_elu_param() {
_has_bits_[1] &= ~0x00000400u;
}
inline void LayerParameter::clear_elu_param() {
if (elu_param_ != NULL) elu_param_->Clear();
clear_has_elu_param();
}
inline const ::opencv_caffe::ELUParameter& LayerParameter::elu_param() const {
const ::opencv_caffe::ELUParameter* p = elu_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.elu_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ELUParameter*>(
&::opencv_caffe::_ELUParameter_default_instance_);
}
inline ::opencv_caffe::ELUParameter* LayerParameter::release_elu_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.elu_param)
clear_has_elu_param();
::opencv_caffe::ELUParameter* temp = elu_param_;
elu_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ELUParameter* LayerParameter::mutable_elu_param() {
set_has_elu_param();
if (elu_param_ == NULL) {
elu_param_ = new ::opencv_caffe::ELUParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.elu_param)
return elu_param_;
}
inline void LayerParameter::set_allocated_elu_param(::opencv_caffe::ELUParameter* elu_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete elu_param_;
}
if (elu_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
elu_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, elu_param, submessage_arena);
}
set_has_elu_param();
} else {
clear_has_elu_param();
}
elu_param_ = elu_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.elu_param)
}
// optional .opencv_caffe.EmbedParameter embed_param = 137;
inline bool LayerParameter::has_embed_param() const {
return (_has_bits_[1] & 0x00000080u) != 0;
}
inline void LayerParameter::set_has_embed_param() {
_has_bits_[1] |= 0x00000080u;
}
inline void LayerParameter::clear_has_embed_param() {
_has_bits_[1] &= ~0x00000080u;
}
inline void LayerParameter::clear_embed_param() {
if (embed_param_ != NULL) embed_param_->Clear();
clear_has_embed_param();
}
inline const ::opencv_caffe::EmbedParameter& LayerParameter::embed_param() const {
const ::opencv_caffe::EmbedParameter* p = embed_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.embed_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::EmbedParameter*>(
&::opencv_caffe::_EmbedParameter_default_instance_);
}
inline ::opencv_caffe::EmbedParameter* LayerParameter::release_embed_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.embed_param)
clear_has_embed_param();
::opencv_caffe::EmbedParameter* temp = embed_param_;
embed_param_ = NULL;
return temp;
}
inline ::opencv_caffe::EmbedParameter* LayerParameter::mutable_embed_param() {
set_has_embed_param();
if (embed_param_ == NULL) {
embed_param_ = new ::opencv_caffe::EmbedParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.embed_param)
return embed_param_;
}
inline void LayerParameter::set_allocated_embed_param(::opencv_caffe::EmbedParameter* embed_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete embed_param_;
}
if (embed_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
embed_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, embed_param, submessage_arena);
}
set_has_embed_param();
} else {
clear_has_embed_param();
}
embed_param_ = embed_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.embed_param)
}
// optional .opencv_caffe.ExpParameter exp_param = 111;
inline bool LayerParameter::has_exp_param() const {
return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void LayerParameter::set_has_exp_param() {
_has_bits_[0] |= 0x00002000u;
}
inline void LayerParameter::clear_has_exp_param() {
_has_bits_[0] &= ~0x00002000u;
}
inline void LayerParameter::clear_exp_param() {
if (exp_param_ != NULL) exp_param_->Clear();
clear_has_exp_param();
}
inline const ::opencv_caffe::ExpParameter& LayerParameter::exp_param() const {
const ::opencv_caffe::ExpParameter* p = exp_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.exp_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ExpParameter*>(
&::opencv_caffe::_ExpParameter_default_instance_);
}
inline ::opencv_caffe::ExpParameter* LayerParameter::release_exp_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.exp_param)
clear_has_exp_param();
::opencv_caffe::ExpParameter* temp = exp_param_;
exp_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ExpParameter* LayerParameter::mutable_exp_param() {
set_has_exp_param();
if (exp_param_ == NULL) {
exp_param_ = new ::opencv_caffe::ExpParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.exp_param)
return exp_param_;
}
inline void LayerParameter::set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete exp_param_;
}
if (exp_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
exp_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, exp_param, submessage_arena);
}
set_has_exp_param();
} else {
clear_has_exp_param();
}
exp_param_ = exp_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.exp_param)
}
// optional .opencv_caffe.FlattenParameter flatten_param = 135;
inline bool LayerParameter::has_flatten_param() const {
return (_has_bits_[1] & 0x00000020u) != 0;
}
inline void LayerParameter::set_has_flatten_param() {
_has_bits_[1] |= 0x00000020u;
}
inline void LayerParameter::clear_has_flatten_param() {
_has_bits_[1] &= ~0x00000020u;
}
inline void LayerParameter::clear_flatten_param() {
if (flatten_param_ != NULL) flatten_param_->Clear();
clear_has_flatten_param();
}
inline const ::opencv_caffe::FlattenParameter& LayerParameter::flatten_param() const {
const ::opencv_caffe::FlattenParameter* p = flatten_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.flatten_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FlattenParameter*>(
&::opencv_caffe::_FlattenParameter_default_instance_);
}
inline ::opencv_caffe::FlattenParameter* LayerParameter::release_flatten_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.flatten_param)
clear_has_flatten_param();
::opencv_caffe::FlattenParameter* temp = flatten_param_;
flatten_param_ = NULL;
return temp;
}
inline ::opencv_caffe::FlattenParameter* LayerParameter::mutable_flatten_param() {
set_has_flatten_param();
if (flatten_param_ == NULL) {
flatten_param_ = new ::opencv_caffe::FlattenParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.flatten_param)
return flatten_param_;
}
inline void LayerParameter::set_allocated_flatten_param(::opencv_caffe::FlattenParameter* flatten_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete flatten_param_;
}
if (flatten_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
flatten_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, flatten_param, submessage_arena);
}
set_has_flatten_param();
} else {
clear_has_flatten_param();
}
flatten_param_ = flatten_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.flatten_param)
}
// optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112;
inline bool LayerParameter::has_hdf5_data_param() const {
return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void LayerParameter::set_has_hdf5_data_param() {
_has_bits_[0] |= 0x00004000u;
}
inline void LayerParameter::clear_has_hdf5_data_param() {
_has_bits_[0] &= ~0x00004000u;
}
inline void LayerParameter::clear_hdf5_data_param() {
if (hdf5_data_param_ != NULL) hdf5_data_param_->Clear();
clear_has_hdf5_data_param();
}
inline const ::opencv_caffe::HDF5DataParameter& LayerParameter::hdf5_data_param() const {
const ::opencv_caffe::HDF5DataParameter* p = hdf5_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hdf5_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::HDF5DataParameter*>(
&::opencv_caffe::_HDF5DataParameter_default_instance_);
}
inline ::opencv_caffe::HDF5DataParameter* LayerParameter::release_hdf5_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hdf5_data_param)
clear_has_hdf5_data_param();
::opencv_caffe::HDF5DataParameter* temp = hdf5_data_param_;
hdf5_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::HDF5DataParameter* LayerParameter::mutable_hdf5_data_param() {
set_has_hdf5_data_param();
if (hdf5_data_param_ == NULL) {
hdf5_data_param_ = new ::opencv_caffe::HDF5DataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hdf5_data_param)
return hdf5_data_param_;
}
inline void LayerParameter::set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete hdf5_data_param_;
}
if (hdf5_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
hdf5_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, hdf5_data_param, submessage_arena);
}
set_has_hdf5_data_param();
} else {
clear_has_hdf5_data_param();
}
hdf5_data_param_ = hdf5_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.hdf5_data_param)
}
// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113;
inline bool LayerParameter::has_hdf5_output_param() const {
return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void LayerParameter::set_has_hdf5_output_param() {
_has_bits_[0] |= 0x00008000u;
}
inline void LayerParameter::clear_has_hdf5_output_param() {
_has_bits_[0] &= ~0x00008000u;
}
inline void LayerParameter::clear_hdf5_output_param() {
if (hdf5_output_param_ != NULL) hdf5_output_param_->Clear();
clear_has_hdf5_output_param();
}
inline const ::opencv_caffe::HDF5OutputParameter& LayerParameter::hdf5_output_param() const {
const ::opencv_caffe::HDF5OutputParameter* p = hdf5_output_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hdf5_output_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::HDF5OutputParameter*>(
&::opencv_caffe::_HDF5OutputParameter_default_instance_);
}
inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::release_hdf5_output_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hdf5_output_param)
clear_has_hdf5_output_param();
::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = NULL;
return temp;
}
inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::mutable_hdf5_output_param() {
set_has_hdf5_output_param();
if (hdf5_output_param_ == NULL) {
hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hdf5_output_param)
return hdf5_output_param_;
}
inline void LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete hdf5_output_param_;
}
if (hdf5_output_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
hdf5_output_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, hdf5_output_param, submessage_arena);
}
set_has_hdf5_output_param();
} else {
clear_has_hdf5_output_param();
}
hdf5_output_param_ = hdf5_output_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.hdf5_output_param)
}
// optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114;
inline bool LayerParameter::has_hinge_loss_param() const {
return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void LayerParameter::set_has_hinge_loss_param() {
_has_bits_[0] |= 0x00010000u;
}
inline void LayerParameter::clear_has_hinge_loss_param() {
_has_bits_[0] &= ~0x00010000u;
}
inline void LayerParameter::clear_hinge_loss_param() {
if (hinge_loss_param_ != NULL) hinge_loss_param_->Clear();
clear_has_hinge_loss_param();
}
inline const ::opencv_caffe::HingeLossParameter& LayerParameter::hinge_loss_param() const {
const ::opencv_caffe::HingeLossParameter* p = hinge_loss_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hinge_loss_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::HingeLossParameter*>(
&::opencv_caffe::_HingeLossParameter_default_instance_);
}
inline ::opencv_caffe::HingeLossParameter* LayerParameter::release_hinge_loss_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hinge_loss_param)
clear_has_hinge_loss_param();
::opencv_caffe::HingeLossParameter* temp = hinge_loss_param_;
hinge_loss_param_ = NULL;
return temp;
}
inline ::opencv_caffe::HingeLossParameter* LayerParameter::mutable_hinge_loss_param() {
set_has_hinge_loss_param();
if (hinge_loss_param_ == NULL) {
hinge_loss_param_ = new ::opencv_caffe::HingeLossParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hinge_loss_param)
return hinge_loss_param_;
}
inline void LayerParameter::set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete hinge_loss_param_;
}
if (hinge_loss_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
hinge_loss_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, hinge_loss_param, submessage_arena);
}
set_has_hinge_loss_param();
} else {
clear_has_hinge_loss_param();
}
hinge_loss_param_ = hinge_loss_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.hinge_loss_param)
}
// optional .opencv_caffe.ImageDataParameter image_data_param = 115;
inline bool LayerParameter::has_image_data_param() const {
return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void LayerParameter::set_has_image_data_param() {
_has_bits_[0] |= 0x00020000u;
}
inline void LayerParameter::clear_has_image_data_param() {
_has_bits_[0] &= ~0x00020000u;
}
inline void LayerParameter::clear_image_data_param() {
if (image_data_param_ != NULL) image_data_param_->Clear();
clear_has_image_data_param();
}
inline const ::opencv_caffe::ImageDataParameter& LayerParameter::image_data_param() const {
const ::opencv_caffe::ImageDataParameter* p = image_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.image_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ImageDataParameter*>(
&::opencv_caffe::_ImageDataParameter_default_instance_);
}
inline ::opencv_caffe::ImageDataParameter* LayerParameter::release_image_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.image_data_param)
clear_has_image_data_param();
::opencv_caffe::ImageDataParameter* temp = image_data_param_;
image_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ImageDataParameter* LayerParameter::mutable_image_data_param() {
set_has_image_data_param();
if (image_data_param_ == NULL) {
image_data_param_ = new ::opencv_caffe::ImageDataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.image_data_param)
return image_data_param_;
}
inline void LayerParameter::set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete image_data_param_;
}
if (image_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
image_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, image_data_param, submessage_arena);
}
set_has_image_data_param();
} else {
clear_has_image_data_param();
}
image_data_param_ = image_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.image_data_param)
}
// optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116;
inline bool LayerParameter::has_infogain_loss_param() const {
return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void LayerParameter::set_has_infogain_loss_param() {
_has_bits_[0] |= 0x00040000u;
}
inline void LayerParameter::clear_has_infogain_loss_param() {
_has_bits_[0] &= ~0x00040000u;
}
inline void LayerParameter::clear_infogain_loss_param() {
if (infogain_loss_param_ != NULL) infogain_loss_param_->Clear();
clear_has_infogain_loss_param();
}
inline const ::opencv_caffe::InfogainLossParameter& LayerParameter::infogain_loss_param() const {
const ::opencv_caffe::InfogainLossParameter* p = infogain_loss_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.infogain_loss_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::InfogainLossParameter*>(
&::opencv_caffe::_InfogainLossParameter_default_instance_);
}
inline ::opencv_caffe::InfogainLossParameter* LayerParameter::release_infogain_loss_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.infogain_loss_param)
clear_has_infogain_loss_param();
::opencv_caffe::InfogainLossParameter* temp = infogain_loss_param_;
infogain_loss_param_ = NULL;
return temp;
}
inline ::opencv_caffe::InfogainLossParameter* LayerParameter::mutable_infogain_loss_param() {
set_has_infogain_loss_param();
if (infogain_loss_param_ == NULL) {
infogain_loss_param_ = new ::opencv_caffe::InfogainLossParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.infogain_loss_param)
return infogain_loss_param_;
}
inline void LayerParameter::set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete infogain_loss_param_;
}
if (infogain_loss_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
infogain_loss_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, infogain_loss_param, submessage_arena);
}
set_has_infogain_loss_param();
} else {
clear_has_infogain_loss_param();
}
infogain_loss_param_ = infogain_loss_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.infogain_loss_param)
}
// optional .opencv_caffe.InnerProductParameter inner_product_param = 117;
inline bool LayerParameter::has_inner_product_param() const {
return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void LayerParameter::set_has_inner_product_param() {
_has_bits_[0] |= 0x00080000u;
}
inline void LayerParameter::clear_has_inner_product_param() {
_has_bits_[0] &= ~0x00080000u;
}
inline void LayerParameter::clear_inner_product_param() {
if (inner_product_param_ != NULL) inner_product_param_->Clear();
clear_has_inner_product_param();
}
inline const ::opencv_caffe::InnerProductParameter& LayerParameter::inner_product_param() const {
const ::opencv_caffe::InnerProductParameter* p = inner_product_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.inner_product_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::InnerProductParameter*>(
&::opencv_caffe::_InnerProductParameter_default_instance_);
}
inline ::opencv_caffe::InnerProductParameter* LayerParameter::release_inner_product_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.inner_product_param)
clear_has_inner_product_param();
::opencv_caffe::InnerProductParameter* temp = inner_product_param_;
inner_product_param_ = NULL;
return temp;
}
inline ::opencv_caffe::InnerProductParameter* LayerParameter::mutable_inner_product_param() {
set_has_inner_product_param();
if (inner_product_param_ == NULL) {
inner_product_param_ = new ::opencv_caffe::InnerProductParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.inner_product_param)
return inner_product_param_;
}
inline void LayerParameter::set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete inner_product_param_;
}
if (inner_product_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
inner_product_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, inner_product_param, submessage_arena);
}
set_has_inner_product_param();
} else {
clear_has_inner_product_param();
}
inner_product_param_ = inner_product_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.inner_product_param)
}
// optional .opencv_caffe.InputParameter input_param = 143;
inline bool LayerParameter::has_input_param() const {
return (_has_bits_[1] & 0x00002000u) != 0;
}
inline void LayerParameter::set_has_input_param() {
_has_bits_[1] |= 0x00002000u;
}
inline void LayerParameter::clear_has_input_param() {
_has_bits_[1] &= ~0x00002000u;
}
inline void LayerParameter::clear_input_param() {
if (input_param_ != NULL) input_param_->Clear();
clear_has_input_param();
}
inline const ::opencv_caffe::InputParameter& LayerParameter::input_param() const {
const ::opencv_caffe::InputParameter* p = input_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.input_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::InputParameter*>(
&::opencv_caffe::_InputParameter_default_instance_);
}
inline ::opencv_caffe::InputParameter* LayerParameter::release_input_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.input_param)
clear_has_input_param();
::opencv_caffe::InputParameter* temp = input_param_;
input_param_ = NULL;
return temp;
}
inline ::opencv_caffe::InputParameter* LayerParameter::mutable_input_param() {
set_has_input_param();
if (input_param_ == NULL) {
input_param_ = new ::opencv_caffe::InputParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.input_param)
return input_param_;
}
inline void LayerParameter::set_allocated_input_param(::opencv_caffe::InputParameter* input_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete input_param_;
}
if (input_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
input_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, input_param, submessage_arena);
}
set_has_input_param();
} else {
clear_has_input_param();
}
input_param_ = input_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.input_param)
}
// optional .opencv_caffe.LogParameter log_param = 134;
inline bool LayerParameter::has_log_param() const {
return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void LayerParameter::set_has_log_param() {
_has_bits_[1] |= 0x00000010u;
}
inline void LayerParameter::clear_has_log_param() {
_has_bits_[1] &= ~0x00000010u;
}
inline void LayerParameter::clear_log_param() {
if (log_param_ != NULL) log_param_->Clear();
clear_has_log_param();
}
inline const ::opencv_caffe::LogParameter& LayerParameter::log_param() const {
const ::opencv_caffe::LogParameter* p = log_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.log_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::LogParameter*>(
&::opencv_caffe::_LogParameter_default_instance_);
}
inline ::opencv_caffe::LogParameter* LayerParameter::release_log_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.log_param)
clear_has_log_param();
::opencv_caffe::LogParameter* temp = log_param_;
log_param_ = NULL;
return temp;
}
inline ::opencv_caffe::LogParameter* LayerParameter::mutable_log_param() {
set_has_log_param();
if (log_param_ == NULL) {
log_param_ = new ::opencv_caffe::LogParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.log_param)
return log_param_;
}
inline void LayerParameter::set_allocated_log_param(::opencv_caffe::LogParameter* log_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete log_param_;
}
if (log_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
log_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, log_param, submessage_arena);
}
set_has_log_param();
} else {
clear_has_log_param();
}
log_param_ = log_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.log_param)
}
// optional .opencv_caffe.LRNParameter lrn_param = 118;
inline bool LayerParameter::has_lrn_param() const {
return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void LayerParameter::set_has_lrn_param() {
_has_bits_[0] |= 0x00100000u;
}
inline void LayerParameter::clear_has_lrn_param() {
_has_bits_[0] &= ~0x00100000u;
}
inline void LayerParameter::clear_lrn_param() {
if (lrn_param_ != NULL) lrn_param_->Clear();
clear_has_lrn_param();
}
inline const ::opencv_caffe::LRNParameter& LayerParameter::lrn_param() const {
const ::opencv_caffe::LRNParameter* p = lrn_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.lrn_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::LRNParameter*>(
&::opencv_caffe::_LRNParameter_default_instance_);
}
inline ::opencv_caffe::LRNParameter* LayerParameter::release_lrn_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.lrn_param)
clear_has_lrn_param();
::opencv_caffe::LRNParameter* temp = lrn_param_;
lrn_param_ = NULL;
return temp;
}
inline ::opencv_caffe::LRNParameter* LayerParameter::mutable_lrn_param() {
set_has_lrn_param();
if (lrn_param_ == NULL) {
lrn_param_ = new ::opencv_caffe::LRNParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.lrn_param)
return lrn_param_;
}
inline void LayerParameter::set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete lrn_param_;
}
if (lrn_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
lrn_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, lrn_param, submessage_arena);
}
set_has_lrn_param();
} else {
clear_has_lrn_param();
}
lrn_param_ = lrn_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.lrn_param)
}
// optional .opencv_caffe.MemoryDataParameter memory_data_param = 119;
inline bool LayerParameter::has_memory_data_param() const {
return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void LayerParameter::set_has_memory_data_param() {
_has_bits_[0] |= 0x00200000u;
}
inline void LayerParameter::clear_has_memory_data_param() {
_has_bits_[0] &= ~0x00200000u;
}
inline void LayerParameter::clear_memory_data_param() {
if (memory_data_param_ != NULL) memory_data_param_->Clear();
clear_has_memory_data_param();
}
inline const ::opencv_caffe::MemoryDataParameter& LayerParameter::memory_data_param() const {
const ::opencv_caffe::MemoryDataParameter* p = memory_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.memory_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::MemoryDataParameter*>(
&::opencv_caffe::_MemoryDataParameter_default_instance_);
}
inline ::opencv_caffe::MemoryDataParameter* LayerParameter::release_memory_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.memory_data_param)
clear_has_memory_data_param();
::opencv_caffe::MemoryDataParameter* temp = memory_data_param_;
memory_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::MemoryDataParameter* LayerParameter::mutable_memory_data_param() {
set_has_memory_data_param();
if (memory_data_param_ == NULL) {
memory_data_param_ = new ::opencv_caffe::MemoryDataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.memory_data_param)
return memory_data_param_;
}
inline void LayerParameter::set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete memory_data_param_;
}
if (memory_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
memory_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, memory_data_param, submessage_arena);
}
set_has_memory_data_param();
} else {
clear_has_memory_data_param();
}
memory_data_param_ = memory_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.memory_data_param)
}
// optional .opencv_caffe.MVNParameter mvn_param = 120;
inline bool LayerParameter::has_mvn_param() const {
return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void LayerParameter::set_has_mvn_param() {
_has_bits_[0] |= 0x00400000u;
}
inline void LayerParameter::clear_has_mvn_param() {
_has_bits_[0] &= ~0x00400000u;
}
inline void LayerParameter::clear_mvn_param() {
if (mvn_param_ != NULL) mvn_param_->Clear();
clear_has_mvn_param();
}
inline const ::opencv_caffe::MVNParameter& LayerParameter::mvn_param() const {
const ::opencv_caffe::MVNParameter* p = mvn_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.mvn_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::MVNParameter*>(
&::opencv_caffe::_MVNParameter_default_instance_);
}
inline ::opencv_caffe::MVNParameter* LayerParameter::release_mvn_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.mvn_param)
clear_has_mvn_param();
::opencv_caffe::MVNParameter* temp = mvn_param_;
mvn_param_ = NULL;
return temp;
}
inline ::opencv_caffe::MVNParameter* LayerParameter::mutable_mvn_param() {
set_has_mvn_param();
if (mvn_param_ == NULL) {
mvn_param_ = new ::opencv_caffe::MVNParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.mvn_param)
return mvn_param_;
}
inline void LayerParameter::set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete mvn_param_;
}
if (mvn_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
mvn_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, mvn_param, submessage_arena);
}
set_has_mvn_param();
} else {
clear_has_mvn_param();
}
mvn_param_ = mvn_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.mvn_param)
}
// optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149;
inline bool LayerParameter::has_norm_param() const {
return (_has_bits_[1] & 0x00080000u) != 0;
}
inline void LayerParameter::set_has_norm_param() {
_has_bits_[1] |= 0x00080000u;
}
inline void LayerParameter::clear_has_norm_param() {
_has_bits_[1] &= ~0x00080000u;
}
inline void LayerParameter::clear_norm_param() {
if (norm_param_ != NULL) norm_param_->Clear();
clear_has_norm_param();
}
inline const ::opencv_caffe::NormalizeBBoxParameter& LayerParameter::norm_param() const {
const ::opencv_caffe::NormalizeBBoxParameter* p = norm_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.norm_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::NormalizeBBoxParameter*>(
&::opencv_caffe::_NormalizeBBoxParameter_default_instance_);
}
inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::release_norm_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.norm_param)
clear_has_norm_param();
::opencv_caffe::NormalizeBBoxParameter* temp = norm_param_;
norm_param_ = NULL;
return temp;
}
inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::mutable_norm_param() {
set_has_norm_param();
if (norm_param_ == NULL) {
norm_param_ = new ::opencv_caffe::NormalizeBBoxParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.norm_param)
return norm_param_;
}
inline void LayerParameter::set_allocated_norm_param(::opencv_caffe::NormalizeBBoxParameter* norm_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete norm_param_;
}
if (norm_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
norm_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, norm_param, submessage_arena);
}
set_has_norm_param();
} else {
clear_has_norm_param();
}
norm_param_ = norm_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.norm_param)
}
// optional .opencv_caffe.PermuteParameter permute_param = 148;
inline bool LayerParameter::has_permute_param() const {
return (_has_bits_[1] & 0x00040000u) != 0;
}
inline void LayerParameter::set_has_permute_param() {
_has_bits_[1] |= 0x00040000u;
}
inline void LayerParameter::clear_has_permute_param() {
_has_bits_[1] &= ~0x00040000u;
}
inline void LayerParameter::clear_permute_param() {
if (permute_param_ != NULL) permute_param_->Clear();
clear_has_permute_param();
}
inline const ::opencv_caffe::PermuteParameter& LayerParameter::permute_param() const {
const ::opencv_caffe::PermuteParameter* p = permute_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.permute_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PermuteParameter*>(
&::opencv_caffe::_PermuteParameter_default_instance_);
}
inline ::opencv_caffe::PermuteParameter* LayerParameter::release_permute_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.permute_param)
clear_has_permute_param();
::opencv_caffe::PermuteParameter* temp = permute_param_;
permute_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PermuteParameter* LayerParameter::mutable_permute_param() {
set_has_permute_param();
if (permute_param_ == NULL) {
permute_param_ = new ::opencv_caffe::PermuteParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.permute_param)
return permute_param_;
}
inline void LayerParameter::set_allocated_permute_param(::opencv_caffe::PermuteParameter* permute_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete permute_param_;
}
if (permute_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
permute_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, permute_param, submessage_arena);
}
set_has_permute_param();
} else {
clear_has_permute_param();
}
permute_param_ = permute_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.permute_param)
}
// optional .opencv_caffe.ParameterParameter parameter_param = 145;
inline bool LayerParameter::has_parameter_param() const {
return (_has_bits_[1] & 0x00008000u) != 0;
}
inline void LayerParameter::set_has_parameter_param() {
_has_bits_[1] |= 0x00008000u;
}
inline void LayerParameter::clear_has_parameter_param() {
_has_bits_[1] &= ~0x00008000u;
}
inline void LayerParameter::clear_parameter_param() {
if (parameter_param_ != NULL) parameter_param_->Clear();
clear_has_parameter_param();
}
inline const ::opencv_caffe::ParameterParameter& LayerParameter::parameter_param() const {
const ::opencv_caffe::ParameterParameter* p = parameter_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.parameter_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ParameterParameter*>(
&::opencv_caffe::_ParameterParameter_default_instance_);
}
inline ::opencv_caffe::ParameterParameter* LayerParameter::release_parameter_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.parameter_param)
clear_has_parameter_param();
::opencv_caffe::ParameterParameter* temp = parameter_param_;
parameter_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ParameterParameter* LayerParameter::mutable_parameter_param() {
set_has_parameter_param();
if (parameter_param_ == NULL) {
parameter_param_ = new ::opencv_caffe::ParameterParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.parameter_param)
return parameter_param_;
}
inline void LayerParameter::set_allocated_parameter_param(::opencv_caffe::ParameterParameter* parameter_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete parameter_param_;
}
if (parameter_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
parameter_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, parameter_param, submessage_arena);
}
set_has_parameter_param();
} else {
clear_has_parameter_param();
}
parameter_param_ = parameter_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.parameter_param)
}
// optional .opencv_caffe.PoolingParameter pooling_param = 121;
inline bool LayerParameter::has_pooling_param() const {
return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void LayerParameter::set_has_pooling_param() {
_has_bits_[0] |= 0x00800000u;
}
inline void LayerParameter::clear_has_pooling_param() {
_has_bits_[0] &= ~0x00800000u;
}
inline void LayerParameter::clear_pooling_param() {
if (pooling_param_ != NULL) pooling_param_->Clear();
clear_has_pooling_param();
}
inline const ::opencv_caffe::PoolingParameter& LayerParameter::pooling_param() const {
const ::opencv_caffe::PoolingParameter* p = pooling_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.pooling_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PoolingParameter*>(
&::opencv_caffe::_PoolingParameter_default_instance_);
}
inline ::opencv_caffe::PoolingParameter* LayerParameter::release_pooling_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.pooling_param)
clear_has_pooling_param();
::opencv_caffe::PoolingParameter* temp = pooling_param_;
pooling_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PoolingParameter* LayerParameter::mutable_pooling_param() {
set_has_pooling_param();
if (pooling_param_ == NULL) {
pooling_param_ = new ::opencv_caffe::PoolingParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.pooling_param)
return pooling_param_;
}
inline void LayerParameter::set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete pooling_param_;
}
if (pooling_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
pooling_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, pooling_param, submessage_arena);
}
set_has_pooling_param();
} else {
clear_has_pooling_param();
}
pooling_param_ = pooling_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.pooling_param)
}
// optional .opencv_caffe.PowerParameter power_param = 122;
inline bool LayerParameter::has_power_param() const {
return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void LayerParameter::set_has_power_param() {
_has_bits_[0] |= 0x01000000u;
}
inline void LayerParameter::clear_has_power_param() {
_has_bits_[0] &= ~0x01000000u;
}
inline void LayerParameter::clear_power_param() {
if (power_param_ != NULL) power_param_->Clear();
clear_has_power_param();
}
inline const ::opencv_caffe::PowerParameter& LayerParameter::power_param() const {
const ::opencv_caffe::PowerParameter* p = power_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.power_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PowerParameter*>(
&::opencv_caffe::_PowerParameter_default_instance_);
}
inline ::opencv_caffe::PowerParameter* LayerParameter::release_power_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.power_param)
clear_has_power_param();
::opencv_caffe::PowerParameter* temp = power_param_;
power_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PowerParameter* LayerParameter::mutable_power_param() {
set_has_power_param();
if (power_param_ == NULL) {
power_param_ = new ::opencv_caffe::PowerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.power_param)
return power_param_;
}
inline void LayerParameter::set_allocated_power_param(::opencv_caffe::PowerParameter* power_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete power_param_;
}
if (power_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
power_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, power_param, submessage_arena);
}
set_has_power_param();
} else {
clear_has_power_param();
}
power_param_ = power_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.power_param)
}
// optional .opencv_caffe.PReLUParameter prelu_param = 131;
inline bool LayerParameter::has_prelu_param() const {
return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void LayerParameter::set_has_prelu_param() {
_has_bits_[1] |= 0x00000002u;
}
inline void LayerParameter::clear_has_prelu_param() {
_has_bits_[1] &= ~0x00000002u;
}
inline void LayerParameter::clear_prelu_param() {
if (prelu_param_ != NULL) prelu_param_->Clear();
clear_has_prelu_param();
}
inline const ::opencv_caffe::PReLUParameter& LayerParameter::prelu_param() const {
const ::opencv_caffe::PReLUParameter* p = prelu_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.prelu_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PReLUParameter*>(
&::opencv_caffe::_PReLUParameter_default_instance_);
}
inline ::opencv_caffe::PReLUParameter* LayerParameter::release_prelu_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.prelu_param)
clear_has_prelu_param();
::opencv_caffe::PReLUParameter* temp = prelu_param_;
prelu_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PReLUParameter* LayerParameter::mutable_prelu_param() {
set_has_prelu_param();
if (prelu_param_ == NULL) {
prelu_param_ = new ::opencv_caffe::PReLUParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.prelu_param)
return prelu_param_;
}
inline void LayerParameter::set_allocated_prelu_param(::opencv_caffe::PReLUParameter* prelu_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete prelu_param_;
}
if (prelu_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
prelu_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, prelu_param, submessage_arena);
}
set_has_prelu_param();
} else {
clear_has_prelu_param();
}
prelu_param_ = prelu_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.prelu_param)
}
// optional .opencv_caffe.PriorBoxParameter prior_box_param = 150;
inline bool LayerParameter::has_prior_box_param() const {
return (_has_bits_[1] & 0x00100000u) != 0;
}
inline void LayerParameter::set_has_prior_box_param() {
_has_bits_[1] |= 0x00100000u;
}
inline void LayerParameter::clear_has_prior_box_param() {
_has_bits_[1] &= ~0x00100000u;
}
inline void LayerParameter::clear_prior_box_param() {
if (prior_box_param_ != NULL) prior_box_param_->Clear();
clear_has_prior_box_param();
}
inline const ::opencv_caffe::PriorBoxParameter& LayerParameter::prior_box_param() const {
const ::opencv_caffe::PriorBoxParameter* p = prior_box_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.prior_box_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PriorBoxParameter*>(
&::opencv_caffe::_PriorBoxParameter_default_instance_);
}
inline ::opencv_caffe::PriorBoxParameter* LayerParameter::release_prior_box_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.prior_box_param)
clear_has_prior_box_param();
::opencv_caffe::PriorBoxParameter* temp = prior_box_param_;
prior_box_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PriorBoxParameter* LayerParameter::mutable_prior_box_param() {
set_has_prior_box_param();
if (prior_box_param_ == NULL) {
prior_box_param_ = new ::opencv_caffe::PriorBoxParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.prior_box_param)
return prior_box_param_;
}
inline void LayerParameter::set_allocated_prior_box_param(::opencv_caffe::PriorBoxParameter* prior_box_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete prior_box_param_;
}
if (prior_box_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
prior_box_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, prior_box_param, submessage_arena);
}
set_has_prior_box_param();
} else {
clear_has_prior_box_param();
}
prior_box_param_ = prior_box_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.prior_box_param)
}
// optional .opencv_caffe.ProposalParameter proposal_param = 201;
inline bool LayerParameter::has_proposal_param() const {
return (_has_bits_[1] & 0x00200000u) != 0;
}
inline void LayerParameter::set_has_proposal_param() {
_has_bits_[1] |= 0x00200000u;
}
inline void LayerParameter::clear_has_proposal_param() {
_has_bits_[1] &= ~0x00200000u;
}
inline void LayerParameter::clear_proposal_param() {
if (proposal_param_ != NULL) proposal_param_->Clear();
clear_has_proposal_param();
}
inline const ::opencv_caffe::ProposalParameter& LayerParameter::proposal_param() const {
const ::opencv_caffe::ProposalParameter* p = proposal_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.proposal_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ProposalParameter*>(
&::opencv_caffe::_ProposalParameter_default_instance_);
}
inline ::opencv_caffe::ProposalParameter* LayerParameter::release_proposal_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.proposal_param)
clear_has_proposal_param();
::opencv_caffe::ProposalParameter* temp = proposal_param_;
proposal_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ProposalParameter* LayerParameter::mutable_proposal_param() {
set_has_proposal_param();
if (proposal_param_ == NULL) {
proposal_param_ = new ::opencv_caffe::ProposalParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.proposal_param)
return proposal_param_;
}
inline void LayerParameter::set_allocated_proposal_param(::opencv_caffe::ProposalParameter* proposal_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete proposal_param_;
}
if (proposal_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
proposal_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, proposal_param, submessage_arena);
}
set_has_proposal_param();
} else {
clear_has_proposal_param();
}
proposal_param_ = proposal_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.proposal_param)
}
// optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002;
inline bool LayerParameter::has_psroi_pooling_param() const {
return (_has_bits_[1] & 0x00400000u) != 0;
}
inline void LayerParameter::set_has_psroi_pooling_param() {
_has_bits_[1] |= 0x00400000u;
}
inline void LayerParameter::clear_has_psroi_pooling_param() {
_has_bits_[1] &= ~0x00400000u;
}
inline void LayerParameter::clear_psroi_pooling_param() {
if (psroi_pooling_param_ != NULL) psroi_pooling_param_->Clear();
clear_has_psroi_pooling_param();
}
inline const ::opencv_caffe::PSROIPoolingParameter& LayerParameter::psroi_pooling_param() const {
const ::opencv_caffe::PSROIPoolingParameter* p = psroi_pooling_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.psroi_pooling_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PSROIPoolingParameter*>(
&::opencv_caffe::_PSROIPoolingParameter_default_instance_);
}
inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::release_psroi_pooling_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.psroi_pooling_param)
clear_has_psroi_pooling_param();
::opencv_caffe::PSROIPoolingParameter* temp = psroi_pooling_param_;
psroi_pooling_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::mutable_psroi_pooling_param() {
set_has_psroi_pooling_param();
if (psroi_pooling_param_ == NULL) {
psroi_pooling_param_ = new ::opencv_caffe::PSROIPoolingParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.psroi_pooling_param)
return psroi_pooling_param_;
}
inline void LayerParameter::set_allocated_psroi_pooling_param(::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete psroi_pooling_param_;
}
if (psroi_pooling_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
psroi_pooling_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, psroi_pooling_param, submessage_arena);
}
set_has_psroi_pooling_param();
} else {
clear_has_psroi_pooling_param();
}
psroi_pooling_param_ = psroi_pooling_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.psroi_pooling_param)
}
// optional .opencv_caffe.PythonParameter python_param = 130;
inline bool LayerParameter::has_python_param() const {
return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void LayerParameter::set_has_python_param() {
_has_bits_[1] |= 0x00000001u;
}
inline void LayerParameter::clear_has_python_param() {
_has_bits_[1] &= ~0x00000001u;
}
inline void LayerParameter::clear_python_param() {
if (python_param_ != NULL) python_param_->Clear();
clear_has_python_param();
}
inline const ::opencv_caffe::PythonParameter& LayerParameter::python_param() const {
const ::opencv_caffe::PythonParameter* p = python_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.python_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PythonParameter*>(
&::opencv_caffe::_PythonParameter_default_instance_);
}
inline ::opencv_caffe::PythonParameter* LayerParameter::release_python_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.python_param)
clear_has_python_param();
::opencv_caffe::PythonParameter* temp = python_param_;
python_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PythonParameter* LayerParameter::mutable_python_param() {
set_has_python_param();
if (python_param_ == NULL) {
python_param_ = new ::opencv_caffe::PythonParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.python_param)
return python_param_;
}
inline void LayerParameter::set_allocated_python_param(::opencv_caffe::PythonParameter* python_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete python_param_;
}
if (python_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
python_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, python_param, submessage_arena);
}
set_has_python_param();
} else {
clear_has_python_param();
}
python_param_ = python_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.python_param)
}
// optional .opencv_caffe.RecurrentParameter recurrent_param = 146;
inline bool LayerParameter::has_recurrent_param() const {
return (_has_bits_[1] & 0x00010000u) != 0;
}
inline void LayerParameter::set_has_recurrent_param() {
_has_bits_[1] |= 0x00010000u;
}
inline void LayerParameter::clear_has_recurrent_param() {
_has_bits_[1] &= ~0x00010000u;
}
inline void LayerParameter::clear_recurrent_param() {
if (recurrent_param_ != NULL) recurrent_param_->Clear();
clear_has_recurrent_param();
}
inline const ::opencv_caffe::RecurrentParameter& LayerParameter::recurrent_param() const {
const ::opencv_caffe::RecurrentParameter* p = recurrent_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.recurrent_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::RecurrentParameter*>(
&::opencv_caffe::_RecurrentParameter_default_instance_);
}
inline ::opencv_caffe::RecurrentParameter* LayerParameter::release_recurrent_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.recurrent_param)
clear_has_recurrent_param();
::opencv_caffe::RecurrentParameter* temp = recurrent_param_;
recurrent_param_ = NULL;
return temp;
}
inline ::opencv_caffe::RecurrentParameter* LayerParameter::mutable_recurrent_param() {
set_has_recurrent_param();
if (recurrent_param_ == NULL) {
recurrent_param_ = new ::opencv_caffe::RecurrentParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.recurrent_param)
return recurrent_param_;
}
inline void LayerParameter::set_allocated_recurrent_param(::opencv_caffe::RecurrentParameter* recurrent_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete recurrent_param_;
}
if (recurrent_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
recurrent_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, recurrent_param, submessage_arena);
}
set_has_recurrent_param();
} else {
clear_has_recurrent_param();
}
recurrent_param_ = recurrent_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.recurrent_param)
}
// optional .opencv_caffe.ReductionParameter reduction_param = 136;
inline bool LayerParameter::has_reduction_param() const {
return (_has_bits_[1] & 0x00000040u) != 0;
}
inline void LayerParameter::set_has_reduction_param() {
_has_bits_[1] |= 0x00000040u;
}
inline void LayerParameter::clear_has_reduction_param() {
_has_bits_[1] &= ~0x00000040u;
}
inline void LayerParameter::clear_reduction_param() {
if (reduction_param_ != NULL) reduction_param_->Clear();
clear_has_reduction_param();
}
inline const ::opencv_caffe::ReductionParameter& LayerParameter::reduction_param() const {
const ::opencv_caffe::ReductionParameter* p = reduction_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.reduction_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ReductionParameter*>(
&::opencv_caffe::_ReductionParameter_default_instance_);
}
inline ::opencv_caffe::ReductionParameter* LayerParameter::release_reduction_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.reduction_param)
clear_has_reduction_param();
::opencv_caffe::ReductionParameter* temp = reduction_param_;
reduction_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ReductionParameter* LayerParameter::mutable_reduction_param() {
set_has_reduction_param();
if (reduction_param_ == NULL) {
reduction_param_ = new ::opencv_caffe::ReductionParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.reduction_param)
return reduction_param_;
}
inline void LayerParameter::set_allocated_reduction_param(::opencv_caffe::ReductionParameter* reduction_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete reduction_param_;
}
if (reduction_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
reduction_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, reduction_param, submessage_arena);
}
set_has_reduction_param();
} else {
clear_has_reduction_param();
}
reduction_param_ = reduction_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.reduction_param)
}
// optional .opencv_caffe.ReLUParameter relu_param = 123;
inline bool LayerParameter::has_relu_param() const {
return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void LayerParameter::set_has_relu_param() {
_has_bits_[0] |= 0x02000000u;
}
inline void LayerParameter::clear_has_relu_param() {
_has_bits_[0] &= ~0x02000000u;
}
inline void LayerParameter::clear_relu_param() {
if (relu_param_ != NULL) relu_param_->Clear();
clear_has_relu_param();
}
inline const ::opencv_caffe::ReLUParameter& LayerParameter::relu_param() const {
const ::opencv_caffe::ReLUParameter* p = relu_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.relu_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ReLUParameter*>(
&::opencv_caffe::_ReLUParameter_default_instance_);
}
inline ::opencv_caffe::ReLUParameter* LayerParameter::release_relu_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.relu_param)
clear_has_relu_param();
::opencv_caffe::ReLUParameter* temp = relu_param_;
relu_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ReLUParameter* LayerParameter::mutable_relu_param() {
set_has_relu_param();
if (relu_param_ == NULL) {
relu_param_ = new ::opencv_caffe::ReLUParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.relu_param)
return relu_param_;
}
inline void LayerParameter::set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete relu_param_;
}
if (relu_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
relu_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, relu_param, submessage_arena);
}
set_has_relu_param();
} else {
clear_has_relu_param();
}
relu_param_ = relu_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.relu_param)
}
// optional .opencv_caffe.ReshapeParameter reshape_param = 133;
inline bool LayerParameter::has_reshape_param() const {
return (_has_bits_[1] & 0x00000008u) != 0;
}
inline void LayerParameter::set_has_reshape_param() {
_has_bits_[1] |= 0x00000008u;
}
inline void LayerParameter::clear_has_reshape_param() {
_has_bits_[1] &= ~0x00000008u;
}
inline void LayerParameter::clear_reshape_param() {
if (reshape_param_ != NULL) reshape_param_->Clear();
clear_has_reshape_param();
}
inline const ::opencv_caffe::ReshapeParameter& LayerParameter::reshape_param() const {
const ::opencv_caffe::ReshapeParameter* p = reshape_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.reshape_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ReshapeParameter*>(
&::opencv_caffe::_ReshapeParameter_default_instance_);
}
inline ::opencv_caffe::ReshapeParameter* LayerParameter::release_reshape_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.reshape_param)
clear_has_reshape_param();
::opencv_caffe::ReshapeParameter* temp = reshape_param_;
reshape_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ReshapeParameter* LayerParameter::mutable_reshape_param() {
set_has_reshape_param();
if (reshape_param_ == NULL) {
reshape_param_ = new ::opencv_caffe::ReshapeParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.reshape_param)
return reshape_param_;
}
inline void LayerParameter::set_allocated_reshape_param(::opencv_caffe::ReshapeParameter* reshape_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete reshape_param_;
}
if (reshape_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
reshape_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, reshape_param, submessage_arena);
}
set_has_reshape_param();
} else {
clear_has_reshape_param();
}
reshape_param_ = reshape_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.reshape_param)
}
// optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711;
inline bool LayerParameter::has_roi_pooling_param() const {
return (_has_bits_[1] & 0x00800000u) != 0;
}
inline void LayerParameter::set_has_roi_pooling_param() {
_has_bits_[1] |= 0x00800000u;
}
inline void LayerParameter::clear_has_roi_pooling_param() {
_has_bits_[1] &= ~0x00800000u;
}
inline void LayerParameter::clear_roi_pooling_param() {
if (roi_pooling_param_ != NULL) roi_pooling_param_->Clear();
clear_has_roi_pooling_param();
}
inline const ::opencv_caffe::ROIPoolingParameter& LayerParameter::roi_pooling_param() const {
const ::opencv_caffe::ROIPoolingParameter* p = roi_pooling_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.roi_pooling_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ROIPoolingParameter*>(
&::opencv_caffe::_ROIPoolingParameter_default_instance_);
}
inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::release_roi_pooling_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.roi_pooling_param)
clear_has_roi_pooling_param();
::opencv_caffe::ROIPoolingParameter* temp = roi_pooling_param_;
roi_pooling_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::mutable_roi_pooling_param() {
set_has_roi_pooling_param();
if (roi_pooling_param_ == NULL) {
roi_pooling_param_ = new ::opencv_caffe::ROIPoolingParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.roi_pooling_param)
return roi_pooling_param_;
}
inline void LayerParameter::set_allocated_roi_pooling_param(::opencv_caffe::ROIPoolingParameter* roi_pooling_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete roi_pooling_param_;
}
if (roi_pooling_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
roi_pooling_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, roi_pooling_param, submessage_arena);
}
set_has_roi_pooling_param();
} else {
clear_has_roi_pooling_param();
}
roi_pooling_param_ = roi_pooling_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.roi_pooling_param)
}
// optional .opencv_caffe.ScaleParameter scale_param = 142;
inline bool LayerParameter::has_scale_param() const {
return (_has_bits_[1] & 0x00001000u) != 0;
}
inline void LayerParameter::set_has_scale_param() {
_has_bits_[1] |= 0x00001000u;
}
inline void LayerParameter::clear_has_scale_param() {
_has_bits_[1] &= ~0x00001000u;
}
inline void LayerParameter::clear_scale_param() {
if (scale_param_ != NULL) scale_param_->Clear();
clear_has_scale_param();
}
inline const ::opencv_caffe::ScaleParameter& LayerParameter::scale_param() const {
const ::opencv_caffe::ScaleParameter* p = scale_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.scale_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ScaleParameter*>(
&::opencv_caffe::_ScaleParameter_default_instance_);
}
inline ::opencv_caffe::ScaleParameter* LayerParameter::release_scale_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.scale_param)
clear_has_scale_param();
::opencv_caffe::ScaleParameter* temp = scale_param_;
scale_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ScaleParameter* LayerParameter::mutable_scale_param() {
set_has_scale_param();
if (scale_param_ == NULL) {
scale_param_ = new ::opencv_caffe::ScaleParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.scale_param)
return scale_param_;
}
inline void LayerParameter::set_allocated_scale_param(::opencv_caffe::ScaleParameter* scale_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete scale_param_;
}
if (scale_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
scale_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, scale_param, submessage_arena);
}
set_has_scale_param();
} else {
clear_has_scale_param();
}
scale_param_ = scale_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.scale_param)
}
// optional .opencv_caffe.SigmoidParameter sigmoid_param = 124;
inline bool LayerParameter::has_sigmoid_param() const {
return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void LayerParameter::set_has_sigmoid_param() {
_has_bits_[0] |= 0x04000000u;
}
inline void LayerParameter::clear_has_sigmoid_param() {
_has_bits_[0] &= ~0x04000000u;
}
inline void LayerParameter::clear_sigmoid_param() {
if (sigmoid_param_ != NULL) sigmoid_param_->Clear();
clear_has_sigmoid_param();
}
inline const ::opencv_caffe::SigmoidParameter& LayerParameter::sigmoid_param() const {
const ::opencv_caffe::SigmoidParameter* p = sigmoid_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.sigmoid_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::SigmoidParameter*>(
&::opencv_caffe::_SigmoidParameter_default_instance_);
}
inline ::opencv_caffe::SigmoidParameter* LayerParameter::release_sigmoid_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.sigmoid_param)
clear_has_sigmoid_param();
::opencv_caffe::SigmoidParameter* temp = sigmoid_param_;
sigmoid_param_ = NULL;
return temp;
}
inline ::opencv_caffe::SigmoidParameter* LayerParameter::mutable_sigmoid_param() {
set_has_sigmoid_param();
if (sigmoid_param_ == NULL) {
sigmoid_param_ = new ::opencv_caffe::SigmoidParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.sigmoid_param)
return sigmoid_param_;
}
inline void LayerParameter::set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete sigmoid_param_;
}
if (sigmoid_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
sigmoid_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, sigmoid_param, submessage_arena);
}
set_has_sigmoid_param();
} else {
clear_has_sigmoid_param();
}
sigmoid_param_ = sigmoid_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.sigmoid_param)
}
// optional .opencv_caffe.SoftmaxParameter softmax_param = 125;
inline bool LayerParameter::has_softmax_param() const {
return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void LayerParameter::set_has_softmax_param() {
_has_bits_[0] |= 0x08000000u;
}
inline void LayerParameter::clear_has_softmax_param() {
_has_bits_[0] &= ~0x08000000u;
}
inline void LayerParameter::clear_softmax_param() {
if (softmax_param_ != NULL) softmax_param_->Clear();
clear_has_softmax_param();
}
inline const ::opencv_caffe::SoftmaxParameter& LayerParameter::softmax_param() const {
const ::opencv_caffe::SoftmaxParameter* p = softmax_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.softmax_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::SoftmaxParameter*>(
&::opencv_caffe::_SoftmaxParameter_default_instance_);
}
inline ::opencv_caffe::SoftmaxParameter* LayerParameter::release_softmax_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.softmax_param)
clear_has_softmax_param();
::opencv_caffe::SoftmaxParameter* temp = softmax_param_;
softmax_param_ = NULL;
return temp;
}
inline ::opencv_caffe::SoftmaxParameter* LayerParameter::mutable_softmax_param() {
set_has_softmax_param();
if (softmax_param_ == NULL) {
softmax_param_ = new ::opencv_caffe::SoftmaxParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.softmax_param)
return softmax_param_;
}
inline void LayerParameter::set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete softmax_param_;
}
if (softmax_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
softmax_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, softmax_param, submessage_arena);
}
set_has_softmax_param();
} else {
clear_has_softmax_param();
}
softmax_param_ = softmax_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.softmax_param)
}
// optional .opencv_caffe.SPPParameter spp_param = 132;
inline bool LayerParameter::has_spp_param() const {
return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void LayerParameter::set_has_spp_param() {
_has_bits_[1] |= 0x00000004u;
}
inline void LayerParameter::clear_has_spp_param() {
_has_bits_[1] &= ~0x00000004u;
}
inline void LayerParameter::clear_spp_param() {
if (spp_param_ != NULL) spp_param_->Clear();
clear_has_spp_param();
}
inline const ::opencv_caffe::SPPParameter& LayerParameter::spp_param() const {
const ::opencv_caffe::SPPParameter* p = spp_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.spp_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::SPPParameter*>(
&::opencv_caffe::_SPPParameter_default_instance_);
}
inline ::opencv_caffe::SPPParameter* LayerParameter::release_spp_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.spp_param)
clear_has_spp_param();
::opencv_caffe::SPPParameter* temp = spp_param_;
spp_param_ = NULL;
return temp;
}
inline ::opencv_caffe::SPPParameter* LayerParameter::mutable_spp_param() {
set_has_spp_param();
if (spp_param_ == NULL) {
spp_param_ = new ::opencv_caffe::SPPParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.spp_param)
return spp_param_;
}
inline void LayerParameter::set_allocated_spp_param(::opencv_caffe::SPPParameter* spp_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete spp_param_;
}
if (spp_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
spp_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, spp_param, submessage_arena);
}
set_has_spp_param();
} else {
clear_has_spp_param();
}
spp_param_ = spp_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.spp_param)
}
// optional .opencv_caffe.SliceParameter slice_param = 126;
inline bool LayerParameter::has_slice_param() const {
return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void LayerParameter::set_has_slice_param() {
_has_bits_[0] |= 0x10000000u;
}
inline void LayerParameter::clear_has_slice_param() {
_has_bits_[0] &= ~0x10000000u;
}
inline void LayerParameter::clear_slice_param() {
if (slice_param_ != NULL) slice_param_->Clear();
clear_has_slice_param();
}
inline const ::opencv_caffe::SliceParameter& LayerParameter::slice_param() const {
const ::opencv_caffe::SliceParameter* p = slice_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.slice_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::SliceParameter*>(
&::opencv_caffe::_SliceParameter_default_instance_);
}
inline ::opencv_caffe::SliceParameter* LayerParameter::release_slice_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.slice_param)
clear_has_slice_param();
::opencv_caffe::SliceParameter* temp = slice_param_;
slice_param_ = NULL;
return temp;
}
inline ::opencv_caffe::SliceParameter* LayerParameter::mutable_slice_param() {
set_has_slice_param();
if (slice_param_ == NULL) {
slice_param_ = new ::opencv_caffe::SliceParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.slice_param)
return slice_param_;
}
inline void LayerParameter::set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete slice_param_;
}
if (slice_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
slice_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, slice_param, submessage_arena);
}
set_has_slice_param();
} else {
clear_has_slice_param();
}
slice_param_ = slice_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.slice_param)
}
// optional .opencv_caffe.TanHParameter tanh_param = 127;
inline bool LayerParameter::has_tanh_param() const {
return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void LayerParameter::set_has_tanh_param() {
_has_bits_[0] |= 0x20000000u;
}
inline void LayerParameter::clear_has_tanh_param() {
_has_bits_[0] &= ~0x20000000u;
}
inline void LayerParameter::clear_tanh_param() {
if (tanh_param_ != NULL) tanh_param_->Clear();
clear_has_tanh_param();
}
inline const ::opencv_caffe::TanHParameter& LayerParameter::tanh_param() const {
const ::opencv_caffe::TanHParameter* p = tanh_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.tanh_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::TanHParameter*>(
&::opencv_caffe::_TanHParameter_default_instance_);
}
inline ::opencv_caffe::TanHParameter* LayerParameter::release_tanh_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.tanh_param)
clear_has_tanh_param();
::opencv_caffe::TanHParameter* temp = tanh_param_;
tanh_param_ = NULL;
return temp;
}
inline ::opencv_caffe::TanHParameter* LayerParameter::mutable_tanh_param() {
set_has_tanh_param();
if (tanh_param_ == NULL) {
tanh_param_ = new ::opencv_caffe::TanHParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.tanh_param)
return tanh_param_;
}
inline void LayerParameter::set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete tanh_param_;
}
if (tanh_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
tanh_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, tanh_param, submessage_arena);
}
set_has_tanh_param();
} else {
clear_has_tanh_param();
}
tanh_param_ = tanh_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.tanh_param)
}
// optional .opencv_caffe.ThresholdParameter threshold_param = 128;
inline bool LayerParameter::has_threshold_param() const {
return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void LayerParameter::set_has_threshold_param() {
_has_bits_[0] |= 0x40000000u;
}
inline void LayerParameter::clear_has_threshold_param() {
_has_bits_[0] &= ~0x40000000u;
}
inline void LayerParameter::clear_threshold_param() {
if (threshold_param_ != NULL) threshold_param_->Clear();
clear_has_threshold_param();
}
inline const ::opencv_caffe::ThresholdParameter& LayerParameter::threshold_param() const {
const ::opencv_caffe::ThresholdParameter* p = threshold_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.threshold_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ThresholdParameter*>(
&::opencv_caffe::_ThresholdParameter_default_instance_);
}
inline ::opencv_caffe::ThresholdParameter* LayerParameter::release_threshold_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.threshold_param)
clear_has_threshold_param();
::opencv_caffe::ThresholdParameter* temp = threshold_param_;
threshold_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ThresholdParameter* LayerParameter::mutable_threshold_param() {
set_has_threshold_param();
if (threshold_param_ == NULL) {
threshold_param_ = new ::opencv_caffe::ThresholdParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.threshold_param)
return threshold_param_;
}
inline void LayerParameter::set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete threshold_param_;
}
if (threshold_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
threshold_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, threshold_param, submessage_arena);
}
set_has_threshold_param();
} else {
clear_has_threshold_param();
}
threshold_param_ = threshold_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.threshold_param)
}
// optional .opencv_caffe.TileParameter tile_param = 138;
inline bool LayerParameter::has_tile_param() const {
return (_has_bits_[1] & 0x00000100u) != 0;
}
inline void LayerParameter::set_has_tile_param() {
_has_bits_[1] |= 0x00000100u;
}
inline void LayerParameter::clear_has_tile_param() {
_has_bits_[1] &= ~0x00000100u;
}
inline void LayerParameter::clear_tile_param() {
if (tile_param_ != NULL) tile_param_->Clear();
clear_has_tile_param();
}
inline const ::opencv_caffe::TileParameter& LayerParameter::tile_param() const {
const ::opencv_caffe::TileParameter* p = tile_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.tile_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::TileParameter*>(
&::opencv_caffe::_TileParameter_default_instance_);
}
inline ::opencv_caffe::TileParameter* LayerParameter::release_tile_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.tile_param)
clear_has_tile_param();
::opencv_caffe::TileParameter* temp = tile_param_;
tile_param_ = NULL;
return temp;
}
inline ::opencv_caffe::TileParameter* LayerParameter::mutable_tile_param() {
set_has_tile_param();
if (tile_param_ == NULL) {
tile_param_ = new ::opencv_caffe::TileParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.tile_param)
return tile_param_;
}
inline void LayerParameter::set_allocated_tile_param(::opencv_caffe::TileParameter* tile_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete tile_param_;
}
if (tile_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
tile_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, tile_param, submessage_arena);
}
set_has_tile_param();
} else {
clear_has_tile_param();
}
tile_param_ = tile_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.tile_param)
}
// optional .opencv_caffe.WindowDataParameter window_data_param = 129;
inline bool LayerParameter::has_window_data_param() const {
return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void LayerParameter::set_has_window_data_param() {
_has_bits_[0] |= 0x80000000u;
}
inline void LayerParameter::clear_has_window_data_param() {
_has_bits_[0] &= ~0x80000000u;
}
inline void LayerParameter::clear_window_data_param() {
if (window_data_param_ != NULL) window_data_param_->Clear();
clear_has_window_data_param();
}
inline const ::opencv_caffe::WindowDataParameter& LayerParameter::window_data_param() const {
const ::opencv_caffe::WindowDataParameter* p = window_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.window_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::WindowDataParameter*>(
&::opencv_caffe::_WindowDataParameter_default_instance_);
}
inline ::opencv_caffe::WindowDataParameter* LayerParameter::release_window_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.window_data_param)
clear_has_window_data_param();
::opencv_caffe::WindowDataParameter* temp = window_data_param_;
window_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::WindowDataParameter* LayerParameter::mutable_window_data_param() {
set_has_window_data_param();
if (window_data_param_ == NULL) {
window_data_param_ = new ::opencv_caffe::WindowDataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.window_data_param)
return window_data_param_;
}
inline void LayerParameter::set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete window_data_param_;
}
if (window_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
window_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, window_data_param, submessage_arena);
}
set_has_window_data_param();
} else {
clear_has_window_data_param();
}
window_data_param_ = window_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.window_data_param)
}
// -------------------------------------------------------------------
// TransformationParameter
// optional float scale = 1 [default = 1];
inline bool TransformationParameter::has_scale() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TransformationParameter::set_has_scale() {
_has_bits_[0] |= 0x00000020u;
}
inline void TransformationParameter::clear_has_scale() {
_has_bits_[0] &= ~0x00000020u;
}
inline void TransformationParameter::clear_scale() {
scale_ = 1;
clear_has_scale();
}
inline float TransformationParameter::scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.scale)
return scale_;
}
inline void TransformationParameter::set_scale(float value) {
set_has_scale();
scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.scale)
}
// optional bool mirror = 2 [default = false];
inline bool TransformationParameter::has_mirror() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TransformationParameter::set_has_mirror() {
_has_bits_[0] |= 0x00000004u;
}
inline void TransformationParameter::clear_has_mirror() {
_has_bits_[0] &= ~0x00000004u;
}
inline void TransformationParameter::clear_mirror() {
mirror_ = false;
clear_has_mirror();
}
inline bool TransformationParameter::mirror() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mirror)
return mirror_;
}
inline void TransformationParameter::set_mirror(bool value) {
set_has_mirror();
mirror_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.mirror)
}
// optional uint32 crop_size = 3 [default = 0];
inline bool TransformationParameter::has_crop_size() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TransformationParameter::set_has_crop_size() {
_has_bits_[0] |= 0x00000002u;
}
inline void TransformationParameter::clear_has_crop_size() {
_has_bits_[0] &= ~0x00000002u;
}
inline void TransformationParameter::clear_crop_size() {
crop_size_ = 0u;
clear_has_crop_size();
}
inline ::google::protobuf::uint32 TransformationParameter::crop_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.crop_size)
return crop_size_;
}
inline void TransformationParameter::set_crop_size(::google::protobuf::uint32 value) {
set_has_crop_size();
crop_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.crop_size)
}
// optional string mean_file = 4;
inline bool TransformationParameter::has_mean_file() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TransformationParameter::set_has_mean_file() {
_has_bits_[0] |= 0x00000001u;
}
inline void TransformationParameter::clear_has_mean_file() {
_has_bits_[0] &= ~0x00000001u;
}
inline void TransformationParameter::clear_mean_file() {
mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_mean_file();
}
inline const ::std::string& TransformationParameter::mean_file() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mean_file)
return mean_file_.GetNoArena();
}
inline void TransformationParameter::set_mean_file(const ::std::string& value) {
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.mean_file)
}
#if LANG_CXX11
inline void TransformationParameter::set_mean_file(::std::string&& value) {
set_has_mean_file();
mean_file_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.TransformationParameter.mean_file)
}
#endif
inline void TransformationParameter::set_mean_file(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.TransformationParameter.mean_file)
}
inline void TransformationParameter::set_mean_file(const char* value, size_t size) {
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.TransformationParameter.mean_file)
}
inline ::std::string* TransformationParameter::mutable_mean_file() {
set_has_mean_file();
// @@protoc_insertion_point(field_mutable:opencv_caffe.TransformationParameter.mean_file)
return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TransformationParameter::release_mean_file() {
// @@protoc_insertion_point(field_release:opencv_caffe.TransformationParameter.mean_file)
clear_has_mean_file();
return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TransformationParameter::set_allocated_mean_file(::std::string* mean_file) {
if (mean_file != NULL) {
set_has_mean_file();
} else {
clear_has_mean_file();
}
mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.TransformationParameter.mean_file)
}
// repeated float mean_value = 5;
inline int TransformationParameter::mean_value_size() const {
return mean_value_.size();
}
inline void TransformationParameter::clear_mean_value() {
mean_value_.Clear();
}
inline float TransformationParameter::mean_value(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mean_value)
return mean_value_.Get(index);
}
inline void TransformationParameter::set_mean_value(int index, float value) {
mean_value_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.mean_value)
}
inline void TransformationParameter::add_mean_value(float value) {
mean_value_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.TransformationParameter.mean_value)
}
inline const ::google::protobuf::RepeatedField< float >&
TransformationParameter::mean_value() const {
// @@protoc_insertion_point(field_list:opencv_caffe.TransformationParameter.mean_value)
return mean_value_;
}
inline ::google::protobuf::RepeatedField< float >*
TransformationParameter::mutable_mean_value() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.TransformationParameter.mean_value)
return &mean_value_;
}
// optional bool force_color = 6 [default = false];
inline bool TransformationParameter::has_force_color() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TransformationParameter::set_has_force_color() {
_has_bits_[0] |= 0x00000008u;
}
inline void TransformationParameter::clear_has_force_color() {
_has_bits_[0] &= ~0x00000008u;
}
inline void TransformationParameter::clear_force_color() {
force_color_ = false;
clear_has_force_color();
}
inline bool TransformationParameter::force_color() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.force_color)
return force_color_;
}
inline void TransformationParameter::set_force_color(bool value) {
set_has_force_color();
force_color_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.force_color)
}
// optional bool force_gray = 7 [default = false];
inline bool TransformationParameter::has_force_gray() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TransformationParameter::set_has_force_gray() {
_has_bits_[0] |= 0x00000010u;
}
inline void TransformationParameter::clear_has_force_gray() {
_has_bits_[0] &= ~0x00000010u;
}
inline void TransformationParameter::clear_force_gray() {
force_gray_ = false;
clear_has_force_gray();
}
inline bool TransformationParameter::force_gray() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.force_gray)
return force_gray_;
}
inline void TransformationParameter::set_force_gray(bool value) {
set_has_force_gray();
force_gray_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.force_gray)
}
// -------------------------------------------------------------------
// LossParameter
// optional int32 ignore_label = 1;
inline bool LossParameter::has_ignore_label() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LossParameter::set_has_ignore_label() {
_has_bits_[0] |= 0x00000001u;
}
inline void LossParameter::clear_has_ignore_label() {
_has_bits_[0] &= ~0x00000001u;
}
inline void LossParameter::clear_ignore_label() {
ignore_label_ = 0;
clear_has_ignore_label();
}
inline ::google::protobuf::int32 LossParameter::ignore_label() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.ignore_label)
return ignore_label_;
}
inline void LossParameter::set_ignore_label(::google::protobuf::int32 value) {
set_has_ignore_label();
ignore_label_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LossParameter.ignore_label)
}
// optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
inline bool LossParameter::has_normalization() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LossParameter::set_has_normalization() {
_has_bits_[0] |= 0x00000004u;
}
inline void LossParameter::clear_has_normalization() {
_has_bits_[0] &= ~0x00000004u;
}
inline void LossParameter::clear_normalization() {
normalization_ = 1;
clear_has_normalization();
}
inline ::opencv_caffe::LossParameter_NormalizationMode LossParameter::normalization() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.normalization)
return static_cast< ::opencv_caffe::LossParameter_NormalizationMode >(normalization_);
}
inline void LossParameter::set_normalization(::opencv_caffe::LossParameter_NormalizationMode value) {
assert(::opencv_caffe::LossParameter_NormalizationMode_IsValid(value));
set_has_normalization();
normalization_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LossParameter.normalization)
}
// optional bool normalize = 2;
inline bool LossParameter::has_normalize() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LossParameter::set_has_normalize() {
_has_bits_[0] |= 0x00000002u;
}
inline void LossParameter::clear_has_normalize() {
_has_bits_[0] &= ~0x00000002u;
}
inline void LossParameter::clear_normalize() {
normalize_ = false;
clear_has_normalize();
}
inline bool LossParameter::normalize() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.normalize)
return normalize_;
}
inline void LossParameter::set_normalize(bool value) {
set_has_normalize();
normalize_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LossParameter.normalize)
}
// -------------------------------------------------------------------
// AccuracyParameter
// optional uint32 top_k = 1 [default = 1];
inline bool AccuracyParameter::has_top_k() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AccuracyParameter::set_has_top_k() {
_has_bits_[0] |= 0x00000002u;
}
inline void AccuracyParameter::clear_has_top_k() {
_has_bits_[0] &= ~0x00000002u;
}
inline void AccuracyParameter::clear_top_k() {
top_k_ = 1u;
clear_has_top_k();
}
inline ::google::protobuf::uint32 AccuracyParameter::top_k() const {
// @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.top_k)
return top_k_;
}
inline void AccuracyParameter::set_top_k(::google::protobuf::uint32 value) {
set_has_top_k();
top_k_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.AccuracyParameter.top_k)
}
// optional int32 axis = 2 [default = 1];
inline bool AccuracyParameter::has_axis() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AccuracyParameter::set_has_axis() {
_has_bits_[0] |= 0x00000004u;
}
inline void AccuracyParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000004u;
}
inline void AccuracyParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 AccuracyParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.axis)
return axis_;
}
inline void AccuracyParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.AccuracyParameter.axis)
}
// optional int32 ignore_label = 3;
inline bool AccuracyParameter::has_ignore_label() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AccuracyParameter::set_has_ignore_label() {
_has_bits_[0] |= 0x00000001u;
}
inline void AccuracyParameter::clear_has_ignore_label() {
_has_bits_[0] &= ~0x00000001u;
}
inline void AccuracyParameter::clear_ignore_label() {
ignore_label_ = 0;
clear_has_ignore_label();
}
inline ::google::protobuf::int32 AccuracyParameter::ignore_label() const {
// @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.ignore_label)
return ignore_label_;
}
inline void AccuracyParameter::set_ignore_label(::google::protobuf::int32 value) {
set_has_ignore_label();
ignore_label_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.AccuracyParameter.ignore_label)
}
// -------------------------------------------------------------------
// ArgMaxParameter
// optional bool out_max_val = 1 [default = false];
inline bool ArgMaxParameter::has_out_max_val() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ArgMaxParameter::set_has_out_max_val() {
_has_bits_[0] |= 0x00000001u;
}
inline void ArgMaxParameter::clear_has_out_max_val() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ArgMaxParameter::clear_out_max_val() {
out_max_val_ = false;
clear_has_out_max_val();
}
inline bool ArgMaxParameter::out_max_val() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.out_max_val)
return out_max_val_;
}
inline void ArgMaxParameter::set_out_max_val(bool value) {
set_has_out_max_val();
out_max_val_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ArgMaxParameter.out_max_val)
}
// optional uint32 top_k = 2 [default = 1];
inline bool ArgMaxParameter::has_top_k() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ArgMaxParameter::set_has_top_k() {
_has_bits_[0] |= 0x00000004u;
}
inline void ArgMaxParameter::clear_has_top_k() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ArgMaxParameter::clear_top_k() {
top_k_ = 1u;
clear_has_top_k();
}
inline ::google::protobuf::uint32 ArgMaxParameter::top_k() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.top_k)
return top_k_;
}
inline void ArgMaxParameter::set_top_k(::google::protobuf::uint32 value) {
set_has_top_k();
top_k_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ArgMaxParameter.top_k)
}
// optional int32 axis = 3;
inline bool ArgMaxParameter::has_axis() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ArgMaxParameter::set_has_axis() {
_has_bits_[0] |= 0x00000002u;
}
inline void ArgMaxParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ArgMaxParameter::clear_axis() {
axis_ = 0;
clear_has_axis();
}
inline ::google::protobuf::int32 ArgMaxParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.axis)
return axis_;
}
inline void ArgMaxParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ArgMaxParameter.axis)
}
// -------------------------------------------------------------------
// ConcatParameter
// optional int32 axis = 2 [default = 1];
inline bool ConcatParameter::has_axis() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ConcatParameter::set_has_axis() {
_has_bits_[0] |= 0x00000002u;
}
inline void ConcatParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ConcatParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 ConcatParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConcatParameter.axis)
return axis_;
}
inline void ConcatParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConcatParameter.axis)
}
// optional uint32 concat_dim = 1 [default = 1];
inline bool ConcatParameter::has_concat_dim() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConcatParameter::set_has_concat_dim() {
_has_bits_[0] |= 0x00000001u;
}
inline void ConcatParameter::clear_has_concat_dim() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ConcatParameter::clear_concat_dim() {
concat_dim_ = 1u;
clear_has_concat_dim();
}
inline ::google::protobuf::uint32 ConcatParameter::concat_dim() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConcatParameter.concat_dim)
return concat_dim_;
}
inline void ConcatParameter::set_concat_dim(::google::protobuf::uint32 value) {
set_has_concat_dim();
concat_dim_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConcatParameter.concat_dim)
}
// -------------------------------------------------------------------
// BatchNormParameter
// optional bool use_global_stats = 1;
inline bool BatchNormParameter::has_use_global_stats() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BatchNormParameter::set_has_use_global_stats() {
_has_bits_[0] |= 0x00000001u;
}
inline void BatchNormParameter::clear_has_use_global_stats() {
_has_bits_[0] &= ~0x00000001u;
}
inline void BatchNormParameter::clear_use_global_stats() {
use_global_stats_ = false;
clear_has_use_global_stats();
}
inline bool BatchNormParameter::use_global_stats() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.use_global_stats)
return use_global_stats_;
}
inline void BatchNormParameter::set_use_global_stats(bool value) {
set_has_use_global_stats();
use_global_stats_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.use_global_stats)
}
// optional float moving_average_fraction = 2 [default = 0.999];
inline bool BatchNormParameter::has_moving_average_fraction() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BatchNormParameter::set_has_moving_average_fraction() {
_has_bits_[0] |= 0x00000004u;
}
inline void BatchNormParameter::clear_has_moving_average_fraction() {
_has_bits_[0] &= ~0x00000004u;
}
inline void BatchNormParameter::clear_moving_average_fraction() {
moving_average_fraction_ = 0.999f;
clear_has_moving_average_fraction();
}
inline float BatchNormParameter::moving_average_fraction() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.moving_average_fraction)
return moving_average_fraction_;
}
inline void BatchNormParameter::set_moving_average_fraction(float value) {
set_has_moving_average_fraction();
moving_average_fraction_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.moving_average_fraction)
}
// optional float eps = 3 [default = 1e-05];
inline bool BatchNormParameter::has_eps() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BatchNormParameter::set_has_eps() {
_has_bits_[0] |= 0x00000008u;
}
inline void BatchNormParameter::clear_has_eps() {
_has_bits_[0] &= ~0x00000008u;
}
inline void BatchNormParameter::clear_eps() {
eps_ = 1e-05f;
clear_has_eps();
}
inline float BatchNormParameter::eps() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.eps)
return eps_;
}
inline void BatchNormParameter::set_eps(float value) {
set_has_eps();
eps_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.eps)
}
// optional bool scale_bias = 7 [default = false];
inline bool BatchNormParameter::has_scale_bias() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BatchNormParameter::set_has_scale_bias() {
_has_bits_[0] |= 0x00000002u;
}
inline void BatchNormParameter::clear_has_scale_bias() {
_has_bits_[0] &= ~0x00000002u;
}
inline void BatchNormParameter::clear_scale_bias() {
scale_bias_ = false;
clear_has_scale_bias();
}
inline bool BatchNormParameter::scale_bias() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.scale_bias)
return scale_bias_;
}
inline void BatchNormParameter::set_scale_bias(bool value) {
set_has_scale_bias();
scale_bias_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.scale_bias)
}
// -------------------------------------------------------------------
// BiasParameter
// optional int32 axis = 1 [default = 1];
inline bool BiasParameter::has_axis() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BiasParameter::set_has_axis() {
_has_bits_[0] |= 0x00000002u;
}
inline void BiasParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000002u;
}
inline void BiasParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 BiasParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.axis)
return axis_;
}
inline void BiasParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BiasParameter.axis)
}
// optional int32 num_axes = 2 [default = 1];
inline bool BiasParameter::has_num_axes() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BiasParameter::set_has_num_axes() {
_has_bits_[0] |= 0x00000004u;
}
inline void BiasParameter::clear_has_num_axes() {
_has_bits_[0] &= ~0x00000004u;
}
inline void BiasParameter::clear_num_axes() {
num_axes_ = 1;
clear_has_num_axes();
}
inline ::google::protobuf::int32 BiasParameter::num_axes() const {
// @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.num_axes)
return num_axes_;
}
inline void BiasParameter::set_num_axes(::google::protobuf::int32 value) {
set_has_num_axes();
num_axes_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.BiasParameter.num_axes)
}
// optional .opencv_caffe.FillerParameter filler = 3;
inline bool BiasParameter::has_filler() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BiasParameter::set_has_filler() {
_has_bits_[0] |= 0x00000001u;
}
inline void BiasParameter::clear_has_filler() {
_has_bits_[0] &= ~0x00000001u;
}
inline void BiasParameter::clear_filler() {
if (filler_ != NULL) filler_->Clear();
clear_has_filler();
}
inline const ::opencv_caffe::FillerParameter& BiasParameter::filler() const {
const ::opencv_caffe::FillerParameter* p = filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* BiasParameter::release_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.BiasParameter.filler)
clear_has_filler();
::opencv_caffe::FillerParameter* temp = filler_;
filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* BiasParameter::mutable_filler() {
set_has_filler();
if (filler_ == NULL) {
filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.BiasParameter.filler)
return filler_;
}
inline void BiasParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete filler_;
}
if (filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, filler, submessage_arena);
}
set_has_filler();
} else {
clear_has_filler();
}
filler_ = filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.BiasParameter.filler)
}
// -------------------------------------------------------------------
// ContrastiveLossParameter
// optional float margin = 1 [default = 1];
inline bool ContrastiveLossParameter::has_margin() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ContrastiveLossParameter::set_has_margin() {
_has_bits_[0] |= 0x00000002u;
}
inline void ContrastiveLossParameter::clear_has_margin() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ContrastiveLossParameter::clear_margin() {
margin_ = 1;
clear_has_margin();
}
inline float ContrastiveLossParameter::margin() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ContrastiveLossParameter.margin)
return margin_;
}
inline void ContrastiveLossParameter::set_margin(float value) {
set_has_margin();
margin_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ContrastiveLossParameter.margin)
}
// optional bool legacy_version = 2 [default = false];
inline bool ContrastiveLossParameter::has_legacy_version() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ContrastiveLossParameter::set_has_legacy_version() {
_has_bits_[0] |= 0x00000001u;
}
inline void ContrastiveLossParameter::clear_has_legacy_version() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ContrastiveLossParameter::clear_legacy_version() {
legacy_version_ = false;
clear_has_legacy_version();
}
inline bool ContrastiveLossParameter::legacy_version() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ContrastiveLossParameter.legacy_version)
return legacy_version_;
}
inline void ContrastiveLossParameter::set_legacy_version(bool value) {
set_has_legacy_version();
legacy_version_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ContrastiveLossParameter.legacy_version)
}
// -------------------------------------------------------------------
// ConvolutionParameter
// optional uint32 num_output = 1;
inline bool ConvolutionParameter::has_num_output() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ConvolutionParameter::set_has_num_output() {
_has_bits_[0] |= 0x00000004u;
}
inline void ConvolutionParameter::clear_has_num_output() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ConvolutionParameter::clear_num_output() {
num_output_ = 0u;
clear_has_num_output();
}
inline ::google::protobuf::uint32 ConvolutionParameter::num_output() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.num_output)
return num_output_;
}
inline void ConvolutionParameter::set_num_output(::google::protobuf::uint32 value) {
set_has_num_output();
num_output_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.num_output)
}
// optional bool bias_term = 2 [default = true];
inline bool ConvolutionParameter::has_bias_term() const {
return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ConvolutionParameter::set_has_bias_term() {
_has_bits_[0] |= 0x00001000u;
}
inline void ConvolutionParameter::clear_has_bias_term() {
_has_bits_[0] &= ~0x00001000u;
}
inline void ConvolutionParameter::clear_bias_term() {
bias_term_ = true;
clear_has_bias_term();
}
inline bool ConvolutionParameter::bias_term() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.bias_term)
return bias_term_;
}
inline void ConvolutionParameter::set_bias_term(bool value) {
set_has_bias_term();
bias_term_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.bias_term)
}
// repeated uint32 pad = 3;
inline int ConvolutionParameter::pad_size() const {
return pad_.size();
}
inline void ConvolutionParameter::clear_pad() {
pad_.Clear();
}
inline ::google::protobuf::uint32 ConvolutionParameter::pad(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad)
return pad_.Get(index);
}
inline void ConvolutionParameter::set_pad(int index, ::google::protobuf::uint32 value) {
pad_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad)
}
inline void ConvolutionParameter::add_pad(::google::protobuf::uint32 value) {
pad_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.pad)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
ConvolutionParameter::pad() const {
// @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.pad)
return pad_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
ConvolutionParameter::mutable_pad() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.pad)
return &pad_;
}
// repeated uint32 kernel_size = 4;
inline int ConvolutionParameter::kernel_size_size() const {
return kernel_size_.size();
}
inline void ConvolutionParameter::clear_kernel_size() {
kernel_size_.Clear();
}
inline ::google::protobuf::uint32 ConvolutionParameter::kernel_size(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_size)
return kernel_size_.Get(index);
}
inline void ConvolutionParameter::set_kernel_size(int index, ::google::protobuf::uint32 value) {
kernel_size_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_size)
}
inline void ConvolutionParameter::add_kernel_size(::google::protobuf::uint32 value) {
kernel_size_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.kernel_size)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
ConvolutionParameter::kernel_size() const {
// @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.kernel_size)
return kernel_size_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
ConvolutionParameter::mutable_kernel_size() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.kernel_size)
return &kernel_size_;
}
// repeated uint32 stride = 6;
inline int ConvolutionParameter::stride_size() const {
return stride_.size();
}
inline void ConvolutionParameter::clear_stride() {
stride_.Clear();
}
inline ::google::protobuf::uint32 ConvolutionParameter::stride(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride)
return stride_.Get(index);
}
inline void ConvolutionParameter::set_stride(int index, ::google::protobuf::uint32 value) {
stride_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride)
}
inline void ConvolutionParameter::add_stride(::google::protobuf::uint32 value) {
stride_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.stride)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
ConvolutionParameter::stride() const {
// @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.stride)
return stride_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
ConvolutionParameter::mutable_stride() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.stride)
return &stride_;
}
// repeated uint32 dilation = 18;
inline int ConvolutionParameter::dilation_size() const {
return dilation_.size();
}
inline void ConvolutionParameter::clear_dilation() {
dilation_.Clear();
}
inline ::google::protobuf::uint32 ConvolutionParameter::dilation(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.dilation)
return dilation_.Get(index);
}
inline void ConvolutionParameter::set_dilation(int index, ::google::protobuf::uint32 value) {
dilation_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.dilation)
}
inline void ConvolutionParameter::add_dilation(::google::protobuf::uint32 value) {
dilation_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.dilation)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
ConvolutionParameter::dilation() const {
// @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.dilation)
return dilation_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
ConvolutionParameter::mutable_dilation() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.dilation)
return &dilation_;
}
// optional uint32 pad_h = 9 [default = 0];
inline bool ConvolutionParameter::has_pad_h() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ConvolutionParameter::set_has_pad_h() {
_has_bits_[0] |= 0x00000008u;
}
inline void ConvolutionParameter::clear_has_pad_h() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ConvolutionParameter::clear_pad_h() {
pad_h_ = 0u;
clear_has_pad_h();
}
inline ::google::protobuf::uint32 ConvolutionParameter::pad_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad_h)
return pad_h_;
}
inline void ConvolutionParameter::set_pad_h(::google::protobuf::uint32 value) {
set_has_pad_h();
pad_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad_h)
}
// optional uint32 pad_w = 10 [default = 0];
inline bool ConvolutionParameter::has_pad_w() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ConvolutionParameter::set_has_pad_w() {
_has_bits_[0] |= 0x00000010u;
}
inline void ConvolutionParameter::clear_has_pad_w() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ConvolutionParameter::clear_pad_w() {
pad_w_ = 0u;
clear_has_pad_w();
}
inline ::google::protobuf::uint32 ConvolutionParameter::pad_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad_w)
return pad_w_;
}
inline void ConvolutionParameter::set_pad_w(::google::protobuf::uint32 value) {
set_has_pad_w();
pad_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad_w)
}
// optional uint32 kernel_h = 11;
inline bool ConvolutionParameter::has_kernel_h() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ConvolutionParameter::set_has_kernel_h() {
_has_bits_[0] |= 0x00000020u;
}
inline void ConvolutionParameter::clear_has_kernel_h() {
_has_bits_[0] &= ~0x00000020u;
}
inline void ConvolutionParameter::clear_kernel_h() {
kernel_h_ = 0u;
clear_has_kernel_h();
}
inline ::google::protobuf::uint32 ConvolutionParameter::kernel_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_h)
return kernel_h_;
}
inline void ConvolutionParameter::set_kernel_h(::google::protobuf::uint32 value) {
set_has_kernel_h();
kernel_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_h)
}
// optional uint32 kernel_w = 12;
inline bool ConvolutionParameter::has_kernel_w() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ConvolutionParameter::set_has_kernel_w() {
_has_bits_[0] |= 0x00000040u;
}
inline void ConvolutionParameter::clear_has_kernel_w() {
_has_bits_[0] &= ~0x00000040u;
}
inline void ConvolutionParameter::clear_kernel_w() {
kernel_w_ = 0u;
clear_has_kernel_w();
}
inline ::google::protobuf::uint32 ConvolutionParameter::kernel_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_w)
return kernel_w_;
}
inline void ConvolutionParameter::set_kernel_w(::google::protobuf::uint32 value) {
set_has_kernel_w();
kernel_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_w)
}
// optional uint32 stride_h = 13;
inline bool ConvolutionParameter::has_stride_h() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ConvolutionParameter::set_has_stride_h() {
_has_bits_[0] |= 0x00000080u;
}
inline void ConvolutionParameter::clear_has_stride_h() {
_has_bits_[0] &= ~0x00000080u;
}
inline void ConvolutionParameter::clear_stride_h() {
stride_h_ = 0u;
clear_has_stride_h();
}
inline ::google::protobuf::uint32 ConvolutionParameter::stride_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride_h)
return stride_h_;
}
inline void ConvolutionParameter::set_stride_h(::google::protobuf::uint32 value) {
set_has_stride_h();
stride_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride_h)
}
// optional uint32 stride_w = 14;
inline bool ConvolutionParameter::has_stride_w() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ConvolutionParameter::set_has_stride_w() {
_has_bits_[0] |= 0x00000100u;
}
inline void ConvolutionParameter::clear_has_stride_w() {
_has_bits_[0] &= ~0x00000100u;
}
inline void ConvolutionParameter::clear_stride_w() {
stride_w_ = 0u;
clear_has_stride_w();
}
inline ::google::protobuf::uint32 ConvolutionParameter::stride_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride_w)
return stride_w_;
}
inline void ConvolutionParameter::set_stride_w(::google::protobuf::uint32 value) {
set_has_stride_w();
stride_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride_w)
}
// optional uint32 group = 5 [default = 1];
inline bool ConvolutionParameter::has_group() const {
return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ConvolutionParameter::set_has_group() {
_has_bits_[0] |= 0x00002000u;
}
inline void ConvolutionParameter::clear_has_group() {
_has_bits_[0] &= ~0x00002000u;
}
inline void ConvolutionParameter::clear_group() {
group_ = 1u;
clear_has_group();
}
inline ::google::protobuf::uint32 ConvolutionParameter::group() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.group)
return group_;
}
inline void ConvolutionParameter::set_group(::google::protobuf::uint32 value) {
set_has_group();
group_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.group)
}
// optional .opencv_caffe.FillerParameter weight_filler = 7;
inline bool ConvolutionParameter::has_weight_filler() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConvolutionParameter::set_has_weight_filler() {
_has_bits_[0] |= 0x00000001u;
}
inline void ConvolutionParameter::clear_has_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ConvolutionParameter::clear_weight_filler() {
if (weight_filler_ != NULL) weight_filler_->Clear();
clear_has_weight_filler();
}
inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::weight_filler() const {
const ::opencv_caffe::FillerParameter* p = weight_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.weight_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::release_weight_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.ConvolutionParameter.weight_filler)
clear_has_weight_filler();
::opencv_caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::mutable_weight_filler() {
set_has_weight_filler();
if (weight_filler_ == NULL) {
weight_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.ConvolutionParameter.weight_filler)
return weight_filler_;
}
inline void ConvolutionParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete weight_filler_;
}
if (weight_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
weight_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
set_has_weight_filler();
} else {
clear_has_weight_filler();
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ConvolutionParameter.weight_filler)
}
// optional .opencv_caffe.FillerParameter bias_filler = 8;
inline bool ConvolutionParameter::has_bias_filler() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ConvolutionParameter::set_has_bias_filler() {
_has_bits_[0] |= 0x00000002u;
}
inline void ConvolutionParameter::clear_has_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ConvolutionParameter::clear_bias_filler() {
if (bias_filler_ != NULL) bias_filler_->Clear();
clear_has_bias_filler();
}
inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::bias_filler() const {
const ::opencv_caffe::FillerParameter* p = bias_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.bias_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::release_bias_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.ConvolutionParameter.bias_filler)
clear_has_bias_filler();
::opencv_caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::mutable_bias_filler() {
set_has_bias_filler();
if (bias_filler_ == NULL) {
bias_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.ConvolutionParameter.bias_filler)
return bias_filler_;
}
inline void ConvolutionParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete bias_filler_;
}
if (bias_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
bias_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
set_has_bias_filler();
} else {
clear_has_bias_filler();
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ConvolutionParameter.bias_filler)
}
// optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
inline bool ConvolutionParameter::has_engine() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ConvolutionParameter::set_has_engine() {
_has_bits_[0] |= 0x00000200u;
}
inline void ConvolutionParameter::clear_has_engine() {
_has_bits_[0] &= ~0x00000200u;
}
inline void ConvolutionParameter::clear_engine() {
engine_ = 0;
clear_has_engine();
}
inline ::opencv_caffe::ConvolutionParameter_Engine ConvolutionParameter::engine() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.engine)
return static_cast< ::opencv_caffe::ConvolutionParameter_Engine >(engine_);
}
inline void ConvolutionParameter::set_engine(::opencv_caffe::ConvolutionParameter_Engine value) {
assert(::opencv_caffe::ConvolutionParameter_Engine_IsValid(value));
set_has_engine();
engine_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.engine)
}
// optional int32 axis = 16 [default = 1];
inline bool ConvolutionParameter::has_axis() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ConvolutionParameter::set_has_axis() {
_has_bits_[0] |= 0x00000800u;
}
inline void ConvolutionParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000800u;
}
inline void ConvolutionParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 ConvolutionParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.axis)
return axis_;
}
inline void ConvolutionParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.axis)
}
// optional bool force_nd_im2col = 17 [default = false];
inline bool ConvolutionParameter::has_force_nd_im2col() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ConvolutionParameter::set_has_force_nd_im2col() {
_has_bits_[0] |= 0x00000400u;
}
inline void ConvolutionParameter::clear_has_force_nd_im2col() {
_has_bits_[0] &= ~0x00000400u;
}
inline void ConvolutionParameter::clear_force_nd_im2col() {
force_nd_im2col_ = false;
clear_has_force_nd_im2col();
}
inline bool ConvolutionParameter::force_nd_im2col() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.force_nd_im2col)
return force_nd_im2col_;
}
inline void ConvolutionParameter::set_force_nd_im2col(bool value) {
set_has_force_nd_im2col();
force_nd_im2col_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.force_nd_im2col)
}
// -------------------------------------------------------------------
// CropParameter
// optional int32 axis = 1 [default = 2];
inline bool CropParameter::has_axis() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CropParameter::set_has_axis() {
_has_bits_[0] |= 0x00000001u;
}
inline void CropParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000001u;
}
inline void CropParameter::clear_axis() {
axis_ = 2;
clear_has_axis();
}
inline ::google::protobuf::int32 CropParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.CropParameter.axis)
return axis_;
}
inline void CropParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.CropParameter.axis)
}
// repeated uint32 offset = 2;
inline int CropParameter::offset_size() const {
return offset_.size();
}
inline void CropParameter::clear_offset() {
offset_.Clear();
}
inline ::google::protobuf::uint32 CropParameter::offset(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.CropParameter.offset)
return offset_.Get(index);
}
inline void CropParameter::set_offset(int index, ::google::protobuf::uint32 value) {
offset_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.CropParameter.offset)
}
inline void CropParameter::add_offset(::google::protobuf::uint32 value) {
offset_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.CropParameter.offset)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
CropParameter::offset() const {
// @@protoc_insertion_point(field_list:opencv_caffe.CropParameter.offset)
return offset_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
CropParameter::mutable_offset() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.CropParameter.offset)
return &offset_;
}
// -------------------------------------------------------------------
// DataParameter
// optional string source = 1;
inline bool DataParameter::has_source() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DataParameter::set_has_source() {
_has_bits_[0] |= 0x00000001u;
}
inline void DataParameter::clear_has_source() {
_has_bits_[0] &= ~0x00000001u;
}
inline void DataParameter::clear_source() {
source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_source();
}
inline const ::std::string& DataParameter::source() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.source)
return source_.GetNoArena();
}
inline void DataParameter::set_source(const ::std::string& value) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.source)
}
#if LANG_CXX11
inline void DataParameter::set_source(::std::string&& value) {
set_has_source();
source_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.DataParameter.source)
}
#endif
inline void DataParameter::set_source(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.DataParameter.source)
}
inline void DataParameter::set_source(const char* value, size_t size) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.DataParameter.source)
}
inline ::std::string* DataParameter::mutable_source() {
set_has_source();
// @@protoc_insertion_point(field_mutable:opencv_caffe.DataParameter.source)
return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataParameter::release_source() {
// @@protoc_insertion_point(field_release:opencv_caffe.DataParameter.source)
clear_has_source();
return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataParameter::set_allocated_source(::std::string* source) {
if (source != NULL) {
set_has_source();
} else {
clear_has_source();
}
source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.DataParameter.source)
}
// optional uint32 batch_size = 4;
inline bool DataParameter::has_batch_size() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DataParameter::set_has_batch_size() {
_has_bits_[0] |= 0x00000004u;
}
inline void DataParameter::clear_has_batch_size() {
_has_bits_[0] &= ~0x00000004u;
}
inline void DataParameter::clear_batch_size() {
batch_size_ = 0u;
clear_has_batch_size();
}
inline ::google::protobuf::uint32 DataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.batch_size)
return batch_size_;
}
inline void DataParameter::set_batch_size(::google::protobuf::uint32 value) {
set_has_batch_size();
batch_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.batch_size)
}
// optional uint32 rand_skip = 7 [default = 0];
inline bool DataParameter::has_rand_skip() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DataParameter::set_has_rand_skip() {
_has_bits_[0] |= 0x00000010u;
}
inline void DataParameter::clear_has_rand_skip() {
_has_bits_[0] &= ~0x00000010u;
}
inline void DataParameter::clear_rand_skip() {
rand_skip_ = 0u;
clear_has_rand_skip();
}
inline ::google::protobuf::uint32 DataParameter::rand_skip() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.rand_skip)
return rand_skip_;
}
inline void DataParameter::set_rand_skip(::google::protobuf::uint32 value) {
set_has_rand_skip();
rand_skip_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.rand_skip)
}
// optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB];
inline bool DataParameter::has_backend() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void DataParameter::set_has_backend() {
_has_bits_[0] |= 0x00000080u;
}
inline void DataParameter::clear_has_backend() {
_has_bits_[0] &= ~0x00000080u;
}
inline void DataParameter::clear_backend() {
backend_ = 0;
clear_has_backend();
}
inline ::opencv_caffe::DataParameter_DB DataParameter::backend() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.backend)
return static_cast< ::opencv_caffe::DataParameter_DB >(backend_);
}
inline void DataParameter::set_backend(::opencv_caffe::DataParameter_DB value) {
assert(::opencv_caffe::DataParameter_DB_IsValid(value));
set_has_backend();
backend_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.backend)
}
// optional float scale = 2 [default = 1];
inline bool DataParameter::has_scale() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void DataParameter::set_has_scale() {
_has_bits_[0] |= 0x00000100u;
}
inline void DataParameter::clear_has_scale() {
_has_bits_[0] &= ~0x00000100u;
}
inline void DataParameter::clear_scale() {
scale_ = 1;
clear_has_scale();
}
inline float DataParameter::scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.scale)
return scale_;
}
inline void DataParameter::set_scale(float value) {
set_has_scale();
scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.scale)
}
// optional string mean_file = 3;
inline bool DataParameter::has_mean_file() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DataParameter::set_has_mean_file() {
_has_bits_[0] |= 0x00000002u;
}
inline void DataParameter::clear_has_mean_file() {
_has_bits_[0] &= ~0x00000002u;
}
inline void DataParameter::clear_mean_file() {
mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_mean_file();
}
inline const ::std::string& DataParameter::mean_file() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.mean_file)
return mean_file_.GetNoArena();
}
inline void DataParameter::set_mean_file(const ::std::string& value) {
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.mean_file)
}
#if LANG_CXX11
inline void DataParameter::set_mean_file(::std::string&& value) {
set_has_mean_file();
mean_file_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.DataParameter.mean_file)
}
#endif
inline void DataParameter::set_mean_file(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.DataParameter.mean_file)
}
inline void DataParameter::set_mean_file(const char* value, size_t size) {
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.DataParameter.mean_file)
}
inline ::std::string* DataParameter::mutable_mean_file() {
set_has_mean_file();
// @@protoc_insertion_point(field_mutable:opencv_caffe.DataParameter.mean_file)
return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataParameter::release_mean_file() {
// @@protoc_insertion_point(field_release:opencv_caffe.DataParameter.mean_file)
clear_has_mean_file();
return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataParameter::set_allocated_mean_file(::std::string* mean_file) {
if (mean_file != NULL) {
set_has_mean_file();
} else {
clear_has_mean_file();
}
mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.DataParameter.mean_file)
}
// optional uint32 crop_size = 5 [default = 0];
inline bool DataParameter::has_crop_size() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DataParameter::set_has_crop_size() {
_has_bits_[0] |= 0x00000008u;
}
inline void DataParameter::clear_has_crop_size() {
_has_bits_[0] &= ~0x00000008u;
}
inline void DataParameter::clear_crop_size() {
crop_size_ = 0u;
clear_has_crop_size();
}
inline ::google::protobuf::uint32 DataParameter::crop_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.crop_size)
return crop_size_;
}
inline void DataParameter::set_crop_size(::google::protobuf::uint32 value) {
set_has_crop_size();
crop_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.crop_size)
}
// optional bool mirror = 6 [default = false];
inline bool DataParameter::has_mirror() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void DataParameter::set_has_mirror() {
_has_bits_[0] |= 0x00000020u;
}
inline void DataParameter::clear_has_mirror() {
_has_bits_[0] &= ~0x00000020u;
}
inline void DataParameter::clear_mirror() {
mirror_ = false;
clear_has_mirror();
}
inline bool DataParameter::mirror() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.mirror)
return mirror_;
}
inline void DataParameter::set_mirror(bool value) {
set_has_mirror();
mirror_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.mirror)
}
// optional bool force_encoded_color = 9 [default = false];
inline bool DataParameter::has_force_encoded_color() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void DataParameter::set_has_force_encoded_color() {
_has_bits_[0] |= 0x00000040u;
}
inline void DataParameter::clear_has_force_encoded_color() {
_has_bits_[0] &= ~0x00000040u;
}
inline void DataParameter::clear_force_encoded_color() {
force_encoded_color_ = false;
clear_has_force_encoded_color();
}
inline bool DataParameter::force_encoded_color() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.force_encoded_color)
return force_encoded_color_;
}
inline void DataParameter::set_force_encoded_color(bool value) {
set_has_force_encoded_color();
force_encoded_color_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.force_encoded_color)
}
// optional uint32 prefetch = 10 [default = 4];
inline bool DataParameter::has_prefetch() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void DataParameter::set_has_prefetch() {
_has_bits_[0] |= 0x00000200u;
}
inline void DataParameter::clear_has_prefetch() {
_has_bits_[0] &= ~0x00000200u;
}
inline void DataParameter::clear_prefetch() {
prefetch_ = 4u;
clear_has_prefetch();
}
inline ::google::protobuf::uint32 DataParameter::prefetch() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.prefetch)
return prefetch_;
}
inline void DataParameter::set_prefetch(::google::protobuf::uint32 value) {
set_has_prefetch();
prefetch_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.prefetch)
}
// -------------------------------------------------------------------
// NonMaximumSuppressionParameter
// optional float nms_threshold = 1 [default = 0.3];
inline bool NonMaximumSuppressionParameter::has_nms_threshold() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NonMaximumSuppressionParameter::set_has_nms_threshold() {
_has_bits_[0] |= 0x00000002u;
}
inline void NonMaximumSuppressionParameter::clear_has_nms_threshold() {
_has_bits_[0] &= ~0x00000002u;
}
inline void NonMaximumSuppressionParameter::clear_nms_threshold() {
nms_threshold_ = 0.3f;
clear_has_nms_threshold();
}
inline float NonMaximumSuppressionParameter::nms_threshold() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.nms_threshold)
return nms_threshold_;
}
inline void NonMaximumSuppressionParameter::set_nms_threshold(float value) {
set_has_nms_threshold();
nms_threshold_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.nms_threshold)
}
// optional int32 top_k = 2;
inline bool NonMaximumSuppressionParameter::has_top_k() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NonMaximumSuppressionParameter::set_has_top_k() {
_has_bits_[0] |= 0x00000001u;
}
inline void NonMaximumSuppressionParameter::clear_has_top_k() {
_has_bits_[0] &= ~0x00000001u;
}
inline void NonMaximumSuppressionParameter::clear_top_k() {
top_k_ = 0;
clear_has_top_k();
}
inline ::google::protobuf::int32 NonMaximumSuppressionParameter::top_k() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.top_k)
return top_k_;
}
inline void NonMaximumSuppressionParameter::set_top_k(::google::protobuf::int32 value) {
set_has_top_k();
top_k_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.top_k)
}
// optional float eta = 3 [default = 1];
inline bool NonMaximumSuppressionParameter::has_eta() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NonMaximumSuppressionParameter::set_has_eta() {
_has_bits_[0] |= 0x00000004u;
}
inline void NonMaximumSuppressionParameter::clear_has_eta() {
_has_bits_[0] &= ~0x00000004u;
}
inline void NonMaximumSuppressionParameter::clear_eta() {
eta_ = 1;
clear_has_eta();
}
inline float NonMaximumSuppressionParameter::eta() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.eta)
return eta_;
}
inline void NonMaximumSuppressionParameter::set_eta(float value) {
set_has_eta();
eta_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.eta)
}
// -------------------------------------------------------------------
// SaveOutputParameter
// optional string output_directory = 1;
inline bool SaveOutputParameter::has_output_directory() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SaveOutputParameter::set_has_output_directory() {
_has_bits_[0] |= 0x00000001u;
}
inline void SaveOutputParameter::clear_has_output_directory() {
_has_bits_[0] &= ~0x00000001u;
}
inline void SaveOutputParameter::clear_output_directory() {
output_directory_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_output_directory();
}
inline const ::std::string& SaveOutputParameter::output_directory() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_directory)
return output_directory_.GetNoArena();
}
inline void SaveOutputParameter::set_output_directory(const ::std::string& value) {
set_has_output_directory();
output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_directory)
}
#if LANG_CXX11
inline void SaveOutputParameter::set_output_directory(::std::string&& value) {
set_has_output_directory();
output_directory_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SaveOutputParameter.output_directory)
}
#endif
inline void SaveOutputParameter::set_output_directory(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_output_directory();
output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SaveOutputParameter.output_directory)
}
inline void SaveOutputParameter::set_output_directory(const char* value, size_t size) {
set_has_output_directory();
output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SaveOutputParameter.output_directory)
}
inline ::std::string* SaveOutputParameter::mutable_output_directory() {
set_has_output_directory();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_directory)
return output_directory_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SaveOutputParameter::release_output_directory() {
// @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_directory)
clear_has_output_directory();
return output_directory_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SaveOutputParameter::set_allocated_output_directory(::std::string* output_directory) {
if (output_directory != NULL) {
set_has_output_directory();
} else {
clear_has_output_directory();
}
output_directory_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_directory);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_directory)
}
// optional string output_name_prefix = 2;
inline bool SaveOutputParameter::has_output_name_prefix() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SaveOutputParameter::set_has_output_name_prefix() {
_has_bits_[0] |= 0x00000002u;
}
inline void SaveOutputParameter::clear_has_output_name_prefix() {
_has_bits_[0] &= ~0x00000002u;
}
inline void SaveOutputParameter::clear_output_name_prefix() {
output_name_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_output_name_prefix();
}
inline const ::std::string& SaveOutputParameter::output_name_prefix() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_name_prefix)
return output_name_prefix_.GetNoArena();
}
inline void SaveOutputParameter::set_output_name_prefix(const ::std::string& value) {
set_has_output_name_prefix();
output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_name_prefix)
}
#if LANG_CXX11
inline void SaveOutputParameter::set_output_name_prefix(::std::string&& value) {
set_has_output_name_prefix();
output_name_prefix_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SaveOutputParameter.output_name_prefix)
}
#endif
inline void SaveOutputParameter::set_output_name_prefix(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_output_name_prefix();
output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SaveOutputParameter.output_name_prefix)
}
inline void SaveOutputParameter::set_output_name_prefix(const char* value, size_t size) {
set_has_output_name_prefix();
output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SaveOutputParameter.output_name_prefix)
}
inline ::std::string* SaveOutputParameter::mutable_output_name_prefix() {
set_has_output_name_prefix();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_name_prefix)
return output_name_prefix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SaveOutputParameter::release_output_name_prefix() {
// @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_name_prefix)
clear_has_output_name_prefix();
return output_name_prefix_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SaveOutputParameter::set_allocated_output_name_prefix(::std::string* output_name_prefix) {
if (output_name_prefix != NULL) {
set_has_output_name_prefix();
} else {
clear_has_output_name_prefix();
}
output_name_prefix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_name_prefix);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_name_prefix)
}
// optional string output_format = 3;
inline bool SaveOutputParameter::has_output_format() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SaveOutputParameter::set_has_output_format() {
_has_bits_[0] |= 0x00000004u;
}
inline void SaveOutputParameter::clear_has_output_format() {
_has_bits_[0] &= ~0x00000004u;
}
inline void SaveOutputParameter::clear_output_format() {
output_format_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_output_format();
}
inline const ::std::string& SaveOutputParameter::output_format() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_format)
return output_format_.GetNoArena();
}
inline void SaveOutputParameter::set_output_format(const ::std::string& value) {
set_has_output_format();
output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_format)
}
#if LANG_CXX11
inline void SaveOutputParameter::set_output_format(::std::string&& value) {
set_has_output_format();
output_format_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SaveOutputParameter.output_format)
}
#endif
inline void SaveOutputParameter::set_output_format(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_output_format();
output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SaveOutputParameter.output_format)
}
inline void SaveOutputParameter::set_output_format(const char* value, size_t size) {
set_has_output_format();
output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SaveOutputParameter.output_format)
}
inline ::std::string* SaveOutputParameter::mutable_output_format() {
set_has_output_format();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_format)
return output_format_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SaveOutputParameter::release_output_format() {
// @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_format)
clear_has_output_format();
return output_format_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SaveOutputParameter::set_allocated_output_format(::std::string* output_format) {
if (output_format != NULL) {
set_has_output_format();
} else {
clear_has_output_format();
}
output_format_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_format);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_format)
}
// optional string label_map_file = 4;
inline bool SaveOutputParameter::has_label_map_file() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SaveOutputParameter::set_has_label_map_file() {
_has_bits_[0] |= 0x00000008u;
}
inline void SaveOutputParameter::clear_has_label_map_file() {
_has_bits_[0] &= ~0x00000008u;
}
inline void SaveOutputParameter::clear_label_map_file() {
label_map_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_label_map_file();
}
inline const ::std::string& SaveOutputParameter::label_map_file() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.label_map_file)
return label_map_file_.GetNoArena();
}
inline void SaveOutputParameter::set_label_map_file(const ::std::string& value) {
set_has_label_map_file();
label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.label_map_file)
}
#if LANG_CXX11
inline void SaveOutputParameter::set_label_map_file(::std::string&& value) {
set_has_label_map_file();
label_map_file_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SaveOutputParameter.label_map_file)
}
#endif
inline void SaveOutputParameter::set_label_map_file(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_label_map_file();
label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SaveOutputParameter.label_map_file)
}
inline void SaveOutputParameter::set_label_map_file(const char* value, size_t size) {
set_has_label_map_file();
label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SaveOutputParameter.label_map_file)
}
inline ::std::string* SaveOutputParameter::mutable_label_map_file() {
set_has_label_map_file();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.label_map_file)
return label_map_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SaveOutputParameter::release_label_map_file() {
// @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.label_map_file)
clear_has_label_map_file();
return label_map_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SaveOutputParameter::set_allocated_label_map_file(::std::string* label_map_file) {
if (label_map_file != NULL) {
set_has_label_map_file();
} else {
clear_has_label_map_file();
}
label_map_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), label_map_file);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.label_map_file)
}
// optional string name_size_file = 5;
inline bool SaveOutputParameter::has_name_size_file() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SaveOutputParameter::set_has_name_size_file() {
_has_bits_[0] |= 0x00000010u;
}
inline void SaveOutputParameter::clear_has_name_size_file() {
_has_bits_[0] &= ~0x00000010u;
}
inline void SaveOutputParameter::clear_name_size_file() {
name_size_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name_size_file();
}
inline const ::std::string& SaveOutputParameter::name_size_file() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.name_size_file)
return name_size_file_.GetNoArena();
}
inline void SaveOutputParameter::set_name_size_file(const ::std::string& value) {
set_has_name_size_file();
name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.name_size_file)
}
#if LANG_CXX11
inline void SaveOutputParameter::set_name_size_file(::std::string&& value) {
set_has_name_size_file();
name_size_file_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.SaveOutputParameter.name_size_file)
}
#endif
inline void SaveOutputParameter::set_name_size_file(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_name_size_file();
name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.SaveOutputParameter.name_size_file)
}
inline void SaveOutputParameter::set_name_size_file(const char* value, size_t size) {
set_has_name_size_file();
name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.SaveOutputParameter.name_size_file)
}
inline ::std::string* SaveOutputParameter::mutable_name_size_file() {
set_has_name_size_file();
// @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.name_size_file)
return name_size_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SaveOutputParameter::release_name_size_file() {
// @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.name_size_file)
clear_has_name_size_file();
return name_size_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SaveOutputParameter::set_allocated_name_size_file(::std::string* name_size_file) {
if (name_size_file != NULL) {
set_has_name_size_file();
} else {
clear_has_name_size_file();
}
name_size_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name_size_file);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.name_size_file)
}
// optional uint32 num_test_image = 6;
inline bool SaveOutputParameter::has_num_test_image() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void SaveOutputParameter::set_has_num_test_image() {
_has_bits_[0] |= 0x00000020u;
}
inline void SaveOutputParameter::clear_has_num_test_image() {
_has_bits_[0] &= ~0x00000020u;
}
inline void SaveOutputParameter::clear_num_test_image() {
num_test_image_ = 0u;
clear_has_num_test_image();
}
inline ::google::protobuf::uint32 SaveOutputParameter::num_test_image() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.num_test_image)
return num_test_image_;
}
inline void SaveOutputParameter::set_num_test_image(::google::protobuf::uint32 value) {
set_has_num_test_image();
num_test_image_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.num_test_image)
}
// -------------------------------------------------------------------
// DropoutParameter
// optional float dropout_ratio = 1 [default = 0.5];
inline bool DropoutParameter::has_dropout_ratio() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DropoutParameter::set_has_dropout_ratio() {
_has_bits_[0] |= 0x00000001u;
}
inline void DropoutParameter::clear_has_dropout_ratio() {
_has_bits_[0] &= ~0x00000001u;
}
inline void DropoutParameter::clear_dropout_ratio() {
dropout_ratio_ = 0.5f;
clear_has_dropout_ratio();
}
inline float DropoutParameter::dropout_ratio() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DropoutParameter.dropout_ratio)
return dropout_ratio_;
}
inline void DropoutParameter::set_dropout_ratio(float value) {
set_has_dropout_ratio();
dropout_ratio_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DropoutParameter.dropout_ratio)
}
// optional bool scale_train = 2 [default = true];
inline bool DropoutParameter::has_scale_train() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DropoutParameter::set_has_scale_train() {
_has_bits_[0] |= 0x00000002u;
}
inline void DropoutParameter::clear_has_scale_train() {
_has_bits_[0] &= ~0x00000002u;
}
inline void DropoutParameter::clear_scale_train() {
scale_train_ = true;
clear_has_scale_train();
}
inline bool DropoutParameter::scale_train() const {
// @@protoc_insertion_point(field_get:opencv_caffe.DropoutParameter.scale_train)
return scale_train_;
}
inline void DropoutParameter::set_scale_train(bool value) {
set_has_scale_train();
scale_train_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.DropoutParameter.scale_train)
}
// -------------------------------------------------------------------
// DummyDataParameter
// repeated .opencv_caffe.FillerParameter data_filler = 1;
inline int DummyDataParameter::data_filler_size() const {
return data_filler_.size();
}
inline void DummyDataParameter::clear_data_filler() {
data_filler_.Clear();
}
inline const ::opencv_caffe::FillerParameter& DummyDataParameter::data_filler(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.data_filler)
return data_filler_.Get(index);
}
inline ::opencv_caffe::FillerParameter* DummyDataParameter::mutable_data_filler(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.DummyDataParameter.data_filler)
return data_filler_.Mutable(index);
}
inline ::opencv_caffe::FillerParameter* DummyDataParameter::add_data_filler() {
// @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.data_filler)
return data_filler_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::FillerParameter >*
DummyDataParameter::mutable_data_filler() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.data_filler)
return &data_filler_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::FillerParameter >&
DummyDataParameter::data_filler() const {
// @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.data_filler)
return data_filler_;
}
// repeated .opencv_caffe.BlobShape shape = 6;
inline int DummyDataParameter::shape_size() const {
return shape_.size();
}
inline void DummyDataParameter::clear_shape() {
shape_.Clear();
}
inline const ::opencv_caffe::BlobShape& DummyDataParameter::shape(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.shape)
return shape_.Get(index);
}
inline ::opencv_caffe::BlobShape* DummyDataParameter::mutable_shape(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.DummyDataParameter.shape)
return shape_.Mutable(index);
}
inline ::opencv_caffe::BlobShape* DummyDataParameter::add_shape() {
// @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.shape)
return shape_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >*
DummyDataParameter::mutable_shape() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.shape)
return &shape_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >&
DummyDataParameter::shape() const {
// @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.shape)
return shape_;
}
// repeated uint32 num = 2;
inline int DummyDataParameter::num_size() const {
return num_.size();
}
inline void DummyDataParameter::clear_num() {
num_.Clear();
}
inline ::google::protobuf::uint32 DummyDataParameter::num(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.num)
return num_.Get(index);
}
inline void DummyDataParameter::set_num(int index, ::google::protobuf::uint32 value) {
num_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.num)
}
inline void DummyDataParameter::add_num(::google::protobuf::uint32 value) {
num_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.num)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DummyDataParameter::num() const {
// @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.num)
return num_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DummyDataParameter::mutable_num() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.num)
return &num_;
}
// repeated uint32 channels = 3;
inline int DummyDataParameter::channels_size() const {
return channels_.size();
}
inline void DummyDataParameter::clear_channels() {
channels_.Clear();
}
inline ::google::protobuf::uint32 DummyDataParameter::channels(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.channels)
return channels_.Get(index);
}
inline void DummyDataParameter::set_channels(int index, ::google::protobuf::uint32 value) {
channels_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.channels)
}
inline void DummyDataParameter::add_channels(::google::protobuf::uint32 value) {
channels_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.channels)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DummyDataParameter::channels() const {
// @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.channels)
return channels_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DummyDataParameter::mutable_channels() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.channels)
return &channels_;
}
// repeated uint32 height = 4;
inline int DummyDataParameter::height_size() const {
return height_.size();
}
inline void DummyDataParameter::clear_height() {
height_.Clear();
}
inline ::google::protobuf::uint32 DummyDataParameter::height(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.height)
return height_.Get(index);
}
inline void DummyDataParameter::set_height(int index, ::google::protobuf::uint32 value) {
height_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.height)
}
inline void DummyDataParameter::add_height(::google::protobuf::uint32 value) {
height_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.height)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DummyDataParameter::height() const {
// @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.height)
return height_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DummyDataParameter::mutable_height() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.height)
return &height_;
}
// repeated uint32 width = 5;
inline int DummyDataParameter::width_size() const {
return width_.size();
}
inline void DummyDataParameter::clear_width() {
width_.Clear();
}
inline ::google::protobuf::uint32 DummyDataParameter::width(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.width)
return width_.Get(index);
}
inline void DummyDataParameter::set_width(int index, ::google::protobuf::uint32 value) {
width_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.width)
}
inline void DummyDataParameter::add_width(::google::protobuf::uint32 value) {
width_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.width)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DummyDataParameter::width() const {
// @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.width)
return width_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DummyDataParameter::mutable_width() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.width)
return &width_;
}
// -------------------------------------------------------------------
// EltwiseParameter
// optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
inline bool EltwiseParameter::has_operation() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EltwiseParameter::set_has_operation() {
_has_bits_[0] |= 0x00000001u;
}
inline void EltwiseParameter::clear_has_operation() {
_has_bits_[0] &= ~0x00000001u;
}
inline void EltwiseParameter::clear_operation() {
operation_ = 1;
clear_has_operation();
}
inline ::opencv_caffe::EltwiseParameter_EltwiseOp EltwiseParameter::operation() const {
// @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.operation)
return static_cast< ::opencv_caffe::EltwiseParameter_EltwiseOp >(operation_);
}
inline void EltwiseParameter::set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value) {
assert(::opencv_caffe::EltwiseParameter_EltwiseOp_IsValid(value));
set_has_operation();
operation_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.EltwiseParameter.operation)
}
// repeated float coeff = 2;
inline int EltwiseParameter::coeff_size() const {
return coeff_.size();
}
inline void EltwiseParameter::clear_coeff() {
coeff_.Clear();
}
inline float EltwiseParameter::coeff(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.coeff)
return coeff_.Get(index);
}
inline void EltwiseParameter::set_coeff(int index, float value) {
coeff_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.EltwiseParameter.coeff)
}
inline void EltwiseParameter::add_coeff(float value) {
coeff_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.EltwiseParameter.coeff)
}
inline const ::google::protobuf::RepeatedField< float >&
EltwiseParameter::coeff() const {
// @@protoc_insertion_point(field_list:opencv_caffe.EltwiseParameter.coeff)
return coeff_;
}
inline ::google::protobuf::RepeatedField< float >*
EltwiseParameter::mutable_coeff() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.EltwiseParameter.coeff)
return &coeff_;
}
// optional bool stable_prod_grad = 3 [default = true];
inline bool EltwiseParameter::has_stable_prod_grad() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EltwiseParameter::set_has_stable_prod_grad() {
_has_bits_[0] |= 0x00000002u;
}
inline void EltwiseParameter::clear_has_stable_prod_grad() {
_has_bits_[0] &= ~0x00000002u;
}
inline void EltwiseParameter::clear_stable_prod_grad() {
stable_prod_grad_ = true;
clear_has_stable_prod_grad();
}
inline bool EltwiseParameter::stable_prod_grad() const {
// @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.stable_prod_grad)
return stable_prod_grad_;
}
inline void EltwiseParameter::set_stable_prod_grad(bool value) {
set_has_stable_prod_grad();
stable_prod_grad_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.EltwiseParameter.stable_prod_grad)
}
// -------------------------------------------------------------------
// ELUParameter
// optional float alpha = 1 [default = 1];
inline bool ELUParameter::has_alpha() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ELUParameter::set_has_alpha() {
_has_bits_[0] |= 0x00000001u;
}
inline void ELUParameter::clear_has_alpha() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ELUParameter::clear_alpha() {
alpha_ = 1;
clear_has_alpha();
}
inline float ELUParameter::alpha() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ELUParameter.alpha)
return alpha_;
}
inline void ELUParameter::set_alpha(float value) {
set_has_alpha();
alpha_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ELUParameter.alpha)
}
// -------------------------------------------------------------------
// EmbedParameter
// optional uint32 num_output = 1;
inline bool EmbedParameter::has_num_output() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void EmbedParameter::set_has_num_output() {
_has_bits_[0] |= 0x00000004u;
}
inline void EmbedParameter::clear_has_num_output() {
_has_bits_[0] &= ~0x00000004u;
}
inline void EmbedParameter::clear_num_output() {
num_output_ = 0u;
clear_has_num_output();
}
inline ::google::protobuf::uint32 EmbedParameter::num_output() const {
// @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.num_output)
return num_output_;
}
inline void EmbedParameter::set_num_output(::google::protobuf::uint32 value) {
set_has_num_output();
num_output_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.num_output)
}
// optional uint32 input_dim = 2;
inline bool EmbedParameter::has_input_dim() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void EmbedParameter::set_has_input_dim() {
_has_bits_[0] |= 0x00000008u;
}
inline void EmbedParameter::clear_has_input_dim() {
_has_bits_[0] &= ~0x00000008u;
}
inline void EmbedParameter::clear_input_dim() {
input_dim_ = 0u;
clear_has_input_dim();
}
inline ::google::protobuf::uint32 EmbedParameter::input_dim() const {
// @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.input_dim)
return input_dim_;
}
inline void EmbedParameter::set_input_dim(::google::protobuf::uint32 value) {
set_has_input_dim();
input_dim_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.input_dim)
}
// optional bool bias_term = 3 [default = true];
inline bool EmbedParameter::has_bias_term() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void EmbedParameter::set_has_bias_term() {
_has_bits_[0] |= 0x00000010u;
}
inline void EmbedParameter::clear_has_bias_term() {
_has_bits_[0] &= ~0x00000010u;
}
inline void EmbedParameter::clear_bias_term() {
bias_term_ = true;
clear_has_bias_term();
}
inline bool EmbedParameter::bias_term() const {
// @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.bias_term)
return bias_term_;
}
inline void EmbedParameter::set_bias_term(bool value) {
set_has_bias_term();
bias_term_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.bias_term)
}
// optional .opencv_caffe.FillerParameter weight_filler = 4;
inline bool EmbedParameter::has_weight_filler() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EmbedParameter::set_has_weight_filler() {
_has_bits_[0] |= 0x00000001u;
}
inline void EmbedParameter::clear_has_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
}
inline void EmbedParameter::clear_weight_filler() {
if (weight_filler_ != NULL) weight_filler_->Clear();
clear_has_weight_filler();
}
inline const ::opencv_caffe::FillerParameter& EmbedParameter::weight_filler() const {
const ::opencv_caffe::FillerParameter* p = weight_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.weight_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::release_weight_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.EmbedParameter.weight_filler)
clear_has_weight_filler();
::opencv_caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::mutable_weight_filler() {
set_has_weight_filler();
if (weight_filler_ == NULL) {
weight_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.EmbedParameter.weight_filler)
return weight_filler_;
}
inline void EmbedParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete weight_filler_;
}
if (weight_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
weight_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
set_has_weight_filler();
} else {
clear_has_weight_filler();
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.EmbedParameter.weight_filler)
}
// optional .opencv_caffe.FillerParameter bias_filler = 5;
inline bool EmbedParameter::has_bias_filler() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EmbedParameter::set_has_bias_filler() {
_has_bits_[0] |= 0x00000002u;
}
inline void EmbedParameter::clear_has_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
}
inline void EmbedParameter::clear_bias_filler() {
if (bias_filler_ != NULL) bias_filler_->Clear();
clear_has_bias_filler();
}
inline const ::opencv_caffe::FillerParameter& EmbedParameter::bias_filler() const {
const ::opencv_caffe::FillerParameter* p = bias_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.bias_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::release_bias_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.EmbedParameter.bias_filler)
clear_has_bias_filler();
::opencv_caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::mutable_bias_filler() {
set_has_bias_filler();
if (bias_filler_ == NULL) {
bias_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.EmbedParameter.bias_filler)
return bias_filler_;
}
inline void EmbedParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete bias_filler_;
}
if (bias_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
bias_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
set_has_bias_filler();
} else {
clear_has_bias_filler();
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.EmbedParameter.bias_filler)
}
// -------------------------------------------------------------------
// ExpParameter
// optional float base = 1 [default = -1];
inline bool ExpParameter::has_base() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ExpParameter::set_has_base() {
_has_bits_[0] |= 0x00000002u;
}
inline void ExpParameter::clear_has_base() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ExpParameter::clear_base() {
base_ = -1;
clear_has_base();
}
inline float ExpParameter::base() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.base)
return base_;
}
inline void ExpParameter::set_base(float value) {
set_has_base();
base_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.base)
}
// optional float scale = 2 [default = 1];
inline bool ExpParameter::has_scale() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ExpParameter::set_has_scale() {
_has_bits_[0] |= 0x00000004u;
}
inline void ExpParameter::clear_has_scale() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ExpParameter::clear_scale() {
scale_ = 1;
clear_has_scale();
}
inline float ExpParameter::scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.scale)
return scale_;
}
inline void ExpParameter::set_scale(float value) {
set_has_scale();
scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.scale)
}
// optional float shift = 3 [default = 0];
inline bool ExpParameter::has_shift() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ExpParameter::set_has_shift() {
_has_bits_[0] |= 0x00000001u;
}
inline void ExpParameter::clear_has_shift() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ExpParameter::clear_shift() {
shift_ = 0;
clear_has_shift();
}
inline float ExpParameter::shift() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.shift)
return shift_;
}
inline void ExpParameter::set_shift(float value) {
set_has_shift();
shift_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.shift)
}
// -------------------------------------------------------------------
// FlattenParameter
// optional int32 axis = 1 [default = 1];
inline bool FlattenParameter::has_axis() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FlattenParameter::set_has_axis() {
_has_bits_[0] |= 0x00000001u;
}
inline void FlattenParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000001u;
}
inline void FlattenParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 FlattenParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FlattenParameter.axis)
return axis_;
}
inline void FlattenParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FlattenParameter.axis)
}
// optional int32 end_axis = 2 [default = -1];
inline bool FlattenParameter::has_end_axis() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FlattenParameter::set_has_end_axis() {
_has_bits_[0] |= 0x00000002u;
}
inline void FlattenParameter::clear_has_end_axis() {
_has_bits_[0] &= ~0x00000002u;
}
inline void FlattenParameter::clear_end_axis() {
end_axis_ = -1;
clear_has_end_axis();
}
inline ::google::protobuf::int32 FlattenParameter::end_axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.FlattenParameter.end_axis)
return end_axis_;
}
inline void FlattenParameter::set_end_axis(::google::protobuf::int32 value) {
set_has_end_axis();
end_axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.FlattenParameter.end_axis)
}
// -------------------------------------------------------------------
// HDF5DataParameter
// optional string source = 1;
inline bool HDF5DataParameter::has_source() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HDF5DataParameter::set_has_source() {
_has_bits_[0] |= 0x00000001u;
}
inline void HDF5DataParameter::clear_has_source() {
_has_bits_[0] &= ~0x00000001u;
}
inline void HDF5DataParameter::clear_source() {
source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_source();
}
inline const ::std::string& HDF5DataParameter::source() const {
// @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.source)
return source_.GetNoArena();
}
inline void HDF5DataParameter::set_source(const ::std::string& value) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.source)
}
#if LANG_CXX11
inline void HDF5DataParameter::set_source(::std::string&& value) {
set_has_source();
source_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.HDF5DataParameter.source)
}
#endif
inline void HDF5DataParameter::set_source(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.HDF5DataParameter.source)
}
inline void HDF5DataParameter::set_source(const char* value, size_t size) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.HDF5DataParameter.source)
}
inline ::std::string* HDF5DataParameter::mutable_source() {
set_has_source();
// @@protoc_insertion_point(field_mutable:opencv_caffe.HDF5DataParameter.source)
return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HDF5DataParameter::release_source() {
// @@protoc_insertion_point(field_release:opencv_caffe.HDF5DataParameter.source)
clear_has_source();
return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HDF5DataParameter::set_allocated_source(::std::string* source) {
if (source != NULL) {
set_has_source();
} else {
clear_has_source();
}
source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.HDF5DataParameter.source)
}
// optional uint32 batch_size = 2;
inline bool HDF5DataParameter::has_batch_size() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HDF5DataParameter::set_has_batch_size() {
_has_bits_[0] |= 0x00000002u;
}
inline void HDF5DataParameter::clear_has_batch_size() {
_has_bits_[0] &= ~0x00000002u;
}
inline void HDF5DataParameter::clear_batch_size() {
batch_size_ = 0u;
clear_has_batch_size();
}
inline ::google::protobuf::uint32 HDF5DataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.batch_size)
return batch_size_;
}
inline void HDF5DataParameter::set_batch_size(::google::protobuf::uint32 value) {
set_has_batch_size();
batch_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.batch_size)
}
// optional bool shuffle = 3 [default = false];
inline bool HDF5DataParameter::has_shuffle() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void HDF5DataParameter::set_has_shuffle() {
_has_bits_[0] |= 0x00000004u;
}
inline void HDF5DataParameter::clear_has_shuffle() {
_has_bits_[0] &= ~0x00000004u;
}
inline void HDF5DataParameter::clear_shuffle() {
shuffle_ = false;
clear_has_shuffle();
}
inline bool HDF5DataParameter::shuffle() const {
// @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.shuffle)
return shuffle_;
}
inline void HDF5DataParameter::set_shuffle(bool value) {
set_has_shuffle();
shuffle_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.shuffle)
}
// -------------------------------------------------------------------
// HDF5OutputParameter
// optional string file_name = 1;
inline bool HDF5OutputParameter::has_file_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HDF5OutputParameter::set_has_file_name() {
_has_bits_[0] |= 0x00000001u;
}
inline void HDF5OutputParameter::clear_has_file_name() {
_has_bits_[0] &= ~0x00000001u;
}
inline void HDF5OutputParameter::clear_file_name() {
file_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_file_name();
}
inline const ::std::string& HDF5OutputParameter::file_name() const {
// @@protoc_insertion_point(field_get:opencv_caffe.HDF5OutputParameter.file_name)
return file_name_.GetNoArena();
}
inline void HDF5OutputParameter::set_file_name(const ::std::string& value) {
set_has_file_name();
file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.HDF5OutputParameter.file_name)
}
#if LANG_CXX11
inline void HDF5OutputParameter::set_file_name(::std::string&& value) {
set_has_file_name();
file_name_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.HDF5OutputParameter.file_name)
}
#endif
inline void HDF5OutputParameter::set_file_name(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_file_name();
file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.HDF5OutputParameter.file_name)
}
inline void HDF5OutputParameter::set_file_name(const char* value, size_t size) {
set_has_file_name();
file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.HDF5OutputParameter.file_name)
}
inline ::std::string* HDF5OutputParameter::mutable_file_name() {
set_has_file_name();
// @@protoc_insertion_point(field_mutable:opencv_caffe.HDF5OutputParameter.file_name)
return file_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HDF5OutputParameter::release_file_name() {
// @@protoc_insertion_point(field_release:opencv_caffe.HDF5OutputParameter.file_name)
clear_has_file_name();
return file_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HDF5OutputParameter::set_allocated_file_name(::std::string* file_name) {
if (file_name != NULL) {
set_has_file_name();
} else {
clear_has_file_name();
}
file_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), file_name);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.HDF5OutputParameter.file_name)
}
// -------------------------------------------------------------------
// HingeLossParameter
// optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1];
inline bool HingeLossParameter::has_norm() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HingeLossParameter::set_has_norm() {
_has_bits_[0] |= 0x00000001u;
}
inline void HingeLossParameter::clear_has_norm() {
_has_bits_[0] &= ~0x00000001u;
}
inline void HingeLossParameter::clear_norm() {
norm_ = 1;
clear_has_norm();
}
inline ::opencv_caffe::HingeLossParameter_Norm HingeLossParameter::norm() const {
// @@protoc_insertion_point(field_get:opencv_caffe.HingeLossParameter.norm)
return static_cast< ::opencv_caffe::HingeLossParameter_Norm >(norm_);
}
inline void HingeLossParameter::set_norm(::opencv_caffe::HingeLossParameter_Norm value) {
assert(::opencv_caffe::HingeLossParameter_Norm_IsValid(value));
set_has_norm();
norm_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.HingeLossParameter.norm)
}
// -------------------------------------------------------------------
// ImageDataParameter
// optional string source = 1;
inline bool ImageDataParameter::has_source() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ImageDataParameter::set_has_source() {
_has_bits_[0] |= 0x00000001u;
}
inline void ImageDataParameter::clear_has_source() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ImageDataParameter::clear_source() {
source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_source();
}
inline const ::std::string& ImageDataParameter::source() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.source)
return source_.GetNoArena();
}
inline void ImageDataParameter::set_source(const ::std::string& value) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.source)
}
#if LANG_CXX11
inline void ImageDataParameter::set_source(::std::string&& value) {
set_has_source();
source_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.ImageDataParameter.source)
}
#endif
inline void ImageDataParameter::set_source(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.ImageDataParameter.source)
}
inline void ImageDataParameter::set_source(const char* value, size_t size) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.ImageDataParameter.source)
}
inline ::std::string* ImageDataParameter::mutable_source() {
set_has_source();
// @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.source)
return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ImageDataParameter::release_source() {
// @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.source)
clear_has_source();
return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ImageDataParameter::set_allocated_source(::std::string* source) {
if (source != NULL) {
set_has_source();
} else {
clear_has_source();
}
source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.source)
}
// optional uint32 batch_size = 4 [default = 1];
inline bool ImageDataParameter::has_batch_size() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ImageDataParameter::set_has_batch_size() {
_has_bits_[0] |= 0x00000800u;
}
inline void ImageDataParameter::clear_has_batch_size() {
_has_bits_[0] &= ~0x00000800u;
}
inline void ImageDataParameter::clear_batch_size() {
batch_size_ = 1u;
clear_has_batch_size();
}
inline ::google::protobuf::uint32 ImageDataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.batch_size)
return batch_size_;
}
inline void ImageDataParameter::set_batch_size(::google::protobuf::uint32 value) {
set_has_batch_size();
batch_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.batch_size)
}
// optional uint32 rand_skip = 7 [default = 0];
inline bool ImageDataParameter::has_rand_skip() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ImageDataParameter::set_has_rand_skip() {
_has_bits_[0] |= 0x00000010u;
}
inline void ImageDataParameter::clear_has_rand_skip() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ImageDataParameter::clear_rand_skip() {
rand_skip_ = 0u;
clear_has_rand_skip();
}
inline ::google::protobuf::uint32 ImageDataParameter::rand_skip() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.rand_skip)
return rand_skip_;
}
inline void ImageDataParameter::set_rand_skip(::google::protobuf::uint32 value) {
set_has_rand_skip();
rand_skip_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.rand_skip)
}
// optional bool shuffle = 8 [default = false];
inline bool ImageDataParameter::has_shuffle() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ImageDataParameter::set_has_shuffle() {
_has_bits_[0] |= 0x00000020u;
}
inline void ImageDataParameter::clear_has_shuffle() {
_has_bits_[0] &= ~0x00000020u;
}
inline void ImageDataParameter::clear_shuffle() {
shuffle_ = false;
clear_has_shuffle();
}
inline bool ImageDataParameter::shuffle() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.shuffle)
return shuffle_;
}
inline void ImageDataParameter::set_shuffle(bool value) {
set_has_shuffle();
shuffle_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.shuffle)
}
// optional uint32 new_height = 9 [default = 0];
inline bool ImageDataParameter::has_new_height() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ImageDataParameter::set_has_new_height() {
_has_bits_[0] |= 0x00000080u;
}
inline void ImageDataParameter::clear_has_new_height() {
_has_bits_[0] &= ~0x00000080u;
}
inline void ImageDataParameter::clear_new_height() {
new_height_ = 0u;
clear_has_new_height();
}
inline ::google::protobuf::uint32 ImageDataParameter::new_height() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.new_height)
return new_height_;
}
inline void ImageDataParameter::set_new_height(::google::protobuf::uint32 value) {
set_has_new_height();
new_height_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.new_height)
}
// optional uint32 new_width = 10 [default = 0];
inline bool ImageDataParameter::has_new_width() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ImageDataParameter::set_has_new_width() {
_has_bits_[0] |= 0x00000100u;
}
inline void ImageDataParameter::clear_has_new_width() {
_has_bits_[0] &= ~0x00000100u;
}
inline void ImageDataParameter::clear_new_width() {
new_width_ = 0u;
clear_has_new_width();
}
inline ::google::protobuf::uint32 ImageDataParameter::new_width() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.new_width)
return new_width_;
}
inline void ImageDataParameter::set_new_width(::google::protobuf::uint32 value) {
set_has_new_width();
new_width_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.new_width)
}
// optional bool is_color = 11 [default = true];
inline bool ImageDataParameter::has_is_color() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ImageDataParameter::set_has_is_color() {
_has_bits_[0] |= 0x00000200u;
}
inline void ImageDataParameter::clear_has_is_color() {
_has_bits_[0] &= ~0x00000200u;
}
inline void ImageDataParameter::clear_is_color() {
is_color_ = true;
clear_has_is_color();
}
inline bool ImageDataParameter::is_color() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.is_color)
return is_color_;
}
inline void ImageDataParameter::set_is_color(bool value) {
set_has_is_color();
is_color_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.is_color)
}
// optional float scale = 2 [default = 1];
inline bool ImageDataParameter::has_scale() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ImageDataParameter::set_has_scale() {
_has_bits_[0] |= 0x00000400u;
}
inline void ImageDataParameter::clear_has_scale() {
_has_bits_[0] &= ~0x00000400u;
}
inline void ImageDataParameter::clear_scale() {
scale_ = 1;
clear_has_scale();
}
inline float ImageDataParameter::scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.scale)
return scale_;
}
inline void ImageDataParameter::set_scale(float value) {
set_has_scale();
scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.scale)
}
// optional string mean_file = 3;
inline bool ImageDataParameter::has_mean_file() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ImageDataParameter::set_has_mean_file() {
_has_bits_[0] |= 0x00000002u;
}
inline void ImageDataParameter::clear_has_mean_file() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ImageDataParameter::clear_mean_file() {
mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_mean_file();
}
inline const ::std::string& ImageDataParameter::mean_file() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.mean_file)
return mean_file_.GetNoArena();
}
inline void ImageDataParameter::set_mean_file(const ::std::string& value) {
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.mean_file)
}
#if LANG_CXX11
inline void ImageDataParameter::set_mean_file(::std::string&& value) {
set_has_mean_file();
mean_file_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.ImageDataParameter.mean_file)
}
#endif
inline void ImageDataParameter::set_mean_file(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.ImageDataParameter.mean_file)
}
inline void ImageDataParameter::set_mean_file(const char* value, size_t size) {
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.ImageDataParameter.mean_file)
}
inline ::std::string* ImageDataParameter::mutable_mean_file() {
set_has_mean_file();
// @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.mean_file)
return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ImageDataParameter::release_mean_file() {
// @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.mean_file)
clear_has_mean_file();
return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ImageDataParameter::set_allocated_mean_file(::std::string* mean_file) {
if (mean_file != NULL) {
set_has_mean_file();
} else {
clear_has_mean_file();
}
mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.mean_file)
}
// optional uint32 crop_size = 5 [default = 0];
inline bool ImageDataParameter::has_crop_size() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ImageDataParameter::set_has_crop_size() {
_has_bits_[0] |= 0x00000008u;
}
inline void ImageDataParameter::clear_has_crop_size() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ImageDataParameter::clear_crop_size() {
crop_size_ = 0u;
clear_has_crop_size();
}
inline ::google::protobuf::uint32 ImageDataParameter::crop_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.crop_size)
return crop_size_;
}
inline void ImageDataParameter::set_crop_size(::google::protobuf::uint32 value) {
set_has_crop_size();
crop_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.crop_size)
}
// optional bool mirror = 6 [default = false];
inline bool ImageDataParameter::has_mirror() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ImageDataParameter::set_has_mirror() {
_has_bits_[0] |= 0x00000040u;
}
inline void ImageDataParameter::clear_has_mirror() {
_has_bits_[0] &= ~0x00000040u;
}
inline void ImageDataParameter::clear_mirror() {
mirror_ = false;
clear_has_mirror();
}
inline bool ImageDataParameter::mirror() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.mirror)
return mirror_;
}
inline void ImageDataParameter::set_mirror(bool value) {
set_has_mirror();
mirror_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.mirror)
}
// optional string root_folder = 12 [default = ""];
inline bool ImageDataParameter::has_root_folder() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ImageDataParameter::set_has_root_folder() {
_has_bits_[0] |= 0x00000004u;
}
inline void ImageDataParameter::clear_has_root_folder() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ImageDataParameter::clear_root_folder() {
root_folder_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_root_folder();
}
inline const ::std::string& ImageDataParameter::root_folder() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.root_folder)
return root_folder_.GetNoArena();
}
inline void ImageDataParameter::set_root_folder(const ::std::string& value) {
set_has_root_folder();
root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.root_folder)
}
#if LANG_CXX11
inline void ImageDataParameter::set_root_folder(::std::string&& value) {
set_has_root_folder();
root_folder_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.ImageDataParameter.root_folder)
}
#endif
inline void ImageDataParameter::set_root_folder(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_root_folder();
root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.ImageDataParameter.root_folder)
}
inline void ImageDataParameter::set_root_folder(const char* value, size_t size) {
set_has_root_folder();
root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.ImageDataParameter.root_folder)
}
inline ::std::string* ImageDataParameter::mutable_root_folder() {
set_has_root_folder();
// @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.root_folder)
return root_folder_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ImageDataParameter::release_root_folder() {
// @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.root_folder)
clear_has_root_folder();
return root_folder_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ImageDataParameter::set_allocated_root_folder(::std::string* root_folder) {
if (root_folder != NULL) {
set_has_root_folder();
} else {
clear_has_root_folder();
}
root_folder_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), root_folder);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.root_folder)
}
// -------------------------------------------------------------------
// InfogainLossParameter
// optional string source = 1;
inline bool InfogainLossParameter::has_source() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InfogainLossParameter::set_has_source() {
_has_bits_[0] |= 0x00000001u;
}
inline void InfogainLossParameter::clear_has_source() {
_has_bits_[0] &= ~0x00000001u;
}
inline void InfogainLossParameter::clear_source() {
source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_source();
}
inline const ::std::string& InfogainLossParameter::source() const {
// @@protoc_insertion_point(field_get:opencv_caffe.InfogainLossParameter.source)
return source_.GetNoArena();
}
inline void InfogainLossParameter::set_source(const ::std::string& value) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.InfogainLossParameter.source)
}
#if LANG_CXX11
inline void InfogainLossParameter::set_source(::std::string&& value) {
set_has_source();
source_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.InfogainLossParameter.source)
}
#endif
inline void InfogainLossParameter::set_source(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.InfogainLossParameter.source)
}
inline void InfogainLossParameter::set_source(const char* value, size_t size) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.InfogainLossParameter.source)
}
inline ::std::string* InfogainLossParameter::mutable_source() {
set_has_source();
// @@protoc_insertion_point(field_mutable:opencv_caffe.InfogainLossParameter.source)
return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* InfogainLossParameter::release_source() {
// @@protoc_insertion_point(field_release:opencv_caffe.InfogainLossParameter.source)
clear_has_source();
return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void InfogainLossParameter::set_allocated_source(::std::string* source) {
if (source != NULL) {
set_has_source();
} else {
clear_has_source();
}
source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.InfogainLossParameter.source)
}
// -------------------------------------------------------------------
// InnerProductParameter
// optional uint32 num_output = 1;
inline bool InnerProductParameter::has_num_output() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void InnerProductParameter::set_has_num_output() {
_has_bits_[0] |= 0x00000004u;
}
inline void InnerProductParameter::clear_has_num_output() {
_has_bits_[0] &= ~0x00000004u;
}
inline void InnerProductParameter::clear_num_output() {
num_output_ = 0u;
clear_has_num_output();
}
inline ::google::protobuf::uint32 InnerProductParameter::num_output() const {
// @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.num_output)
return num_output_;
}
inline void InnerProductParameter::set_num_output(::google::protobuf::uint32 value) {
set_has_num_output();
num_output_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.num_output)
}
// optional bool bias_term = 2 [default = true];
inline bool InnerProductParameter::has_bias_term() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void InnerProductParameter::set_has_bias_term() {
_has_bits_[0] |= 0x00000010u;
}
inline void InnerProductParameter::clear_has_bias_term() {
_has_bits_[0] &= ~0x00000010u;
}
inline void InnerProductParameter::clear_bias_term() {
bias_term_ = true;
clear_has_bias_term();
}
inline bool InnerProductParameter::bias_term() const {
// @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.bias_term)
return bias_term_;
}
inline void InnerProductParameter::set_bias_term(bool value) {
set_has_bias_term();
bias_term_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.bias_term)
}
// optional .opencv_caffe.FillerParameter weight_filler = 3;
inline bool InnerProductParameter::has_weight_filler() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InnerProductParameter::set_has_weight_filler() {
_has_bits_[0] |= 0x00000001u;
}
inline void InnerProductParameter::clear_has_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
}
inline void InnerProductParameter::clear_weight_filler() {
if (weight_filler_ != NULL) weight_filler_->Clear();
clear_has_weight_filler();
}
inline const ::opencv_caffe::FillerParameter& InnerProductParameter::weight_filler() const {
const ::opencv_caffe::FillerParameter* p = weight_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.weight_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::release_weight_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.InnerProductParameter.weight_filler)
clear_has_weight_filler();
::opencv_caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::mutable_weight_filler() {
set_has_weight_filler();
if (weight_filler_ == NULL) {
weight_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.InnerProductParameter.weight_filler)
return weight_filler_;
}
inline void InnerProductParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete weight_filler_;
}
if (weight_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
weight_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
set_has_weight_filler();
} else {
clear_has_weight_filler();
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.InnerProductParameter.weight_filler)
}
// optional .opencv_caffe.FillerParameter bias_filler = 4;
inline bool InnerProductParameter::has_bias_filler() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void InnerProductParameter::set_has_bias_filler() {
_has_bits_[0] |= 0x00000002u;
}
inline void InnerProductParameter::clear_has_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
}
inline void InnerProductParameter::clear_bias_filler() {
if (bias_filler_ != NULL) bias_filler_->Clear();
clear_has_bias_filler();
}
inline const ::opencv_caffe::FillerParameter& InnerProductParameter::bias_filler() const {
const ::opencv_caffe::FillerParameter* p = bias_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.bias_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::release_bias_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.InnerProductParameter.bias_filler)
clear_has_bias_filler();
::opencv_caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::mutable_bias_filler() {
set_has_bias_filler();
if (bias_filler_ == NULL) {
bias_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.InnerProductParameter.bias_filler)
return bias_filler_;
}
inline void InnerProductParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete bias_filler_;
}
if (bias_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
bias_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
set_has_bias_filler();
} else {
clear_has_bias_filler();
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.InnerProductParameter.bias_filler)
}
// optional int32 axis = 5 [default = 1];
inline bool InnerProductParameter::has_axis() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void InnerProductParameter::set_has_axis() {
_has_bits_[0] |= 0x00000020u;
}
inline void InnerProductParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000020u;
}
inline void InnerProductParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 InnerProductParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.axis)
return axis_;
}
inline void InnerProductParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.axis)
}
// optional bool transpose = 6 [default = false];
inline bool InnerProductParameter::has_transpose() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void InnerProductParameter::set_has_transpose() {
_has_bits_[0] |= 0x00000008u;
}
inline void InnerProductParameter::clear_has_transpose() {
_has_bits_[0] &= ~0x00000008u;
}
inline void InnerProductParameter::clear_transpose() {
transpose_ = false;
clear_has_transpose();
}
inline bool InnerProductParameter::transpose() const {
// @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.transpose)
return transpose_;
}
inline void InnerProductParameter::set_transpose(bool value) {
set_has_transpose();
transpose_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.transpose)
}
// -------------------------------------------------------------------
// InputParameter
// repeated .opencv_caffe.BlobShape shape = 1;
inline int InputParameter::shape_size() const {
return shape_.size();
}
inline void InputParameter::clear_shape() {
shape_.Clear();
}
inline const ::opencv_caffe::BlobShape& InputParameter::shape(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.InputParameter.shape)
return shape_.Get(index);
}
inline ::opencv_caffe::BlobShape* InputParameter::mutable_shape(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.InputParameter.shape)
return shape_.Mutable(index);
}
inline ::opencv_caffe::BlobShape* InputParameter::add_shape() {
// @@protoc_insertion_point(field_add:opencv_caffe.InputParameter.shape)
return shape_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >*
InputParameter::mutable_shape() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.InputParameter.shape)
return &shape_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobShape >&
InputParameter::shape() const {
// @@protoc_insertion_point(field_list:opencv_caffe.InputParameter.shape)
return shape_;
}
// -------------------------------------------------------------------
// LogParameter
// optional float base = 1 [default = -1];
inline bool LogParameter::has_base() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LogParameter::set_has_base() {
_has_bits_[0] |= 0x00000002u;
}
inline void LogParameter::clear_has_base() {
_has_bits_[0] &= ~0x00000002u;
}
inline void LogParameter::clear_base() {
base_ = -1;
clear_has_base();
}
inline float LogParameter::base() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.base)
return base_;
}
inline void LogParameter::set_base(float value) {
set_has_base();
base_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.base)
}
// optional float scale = 2 [default = 1];
inline bool LogParameter::has_scale() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LogParameter::set_has_scale() {
_has_bits_[0] |= 0x00000004u;
}
inline void LogParameter::clear_has_scale() {
_has_bits_[0] &= ~0x00000004u;
}
inline void LogParameter::clear_scale() {
scale_ = 1;
clear_has_scale();
}
inline float LogParameter::scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.scale)
return scale_;
}
inline void LogParameter::set_scale(float value) {
set_has_scale();
scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.scale)
}
// optional float shift = 3 [default = 0];
inline bool LogParameter::has_shift() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LogParameter::set_has_shift() {
_has_bits_[0] |= 0x00000001u;
}
inline void LogParameter::clear_has_shift() {
_has_bits_[0] &= ~0x00000001u;
}
inline void LogParameter::clear_shift() {
shift_ = 0;
clear_has_shift();
}
inline float LogParameter::shift() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.shift)
return shift_;
}
inline void LogParameter::set_shift(float value) {
set_has_shift();
shift_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.shift)
}
// -------------------------------------------------------------------
// LRNParameter
// optional uint32 local_size = 1 [default = 5];
inline bool LRNParameter::has_local_size() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LRNParameter::set_has_local_size() {
_has_bits_[0] |= 0x00000004u;
}
inline void LRNParameter::clear_has_local_size() {
_has_bits_[0] &= ~0x00000004u;
}
inline void LRNParameter::clear_local_size() {
local_size_ = 5u;
clear_has_local_size();
}
inline ::google::protobuf::uint32 LRNParameter::local_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.local_size)
return local_size_;
}
inline void LRNParameter::set_local_size(::google::protobuf::uint32 value) {
set_has_local_size();
local_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.local_size)
}
// optional float alpha = 2 [default = 1];
inline bool LRNParameter::has_alpha() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LRNParameter::set_has_alpha() {
_has_bits_[0] |= 0x00000008u;
}
inline void LRNParameter::clear_has_alpha() {
_has_bits_[0] &= ~0x00000008u;
}
inline void LRNParameter::clear_alpha() {
alpha_ = 1;
clear_has_alpha();
}
inline float LRNParameter::alpha() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.alpha)
return alpha_;
}
inline void LRNParameter::set_alpha(float value) {
set_has_alpha();
alpha_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.alpha)
}
// optional float beta = 3 [default = 0.75];
inline bool LRNParameter::has_beta() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LRNParameter::set_has_beta() {
_has_bits_[0] |= 0x00000010u;
}
inline void LRNParameter::clear_has_beta() {
_has_bits_[0] &= ~0x00000010u;
}
inline void LRNParameter::clear_beta() {
beta_ = 0.75f;
clear_has_beta();
}
inline float LRNParameter::beta() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.beta)
return beta_;
}
inline void LRNParameter::set_beta(float value) {
set_has_beta();
beta_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.beta)
}
// optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
inline bool LRNParameter::has_norm_region() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LRNParameter::set_has_norm_region() {
_has_bits_[0] |= 0x00000001u;
}
inline void LRNParameter::clear_has_norm_region() {
_has_bits_[0] &= ~0x00000001u;
}
inline void LRNParameter::clear_norm_region() {
norm_region_ = 0;
clear_has_norm_region();
}
inline ::opencv_caffe::LRNParameter_NormRegion LRNParameter::norm_region() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.norm_region)
return static_cast< ::opencv_caffe::LRNParameter_NormRegion >(norm_region_);
}
inline void LRNParameter::set_norm_region(::opencv_caffe::LRNParameter_NormRegion value) {
assert(::opencv_caffe::LRNParameter_NormRegion_IsValid(value));
set_has_norm_region();
norm_region_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.norm_region)
}
// optional float k = 5 [default = 1];
inline bool LRNParameter::has_k() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void LRNParameter::set_has_k() {
_has_bits_[0] |= 0x00000020u;
}
inline void LRNParameter::clear_has_k() {
_has_bits_[0] &= ~0x00000020u;
}
inline void LRNParameter::clear_k() {
k_ = 1;
clear_has_k();
}
inline float LRNParameter::k() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.k)
return k_;
}
inline void LRNParameter::set_k(float value) {
set_has_k();
k_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.k)
}
// optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
inline bool LRNParameter::has_engine() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LRNParameter::set_has_engine() {
_has_bits_[0] |= 0x00000002u;
}
inline void LRNParameter::clear_has_engine() {
_has_bits_[0] &= ~0x00000002u;
}
inline void LRNParameter::clear_engine() {
engine_ = 0;
clear_has_engine();
}
inline ::opencv_caffe::LRNParameter_Engine LRNParameter::engine() const {
// @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.engine)
return static_cast< ::opencv_caffe::LRNParameter_Engine >(engine_);
}
inline void LRNParameter::set_engine(::opencv_caffe::LRNParameter_Engine value) {
assert(::opencv_caffe::LRNParameter_Engine_IsValid(value));
set_has_engine();
engine_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.engine)
}
// -------------------------------------------------------------------
// MemoryDataParameter
// optional uint32 batch_size = 1;
inline bool MemoryDataParameter::has_batch_size() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MemoryDataParameter::set_has_batch_size() {
_has_bits_[0] |= 0x00000001u;
}
inline void MemoryDataParameter::clear_has_batch_size() {
_has_bits_[0] &= ~0x00000001u;
}
inline void MemoryDataParameter::clear_batch_size() {
batch_size_ = 0u;
clear_has_batch_size();
}
inline ::google::protobuf::uint32 MemoryDataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.batch_size)
return batch_size_;
}
inline void MemoryDataParameter::set_batch_size(::google::protobuf::uint32 value) {
set_has_batch_size();
batch_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.batch_size)
}
// optional uint32 channels = 2;
inline bool MemoryDataParameter::has_channels() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MemoryDataParameter::set_has_channels() {
_has_bits_[0] |= 0x00000002u;
}
inline void MemoryDataParameter::clear_has_channels() {
_has_bits_[0] &= ~0x00000002u;
}
inline void MemoryDataParameter::clear_channels() {
channels_ = 0u;
clear_has_channels();
}
inline ::google::protobuf::uint32 MemoryDataParameter::channels() const {
// @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.channels)
return channels_;
}
inline void MemoryDataParameter::set_channels(::google::protobuf::uint32 value) {
set_has_channels();
channels_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.channels)
}
// optional uint32 height = 3;
inline bool MemoryDataParameter::has_height() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MemoryDataParameter::set_has_height() {
_has_bits_[0] |= 0x00000004u;
}
inline void MemoryDataParameter::clear_has_height() {
_has_bits_[0] &= ~0x00000004u;
}
inline void MemoryDataParameter::clear_height() {
height_ = 0u;
clear_has_height();
}
inline ::google::protobuf::uint32 MemoryDataParameter::height() const {
// @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.height)
return height_;
}
inline void MemoryDataParameter::set_height(::google::protobuf::uint32 value) {
set_has_height();
height_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.height)
}
// optional uint32 width = 4;
inline bool MemoryDataParameter::has_width() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MemoryDataParameter::set_has_width() {
_has_bits_[0] |= 0x00000008u;
}
inline void MemoryDataParameter::clear_has_width() {
_has_bits_[0] &= ~0x00000008u;
}
inline void MemoryDataParameter::clear_width() {
width_ = 0u;
clear_has_width();
}
inline ::google::protobuf::uint32 MemoryDataParameter::width() const {
// @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.width)
return width_;
}
inline void MemoryDataParameter::set_width(::google::protobuf::uint32 value) {
set_has_width();
width_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.width)
}
// -------------------------------------------------------------------
// MVNParameter
// optional bool normalize_variance = 1 [default = true];
inline bool MVNParameter::has_normalize_variance() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MVNParameter::set_has_normalize_variance() {
_has_bits_[0] |= 0x00000002u;
}
inline void MVNParameter::clear_has_normalize_variance() {
_has_bits_[0] &= ~0x00000002u;
}
inline void MVNParameter::clear_normalize_variance() {
normalize_variance_ = true;
clear_has_normalize_variance();
}
inline bool MVNParameter::normalize_variance() const {
// @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.normalize_variance)
return normalize_variance_;
}
inline void MVNParameter::set_normalize_variance(bool value) {
set_has_normalize_variance();
normalize_variance_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.normalize_variance)
}
// optional bool across_channels = 2 [default = false];
inline bool MVNParameter::has_across_channels() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MVNParameter::set_has_across_channels() {
_has_bits_[0] |= 0x00000001u;
}
inline void MVNParameter::clear_has_across_channels() {
_has_bits_[0] &= ~0x00000001u;
}
inline void MVNParameter::clear_across_channels() {
across_channels_ = false;
clear_has_across_channels();
}
inline bool MVNParameter::across_channels() const {
// @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.across_channels)
return across_channels_;
}
inline void MVNParameter::set_across_channels(bool value) {
set_has_across_channels();
across_channels_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.across_channels)
}
// optional float eps = 3 [default = 1e-09];
inline bool MVNParameter::has_eps() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MVNParameter::set_has_eps() {
_has_bits_[0] |= 0x00000004u;
}
inline void MVNParameter::clear_has_eps() {
_has_bits_[0] &= ~0x00000004u;
}
inline void MVNParameter::clear_eps() {
eps_ = 1e-09f;
clear_has_eps();
}
inline float MVNParameter::eps() const {
// @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.eps)
return eps_;
}
inline void MVNParameter::set_eps(float value) {
set_has_eps();
eps_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.eps)
}
// -------------------------------------------------------------------
// ParameterParameter
// optional .opencv_caffe.BlobShape shape = 1;
inline bool ParameterParameter::has_shape() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ParameterParameter::set_has_shape() {
_has_bits_[0] |= 0x00000001u;
}
inline void ParameterParameter::clear_has_shape() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ParameterParameter::clear_shape() {
if (shape_ != NULL) shape_->Clear();
clear_has_shape();
}
inline const ::opencv_caffe::BlobShape& ParameterParameter::shape() const {
const ::opencv_caffe::BlobShape* p = shape_;
// @@protoc_insertion_point(field_get:opencv_caffe.ParameterParameter.shape)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::BlobShape*>(
&::opencv_caffe::_BlobShape_default_instance_);
}
inline ::opencv_caffe::BlobShape* ParameterParameter::release_shape() {
// @@protoc_insertion_point(field_release:opencv_caffe.ParameterParameter.shape)
clear_has_shape();
::opencv_caffe::BlobShape* temp = shape_;
shape_ = NULL;
return temp;
}
inline ::opencv_caffe::BlobShape* ParameterParameter::mutable_shape() {
set_has_shape();
if (shape_ == NULL) {
shape_ = new ::opencv_caffe::BlobShape;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.ParameterParameter.shape)
return shape_;
}
inline void ParameterParameter::set_allocated_shape(::opencv_caffe::BlobShape* shape) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete shape_;
}
if (shape) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
shape = ::google::protobuf::internal::GetOwnedMessage(
message_arena, shape, submessage_arena);
}
set_has_shape();
} else {
clear_has_shape();
}
shape_ = shape;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ParameterParameter.shape)
}
// -------------------------------------------------------------------
// PoolingParameter
// optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
inline bool PoolingParameter::has_pool() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PoolingParameter::set_has_pool() {
_has_bits_[0] |= 0x00000001u;
}
inline void PoolingParameter::clear_has_pool() {
_has_bits_[0] &= ~0x00000001u;
}
inline void PoolingParameter::clear_pool() {
pool_ = 0;
clear_has_pool();
}
inline ::opencv_caffe::PoolingParameter_PoolMethod PoolingParameter::pool() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pool)
return static_cast< ::opencv_caffe::PoolingParameter_PoolMethod >(pool_);
}
inline void PoolingParameter::set_pool(::opencv_caffe::PoolingParameter_PoolMethod value) {
assert(::opencv_caffe::PoolingParameter_PoolMethod_IsValid(value));
set_has_pool();
pool_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pool)
}
// optional uint32 pad = 4 [default = 0];
inline bool PoolingParameter::has_pad() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PoolingParameter::set_has_pad() {
_has_bits_[0] |= 0x00000004u;
}
inline void PoolingParameter::clear_has_pad() {
_has_bits_[0] &= ~0x00000004u;
}
inline void PoolingParameter::clear_pad() {
pad_ = 0u;
clear_has_pad();
}
inline ::google::protobuf::uint32 PoolingParameter::pad() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad)
return pad_;
}
inline void PoolingParameter::set_pad(::google::protobuf::uint32 value) {
set_has_pad();
pad_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad)
}
// optional uint32 pad_h = 9 [default = 0];
inline bool PoolingParameter::has_pad_h() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void PoolingParameter::set_has_pad_h() {
_has_bits_[0] |= 0x00000080u;
}
inline void PoolingParameter::clear_has_pad_h() {
_has_bits_[0] &= ~0x00000080u;
}
inline void PoolingParameter::clear_pad_h() {
pad_h_ = 0u;
clear_has_pad_h();
}
inline ::google::protobuf::uint32 PoolingParameter::pad_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad_h)
return pad_h_;
}
inline void PoolingParameter::set_pad_h(::google::protobuf::uint32 value) {
set_has_pad_h();
pad_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad_h)
}
// optional uint32 pad_w = 10 [default = 0];
inline bool PoolingParameter::has_pad_w() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void PoolingParameter::set_has_pad_w() {
_has_bits_[0] |= 0x00000100u;
}
inline void PoolingParameter::clear_has_pad_w() {
_has_bits_[0] &= ~0x00000100u;
}
inline void PoolingParameter::clear_pad_w() {
pad_w_ = 0u;
clear_has_pad_w();
}
inline ::google::protobuf::uint32 PoolingParameter::pad_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad_w)
return pad_w_;
}
inline void PoolingParameter::set_pad_w(::google::protobuf::uint32 value) {
set_has_pad_w();
pad_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad_w)
}
// optional uint32 kernel_size = 2;
inline bool PoolingParameter::has_kernel_size() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PoolingParameter::set_has_kernel_size() {
_has_bits_[0] |= 0x00000002u;
}
inline void PoolingParameter::clear_has_kernel_size() {
_has_bits_[0] &= ~0x00000002u;
}
inline void PoolingParameter::clear_kernel_size() {
kernel_size_ = 0u;
clear_has_kernel_size();
}
inline ::google::protobuf::uint32 PoolingParameter::kernel_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_size)
return kernel_size_;
}
inline void PoolingParameter::set_kernel_size(::google::protobuf::uint32 value) {
set_has_kernel_size();
kernel_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_size)
}
// optional uint32 kernel_h = 5;
inline bool PoolingParameter::has_kernel_h() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PoolingParameter::set_has_kernel_h() {
_has_bits_[0] |= 0x00000008u;
}
inline void PoolingParameter::clear_has_kernel_h() {
_has_bits_[0] &= ~0x00000008u;
}
inline void PoolingParameter::clear_kernel_h() {
kernel_h_ = 0u;
clear_has_kernel_h();
}
inline ::google::protobuf::uint32 PoolingParameter::kernel_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_h)
return kernel_h_;
}
inline void PoolingParameter::set_kernel_h(::google::protobuf::uint32 value) {
set_has_kernel_h();
kernel_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_h)
}
// optional uint32 kernel_w = 6;
inline bool PoolingParameter::has_kernel_w() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PoolingParameter::set_has_kernel_w() {
_has_bits_[0] |= 0x00000010u;
}
inline void PoolingParameter::clear_has_kernel_w() {
_has_bits_[0] &= ~0x00000010u;
}
inline void PoolingParameter::clear_kernel_w() {
kernel_w_ = 0u;
clear_has_kernel_w();
}
inline ::google::protobuf::uint32 PoolingParameter::kernel_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_w)
return kernel_w_;
}
inline void PoolingParameter::set_kernel_w(::google::protobuf::uint32 value) {
set_has_kernel_w();
kernel_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_w)
}
// optional uint32 stride = 3 [default = 1];
inline bool PoolingParameter::has_stride() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void PoolingParameter::set_has_stride() {
_has_bits_[0] |= 0x00000800u;
}
inline void PoolingParameter::clear_has_stride() {
_has_bits_[0] &= ~0x00000800u;
}
inline void PoolingParameter::clear_stride() {
stride_ = 1u;
clear_has_stride();
}
inline ::google::protobuf::uint32 PoolingParameter::stride() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride)
return stride_;
}
inline void PoolingParameter::set_stride(::google::protobuf::uint32 value) {
set_has_stride();
stride_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.stride)
}
// optional uint32 stride_h = 7;
inline bool PoolingParameter::has_stride_h() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void PoolingParameter::set_has_stride_h() {
_has_bits_[0] |= 0x00000020u;
}
inline void PoolingParameter::clear_has_stride_h() {
_has_bits_[0] &= ~0x00000020u;
}
inline void PoolingParameter::clear_stride_h() {
stride_h_ = 0u;
clear_has_stride_h();
}
inline ::google::protobuf::uint32 PoolingParameter::stride_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride_h)
return stride_h_;
}
inline void PoolingParameter::set_stride_h(::google::protobuf::uint32 value) {
set_has_stride_h();
stride_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.stride_h)
}
// optional uint32 stride_w = 8;
inline bool PoolingParameter::has_stride_w() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void PoolingParameter::set_has_stride_w() {
_has_bits_[0] |= 0x00000040u;
}
inline void PoolingParameter::clear_has_stride_w() {
_has_bits_[0] &= ~0x00000040u;
}
inline void PoolingParameter::clear_stride_w() {
stride_w_ = 0u;
clear_has_stride_w();
}
inline ::google::protobuf::uint32 PoolingParameter::stride_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride_w)
return stride_w_;
}
inline void PoolingParameter::set_stride_w(::google::protobuf::uint32 value) {
set_has_stride_w();
stride_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.stride_w)
}
// optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
inline bool PoolingParameter::has_engine() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void PoolingParameter::set_has_engine() {
_has_bits_[0] |= 0x00000200u;
}
inline void PoolingParameter::clear_has_engine() {
_has_bits_[0] &= ~0x00000200u;
}
inline void PoolingParameter::clear_engine() {
engine_ = 0;
clear_has_engine();
}
inline ::opencv_caffe::PoolingParameter_Engine PoolingParameter::engine() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.engine)
return static_cast< ::opencv_caffe::PoolingParameter_Engine >(engine_);
}
inline void PoolingParameter::set_engine(::opencv_caffe::PoolingParameter_Engine value) {
assert(::opencv_caffe::PoolingParameter_Engine_IsValid(value));
set_has_engine();
engine_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.engine)
}
// optional bool global_pooling = 12 [default = false];
inline bool PoolingParameter::has_global_pooling() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void PoolingParameter::set_has_global_pooling() {
_has_bits_[0] |= 0x00000400u;
}
inline void PoolingParameter::clear_has_global_pooling() {
_has_bits_[0] &= ~0x00000400u;
}
inline void PoolingParameter::clear_global_pooling() {
global_pooling_ = false;
clear_has_global_pooling();
}
inline bool PoolingParameter::global_pooling() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.global_pooling)
return global_pooling_;
}
inline void PoolingParameter::set_global_pooling(bool value) {
set_has_global_pooling();
global_pooling_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.global_pooling)
}
// optional bool ceil_mode = 13 [default = true];
inline bool PoolingParameter::has_ceil_mode() const {
return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void PoolingParameter::set_has_ceil_mode() {
_has_bits_[0] |= 0x00001000u;
}
inline void PoolingParameter::clear_has_ceil_mode() {
_has_bits_[0] &= ~0x00001000u;
}
inline void PoolingParameter::clear_ceil_mode() {
ceil_mode_ = true;
clear_has_ceil_mode();
}
inline bool PoolingParameter::ceil_mode() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.ceil_mode)
return ceil_mode_;
}
inline void PoolingParameter::set_ceil_mode(bool value) {
set_has_ceil_mode();
ceil_mode_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.ceil_mode)
}
// -------------------------------------------------------------------
// PowerParameter
// optional float power = 1 [default = 1];
inline bool PowerParameter::has_power() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PowerParameter::set_has_power() {
_has_bits_[0] |= 0x00000002u;
}
inline void PowerParameter::clear_has_power() {
_has_bits_[0] &= ~0x00000002u;
}
inline void PowerParameter::clear_power() {
power_ = 1;
clear_has_power();
}
inline float PowerParameter::power() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.power)
return power_;
}
inline void PowerParameter::set_power(float value) {
set_has_power();
power_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.power)
}
// optional float scale = 2 [default = 1];
inline bool PowerParameter::has_scale() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PowerParameter::set_has_scale() {
_has_bits_[0] |= 0x00000004u;
}
inline void PowerParameter::clear_has_scale() {
_has_bits_[0] &= ~0x00000004u;
}
inline void PowerParameter::clear_scale() {
scale_ = 1;
clear_has_scale();
}
inline float PowerParameter::scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.scale)
return scale_;
}
inline void PowerParameter::set_scale(float value) {
set_has_scale();
scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.scale)
}
// optional float shift = 3 [default = 0];
inline bool PowerParameter::has_shift() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PowerParameter::set_has_shift() {
_has_bits_[0] |= 0x00000001u;
}
inline void PowerParameter::clear_has_shift() {
_has_bits_[0] &= ~0x00000001u;
}
inline void PowerParameter::clear_shift() {
shift_ = 0;
clear_has_shift();
}
inline float PowerParameter::shift() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.shift)
return shift_;
}
inline void PowerParameter::set_shift(float value) {
set_has_shift();
shift_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.shift)
}
// -------------------------------------------------------------------
// PythonParameter
// optional string module = 1;
inline bool PythonParameter::has_module() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PythonParameter::set_has_module() {
_has_bits_[0] |= 0x00000001u;
}
inline void PythonParameter::clear_has_module() {
_has_bits_[0] &= ~0x00000001u;
}
inline void PythonParameter::clear_module() {
module_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_module();
}
inline const ::std::string& PythonParameter::module() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.module)
return module_.GetNoArena();
}
inline void PythonParameter::set_module(const ::std::string& value) {
set_has_module();
module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.module)
}
#if LANG_CXX11
inline void PythonParameter::set_module(::std::string&& value) {
set_has_module();
module_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.PythonParameter.module)
}
#endif
inline void PythonParameter::set_module(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_module();
module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.PythonParameter.module)
}
inline void PythonParameter::set_module(const char* value, size_t size) {
set_has_module();
module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.PythonParameter.module)
}
inline ::std::string* PythonParameter::mutable_module() {
set_has_module();
// @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.module)
return module_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PythonParameter::release_module() {
// @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.module)
clear_has_module();
return module_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PythonParameter::set_allocated_module(::std::string* module) {
if (module != NULL) {
set_has_module();
} else {
clear_has_module();
}
module_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), module);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.module)
}
// optional string layer = 2;
inline bool PythonParameter::has_layer() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PythonParameter::set_has_layer() {
_has_bits_[0] |= 0x00000002u;
}
inline void PythonParameter::clear_has_layer() {
_has_bits_[0] &= ~0x00000002u;
}
inline void PythonParameter::clear_layer() {
layer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_layer();
}
inline const ::std::string& PythonParameter::layer() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.layer)
return layer_.GetNoArena();
}
inline void PythonParameter::set_layer(const ::std::string& value) {
set_has_layer();
layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.layer)
}
#if LANG_CXX11
inline void PythonParameter::set_layer(::std::string&& value) {
set_has_layer();
layer_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.PythonParameter.layer)
}
#endif
inline void PythonParameter::set_layer(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_layer();
layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.PythonParameter.layer)
}
inline void PythonParameter::set_layer(const char* value, size_t size) {
set_has_layer();
layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.PythonParameter.layer)
}
inline ::std::string* PythonParameter::mutable_layer() {
set_has_layer();
// @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.layer)
return layer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PythonParameter::release_layer() {
// @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.layer)
clear_has_layer();
return layer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PythonParameter::set_allocated_layer(::std::string* layer) {
if (layer != NULL) {
set_has_layer();
} else {
clear_has_layer();
}
layer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), layer);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.layer)
}
// optional string param_str = 3 [default = ""];
inline bool PythonParameter::has_param_str() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PythonParameter::set_has_param_str() {
_has_bits_[0] |= 0x00000004u;
}
inline void PythonParameter::clear_has_param_str() {
_has_bits_[0] &= ~0x00000004u;
}
inline void PythonParameter::clear_param_str() {
param_str_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_param_str();
}
inline const ::std::string& PythonParameter::param_str() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.param_str)
return param_str_.GetNoArena();
}
inline void PythonParameter::set_param_str(const ::std::string& value) {
set_has_param_str();
param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.param_str)
}
#if LANG_CXX11
inline void PythonParameter::set_param_str(::std::string&& value) {
set_has_param_str();
param_str_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.PythonParameter.param_str)
}
#endif
inline void PythonParameter::set_param_str(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_param_str();
param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.PythonParameter.param_str)
}
inline void PythonParameter::set_param_str(const char* value, size_t size) {
set_has_param_str();
param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.PythonParameter.param_str)
}
inline ::std::string* PythonParameter::mutable_param_str() {
set_has_param_str();
// @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.param_str)
return param_str_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PythonParameter::release_param_str() {
// @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.param_str)
clear_has_param_str();
return param_str_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PythonParameter::set_allocated_param_str(::std::string* param_str) {
if (param_str != NULL) {
set_has_param_str();
} else {
clear_has_param_str();
}
param_str_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), param_str);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.param_str)
}
// optional bool share_in_parallel = 4 [default = false];
inline bool PythonParameter::has_share_in_parallel() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PythonParameter::set_has_share_in_parallel() {
_has_bits_[0] |= 0x00000008u;
}
inline void PythonParameter::clear_has_share_in_parallel() {
_has_bits_[0] &= ~0x00000008u;
}
inline void PythonParameter::clear_share_in_parallel() {
share_in_parallel_ = false;
clear_has_share_in_parallel();
}
inline bool PythonParameter::share_in_parallel() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.share_in_parallel)
return share_in_parallel_;
}
inline void PythonParameter::set_share_in_parallel(bool value) {
set_has_share_in_parallel();
share_in_parallel_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.share_in_parallel)
}
// -------------------------------------------------------------------
// RecurrentParameter
// optional uint32 num_output = 1 [default = 0];
inline bool RecurrentParameter::has_num_output() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RecurrentParameter::set_has_num_output() {
_has_bits_[0] |= 0x00000004u;
}
inline void RecurrentParameter::clear_has_num_output() {
_has_bits_[0] &= ~0x00000004u;
}
inline void RecurrentParameter::clear_num_output() {
num_output_ = 0u;
clear_has_num_output();
}
inline ::google::protobuf::uint32 RecurrentParameter::num_output() const {
// @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.num_output)
return num_output_;
}
inline void RecurrentParameter::set_num_output(::google::protobuf::uint32 value) {
set_has_num_output();
num_output_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.RecurrentParameter.num_output)
}
// optional .opencv_caffe.FillerParameter weight_filler = 2;
inline bool RecurrentParameter::has_weight_filler() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RecurrentParameter::set_has_weight_filler() {
_has_bits_[0] |= 0x00000001u;
}
inline void RecurrentParameter::clear_has_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
}
inline void RecurrentParameter::clear_weight_filler() {
if (weight_filler_ != NULL) weight_filler_->Clear();
clear_has_weight_filler();
}
inline const ::opencv_caffe::FillerParameter& RecurrentParameter::weight_filler() const {
const ::opencv_caffe::FillerParameter* p = weight_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.weight_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::release_weight_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.RecurrentParameter.weight_filler)
clear_has_weight_filler();
::opencv_caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::mutable_weight_filler() {
set_has_weight_filler();
if (weight_filler_ == NULL) {
weight_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.RecurrentParameter.weight_filler)
return weight_filler_;
}
inline void RecurrentParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete weight_filler_;
}
if (weight_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
weight_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
set_has_weight_filler();
} else {
clear_has_weight_filler();
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.RecurrentParameter.weight_filler)
}
// optional .opencv_caffe.FillerParameter bias_filler = 3;
inline bool RecurrentParameter::has_bias_filler() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RecurrentParameter::set_has_bias_filler() {
_has_bits_[0] |= 0x00000002u;
}
inline void RecurrentParameter::clear_has_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
}
inline void RecurrentParameter::clear_bias_filler() {
if (bias_filler_ != NULL) bias_filler_->Clear();
clear_has_bias_filler();
}
inline const ::opencv_caffe::FillerParameter& RecurrentParameter::bias_filler() const {
const ::opencv_caffe::FillerParameter* p = bias_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.bias_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::release_bias_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.RecurrentParameter.bias_filler)
clear_has_bias_filler();
::opencv_caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::mutable_bias_filler() {
set_has_bias_filler();
if (bias_filler_ == NULL) {
bias_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.RecurrentParameter.bias_filler)
return bias_filler_;
}
inline void RecurrentParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete bias_filler_;
}
if (bias_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
bias_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
set_has_bias_filler();
} else {
clear_has_bias_filler();
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.RecurrentParameter.bias_filler)
}
// optional bool debug_info = 4 [default = false];
inline bool RecurrentParameter::has_debug_info() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void RecurrentParameter::set_has_debug_info() {
_has_bits_[0] |= 0x00000008u;
}
inline void RecurrentParameter::clear_has_debug_info() {
_has_bits_[0] &= ~0x00000008u;
}
inline void RecurrentParameter::clear_debug_info() {
debug_info_ = false;
clear_has_debug_info();
}
inline bool RecurrentParameter::debug_info() const {
// @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.debug_info)
return debug_info_;
}
inline void RecurrentParameter::set_debug_info(bool value) {
set_has_debug_info();
debug_info_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.RecurrentParameter.debug_info)
}
// optional bool expose_hidden = 5 [default = false];
inline bool RecurrentParameter::has_expose_hidden() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void RecurrentParameter::set_has_expose_hidden() {
_has_bits_[0] |= 0x00000010u;
}
inline void RecurrentParameter::clear_has_expose_hidden() {
_has_bits_[0] &= ~0x00000010u;
}
inline void RecurrentParameter::clear_expose_hidden() {
expose_hidden_ = false;
clear_has_expose_hidden();
}
inline bool RecurrentParameter::expose_hidden() const {
// @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.expose_hidden)
return expose_hidden_;
}
inline void RecurrentParameter::set_expose_hidden(bool value) {
set_has_expose_hidden();
expose_hidden_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.RecurrentParameter.expose_hidden)
}
// -------------------------------------------------------------------
// ReductionParameter
// optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
inline bool ReductionParameter::has_operation() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReductionParameter::set_has_operation() {
_has_bits_[0] |= 0x00000002u;
}
inline void ReductionParameter::clear_has_operation() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ReductionParameter::clear_operation() {
operation_ = 1;
clear_has_operation();
}
inline ::opencv_caffe::ReductionParameter_ReductionOp ReductionParameter::operation() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.operation)
return static_cast< ::opencv_caffe::ReductionParameter_ReductionOp >(operation_);
}
inline void ReductionParameter::set_operation(::opencv_caffe::ReductionParameter_ReductionOp value) {
assert(::opencv_caffe::ReductionParameter_ReductionOp_IsValid(value));
set_has_operation();
operation_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.operation)
}
// optional int32 axis = 2 [default = 0];
inline bool ReductionParameter::has_axis() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReductionParameter::set_has_axis() {
_has_bits_[0] |= 0x00000001u;
}
inline void ReductionParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ReductionParameter::clear_axis() {
axis_ = 0;
clear_has_axis();
}
inline ::google::protobuf::int32 ReductionParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.axis)
return axis_;
}
inline void ReductionParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.axis)
}
// optional float coeff = 3 [default = 1];
inline bool ReductionParameter::has_coeff() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ReductionParameter::set_has_coeff() {
_has_bits_[0] |= 0x00000004u;
}
inline void ReductionParameter::clear_has_coeff() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ReductionParameter::clear_coeff() {
coeff_ = 1;
clear_has_coeff();
}
inline float ReductionParameter::coeff() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.coeff)
return coeff_;
}
inline void ReductionParameter::set_coeff(float value) {
set_has_coeff();
coeff_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.coeff)
}
// -------------------------------------------------------------------
// ReLUParameter
// optional float negative_slope = 1 [default = 0];
inline bool ReLUParameter::has_negative_slope() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReLUParameter::set_has_negative_slope() {
_has_bits_[0] |= 0x00000001u;
}
inline void ReLUParameter::clear_has_negative_slope() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ReLUParameter::clear_negative_slope() {
negative_slope_ = 0;
clear_has_negative_slope();
}
inline float ReLUParameter::negative_slope() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ReLUParameter.negative_slope)
return negative_slope_;
}
inline void ReLUParameter::set_negative_slope(float value) {
set_has_negative_slope();
negative_slope_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ReLUParameter.negative_slope)
}
// optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
inline bool ReLUParameter::has_engine() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReLUParameter::set_has_engine() {
_has_bits_[0] |= 0x00000002u;
}
inline void ReLUParameter::clear_has_engine() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ReLUParameter::clear_engine() {
engine_ = 0;
clear_has_engine();
}
inline ::opencv_caffe::ReLUParameter_Engine ReLUParameter::engine() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ReLUParameter.engine)
return static_cast< ::opencv_caffe::ReLUParameter_Engine >(engine_);
}
inline void ReLUParameter::set_engine(::opencv_caffe::ReLUParameter_Engine value) {
assert(::opencv_caffe::ReLUParameter_Engine_IsValid(value));
set_has_engine();
engine_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ReLUParameter.engine)
}
// -------------------------------------------------------------------
// ReshapeParameter
// optional .opencv_caffe.BlobShape shape = 1;
inline bool ReshapeParameter::has_shape() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReshapeParameter::set_has_shape() {
_has_bits_[0] |= 0x00000001u;
}
inline void ReshapeParameter::clear_has_shape() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ReshapeParameter::clear_shape() {
if (shape_ != NULL) shape_->Clear();
clear_has_shape();
}
inline const ::opencv_caffe::BlobShape& ReshapeParameter::shape() const {
const ::opencv_caffe::BlobShape* p = shape_;
// @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.shape)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::BlobShape*>(
&::opencv_caffe::_BlobShape_default_instance_);
}
inline ::opencv_caffe::BlobShape* ReshapeParameter::release_shape() {
// @@protoc_insertion_point(field_release:opencv_caffe.ReshapeParameter.shape)
clear_has_shape();
::opencv_caffe::BlobShape* temp = shape_;
shape_ = NULL;
return temp;
}
inline ::opencv_caffe::BlobShape* ReshapeParameter::mutable_shape() {
set_has_shape();
if (shape_ == NULL) {
shape_ = new ::opencv_caffe::BlobShape;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.ReshapeParameter.shape)
return shape_;
}
inline void ReshapeParameter::set_allocated_shape(::opencv_caffe::BlobShape* shape) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete shape_;
}
if (shape) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
shape = ::google::protobuf::internal::GetOwnedMessage(
message_arena, shape, submessage_arena);
}
set_has_shape();
} else {
clear_has_shape();
}
shape_ = shape;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ReshapeParameter.shape)
}
// optional int32 axis = 2 [default = 0];
inline bool ReshapeParameter::has_axis() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReshapeParameter::set_has_axis() {
_has_bits_[0] |= 0x00000002u;
}
inline void ReshapeParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ReshapeParameter::clear_axis() {
axis_ = 0;
clear_has_axis();
}
inline ::google::protobuf::int32 ReshapeParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.axis)
return axis_;
}
inline void ReshapeParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ReshapeParameter.axis)
}
// optional int32 num_axes = 3 [default = -1];
inline bool ReshapeParameter::has_num_axes() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ReshapeParameter::set_has_num_axes() {
_has_bits_[0] |= 0x00000004u;
}
inline void ReshapeParameter::clear_has_num_axes() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ReshapeParameter::clear_num_axes() {
num_axes_ = -1;
clear_has_num_axes();
}
inline ::google::protobuf::int32 ReshapeParameter::num_axes() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.num_axes)
return num_axes_;
}
inline void ReshapeParameter::set_num_axes(::google::protobuf::int32 value) {
set_has_num_axes();
num_axes_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ReshapeParameter.num_axes)
}
// -------------------------------------------------------------------
// ScaleParameter
// optional int32 axis = 1 [default = 1];
inline bool ScaleParameter::has_axis() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ScaleParameter::set_has_axis() {
_has_bits_[0] |= 0x00000008u;
}
inline void ScaleParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ScaleParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 ScaleParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.axis)
return axis_;
}
inline void ScaleParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.axis)
}
// optional int32 num_axes = 2 [default = 1];
inline bool ScaleParameter::has_num_axes() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ScaleParameter::set_has_num_axes() {
_has_bits_[0] |= 0x00000010u;
}
inline void ScaleParameter::clear_has_num_axes() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ScaleParameter::clear_num_axes() {
num_axes_ = 1;
clear_has_num_axes();
}
inline ::google::protobuf::int32 ScaleParameter::num_axes() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.num_axes)
return num_axes_;
}
inline void ScaleParameter::set_num_axes(::google::protobuf::int32 value) {
set_has_num_axes();
num_axes_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.num_axes)
}
// optional .opencv_caffe.FillerParameter filler = 3;
inline bool ScaleParameter::has_filler() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ScaleParameter::set_has_filler() {
_has_bits_[0] |= 0x00000001u;
}
inline void ScaleParameter::clear_has_filler() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ScaleParameter::clear_filler() {
if (filler_ != NULL) filler_->Clear();
clear_has_filler();
}
inline const ::opencv_caffe::FillerParameter& ScaleParameter::filler() const {
const ::opencv_caffe::FillerParameter* p = filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::release_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.ScaleParameter.filler)
clear_has_filler();
::opencv_caffe::FillerParameter* temp = filler_;
filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::mutable_filler() {
set_has_filler();
if (filler_ == NULL) {
filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.ScaleParameter.filler)
return filler_;
}
inline void ScaleParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete filler_;
}
if (filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, filler, submessage_arena);
}
set_has_filler();
} else {
clear_has_filler();
}
filler_ = filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ScaleParameter.filler)
}
// optional bool bias_term = 4 [default = false];
inline bool ScaleParameter::has_bias_term() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ScaleParameter::set_has_bias_term() {
_has_bits_[0] |= 0x00000004u;
}
inline void ScaleParameter::clear_has_bias_term() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ScaleParameter::clear_bias_term() {
bias_term_ = false;
clear_has_bias_term();
}
inline bool ScaleParameter::bias_term() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.bias_term)
return bias_term_;
}
inline void ScaleParameter::set_bias_term(bool value) {
set_has_bias_term();
bias_term_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.bias_term)
}
// optional .opencv_caffe.FillerParameter bias_filler = 5;
inline bool ScaleParameter::has_bias_filler() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ScaleParameter::set_has_bias_filler() {
_has_bits_[0] |= 0x00000002u;
}
inline void ScaleParameter::clear_has_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ScaleParameter::clear_bias_filler() {
if (bias_filler_ != NULL) bias_filler_->Clear();
clear_has_bias_filler();
}
inline const ::opencv_caffe::FillerParameter& ScaleParameter::bias_filler() const {
const ::opencv_caffe::FillerParameter* p = bias_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.bias_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::release_bias_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.ScaleParameter.bias_filler)
clear_has_bias_filler();
::opencv_caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::mutable_bias_filler() {
set_has_bias_filler();
if (bias_filler_ == NULL) {
bias_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.ScaleParameter.bias_filler)
return bias_filler_;
}
inline void ScaleParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete bias_filler_;
}
if (bias_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
bias_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
set_has_bias_filler();
} else {
clear_has_bias_filler();
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.ScaleParameter.bias_filler)
}
// -------------------------------------------------------------------
// SigmoidParameter
// optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
inline bool SigmoidParameter::has_engine() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SigmoidParameter::set_has_engine() {
_has_bits_[0] |= 0x00000001u;
}
inline void SigmoidParameter::clear_has_engine() {
_has_bits_[0] &= ~0x00000001u;
}
inline void SigmoidParameter::clear_engine() {
engine_ = 0;
clear_has_engine();
}
inline ::opencv_caffe::SigmoidParameter_Engine SigmoidParameter::engine() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SigmoidParameter.engine)
return static_cast< ::opencv_caffe::SigmoidParameter_Engine >(engine_);
}
inline void SigmoidParameter::set_engine(::opencv_caffe::SigmoidParameter_Engine value) {
assert(::opencv_caffe::SigmoidParameter_Engine_IsValid(value));
set_has_engine();
engine_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SigmoidParameter.engine)
}
// -------------------------------------------------------------------
// SliceParameter
// optional int32 axis = 3 [default = 1];
inline bool SliceParameter::has_axis() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SliceParameter::set_has_axis() {
_has_bits_[0] |= 0x00000002u;
}
inline void SliceParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000002u;
}
inline void SliceParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 SliceParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.axis)
return axis_;
}
inline void SliceParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SliceParameter.axis)
}
// repeated uint32 slice_point = 2;
inline int SliceParameter::slice_point_size() const {
return slice_point_.size();
}
inline void SliceParameter::clear_slice_point() {
slice_point_.Clear();
}
inline ::google::protobuf::uint32 SliceParameter::slice_point(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.slice_point)
return slice_point_.Get(index);
}
inline void SliceParameter::set_slice_point(int index, ::google::protobuf::uint32 value) {
slice_point_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.SliceParameter.slice_point)
}
inline void SliceParameter::add_slice_point(::google::protobuf::uint32 value) {
slice_point_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.SliceParameter.slice_point)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
SliceParameter::slice_point() const {
// @@protoc_insertion_point(field_list:opencv_caffe.SliceParameter.slice_point)
return slice_point_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
SliceParameter::mutable_slice_point() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.SliceParameter.slice_point)
return &slice_point_;
}
// optional uint32 slice_dim = 1 [default = 1];
inline bool SliceParameter::has_slice_dim() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SliceParameter::set_has_slice_dim() {
_has_bits_[0] |= 0x00000001u;
}
inline void SliceParameter::clear_has_slice_dim() {
_has_bits_[0] &= ~0x00000001u;
}
inline void SliceParameter::clear_slice_dim() {
slice_dim_ = 1u;
clear_has_slice_dim();
}
inline ::google::protobuf::uint32 SliceParameter::slice_dim() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.slice_dim)
return slice_dim_;
}
inline void SliceParameter::set_slice_dim(::google::protobuf::uint32 value) {
set_has_slice_dim();
slice_dim_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SliceParameter.slice_dim)
}
// -------------------------------------------------------------------
// SoftmaxParameter
// optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
inline bool SoftmaxParameter::has_engine() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SoftmaxParameter::set_has_engine() {
_has_bits_[0] |= 0x00000001u;
}
inline void SoftmaxParameter::clear_has_engine() {
_has_bits_[0] &= ~0x00000001u;
}
inline void SoftmaxParameter::clear_engine() {
engine_ = 0;
clear_has_engine();
}
inline ::opencv_caffe::SoftmaxParameter_Engine SoftmaxParameter::engine() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SoftmaxParameter.engine)
return static_cast< ::opencv_caffe::SoftmaxParameter_Engine >(engine_);
}
inline void SoftmaxParameter::set_engine(::opencv_caffe::SoftmaxParameter_Engine value) {
assert(::opencv_caffe::SoftmaxParameter_Engine_IsValid(value));
set_has_engine();
engine_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SoftmaxParameter.engine)
}
// optional int32 axis = 2 [default = 1];
inline bool SoftmaxParameter::has_axis() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SoftmaxParameter::set_has_axis() {
_has_bits_[0] |= 0x00000002u;
}
inline void SoftmaxParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000002u;
}
inline void SoftmaxParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 SoftmaxParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SoftmaxParameter.axis)
return axis_;
}
inline void SoftmaxParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SoftmaxParameter.axis)
}
// -------------------------------------------------------------------
// TanHParameter
// optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
inline bool TanHParameter::has_engine() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TanHParameter::set_has_engine() {
_has_bits_[0] |= 0x00000001u;
}
inline void TanHParameter::clear_has_engine() {
_has_bits_[0] &= ~0x00000001u;
}
inline void TanHParameter::clear_engine() {
engine_ = 0;
clear_has_engine();
}
inline ::opencv_caffe::TanHParameter_Engine TanHParameter::engine() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TanHParameter.engine)
return static_cast< ::opencv_caffe::TanHParameter_Engine >(engine_);
}
inline void TanHParameter::set_engine(::opencv_caffe::TanHParameter_Engine value) {
assert(::opencv_caffe::TanHParameter_Engine_IsValid(value));
set_has_engine();
engine_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.TanHParameter.engine)
}
// -------------------------------------------------------------------
// TileParameter
// optional int32 axis = 1 [default = 1];
inline bool TileParameter::has_axis() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TileParameter::set_has_axis() {
_has_bits_[0] |= 0x00000002u;
}
inline void TileParameter::clear_has_axis() {
_has_bits_[0] &= ~0x00000002u;
}
inline void TileParameter::clear_axis() {
axis_ = 1;
clear_has_axis();
}
inline ::google::protobuf::int32 TileParameter::axis() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TileParameter.axis)
return axis_;
}
inline void TileParameter::set_axis(::google::protobuf::int32 value) {
set_has_axis();
axis_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.TileParameter.axis)
}
// optional int32 tiles = 2;
inline bool TileParameter::has_tiles() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TileParameter::set_has_tiles() {
_has_bits_[0] |= 0x00000001u;
}
inline void TileParameter::clear_has_tiles() {
_has_bits_[0] &= ~0x00000001u;
}
inline void TileParameter::clear_tiles() {
tiles_ = 0;
clear_has_tiles();
}
inline ::google::protobuf::int32 TileParameter::tiles() const {
// @@protoc_insertion_point(field_get:opencv_caffe.TileParameter.tiles)
return tiles_;
}
inline void TileParameter::set_tiles(::google::protobuf::int32 value) {
set_has_tiles();
tiles_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.TileParameter.tiles)
}
// -------------------------------------------------------------------
// ThresholdParameter
// optional float threshold = 1 [default = 0];
inline bool ThresholdParameter::has_threshold() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ThresholdParameter::set_has_threshold() {
_has_bits_[0] |= 0x00000001u;
}
inline void ThresholdParameter::clear_has_threshold() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ThresholdParameter::clear_threshold() {
threshold_ = 0;
clear_has_threshold();
}
inline float ThresholdParameter::threshold() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ThresholdParameter.threshold)
return threshold_;
}
inline void ThresholdParameter::set_threshold(float value) {
set_has_threshold();
threshold_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ThresholdParameter.threshold)
}
// -------------------------------------------------------------------
// WindowDataParameter
// optional string source = 1;
inline bool WindowDataParameter::has_source() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WindowDataParameter::set_has_source() {
_has_bits_[0] |= 0x00000001u;
}
inline void WindowDataParameter::clear_has_source() {
_has_bits_[0] &= ~0x00000001u;
}
inline void WindowDataParameter::clear_source() {
source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_source();
}
inline const ::std::string& WindowDataParameter::source() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.source)
return source_.GetNoArena();
}
inline void WindowDataParameter::set_source(const ::std::string& value) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.source)
}
#if LANG_CXX11
inline void WindowDataParameter::set_source(::std::string&& value) {
set_has_source();
source_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.WindowDataParameter.source)
}
#endif
inline void WindowDataParameter::set_source(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.WindowDataParameter.source)
}
inline void WindowDataParameter::set_source(const char* value, size_t size) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.WindowDataParameter.source)
}
inline ::std::string* WindowDataParameter::mutable_source() {
set_has_source();
// @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.source)
return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* WindowDataParameter::release_source() {
// @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.source)
clear_has_source();
return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void WindowDataParameter::set_allocated_source(::std::string* source) {
if (source != NULL) {
set_has_source();
} else {
clear_has_source();
}
source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.source)
}
// optional float scale = 2 [default = 1];
inline bool WindowDataParameter::has_scale() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void WindowDataParameter::set_has_scale() {
_has_bits_[0] |= 0x00000200u;
}
inline void WindowDataParameter::clear_has_scale() {
_has_bits_[0] &= ~0x00000200u;
}
inline void WindowDataParameter::clear_scale() {
scale_ = 1;
clear_has_scale();
}
inline float WindowDataParameter::scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.scale)
return scale_;
}
inline void WindowDataParameter::set_scale(float value) {
set_has_scale();
scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.scale)
}
// optional string mean_file = 3;
inline bool WindowDataParameter::has_mean_file() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WindowDataParameter::set_has_mean_file() {
_has_bits_[0] |= 0x00000002u;
}
inline void WindowDataParameter::clear_has_mean_file() {
_has_bits_[0] &= ~0x00000002u;
}
inline void WindowDataParameter::clear_mean_file() {
mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_mean_file();
}
inline const ::std::string& WindowDataParameter::mean_file() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.mean_file)
return mean_file_.GetNoArena();
}
inline void WindowDataParameter::set_mean_file(const ::std::string& value) {
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.mean_file)
}
#if LANG_CXX11
inline void WindowDataParameter::set_mean_file(::std::string&& value) {
set_has_mean_file();
mean_file_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.WindowDataParameter.mean_file)
}
#endif
inline void WindowDataParameter::set_mean_file(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.WindowDataParameter.mean_file)
}
inline void WindowDataParameter::set_mean_file(const char* value, size_t size) {
set_has_mean_file();
mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.WindowDataParameter.mean_file)
}
inline ::std::string* WindowDataParameter::mutable_mean_file() {
set_has_mean_file();
// @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.mean_file)
return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* WindowDataParameter::release_mean_file() {
// @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.mean_file)
clear_has_mean_file();
return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void WindowDataParameter::set_allocated_mean_file(::std::string* mean_file) {
if (mean_file != NULL) {
set_has_mean_file();
} else {
clear_has_mean_file();
}
mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.mean_file)
}
// optional uint32 batch_size = 4;
inline bool WindowDataParameter::has_batch_size() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void WindowDataParameter::set_has_batch_size() {
_has_bits_[0] |= 0x00000010u;
}
inline void WindowDataParameter::clear_has_batch_size() {
_has_bits_[0] &= ~0x00000010u;
}
inline void WindowDataParameter::clear_batch_size() {
batch_size_ = 0u;
clear_has_batch_size();
}
inline ::google::protobuf::uint32 WindowDataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.batch_size)
return batch_size_;
}
inline void WindowDataParameter::set_batch_size(::google::protobuf::uint32 value) {
set_has_batch_size();
batch_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.batch_size)
}
// optional uint32 crop_size = 5 [default = 0];
inline bool WindowDataParameter::has_crop_size() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void WindowDataParameter::set_has_crop_size() {
_has_bits_[0] |= 0x00000020u;
}
inline void WindowDataParameter::clear_has_crop_size() {
_has_bits_[0] &= ~0x00000020u;
}
inline void WindowDataParameter::clear_crop_size() {
crop_size_ = 0u;
clear_has_crop_size();
}
inline ::google::protobuf::uint32 WindowDataParameter::crop_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.crop_size)
return crop_size_;
}
inline void WindowDataParameter::set_crop_size(::google::protobuf::uint32 value) {
set_has_crop_size();
crop_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.crop_size)
}
// optional bool mirror = 6 [default = false];
inline bool WindowDataParameter::has_mirror() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void WindowDataParameter::set_has_mirror() {
_has_bits_[0] |= 0x00000040u;
}
inline void WindowDataParameter::clear_has_mirror() {
_has_bits_[0] &= ~0x00000040u;
}
inline void WindowDataParameter::clear_mirror() {
mirror_ = false;
clear_has_mirror();
}
inline bool WindowDataParameter::mirror() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.mirror)
return mirror_;
}
inline void WindowDataParameter::set_mirror(bool value) {
set_has_mirror();
mirror_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.mirror)
}
// optional float fg_threshold = 7 [default = 0.5];
inline bool WindowDataParameter::has_fg_threshold() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void WindowDataParameter::set_has_fg_threshold() {
_has_bits_[0] |= 0x00000400u;
}
inline void WindowDataParameter::clear_has_fg_threshold() {
_has_bits_[0] &= ~0x00000400u;
}
inline void WindowDataParameter::clear_fg_threshold() {
fg_threshold_ = 0.5f;
clear_has_fg_threshold();
}
inline float WindowDataParameter::fg_threshold() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.fg_threshold)
return fg_threshold_;
}
inline void WindowDataParameter::set_fg_threshold(float value) {
set_has_fg_threshold();
fg_threshold_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.fg_threshold)
}
// optional float bg_threshold = 8 [default = 0.5];
inline bool WindowDataParameter::has_bg_threshold() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void WindowDataParameter::set_has_bg_threshold() {
_has_bits_[0] |= 0x00000800u;
}
inline void WindowDataParameter::clear_has_bg_threshold() {
_has_bits_[0] &= ~0x00000800u;
}
inline void WindowDataParameter::clear_bg_threshold() {
bg_threshold_ = 0.5f;
clear_has_bg_threshold();
}
inline float WindowDataParameter::bg_threshold() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.bg_threshold)
return bg_threshold_;
}
inline void WindowDataParameter::set_bg_threshold(float value) {
set_has_bg_threshold();
bg_threshold_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.bg_threshold)
}
// optional float fg_fraction = 9 [default = 0.25];
inline bool WindowDataParameter::has_fg_fraction() const {
return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void WindowDataParameter::set_has_fg_fraction() {
_has_bits_[0] |= 0x00001000u;
}
inline void WindowDataParameter::clear_has_fg_fraction() {
_has_bits_[0] &= ~0x00001000u;
}
inline void WindowDataParameter::clear_fg_fraction() {
fg_fraction_ = 0.25f;
clear_has_fg_fraction();
}
inline float WindowDataParameter::fg_fraction() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.fg_fraction)
return fg_fraction_;
}
inline void WindowDataParameter::set_fg_fraction(float value) {
set_has_fg_fraction();
fg_fraction_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.fg_fraction)
}
// optional uint32 context_pad = 10 [default = 0];
inline bool WindowDataParameter::has_context_pad() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void WindowDataParameter::set_has_context_pad() {
_has_bits_[0] |= 0x00000100u;
}
inline void WindowDataParameter::clear_has_context_pad() {
_has_bits_[0] &= ~0x00000100u;
}
inline void WindowDataParameter::clear_context_pad() {
context_pad_ = 0u;
clear_has_context_pad();
}
inline ::google::protobuf::uint32 WindowDataParameter::context_pad() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.context_pad)
return context_pad_;
}
inline void WindowDataParameter::set_context_pad(::google::protobuf::uint32 value) {
set_has_context_pad();
context_pad_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.context_pad)
}
// optional string crop_mode = 11 [default = "warp"];
inline bool WindowDataParameter::has_crop_mode() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void WindowDataParameter::set_has_crop_mode() {
_has_bits_[0] |= 0x00000004u;
}
inline void WindowDataParameter::clear_has_crop_mode() {
_has_bits_[0] &= ~0x00000004u;
}
inline void WindowDataParameter::clear_crop_mode() {
crop_mode_.ClearToDefaultNoArena(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get());
clear_has_crop_mode();
}
inline const ::std::string& WindowDataParameter::crop_mode() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.crop_mode)
return crop_mode_.GetNoArena();
}
inline void WindowDataParameter::set_crop_mode(const ::std::string& value) {
set_has_crop_mode();
crop_mode_.SetNoArena(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.crop_mode)
}
#if LANG_CXX11
inline void WindowDataParameter::set_crop_mode(::std::string&& value) {
set_has_crop_mode();
crop_mode_.SetNoArena(
&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.WindowDataParameter.crop_mode)
}
#endif
inline void WindowDataParameter::set_crop_mode(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_crop_mode();
crop_mode_.SetNoArena(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.WindowDataParameter.crop_mode)
}
inline void WindowDataParameter::set_crop_mode(const char* value, size_t size) {
set_has_crop_mode();
crop_mode_.SetNoArena(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.WindowDataParameter.crop_mode)
}
inline ::std::string* WindowDataParameter::mutable_crop_mode() {
set_has_crop_mode();
// @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.crop_mode)
return crop_mode_.MutableNoArena(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get());
}
inline ::std::string* WindowDataParameter::release_crop_mode() {
// @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.crop_mode)
clear_has_crop_mode();
return crop_mode_.ReleaseNoArena(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get());
}
inline void WindowDataParameter::set_allocated_crop_mode(::std::string* crop_mode) {
if (crop_mode != NULL) {
set_has_crop_mode();
} else {
clear_has_crop_mode();
}
crop_mode_.SetAllocatedNoArena(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get(), crop_mode);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.crop_mode)
}
// optional bool cache_images = 12 [default = false];
inline bool WindowDataParameter::has_cache_images() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void WindowDataParameter::set_has_cache_images() {
_has_bits_[0] |= 0x00000080u;
}
inline void WindowDataParameter::clear_has_cache_images() {
_has_bits_[0] &= ~0x00000080u;
}
inline void WindowDataParameter::clear_cache_images() {
cache_images_ = false;
clear_has_cache_images();
}
inline bool WindowDataParameter::cache_images() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.cache_images)
return cache_images_;
}
inline void WindowDataParameter::set_cache_images(bool value) {
set_has_cache_images();
cache_images_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.cache_images)
}
// optional string root_folder = 13 [default = ""];
inline bool WindowDataParameter::has_root_folder() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void WindowDataParameter::set_has_root_folder() {
_has_bits_[0] |= 0x00000008u;
}
inline void WindowDataParameter::clear_has_root_folder() {
_has_bits_[0] &= ~0x00000008u;
}
inline void WindowDataParameter::clear_root_folder() {
root_folder_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_root_folder();
}
inline const ::std::string& WindowDataParameter::root_folder() const {
// @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.root_folder)
return root_folder_.GetNoArena();
}
inline void WindowDataParameter::set_root_folder(const ::std::string& value) {
set_has_root_folder();
root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.root_folder)
}
#if LANG_CXX11
inline void WindowDataParameter::set_root_folder(::std::string&& value) {
set_has_root_folder();
root_folder_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.WindowDataParameter.root_folder)
}
#endif
inline void WindowDataParameter::set_root_folder(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_root_folder();
root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.WindowDataParameter.root_folder)
}
inline void WindowDataParameter::set_root_folder(const char* value, size_t size) {
set_has_root_folder();
root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.WindowDataParameter.root_folder)
}
inline ::std::string* WindowDataParameter::mutable_root_folder() {
set_has_root_folder();
// @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.root_folder)
return root_folder_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* WindowDataParameter::release_root_folder() {
// @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.root_folder)
clear_has_root_folder();
return root_folder_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void WindowDataParameter::set_allocated_root_folder(::std::string* root_folder) {
if (root_folder != NULL) {
set_has_root_folder();
} else {
clear_has_root_folder();
}
root_folder_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), root_folder);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.root_folder)
}
// -------------------------------------------------------------------
// SPPParameter
// optional uint32 pyramid_height = 1;
inline bool SPPParameter::has_pyramid_height() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SPPParameter::set_has_pyramid_height() {
_has_bits_[0] |= 0x00000001u;
}
inline void SPPParameter::clear_has_pyramid_height() {
_has_bits_[0] &= ~0x00000001u;
}
inline void SPPParameter::clear_pyramid_height() {
pyramid_height_ = 0u;
clear_has_pyramid_height();
}
inline ::google::protobuf::uint32 SPPParameter::pyramid_height() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.pyramid_height)
return pyramid_height_;
}
inline void SPPParameter::set_pyramid_height(::google::protobuf::uint32 value) {
set_has_pyramid_height();
pyramid_height_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SPPParameter.pyramid_height)
}
// optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
inline bool SPPParameter::has_pool() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SPPParameter::set_has_pool() {
_has_bits_[0] |= 0x00000002u;
}
inline void SPPParameter::clear_has_pool() {
_has_bits_[0] &= ~0x00000002u;
}
inline void SPPParameter::clear_pool() {
pool_ = 0;
clear_has_pool();
}
inline ::opencv_caffe::SPPParameter_PoolMethod SPPParameter::pool() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.pool)
return static_cast< ::opencv_caffe::SPPParameter_PoolMethod >(pool_);
}
inline void SPPParameter::set_pool(::opencv_caffe::SPPParameter_PoolMethod value) {
assert(::opencv_caffe::SPPParameter_PoolMethod_IsValid(value));
set_has_pool();
pool_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SPPParameter.pool)
}
// optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
inline bool SPPParameter::has_engine() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SPPParameter::set_has_engine() {
_has_bits_[0] |= 0x00000004u;
}
inline void SPPParameter::clear_has_engine() {
_has_bits_[0] &= ~0x00000004u;
}
inline void SPPParameter::clear_engine() {
engine_ = 0;
clear_has_engine();
}
inline ::opencv_caffe::SPPParameter_Engine SPPParameter::engine() const {
// @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.engine)
return static_cast< ::opencv_caffe::SPPParameter_Engine >(engine_);
}
inline void SPPParameter::set_engine(::opencv_caffe::SPPParameter_Engine value) {
assert(::opencv_caffe::SPPParameter_Engine_IsValid(value));
set_has_engine();
engine_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.SPPParameter.engine)
}
// -------------------------------------------------------------------
// V1LayerParameter
// repeated string bottom = 2;
inline int V1LayerParameter::bottom_size() const {
return bottom_.size();
}
inline void V1LayerParameter::clear_bottom() {
bottom_.Clear();
}
inline const ::std::string& V1LayerParameter::bottom(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.bottom)
return bottom_.Get(index);
}
inline ::std::string* V1LayerParameter::mutable_bottom(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.bottom)
return bottom_.Mutable(index);
}
inline void V1LayerParameter::set_bottom(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.bottom)
bottom_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void V1LayerParameter::set_bottom(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.bottom)
bottom_.Mutable(index)->assign(std::move(value));
}
#endif
inline void V1LayerParameter::set_bottom(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
bottom_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::set_bottom(int index, const char* value, size_t size) {
bottom_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.bottom)
}
inline ::std::string* V1LayerParameter::add_bottom() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.bottom)
return bottom_.Add();
}
inline void V1LayerParameter::add_bottom(const ::std::string& value) {
bottom_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.bottom)
}
#if LANG_CXX11
inline void V1LayerParameter::add_bottom(::std::string&& value) {
bottom_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.bottom)
}
#endif
inline void V1LayerParameter::add_bottom(const char* value) {
GOOGLE_DCHECK(value != NULL);
bottom_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::add_bottom(const char* value, size_t size) {
bottom_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.bottom)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
V1LayerParameter::bottom() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.bottom)
return bottom_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
V1LayerParameter::mutable_bottom() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.bottom)
return &bottom_;
}
// repeated string top = 3;
inline int V1LayerParameter::top_size() const {
return top_.size();
}
inline void V1LayerParameter::clear_top() {
top_.Clear();
}
inline const ::std::string& V1LayerParameter::top(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.top)
return top_.Get(index);
}
inline ::std::string* V1LayerParameter::mutable_top(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.top)
return top_.Mutable(index);
}
inline void V1LayerParameter::set_top(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.top)
top_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void V1LayerParameter::set_top(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.top)
top_.Mutable(index)->assign(std::move(value));
}
#endif
inline void V1LayerParameter::set_top(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
top_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::set_top(int index, const char* value, size_t size) {
top_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.top)
}
inline ::std::string* V1LayerParameter::add_top() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.top)
return top_.Add();
}
inline void V1LayerParameter::add_top(const ::std::string& value) {
top_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.top)
}
#if LANG_CXX11
inline void V1LayerParameter::add_top(::std::string&& value) {
top_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.top)
}
#endif
inline void V1LayerParameter::add_top(const char* value) {
GOOGLE_DCHECK(value != NULL);
top_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::add_top(const char* value, size_t size) {
top_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.top)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
V1LayerParameter::top() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.top)
return top_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
V1LayerParameter::mutable_top() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.top)
return &top_;
}
// optional string name = 4;
inline bool V1LayerParameter::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void V1LayerParameter::set_has_name() {
_has_bits_[0] |= 0x00000001u;
}
inline void V1LayerParameter::clear_has_name() {
_has_bits_[0] &= ~0x00000001u;
}
inline void V1LayerParameter::clear_name() {
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string& V1LayerParameter::name() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.name)
return name_.GetNoArena();
}
inline void V1LayerParameter::set_name(const ::std::string& value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.name)
}
#if LANG_CXX11
inline void V1LayerParameter::set_name(::std::string&& value) {
set_has_name();
name_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.V1LayerParameter.name)
}
#endif
inline void V1LayerParameter::set_name(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.V1LayerParameter.name)
}
inline void V1LayerParameter::set_name(const char* value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.name)
}
inline ::std::string* V1LayerParameter::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.name)
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* V1LayerParameter::release_name() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.name)
clear_has_name();
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void V1LayerParameter::set_allocated_name(::std::string* name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.name)
}
// repeated .opencv_caffe.NetStateRule include = 32;
inline int V1LayerParameter::include_size() const {
return include_.size();
}
inline void V1LayerParameter::clear_include() {
include_.Clear();
}
inline const ::opencv_caffe::NetStateRule& V1LayerParameter::include(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.include)
return include_.Get(index);
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::mutable_include(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.include)
return include_.Mutable(index);
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::add_include() {
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.include)
return include_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
V1LayerParameter::mutable_include() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.include)
return &include_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
V1LayerParameter::include() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.include)
return include_;
}
// repeated .opencv_caffe.NetStateRule exclude = 33;
inline int V1LayerParameter::exclude_size() const {
return exclude_.size();
}
inline void V1LayerParameter::clear_exclude() {
exclude_.Clear();
}
inline const ::opencv_caffe::NetStateRule& V1LayerParameter::exclude(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.exclude)
return exclude_.Get(index);
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::mutable_exclude(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.exclude)
return exclude_.Mutable(index);
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::add_exclude() {
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.exclude)
return exclude_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
V1LayerParameter::mutable_exclude() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.exclude)
return &exclude_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
V1LayerParameter::exclude() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.exclude)
return exclude_;
}
// optional .opencv_caffe.V1LayerParameter.LayerType type = 5;
inline bool V1LayerParameter::has_type() const {
return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void V1LayerParameter::set_has_type() {
_has_bits_[1] |= 0x00000001u;
}
inline void V1LayerParameter::clear_has_type() {
_has_bits_[1] &= ~0x00000001u;
}
inline void V1LayerParameter::clear_type() {
type_ = 0;
clear_has_type();
}
inline ::opencv_caffe::V1LayerParameter_LayerType V1LayerParameter::type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.type)
return static_cast< ::opencv_caffe::V1LayerParameter_LayerType >(type_);
}
inline void V1LayerParameter::set_type(::opencv_caffe::V1LayerParameter_LayerType value) {
assert(::opencv_caffe::V1LayerParameter_LayerType_IsValid(value));
set_has_type();
type_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.type)
}
// repeated .opencv_caffe.BlobProto blobs = 6;
inline int V1LayerParameter::blobs_size() const {
return blobs_.size();
}
inline void V1LayerParameter::clear_blobs() {
blobs_.Clear();
}
inline const ::opencv_caffe::BlobProto& V1LayerParameter::blobs(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blobs)
return blobs_.Get(index);
}
inline ::opencv_caffe::BlobProto* V1LayerParameter::mutable_blobs(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.blobs)
return blobs_.Mutable(index);
}
inline ::opencv_caffe::BlobProto* V1LayerParameter::add_blobs() {
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blobs)
return blobs_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
V1LayerParameter::mutable_blobs() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blobs)
return &blobs_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
V1LayerParameter::blobs() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.blobs)
return blobs_;
}
// repeated string param = 1001;
inline int V1LayerParameter::param_size() const {
return param_.size();
}
inline void V1LayerParameter::clear_param() {
param_.Clear();
}
inline const ::std::string& V1LayerParameter::param(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.param)
return param_.Get(index);
}
inline ::std::string* V1LayerParameter::mutable_param(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.param)
return param_.Mutable(index);
}
inline void V1LayerParameter::set_param(int index, const ::std::string& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.param)
param_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void V1LayerParameter::set_param(int index, ::std::string&& value) {
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.param)
param_.Mutable(index)->assign(std::move(value));
}
#endif
inline void V1LayerParameter::set_param(int index, const char* value) {
GOOGLE_DCHECK(value != NULL);
param_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::set_param(int index, const char* value, size_t size) {
param_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.param)
}
inline ::std::string* V1LayerParameter::add_param() {
// @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.param)
return param_.Add();
}
inline void V1LayerParameter::add_param(const ::std::string& value) {
param_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.param)
}
#if LANG_CXX11
inline void V1LayerParameter::add_param(::std::string&& value) {
param_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.param)
}
#endif
inline void V1LayerParameter::add_param(const char* value) {
GOOGLE_DCHECK(value != NULL);
param_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::add_param(const char* value, size_t size) {
param_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.param)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
V1LayerParameter::param() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.param)
return param_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
V1LayerParameter::mutable_param() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.param)
return &param_;
}
// repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
inline int V1LayerParameter::blob_share_mode_size() const {
return blob_share_mode_.size();
}
inline void V1LayerParameter::clear_blob_share_mode() {
blob_share_mode_.Clear();
}
inline ::opencv_caffe::V1LayerParameter_DimCheckMode V1LayerParameter::blob_share_mode(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blob_share_mode)
return static_cast< ::opencv_caffe::V1LayerParameter_DimCheckMode >(blob_share_mode_.Get(index));
}
inline void V1LayerParameter::set_blob_share_mode(int index, ::opencv_caffe::V1LayerParameter_DimCheckMode value) {
assert(::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid(value));
blob_share_mode_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.blob_share_mode)
}
inline void V1LayerParameter::add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value) {
assert(::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid(value));
blob_share_mode_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blob_share_mode)
}
inline const ::google::protobuf::RepeatedField<int>&
V1LayerParameter::blob_share_mode() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.blob_share_mode)
return blob_share_mode_;
}
inline ::google::protobuf::RepeatedField<int>*
V1LayerParameter::mutable_blob_share_mode() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blob_share_mode)
return &blob_share_mode_;
}
// repeated float blobs_lr = 7;
inline int V1LayerParameter::blobs_lr_size() const {
return blobs_lr_.size();
}
inline void V1LayerParameter::clear_blobs_lr() {
blobs_lr_.Clear();
}
inline float V1LayerParameter::blobs_lr(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blobs_lr)
return blobs_lr_.Get(index);
}
inline void V1LayerParameter::set_blobs_lr(int index, float value) {
blobs_lr_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.blobs_lr)
}
inline void V1LayerParameter::add_blobs_lr(float value) {
blobs_lr_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blobs_lr)
}
inline const ::google::protobuf::RepeatedField< float >&
V1LayerParameter::blobs_lr() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.blobs_lr)
return blobs_lr_;
}
inline ::google::protobuf::RepeatedField< float >*
V1LayerParameter::mutable_blobs_lr() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blobs_lr)
return &blobs_lr_;
}
// repeated float weight_decay = 8;
inline int V1LayerParameter::weight_decay_size() const {
return weight_decay_.size();
}
inline void V1LayerParameter::clear_weight_decay() {
weight_decay_.Clear();
}
inline float V1LayerParameter::weight_decay(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.weight_decay)
return weight_decay_.Get(index);
}
inline void V1LayerParameter::set_weight_decay(int index, float value) {
weight_decay_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.weight_decay)
}
inline void V1LayerParameter::add_weight_decay(float value) {
weight_decay_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.weight_decay)
}
inline const ::google::protobuf::RepeatedField< float >&
V1LayerParameter::weight_decay() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.weight_decay)
return weight_decay_;
}
inline ::google::protobuf::RepeatedField< float >*
V1LayerParameter::mutable_weight_decay() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.weight_decay)
return &weight_decay_;
}
// repeated float loss_weight = 35;
inline int V1LayerParameter::loss_weight_size() const {
return loss_weight_.size();
}
inline void V1LayerParameter::clear_loss_weight() {
loss_weight_.Clear();
}
inline float V1LayerParameter::loss_weight(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.loss_weight)
return loss_weight_.Get(index);
}
inline void V1LayerParameter::set_loss_weight(int index, float value) {
loss_weight_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.loss_weight)
}
inline void V1LayerParameter::add_loss_weight(float value) {
loss_weight_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.loss_weight)
}
inline const ::google::protobuf::RepeatedField< float >&
V1LayerParameter::loss_weight() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.loss_weight)
return loss_weight_;
}
inline ::google::protobuf::RepeatedField< float >*
V1LayerParameter::mutable_loss_weight() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.loss_weight)
return &loss_weight_;
}
// optional .opencv_caffe.AccuracyParameter accuracy_param = 27;
inline bool V1LayerParameter::has_accuracy_param() const {
return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void V1LayerParameter::set_has_accuracy_param() {
_has_bits_[0] |= 0x00100000u;
}
inline void V1LayerParameter::clear_has_accuracy_param() {
_has_bits_[0] &= ~0x00100000u;
}
inline void V1LayerParameter::clear_accuracy_param() {
if (accuracy_param_ != NULL) accuracy_param_->Clear();
clear_has_accuracy_param();
}
inline const ::opencv_caffe::AccuracyParameter& V1LayerParameter::accuracy_param() const {
const ::opencv_caffe::AccuracyParameter* p = accuracy_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.accuracy_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::AccuracyParameter*>(
&::opencv_caffe::_AccuracyParameter_default_instance_);
}
inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::release_accuracy_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.accuracy_param)
clear_has_accuracy_param();
::opencv_caffe::AccuracyParameter* temp = accuracy_param_;
accuracy_param_ = NULL;
return temp;
}
inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::mutable_accuracy_param() {
set_has_accuracy_param();
if (accuracy_param_ == NULL) {
accuracy_param_ = new ::opencv_caffe::AccuracyParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.accuracy_param)
return accuracy_param_;
}
inline void V1LayerParameter::set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete accuracy_param_;
}
if (accuracy_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
accuracy_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, accuracy_param, submessage_arena);
}
set_has_accuracy_param();
} else {
clear_has_accuracy_param();
}
accuracy_param_ = accuracy_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.accuracy_param)
}
// optional .opencv_caffe.ArgMaxParameter argmax_param = 23;
inline bool V1LayerParameter::has_argmax_param() const {
return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void V1LayerParameter::set_has_argmax_param() {
_has_bits_[0] |= 0x00010000u;
}
inline void V1LayerParameter::clear_has_argmax_param() {
_has_bits_[0] &= ~0x00010000u;
}
inline void V1LayerParameter::clear_argmax_param() {
if (argmax_param_ != NULL) argmax_param_->Clear();
clear_has_argmax_param();
}
inline const ::opencv_caffe::ArgMaxParameter& V1LayerParameter::argmax_param() const {
const ::opencv_caffe::ArgMaxParameter* p = argmax_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.argmax_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ArgMaxParameter*>(
&::opencv_caffe::_ArgMaxParameter_default_instance_);
}
inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::release_argmax_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.argmax_param)
clear_has_argmax_param();
::opencv_caffe::ArgMaxParameter* temp = argmax_param_;
argmax_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::mutable_argmax_param() {
set_has_argmax_param();
if (argmax_param_ == NULL) {
argmax_param_ = new ::opencv_caffe::ArgMaxParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.argmax_param)
return argmax_param_;
}
inline void V1LayerParameter::set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete argmax_param_;
}
if (argmax_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
argmax_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, argmax_param, submessage_arena);
}
set_has_argmax_param();
} else {
clear_has_argmax_param();
}
argmax_param_ = argmax_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.argmax_param)
}
// optional .opencv_caffe.ConcatParameter concat_param = 9;
inline bool V1LayerParameter::has_concat_param() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void V1LayerParameter::set_has_concat_param() {
_has_bits_[0] |= 0x00000004u;
}
inline void V1LayerParameter::clear_has_concat_param() {
_has_bits_[0] &= ~0x00000004u;
}
inline void V1LayerParameter::clear_concat_param() {
if (concat_param_ != NULL) concat_param_->Clear();
clear_has_concat_param();
}
inline const ::opencv_caffe::ConcatParameter& V1LayerParameter::concat_param() const {
const ::opencv_caffe::ConcatParameter* p = concat_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.concat_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ConcatParameter*>(
&::opencv_caffe::_ConcatParameter_default_instance_);
}
inline ::opencv_caffe::ConcatParameter* V1LayerParameter::release_concat_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.concat_param)
clear_has_concat_param();
::opencv_caffe::ConcatParameter* temp = concat_param_;
concat_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ConcatParameter* V1LayerParameter::mutable_concat_param() {
set_has_concat_param();
if (concat_param_ == NULL) {
concat_param_ = new ::opencv_caffe::ConcatParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.concat_param)
return concat_param_;
}
inline void V1LayerParameter::set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete concat_param_;
}
if (concat_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
concat_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, concat_param, submessage_arena);
}
set_has_concat_param();
} else {
clear_has_concat_param();
}
concat_param_ = concat_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.concat_param)
}
// optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40;
inline bool V1LayerParameter::has_contrastive_loss_param() const {
return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void V1LayerParameter::set_has_contrastive_loss_param() {
_has_bits_[0] |= 0x20000000u;
}
inline void V1LayerParameter::clear_has_contrastive_loss_param() {
_has_bits_[0] &= ~0x20000000u;
}
inline void V1LayerParameter::clear_contrastive_loss_param() {
if (contrastive_loss_param_ != NULL) contrastive_loss_param_->Clear();
clear_has_contrastive_loss_param();
}
inline const ::opencv_caffe::ContrastiveLossParameter& V1LayerParameter::contrastive_loss_param() const {
const ::opencv_caffe::ContrastiveLossParameter* p = contrastive_loss_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.contrastive_loss_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ContrastiveLossParameter*>(
&::opencv_caffe::_ContrastiveLossParameter_default_instance_);
}
inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::release_contrastive_loss_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.contrastive_loss_param)
clear_has_contrastive_loss_param();
::opencv_caffe::ContrastiveLossParameter* temp = contrastive_loss_param_;
contrastive_loss_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::mutable_contrastive_loss_param() {
set_has_contrastive_loss_param();
if (contrastive_loss_param_ == NULL) {
contrastive_loss_param_ = new ::opencv_caffe::ContrastiveLossParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.contrastive_loss_param)
return contrastive_loss_param_;
}
inline void V1LayerParameter::set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete contrastive_loss_param_;
}
if (contrastive_loss_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
contrastive_loss_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, contrastive_loss_param, submessage_arena);
}
set_has_contrastive_loss_param();
} else {
clear_has_contrastive_loss_param();
}
contrastive_loss_param_ = contrastive_loss_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.contrastive_loss_param)
}
// optional .opencv_caffe.ConvolutionParameter convolution_param = 10;
inline bool V1LayerParameter::has_convolution_param() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void V1LayerParameter::set_has_convolution_param() {
_has_bits_[0] |= 0x00000008u;
}
inline void V1LayerParameter::clear_has_convolution_param() {
_has_bits_[0] &= ~0x00000008u;
}
inline void V1LayerParameter::clear_convolution_param() {
if (convolution_param_ != NULL) convolution_param_->Clear();
clear_has_convolution_param();
}
inline const ::opencv_caffe::ConvolutionParameter& V1LayerParameter::convolution_param() const {
const ::opencv_caffe::ConvolutionParameter* p = convolution_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.convolution_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ConvolutionParameter*>(
&::opencv_caffe::_ConvolutionParameter_default_instance_);
}
inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::release_convolution_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.convolution_param)
clear_has_convolution_param();
::opencv_caffe::ConvolutionParameter* temp = convolution_param_;
convolution_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::mutable_convolution_param() {
set_has_convolution_param();
if (convolution_param_ == NULL) {
convolution_param_ = new ::opencv_caffe::ConvolutionParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.convolution_param)
return convolution_param_;
}
inline void V1LayerParameter::set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete convolution_param_;
}
if (convolution_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
convolution_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, convolution_param, submessage_arena);
}
set_has_convolution_param();
} else {
clear_has_convolution_param();
}
convolution_param_ = convolution_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.convolution_param)
}
// optional .opencv_caffe.DataParameter data_param = 11;
inline bool V1LayerParameter::has_data_param() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void V1LayerParameter::set_has_data_param() {
_has_bits_[0] |= 0x00000010u;
}
inline void V1LayerParameter::clear_has_data_param() {
_has_bits_[0] &= ~0x00000010u;
}
inline void V1LayerParameter::clear_data_param() {
if (data_param_ != NULL) data_param_->Clear();
clear_has_data_param();
}
inline const ::opencv_caffe::DataParameter& V1LayerParameter::data_param() const {
const ::opencv_caffe::DataParameter* p = data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::DataParameter*>(
&::opencv_caffe::_DataParameter_default_instance_);
}
inline ::opencv_caffe::DataParameter* V1LayerParameter::release_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.data_param)
clear_has_data_param();
::opencv_caffe::DataParameter* temp = data_param_;
data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::DataParameter* V1LayerParameter::mutable_data_param() {
set_has_data_param();
if (data_param_ == NULL) {
data_param_ = new ::opencv_caffe::DataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.data_param)
return data_param_;
}
inline void V1LayerParameter::set_allocated_data_param(::opencv_caffe::DataParameter* data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete data_param_;
}
if (data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, data_param, submessage_arena);
}
set_has_data_param();
} else {
clear_has_data_param();
}
data_param_ = data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.data_param)
}
// optional .opencv_caffe.DropoutParameter dropout_param = 12;
inline bool V1LayerParameter::has_dropout_param() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void V1LayerParameter::set_has_dropout_param() {
_has_bits_[0] |= 0x00000020u;
}
inline void V1LayerParameter::clear_has_dropout_param() {
_has_bits_[0] &= ~0x00000020u;
}
inline void V1LayerParameter::clear_dropout_param() {
if (dropout_param_ != NULL) dropout_param_->Clear();
clear_has_dropout_param();
}
inline const ::opencv_caffe::DropoutParameter& V1LayerParameter::dropout_param() const {
const ::opencv_caffe::DropoutParameter* p = dropout_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.dropout_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::DropoutParameter*>(
&::opencv_caffe::_DropoutParameter_default_instance_);
}
inline ::opencv_caffe::DropoutParameter* V1LayerParameter::release_dropout_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.dropout_param)
clear_has_dropout_param();
::opencv_caffe::DropoutParameter* temp = dropout_param_;
dropout_param_ = NULL;
return temp;
}
inline ::opencv_caffe::DropoutParameter* V1LayerParameter::mutable_dropout_param() {
set_has_dropout_param();
if (dropout_param_ == NULL) {
dropout_param_ = new ::opencv_caffe::DropoutParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.dropout_param)
return dropout_param_;
}
inline void V1LayerParameter::set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete dropout_param_;
}
if (dropout_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
dropout_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, dropout_param, submessage_arena);
}
set_has_dropout_param();
} else {
clear_has_dropout_param();
}
dropout_param_ = dropout_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.dropout_param)
}
// optional .opencv_caffe.DummyDataParameter dummy_data_param = 26;
inline bool V1LayerParameter::has_dummy_data_param() const {
return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void V1LayerParameter::set_has_dummy_data_param() {
_has_bits_[0] |= 0x00080000u;
}
inline void V1LayerParameter::clear_has_dummy_data_param() {
_has_bits_[0] &= ~0x00080000u;
}
inline void V1LayerParameter::clear_dummy_data_param() {
if (dummy_data_param_ != NULL) dummy_data_param_->Clear();
clear_has_dummy_data_param();
}
inline const ::opencv_caffe::DummyDataParameter& V1LayerParameter::dummy_data_param() const {
const ::opencv_caffe::DummyDataParameter* p = dummy_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.dummy_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::DummyDataParameter*>(
&::opencv_caffe::_DummyDataParameter_default_instance_);
}
inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::release_dummy_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.dummy_data_param)
clear_has_dummy_data_param();
::opencv_caffe::DummyDataParameter* temp = dummy_data_param_;
dummy_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::mutable_dummy_data_param() {
set_has_dummy_data_param();
if (dummy_data_param_ == NULL) {
dummy_data_param_ = new ::opencv_caffe::DummyDataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.dummy_data_param)
return dummy_data_param_;
}
inline void V1LayerParameter::set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete dummy_data_param_;
}
if (dummy_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
dummy_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, dummy_data_param, submessage_arena);
}
set_has_dummy_data_param();
} else {
clear_has_dummy_data_param();
}
dummy_data_param_ = dummy_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.dummy_data_param)
}
// optional .opencv_caffe.EltwiseParameter eltwise_param = 24;
inline bool V1LayerParameter::has_eltwise_param() const {
return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void V1LayerParameter::set_has_eltwise_param() {
_has_bits_[0] |= 0x00020000u;
}
inline void V1LayerParameter::clear_has_eltwise_param() {
_has_bits_[0] &= ~0x00020000u;
}
inline void V1LayerParameter::clear_eltwise_param() {
if (eltwise_param_ != NULL) eltwise_param_->Clear();
clear_has_eltwise_param();
}
inline const ::opencv_caffe::EltwiseParameter& V1LayerParameter::eltwise_param() const {
const ::opencv_caffe::EltwiseParameter* p = eltwise_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.eltwise_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::EltwiseParameter*>(
&::opencv_caffe::_EltwiseParameter_default_instance_);
}
inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::release_eltwise_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.eltwise_param)
clear_has_eltwise_param();
::opencv_caffe::EltwiseParameter* temp = eltwise_param_;
eltwise_param_ = NULL;
return temp;
}
inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::mutable_eltwise_param() {
set_has_eltwise_param();
if (eltwise_param_ == NULL) {
eltwise_param_ = new ::opencv_caffe::EltwiseParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.eltwise_param)
return eltwise_param_;
}
inline void V1LayerParameter::set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete eltwise_param_;
}
if (eltwise_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
eltwise_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, eltwise_param, submessage_arena);
}
set_has_eltwise_param();
} else {
clear_has_eltwise_param();
}
eltwise_param_ = eltwise_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.eltwise_param)
}
// optional .opencv_caffe.ExpParameter exp_param = 41;
inline bool V1LayerParameter::has_exp_param() const {
return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void V1LayerParameter::set_has_exp_param() {
_has_bits_[0] |= 0x40000000u;
}
inline void V1LayerParameter::clear_has_exp_param() {
_has_bits_[0] &= ~0x40000000u;
}
inline void V1LayerParameter::clear_exp_param() {
if (exp_param_ != NULL) exp_param_->Clear();
clear_has_exp_param();
}
inline const ::opencv_caffe::ExpParameter& V1LayerParameter::exp_param() const {
const ::opencv_caffe::ExpParameter* p = exp_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.exp_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ExpParameter*>(
&::opencv_caffe::_ExpParameter_default_instance_);
}
inline ::opencv_caffe::ExpParameter* V1LayerParameter::release_exp_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.exp_param)
clear_has_exp_param();
::opencv_caffe::ExpParameter* temp = exp_param_;
exp_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ExpParameter* V1LayerParameter::mutable_exp_param() {
set_has_exp_param();
if (exp_param_ == NULL) {
exp_param_ = new ::opencv_caffe::ExpParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.exp_param)
return exp_param_;
}
inline void V1LayerParameter::set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete exp_param_;
}
if (exp_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
exp_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, exp_param, submessage_arena);
}
set_has_exp_param();
} else {
clear_has_exp_param();
}
exp_param_ = exp_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.exp_param)
}
// optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13;
inline bool V1LayerParameter::has_hdf5_data_param() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void V1LayerParameter::set_has_hdf5_data_param() {
_has_bits_[0] |= 0x00000040u;
}
inline void V1LayerParameter::clear_has_hdf5_data_param() {
_has_bits_[0] &= ~0x00000040u;
}
inline void V1LayerParameter::clear_hdf5_data_param() {
if (hdf5_data_param_ != NULL) hdf5_data_param_->Clear();
clear_has_hdf5_data_param();
}
inline const ::opencv_caffe::HDF5DataParameter& V1LayerParameter::hdf5_data_param() const {
const ::opencv_caffe::HDF5DataParameter* p = hdf5_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hdf5_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::HDF5DataParameter*>(
&::opencv_caffe::_HDF5DataParameter_default_instance_);
}
inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::release_hdf5_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hdf5_data_param)
clear_has_hdf5_data_param();
::opencv_caffe::HDF5DataParameter* temp = hdf5_data_param_;
hdf5_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::mutable_hdf5_data_param() {
set_has_hdf5_data_param();
if (hdf5_data_param_ == NULL) {
hdf5_data_param_ = new ::opencv_caffe::HDF5DataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hdf5_data_param)
return hdf5_data_param_;
}
inline void V1LayerParameter::set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete hdf5_data_param_;
}
if (hdf5_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
hdf5_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, hdf5_data_param, submessage_arena);
}
set_has_hdf5_data_param();
} else {
clear_has_hdf5_data_param();
}
hdf5_data_param_ = hdf5_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.hdf5_data_param)
}
// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14;
inline bool V1LayerParameter::has_hdf5_output_param() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void V1LayerParameter::set_has_hdf5_output_param() {
_has_bits_[0] |= 0x00000080u;
}
inline void V1LayerParameter::clear_has_hdf5_output_param() {
_has_bits_[0] &= ~0x00000080u;
}
inline void V1LayerParameter::clear_hdf5_output_param() {
if (hdf5_output_param_ != NULL) hdf5_output_param_->Clear();
clear_has_hdf5_output_param();
}
inline const ::opencv_caffe::HDF5OutputParameter& V1LayerParameter::hdf5_output_param() const {
const ::opencv_caffe::HDF5OutputParameter* p = hdf5_output_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hdf5_output_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::HDF5OutputParameter*>(
&::opencv_caffe::_HDF5OutputParameter_default_instance_);
}
inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::release_hdf5_output_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hdf5_output_param)
clear_has_hdf5_output_param();
::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = NULL;
return temp;
}
inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::mutable_hdf5_output_param() {
set_has_hdf5_output_param();
if (hdf5_output_param_ == NULL) {
hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hdf5_output_param)
return hdf5_output_param_;
}
inline void V1LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete hdf5_output_param_;
}
if (hdf5_output_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
hdf5_output_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, hdf5_output_param, submessage_arena);
}
set_has_hdf5_output_param();
} else {
clear_has_hdf5_output_param();
}
hdf5_output_param_ = hdf5_output_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.hdf5_output_param)
}
// optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29;
inline bool V1LayerParameter::has_hinge_loss_param() const {
return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void V1LayerParameter::set_has_hinge_loss_param() {
_has_bits_[0] |= 0x00200000u;
}
inline void V1LayerParameter::clear_has_hinge_loss_param() {
_has_bits_[0] &= ~0x00200000u;
}
inline void V1LayerParameter::clear_hinge_loss_param() {
if (hinge_loss_param_ != NULL) hinge_loss_param_->Clear();
clear_has_hinge_loss_param();
}
inline const ::opencv_caffe::HingeLossParameter& V1LayerParameter::hinge_loss_param() const {
const ::opencv_caffe::HingeLossParameter* p = hinge_loss_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hinge_loss_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::HingeLossParameter*>(
&::opencv_caffe::_HingeLossParameter_default_instance_);
}
inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::release_hinge_loss_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hinge_loss_param)
clear_has_hinge_loss_param();
::opencv_caffe::HingeLossParameter* temp = hinge_loss_param_;
hinge_loss_param_ = NULL;
return temp;
}
inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::mutable_hinge_loss_param() {
set_has_hinge_loss_param();
if (hinge_loss_param_ == NULL) {
hinge_loss_param_ = new ::opencv_caffe::HingeLossParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hinge_loss_param)
return hinge_loss_param_;
}
inline void V1LayerParameter::set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete hinge_loss_param_;
}
if (hinge_loss_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
hinge_loss_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, hinge_loss_param, submessage_arena);
}
set_has_hinge_loss_param();
} else {
clear_has_hinge_loss_param();
}
hinge_loss_param_ = hinge_loss_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.hinge_loss_param)
}
// optional .opencv_caffe.ImageDataParameter image_data_param = 15;
inline bool V1LayerParameter::has_image_data_param() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void V1LayerParameter::set_has_image_data_param() {
_has_bits_[0] |= 0x00000100u;
}
inline void V1LayerParameter::clear_has_image_data_param() {
_has_bits_[0] &= ~0x00000100u;
}
inline void V1LayerParameter::clear_image_data_param() {
if (image_data_param_ != NULL) image_data_param_->Clear();
clear_has_image_data_param();
}
inline const ::opencv_caffe::ImageDataParameter& V1LayerParameter::image_data_param() const {
const ::opencv_caffe::ImageDataParameter* p = image_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.image_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ImageDataParameter*>(
&::opencv_caffe::_ImageDataParameter_default_instance_);
}
inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::release_image_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.image_data_param)
clear_has_image_data_param();
::opencv_caffe::ImageDataParameter* temp = image_data_param_;
image_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::mutable_image_data_param() {
set_has_image_data_param();
if (image_data_param_ == NULL) {
image_data_param_ = new ::opencv_caffe::ImageDataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.image_data_param)
return image_data_param_;
}
inline void V1LayerParameter::set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete image_data_param_;
}
if (image_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
image_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, image_data_param, submessage_arena);
}
set_has_image_data_param();
} else {
clear_has_image_data_param();
}
image_data_param_ = image_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.image_data_param)
}
// optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16;
inline bool V1LayerParameter::has_infogain_loss_param() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void V1LayerParameter::set_has_infogain_loss_param() {
_has_bits_[0] |= 0x00000200u;
}
inline void V1LayerParameter::clear_has_infogain_loss_param() {
_has_bits_[0] &= ~0x00000200u;
}
inline void V1LayerParameter::clear_infogain_loss_param() {
if (infogain_loss_param_ != NULL) infogain_loss_param_->Clear();
clear_has_infogain_loss_param();
}
inline const ::opencv_caffe::InfogainLossParameter& V1LayerParameter::infogain_loss_param() const {
const ::opencv_caffe::InfogainLossParameter* p = infogain_loss_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.infogain_loss_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::InfogainLossParameter*>(
&::opencv_caffe::_InfogainLossParameter_default_instance_);
}
inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::release_infogain_loss_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.infogain_loss_param)
clear_has_infogain_loss_param();
::opencv_caffe::InfogainLossParameter* temp = infogain_loss_param_;
infogain_loss_param_ = NULL;
return temp;
}
inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::mutable_infogain_loss_param() {
set_has_infogain_loss_param();
if (infogain_loss_param_ == NULL) {
infogain_loss_param_ = new ::opencv_caffe::InfogainLossParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.infogain_loss_param)
return infogain_loss_param_;
}
inline void V1LayerParameter::set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete infogain_loss_param_;
}
if (infogain_loss_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
infogain_loss_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, infogain_loss_param, submessage_arena);
}
set_has_infogain_loss_param();
} else {
clear_has_infogain_loss_param();
}
infogain_loss_param_ = infogain_loss_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.infogain_loss_param)
}
// optional .opencv_caffe.InnerProductParameter inner_product_param = 17;
inline bool V1LayerParameter::has_inner_product_param() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void V1LayerParameter::set_has_inner_product_param() {
_has_bits_[0] |= 0x00000400u;
}
inline void V1LayerParameter::clear_has_inner_product_param() {
_has_bits_[0] &= ~0x00000400u;
}
inline void V1LayerParameter::clear_inner_product_param() {
if (inner_product_param_ != NULL) inner_product_param_->Clear();
clear_has_inner_product_param();
}
inline const ::opencv_caffe::InnerProductParameter& V1LayerParameter::inner_product_param() const {
const ::opencv_caffe::InnerProductParameter* p = inner_product_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.inner_product_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::InnerProductParameter*>(
&::opencv_caffe::_InnerProductParameter_default_instance_);
}
inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::release_inner_product_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.inner_product_param)
clear_has_inner_product_param();
::opencv_caffe::InnerProductParameter* temp = inner_product_param_;
inner_product_param_ = NULL;
return temp;
}
inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::mutable_inner_product_param() {
set_has_inner_product_param();
if (inner_product_param_ == NULL) {
inner_product_param_ = new ::opencv_caffe::InnerProductParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.inner_product_param)
return inner_product_param_;
}
inline void V1LayerParameter::set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete inner_product_param_;
}
if (inner_product_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
inner_product_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, inner_product_param, submessage_arena);
}
set_has_inner_product_param();
} else {
clear_has_inner_product_param();
}
inner_product_param_ = inner_product_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.inner_product_param)
}
// optional .opencv_caffe.LRNParameter lrn_param = 18;
inline bool V1LayerParameter::has_lrn_param() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void V1LayerParameter::set_has_lrn_param() {
_has_bits_[0] |= 0x00000800u;
}
inline void V1LayerParameter::clear_has_lrn_param() {
_has_bits_[0] &= ~0x00000800u;
}
inline void V1LayerParameter::clear_lrn_param() {
if (lrn_param_ != NULL) lrn_param_->Clear();
clear_has_lrn_param();
}
inline const ::opencv_caffe::LRNParameter& V1LayerParameter::lrn_param() const {
const ::opencv_caffe::LRNParameter* p = lrn_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.lrn_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::LRNParameter*>(
&::opencv_caffe::_LRNParameter_default_instance_);
}
inline ::opencv_caffe::LRNParameter* V1LayerParameter::release_lrn_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.lrn_param)
clear_has_lrn_param();
::opencv_caffe::LRNParameter* temp = lrn_param_;
lrn_param_ = NULL;
return temp;
}
inline ::opencv_caffe::LRNParameter* V1LayerParameter::mutable_lrn_param() {
set_has_lrn_param();
if (lrn_param_ == NULL) {
lrn_param_ = new ::opencv_caffe::LRNParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.lrn_param)
return lrn_param_;
}
inline void V1LayerParameter::set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete lrn_param_;
}
if (lrn_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
lrn_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, lrn_param, submessage_arena);
}
set_has_lrn_param();
} else {
clear_has_lrn_param();
}
lrn_param_ = lrn_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.lrn_param)
}
// optional .opencv_caffe.MemoryDataParameter memory_data_param = 22;
inline bool V1LayerParameter::has_memory_data_param() const {
return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void V1LayerParameter::set_has_memory_data_param() {
_has_bits_[0] |= 0x00008000u;
}
inline void V1LayerParameter::clear_has_memory_data_param() {
_has_bits_[0] &= ~0x00008000u;
}
inline void V1LayerParameter::clear_memory_data_param() {
if (memory_data_param_ != NULL) memory_data_param_->Clear();
clear_has_memory_data_param();
}
inline const ::opencv_caffe::MemoryDataParameter& V1LayerParameter::memory_data_param() const {
const ::opencv_caffe::MemoryDataParameter* p = memory_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.memory_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::MemoryDataParameter*>(
&::opencv_caffe::_MemoryDataParameter_default_instance_);
}
inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::release_memory_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.memory_data_param)
clear_has_memory_data_param();
::opencv_caffe::MemoryDataParameter* temp = memory_data_param_;
memory_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::mutable_memory_data_param() {
set_has_memory_data_param();
if (memory_data_param_ == NULL) {
memory_data_param_ = new ::opencv_caffe::MemoryDataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.memory_data_param)
return memory_data_param_;
}
inline void V1LayerParameter::set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete memory_data_param_;
}
if (memory_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
memory_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, memory_data_param, submessage_arena);
}
set_has_memory_data_param();
} else {
clear_has_memory_data_param();
}
memory_data_param_ = memory_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.memory_data_param)
}
// optional .opencv_caffe.MVNParameter mvn_param = 34;
inline bool V1LayerParameter::has_mvn_param() const {
return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void V1LayerParameter::set_has_mvn_param() {
_has_bits_[0] |= 0x01000000u;
}
inline void V1LayerParameter::clear_has_mvn_param() {
_has_bits_[0] &= ~0x01000000u;
}
inline void V1LayerParameter::clear_mvn_param() {
if (mvn_param_ != NULL) mvn_param_->Clear();
clear_has_mvn_param();
}
inline const ::opencv_caffe::MVNParameter& V1LayerParameter::mvn_param() const {
const ::opencv_caffe::MVNParameter* p = mvn_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.mvn_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::MVNParameter*>(
&::opencv_caffe::_MVNParameter_default_instance_);
}
inline ::opencv_caffe::MVNParameter* V1LayerParameter::release_mvn_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.mvn_param)
clear_has_mvn_param();
::opencv_caffe::MVNParameter* temp = mvn_param_;
mvn_param_ = NULL;
return temp;
}
inline ::opencv_caffe::MVNParameter* V1LayerParameter::mutable_mvn_param() {
set_has_mvn_param();
if (mvn_param_ == NULL) {
mvn_param_ = new ::opencv_caffe::MVNParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.mvn_param)
return mvn_param_;
}
inline void V1LayerParameter::set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete mvn_param_;
}
if (mvn_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
mvn_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, mvn_param, submessage_arena);
}
set_has_mvn_param();
} else {
clear_has_mvn_param();
}
mvn_param_ = mvn_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.mvn_param)
}
// optional .opencv_caffe.PoolingParameter pooling_param = 19;
inline bool V1LayerParameter::has_pooling_param() const {
return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void V1LayerParameter::set_has_pooling_param() {
_has_bits_[0] |= 0x00001000u;
}
inline void V1LayerParameter::clear_has_pooling_param() {
_has_bits_[0] &= ~0x00001000u;
}
inline void V1LayerParameter::clear_pooling_param() {
if (pooling_param_ != NULL) pooling_param_->Clear();
clear_has_pooling_param();
}
inline const ::opencv_caffe::PoolingParameter& V1LayerParameter::pooling_param() const {
const ::opencv_caffe::PoolingParameter* p = pooling_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.pooling_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PoolingParameter*>(
&::opencv_caffe::_PoolingParameter_default_instance_);
}
inline ::opencv_caffe::PoolingParameter* V1LayerParameter::release_pooling_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.pooling_param)
clear_has_pooling_param();
::opencv_caffe::PoolingParameter* temp = pooling_param_;
pooling_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PoolingParameter* V1LayerParameter::mutable_pooling_param() {
set_has_pooling_param();
if (pooling_param_ == NULL) {
pooling_param_ = new ::opencv_caffe::PoolingParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.pooling_param)
return pooling_param_;
}
inline void V1LayerParameter::set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete pooling_param_;
}
if (pooling_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
pooling_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, pooling_param, submessage_arena);
}
set_has_pooling_param();
} else {
clear_has_pooling_param();
}
pooling_param_ = pooling_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.pooling_param)
}
// optional .opencv_caffe.PowerParameter power_param = 21;
inline bool V1LayerParameter::has_power_param() const {
return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void V1LayerParameter::set_has_power_param() {
_has_bits_[0] |= 0x00004000u;
}
inline void V1LayerParameter::clear_has_power_param() {
_has_bits_[0] &= ~0x00004000u;
}
inline void V1LayerParameter::clear_power_param() {
if (power_param_ != NULL) power_param_->Clear();
clear_has_power_param();
}
inline const ::opencv_caffe::PowerParameter& V1LayerParameter::power_param() const {
const ::opencv_caffe::PowerParameter* p = power_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.power_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::PowerParameter*>(
&::opencv_caffe::_PowerParameter_default_instance_);
}
inline ::opencv_caffe::PowerParameter* V1LayerParameter::release_power_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.power_param)
clear_has_power_param();
::opencv_caffe::PowerParameter* temp = power_param_;
power_param_ = NULL;
return temp;
}
inline ::opencv_caffe::PowerParameter* V1LayerParameter::mutable_power_param() {
set_has_power_param();
if (power_param_ == NULL) {
power_param_ = new ::opencv_caffe::PowerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.power_param)
return power_param_;
}
inline void V1LayerParameter::set_allocated_power_param(::opencv_caffe::PowerParameter* power_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete power_param_;
}
if (power_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
power_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, power_param, submessage_arena);
}
set_has_power_param();
} else {
clear_has_power_param();
}
power_param_ = power_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.power_param)
}
// optional .opencv_caffe.ReLUParameter relu_param = 30;
inline bool V1LayerParameter::has_relu_param() const {
return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void V1LayerParameter::set_has_relu_param() {
_has_bits_[0] |= 0x00400000u;
}
inline void V1LayerParameter::clear_has_relu_param() {
_has_bits_[0] &= ~0x00400000u;
}
inline void V1LayerParameter::clear_relu_param() {
if (relu_param_ != NULL) relu_param_->Clear();
clear_has_relu_param();
}
inline const ::opencv_caffe::ReLUParameter& V1LayerParameter::relu_param() const {
const ::opencv_caffe::ReLUParameter* p = relu_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.relu_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ReLUParameter*>(
&::opencv_caffe::_ReLUParameter_default_instance_);
}
inline ::opencv_caffe::ReLUParameter* V1LayerParameter::release_relu_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.relu_param)
clear_has_relu_param();
::opencv_caffe::ReLUParameter* temp = relu_param_;
relu_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ReLUParameter* V1LayerParameter::mutable_relu_param() {
set_has_relu_param();
if (relu_param_ == NULL) {
relu_param_ = new ::opencv_caffe::ReLUParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.relu_param)
return relu_param_;
}
inline void V1LayerParameter::set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete relu_param_;
}
if (relu_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
relu_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, relu_param, submessage_arena);
}
set_has_relu_param();
} else {
clear_has_relu_param();
}
relu_param_ = relu_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.relu_param)
}
// optional .opencv_caffe.SigmoidParameter sigmoid_param = 38;
inline bool V1LayerParameter::has_sigmoid_param() const {
return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void V1LayerParameter::set_has_sigmoid_param() {
_has_bits_[0] |= 0x08000000u;
}
inline void V1LayerParameter::clear_has_sigmoid_param() {
_has_bits_[0] &= ~0x08000000u;
}
inline void V1LayerParameter::clear_sigmoid_param() {
if (sigmoid_param_ != NULL) sigmoid_param_->Clear();
clear_has_sigmoid_param();
}
inline const ::opencv_caffe::SigmoidParameter& V1LayerParameter::sigmoid_param() const {
const ::opencv_caffe::SigmoidParameter* p = sigmoid_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.sigmoid_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::SigmoidParameter*>(
&::opencv_caffe::_SigmoidParameter_default_instance_);
}
inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::release_sigmoid_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.sigmoid_param)
clear_has_sigmoid_param();
::opencv_caffe::SigmoidParameter* temp = sigmoid_param_;
sigmoid_param_ = NULL;
return temp;
}
inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::mutable_sigmoid_param() {
set_has_sigmoid_param();
if (sigmoid_param_ == NULL) {
sigmoid_param_ = new ::opencv_caffe::SigmoidParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.sigmoid_param)
return sigmoid_param_;
}
inline void V1LayerParameter::set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete sigmoid_param_;
}
if (sigmoid_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
sigmoid_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, sigmoid_param, submessage_arena);
}
set_has_sigmoid_param();
} else {
clear_has_sigmoid_param();
}
sigmoid_param_ = sigmoid_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.sigmoid_param)
}
// optional .opencv_caffe.SoftmaxParameter softmax_param = 39;
inline bool V1LayerParameter::has_softmax_param() const {
return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void V1LayerParameter::set_has_softmax_param() {
_has_bits_[0] |= 0x10000000u;
}
inline void V1LayerParameter::clear_has_softmax_param() {
_has_bits_[0] &= ~0x10000000u;
}
inline void V1LayerParameter::clear_softmax_param() {
if (softmax_param_ != NULL) softmax_param_->Clear();
clear_has_softmax_param();
}
inline const ::opencv_caffe::SoftmaxParameter& V1LayerParameter::softmax_param() const {
const ::opencv_caffe::SoftmaxParameter* p = softmax_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.softmax_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::SoftmaxParameter*>(
&::opencv_caffe::_SoftmaxParameter_default_instance_);
}
inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::release_softmax_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.softmax_param)
clear_has_softmax_param();
::opencv_caffe::SoftmaxParameter* temp = softmax_param_;
softmax_param_ = NULL;
return temp;
}
inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::mutable_softmax_param() {
set_has_softmax_param();
if (softmax_param_ == NULL) {
softmax_param_ = new ::opencv_caffe::SoftmaxParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.softmax_param)
return softmax_param_;
}
inline void V1LayerParameter::set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete softmax_param_;
}
if (softmax_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
softmax_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, softmax_param, submessage_arena);
}
set_has_softmax_param();
} else {
clear_has_softmax_param();
}
softmax_param_ = softmax_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.softmax_param)
}
// optional .opencv_caffe.SliceParameter slice_param = 31;
inline bool V1LayerParameter::has_slice_param() const {
return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void V1LayerParameter::set_has_slice_param() {
_has_bits_[0] |= 0x00800000u;
}
inline void V1LayerParameter::clear_has_slice_param() {
_has_bits_[0] &= ~0x00800000u;
}
inline void V1LayerParameter::clear_slice_param() {
if (slice_param_ != NULL) slice_param_->Clear();
clear_has_slice_param();
}
inline const ::opencv_caffe::SliceParameter& V1LayerParameter::slice_param() const {
const ::opencv_caffe::SliceParameter* p = slice_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.slice_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::SliceParameter*>(
&::opencv_caffe::_SliceParameter_default_instance_);
}
inline ::opencv_caffe::SliceParameter* V1LayerParameter::release_slice_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.slice_param)
clear_has_slice_param();
::opencv_caffe::SliceParameter* temp = slice_param_;
slice_param_ = NULL;
return temp;
}
inline ::opencv_caffe::SliceParameter* V1LayerParameter::mutable_slice_param() {
set_has_slice_param();
if (slice_param_ == NULL) {
slice_param_ = new ::opencv_caffe::SliceParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.slice_param)
return slice_param_;
}
inline void V1LayerParameter::set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete slice_param_;
}
if (slice_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
slice_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, slice_param, submessage_arena);
}
set_has_slice_param();
} else {
clear_has_slice_param();
}
slice_param_ = slice_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.slice_param)
}
// optional .opencv_caffe.TanHParameter tanh_param = 37;
inline bool V1LayerParameter::has_tanh_param() const {
return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void V1LayerParameter::set_has_tanh_param() {
_has_bits_[0] |= 0x04000000u;
}
inline void V1LayerParameter::clear_has_tanh_param() {
_has_bits_[0] &= ~0x04000000u;
}
inline void V1LayerParameter::clear_tanh_param() {
if (tanh_param_ != NULL) tanh_param_->Clear();
clear_has_tanh_param();
}
inline const ::opencv_caffe::TanHParameter& V1LayerParameter::tanh_param() const {
const ::opencv_caffe::TanHParameter* p = tanh_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.tanh_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::TanHParameter*>(
&::opencv_caffe::_TanHParameter_default_instance_);
}
inline ::opencv_caffe::TanHParameter* V1LayerParameter::release_tanh_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.tanh_param)
clear_has_tanh_param();
::opencv_caffe::TanHParameter* temp = tanh_param_;
tanh_param_ = NULL;
return temp;
}
inline ::opencv_caffe::TanHParameter* V1LayerParameter::mutable_tanh_param() {
set_has_tanh_param();
if (tanh_param_ == NULL) {
tanh_param_ = new ::opencv_caffe::TanHParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.tanh_param)
return tanh_param_;
}
inline void V1LayerParameter::set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete tanh_param_;
}
if (tanh_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
tanh_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, tanh_param, submessage_arena);
}
set_has_tanh_param();
} else {
clear_has_tanh_param();
}
tanh_param_ = tanh_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.tanh_param)
}
// optional .opencv_caffe.ThresholdParameter threshold_param = 25;
inline bool V1LayerParameter::has_threshold_param() const {
return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void V1LayerParameter::set_has_threshold_param() {
_has_bits_[0] |= 0x00040000u;
}
inline void V1LayerParameter::clear_has_threshold_param() {
_has_bits_[0] &= ~0x00040000u;
}
inline void V1LayerParameter::clear_threshold_param() {
if (threshold_param_ != NULL) threshold_param_->Clear();
clear_has_threshold_param();
}
inline const ::opencv_caffe::ThresholdParameter& V1LayerParameter::threshold_param() const {
const ::opencv_caffe::ThresholdParameter* p = threshold_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.threshold_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::ThresholdParameter*>(
&::opencv_caffe::_ThresholdParameter_default_instance_);
}
inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::release_threshold_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.threshold_param)
clear_has_threshold_param();
::opencv_caffe::ThresholdParameter* temp = threshold_param_;
threshold_param_ = NULL;
return temp;
}
inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::mutable_threshold_param() {
set_has_threshold_param();
if (threshold_param_ == NULL) {
threshold_param_ = new ::opencv_caffe::ThresholdParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.threshold_param)
return threshold_param_;
}
inline void V1LayerParameter::set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete threshold_param_;
}
if (threshold_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
threshold_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, threshold_param, submessage_arena);
}
set_has_threshold_param();
} else {
clear_has_threshold_param();
}
threshold_param_ = threshold_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.threshold_param)
}
// optional .opencv_caffe.WindowDataParameter window_data_param = 20;
inline bool V1LayerParameter::has_window_data_param() const {
return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void V1LayerParameter::set_has_window_data_param() {
_has_bits_[0] |= 0x00002000u;
}
inline void V1LayerParameter::clear_has_window_data_param() {
_has_bits_[0] &= ~0x00002000u;
}
inline void V1LayerParameter::clear_window_data_param() {
if (window_data_param_ != NULL) window_data_param_->Clear();
clear_has_window_data_param();
}
inline const ::opencv_caffe::WindowDataParameter& V1LayerParameter::window_data_param() const {
const ::opencv_caffe::WindowDataParameter* p = window_data_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.window_data_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::WindowDataParameter*>(
&::opencv_caffe::_WindowDataParameter_default_instance_);
}
inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::release_window_data_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.window_data_param)
clear_has_window_data_param();
::opencv_caffe::WindowDataParameter* temp = window_data_param_;
window_data_param_ = NULL;
return temp;
}
inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::mutable_window_data_param() {
set_has_window_data_param();
if (window_data_param_ == NULL) {
window_data_param_ = new ::opencv_caffe::WindowDataParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.window_data_param)
return window_data_param_;
}
inline void V1LayerParameter::set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete window_data_param_;
}
if (window_data_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
window_data_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, window_data_param, submessage_arena);
}
set_has_window_data_param();
} else {
clear_has_window_data_param();
}
window_data_param_ = window_data_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.window_data_param)
}
// optional .opencv_caffe.TransformationParameter transform_param = 36;
inline bool V1LayerParameter::has_transform_param() const {
return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void V1LayerParameter::set_has_transform_param() {
_has_bits_[0] |= 0x02000000u;
}
inline void V1LayerParameter::clear_has_transform_param() {
_has_bits_[0] &= ~0x02000000u;
}
inline void V1LayerParameter::clear_transform_param() {
if (transform_param_ != NULL) transform_param_->Clear();
clear_has_transform_param();
}
inline const ::opencv_caffe::TransformationParameter& V1LayerParameter::transform_param() const {
const ::opencv_caffe::TransformationParameter* p = transform_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.transform_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::TransformationParameter*>(
&::opencv_caffe::_TransformationParameter_default_instance_);
}
inline ::opencv_caffe::TransformationParameter* V1LayerParameter::release_transform_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.transform_param)
clear_has_transform_param();
::opencv_caffe::TransformationParameter* temp = transform_param_;
transform_param_ = NULL;
return temp;
}
inline ::opencv_caffe::TransformationParameter* V1LayerParameter::mutable_transform_param() {
set_has_transform_param();
if (transform_param_ == NULL) {
transform_param_ = new ::opencv_caffe::TransformationParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.transform_param)
return transform_param_;
}
inline void V1LayerParameter::set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete transform_param_;
}
if (transform_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
transform_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, transform_param, submessage_arena);
}
set_has_transform_param();
} else {
clear_has_transform_param();
}
transform_param_ = transform_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.transform_param)
}
// optional .opencv_caffe.LossParameter loss_param = 42;
inline bool V1LayerParameter::has_loss_param() const {
return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void V1LayerParameter::set_has_loss_param() {
_has_bits_[0] |= 0x80000000u;
}
inline void V1LayerParameter::clear_has_loss_param() {
_has_bits_[0] &= ~0x80000000u;
}
inline void V1LayerParameter::clear_loss_param() {
if (loss_param_ != NULL) loss_param_->Clear();
clear_has_loss_param();
}
inline const ::opencv_caffe::LossParameter& V1LayerParameter::loss_param() const {
const ::opencv_caffe::LossParameter* p = loss_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.loss_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::LossParameter*>(
&::opencv_caffe::_LossParameter_default_instance_);
}
inline ::opencv_caffe::LossParameter* V1LayerParameter::release_loss_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.loss_param)
clear_has_loss_param();
::opencv_caffe::LossParameter* temp = loss_param_;
loss_param_ = NULL;
return temp;
}
inline ::opencv_caffe::LossParameter* V1LayerParameter::mutable_loss_param() {
set_has_loss_param();
if (loss_param_ == NULL) {
loss_param_ = new ::opencv_caffe::LossParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.loss_param)
return loss_param_;
}
inline void V1LayerParameter::set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete loss_param_;
}
if (loss_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
loss_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, loss_param, submessage_arena);
}
set_has_loss_param();
} else {
clear_has_loss_param();
}
loss_param_ = loss_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.loss_param)
}
// optional .opencv_caffe.V0LayerParameter layer = 1;
inline bool V1LayerParameter::has_layer() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void V1LayerParameter::set_has_layer() {
_has_bits_[0] |= 0x00000002u;
}
inline void V1LayerParameter::clear_has_layer() {
_has_bits_[0] &= ~0x00000002u;
}
inline void V1LayerParameter::clear_layer() {
if (layer_ != NULL) layer_->Clear();
clear_has_layer();
}
inline const ::opencv_caffe::V0LayerParameter& V1LayerParameter::layer() const {
const ::opencv_caffe::V0LayerParameter* p = layer_;
// @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.layer)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::V0LayerParameter*>(
&::opencv_caffe::_V0LayerParameter_default_instance_);
}
inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::release_layer() {
// @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.layer)
clear_has_layer();
::opencv_caffe::V0LayerParameter* temp = layer_;
layer_ = NULL;
return temp;
}
inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::mutable_layer() {
set_has_layer();
if (layer_ == NULL) {
layer_ = new ::opencv_caffe::V0LayerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.layer)
return layer_;
}
inline void V1LayerParameter::set_allocated_layer(::opencv_caffe::V0LayerParameter* layer) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete layer_;
}
if (layer) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
layer = ::google::protobuf::internal::GetOwnedMessage(
message_arena, layer, submessage_arena);
}
set_has_layer();
} else {
clear_has_layer();
}
layer_ = layer;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.layer)
}
// -------------------------------------------------------------------
// V0LayerParameter
// optional string name = 1;
inline bool V0LayerParameter::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void V0LayerParameter::set_has_name() {
_has_bits_[0] |= 0x00000001u;
}
inline void V0LayerParameter::clear_has_name() {
_has_bits_[0] &= ~0x00000001u;
}
inline void V0LayerParameter::clear_name() {
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string& V0LayerParameter::name() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.name)
return name_.GetNoArena();
}
inline void V0LayerParameter::set_name(const ::std::string& value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.name)
}
#if LANG_CXX11
inline void V0LayerParameter::set_name(::std::string&& value) {
set_has_name();
name_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.V0LayerParameter.name)
}
#endif
inline void V0LayerParameter::set_name(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.V0LayerParameter.name)
}
inline void V0LayerParameter::set_name(const char* value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V0LayerParameter.name)
}
inline ::std::string* V0LayerParameter::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.name)
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* V0LayerParameter::release_name() {
// @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.name)
clear_has_name();
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void V0LayerParameter::set_allocated_name(::std::string* name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.name)
}
// optional string type = 2;
inline bool V0LayerParameter::has_type() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void V0LayerParameter::set_has_type() {
_has_bits_[0] |= 0x00000002u;
}
inline void V0LayerParameter::clear_has_type() {
_has_bits_[0] &= ~0x00000002u;
}
inline void V0LayerParameter::clear_type() {
type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_type();
}
inline const ::std::string& V0LayerParameter::type() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.type)
return type_.GetNoArena();
}
inline void V0LayerParameter::set_type(const ::std::string& value) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.type)
}
#if LANG_CXX11
inline void V0LayerParameter::set_type(::std::string&& value) {
set_has_type();
type_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.V0LayerParameter.type)
}
#endif
inline void V0LayerParameter::set_type(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.V0LayerParameter.type)
}
inline void V0LayerParameter::set_type(const char* value, size_t size) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V0LayerParameter.type)
}
inline ::std::string* V0LayerParameter::mutable_type() {
set_has_type();
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.type)
return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* V0LayerParameter::release_type() {
// @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.type)
clear_has_type();
return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void V0LayerParameter::set_allocated_type(::std::string* type) {
if (type != NULL) {
set_has_type();
} else {
clear_has_type();
}
type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.type)
}
// optional uint32 num_output = 3;
inline bool V0LayerParameter::has_num_output() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void V0LayerParameter::set_has_num_output() {
_has_bits_[0] |= 0x00000100u;
}
inline void V0LayerParameter::clear_has_num_output() {
_has_bits_[0] &= ~0x00000100u;
}
inline void V0LayerParameter::clear_num_output() {
num_output_ = 0u;
clear_has_num_output();
}
inline ::google::protobuf::uint32 V0LayerParameter::num_output() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.num_output)
return num_output_;
}
inline void V0LayerParameter::set_num_output(::google::protobuf::uint32 value) {
set_has_num_output();
num_output_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.num_output)
}
// optional bool biasterm = 4 [default = true];
inline bool V0LayerParameter::has_biasterm() const {
return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void V0LayerParameter::set_has_biasterm() {
_has_bits_[0] |= 0x00800000u;
}
inline void V0LayerParameter::clear_has_biasterm() {
_has_bits_[0] &= ~0x00800000u;
}
inline void V0LayerParameter::clear_biasterm() {
biasterm_ = true;
clear_has_biasterm();
}
inline bool V0LayerParameter::biasterm() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.biasterm)
return biasterm_;
}
inline void V0LayerParameter::set_biasterm(bool value) {
set_has_biasterm();
biasterm_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.biasterm)
}
// optional .opencv_caffe.FillerParameter weight_filler = 5;
inline bool V0LayerParameter::has_weight_filler() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void V0LayerParameter::set_has_weight_filler() {
_has_bits_[0] |= 0x00000020u;
}
inline void V0LayerParameter::clear_has_weight_filler() {
_has_bits_[0] &= ~0x00000020u;
}
inline void V0LayerParameter::clear_weight_filler() {
if (weight_filler_ != NULL) weight_filler_->Clear();
clear_has_weight_filler();
}
inline const ::opencv_caffe::FillerParameter& V0LayerParameter::weight_filler() const {
const ::opencv_caffe::FillerParameter* p = weight_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.weight_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::release_weight_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.weight_filler)
clear_has_weight_filler();
::opencv_caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::mutable_weight_filler() {
set_has_weight_filler();
if (weight_filler_ == NULL) {
weight_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.weight_filler)
return weight_filler_;
}
inline void V0LayerParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete weight_filler_;
}
if (weight_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
weight_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
set_has_weight_filler();
} else {
clear_has_weight_filler();
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.weight_filler)
}
// optional .opencv_caffe.FillerParameter bias_filler = 6;
inline bool V0LayerParameter::has_bias_filler() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void V0LayerParameter::set_has_bias_filler() {
_has_bits_[0] |= 0x00000040u;
}
inline void V0LayerParameter::clear_has_bias_filler() {
_has_bits_[0] &= ~0x00000040u;
}
inline void V0LayerParameter::clear_bias_filler() {
if (bias_filler_ != NULL) bias_filler_->Clear();
clear_has_bias_filler();
}
inline const ::opencv_caffe::FillerParameter& V0LayerParameter::bias_filler() const {
const ::opencv_caffe::FillerParameter* p = bias_filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.bias_filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::release_bias_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.bias_filler)
clear_has_bias_filler();
::opencv_caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::mutable_bias_filler() {
set_has_bias_filler();
if (bias_filler_ == NULL) {
bias_filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.bias_filler)
return bias_filler_;
}
inline void V0LayerParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete bias_filler_;
}
if (bias_filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
bias_filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
set_has_bias_filler();
} else {
clear_has_bias_filler();
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.bias_filler)
}
// optional uint32 pad = 7 [default = 0];
inline bool V0LayerParameter::has_pad() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void V0LayerParameter::set_has_pad() {
_has_bits_[0] |= 0x00000200u;
}
inline void V0LayerParameter::clear_has_pad() {
_has_bits_[0] &= ~0x00000200u;
}
inline void V0LayerParameter::clear_pad() {
pad_ = 0u;
clear_has_pad();
}
inline ::google::protobuf::uint32 V0LayerParameter::pad() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.pad)
return pad_;
}
inline void V0LayerParameter::set_pad(::google::protobuf::uint32 value) {
set_has_pad();
pad_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.pad)
}
// optional uint32 kernelsize = 8;
inline bool V0LayerParameter::has_kernelsize() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void V0LayerParameter::set_has_kernelsize() {
_has_bits_[0] |= 0x00000400u;
}
inline void V0LayerParameter::clear_has_kernelsize() {
_has_bits_[0] &= ~0x00000400u;
}
inline void V0LayerParameter::clear_kernelsize() {
kernelsize_ = 0u;
clear_has_kernelsize();
}
inline ::google::protobuf::uint32 V0LayerParameter::kernelsize() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.kernelsize)
return kernelsize_;
}
inline void V0LayerParameter::set_kernelsize(::google::protobuf::uint32 value) {
set_has_kernelsize();
kernelsize_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.kernelsize)
}
// optional uint32 group = 9 [default = 1];
inline bool V0LayerParameter::has_group() const {
return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void V0LayerParameter::set_has_group() {
_has_bits_[0] |= 0x01000000u;
}
inline void V0LayerParameter::clear_has_group() {
_has_bits_[0] &= ~0x01000000u;
}
inline void V0LayerParameter::clear_group() {
group_ = 1u;
clear_has_group();
}
inline ::google::protobuf::uint32 V0LayerParameter::group() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.group)
return group_;
}
inline void V0LayerParameter::set_group(::google::protobuf::uint32 value) {
set_has_group();
group_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.group)
}
// optional uint32 stride = 10 [default = 1];
inline bool V0LayerParameter::has_stride() const {
return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void V0LayerParameter::set_has_stride() {
_has_bits_[0] |= 0x02000000u;
}
inline void V0LayerParameter::clear_has_stride() {
_has_bits_[0] &= ~0x02000000u;
}
inline void V0LayerParameter::clear_stride() {
stride_ = 1u;
clear_has_stride();
}
inline ::google::protobuf::uint32 V0LayerParameter::stride() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.stride)
return stride_;
}
inline void V0LayerParameter::set_stride(::google::protobuf::uint32 value) {
set_has_stride();
stride_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.stride)
}
// optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
inline bool V0LayerParameter::has_pool() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void V0LayerParameter::set_has_pool() {
_has_bits_[0] |= 0x00000800u;
}
inline void V0LayerParameter::clear_has_pool() {
_has_bits_[0] &= ~0x00000800u;
}
inline void V0LayerParameter::clear_pool() {
pool_ = 0;
clear_has_pool();
}
inline ::opencv_caffe::V0LayerParameter_PoolMethod V0LayerParameter::pool() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.pool)
return static_cast< ::opencv_caffe::V0LayerParameter_PoolMethod >(pool_);
}
inline void V0LayerParameter::set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value) {
assert(::opencv_caffe::V0LayerParameter_PoolMethod_IsValid(value));
set_has_pool();
pool_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.pool)
}
// optional float dropout_ratio = 12 [default = 0.5];
inline bool V0LayerParameter::has_dropout_ratio() const {
return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void V0LayerParameter::set_has_dropout_ratio() {
_has_bits_[0] |= 0x04000000u;
}
inline void V0LayerParameter::clear_has_dropout_ratio() {
_has_bits_[0] &= ~0x04000000u;
}
inline void V0LayerParameter::clear_dropout_ratio() {
dropout_ratio_ = 0.5f;
clear_has_dropout_ratio();
}
inline float V0LayerParameter::dropout_ratio() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.dropout_ratio)
return dropout_ratio_;
}
inline void V0LayerParameter::set_dropout_ratio(float value) {
set_has_dropout_ratio();
dropout_ratio_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.dropout_ratio)
}
// optional uint32 local_size = 13 [default = 5];
inline bool V0LayerParameter::has_local_size() const {
return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void V0LayerParameter::set_has_local_size() {
_has_bits_[0] |= 0x08000000u;
}
inline void V0LayerParameter::clear_has_local_size() {
_has_bits_[0] &= ~0x08000000u;
}
inline void V0LayerParameter::clear_local_size() {
local_size_ = 5u;
clear_has_local_size();
}
inline ::google::protobuf::uint32 V0LayerParameter::local_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.local_size)
return local_size_;
}
inline void V0LayerParameter::set_local_size(::google::protobuf::uint32 value) {
set_has_local_size();
local_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.local_size)
}
// optional float alpha = 14 [default = 1];
inline bool V0LayerParameter::has_alpha() const {
return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void V0LayerParameter::set_has_alpha() {
_has_bits_[0] |= 0x10000000u;
}
inline void V0LayerParameter::clear_has_alpha() {
_has_bits_[0] &= ~0x10000000u;
}
inline void V0LayerParameter::clear_alpha() {
alpha_ = 1;
clear_has_alpha();
}
inline float V0LayerParameter::alpha() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.alpha)
return alpha_;
}
inline void V0LayerParameter::set_alpha(float value) {
set_has_alpha();
alpha_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.alpha)
}
// optional float beta = 15 [default = 0.75];
inline bool V0LayerParameter::has_beta() const {
return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void V0LayerParameter::set_has_beta() {
_has_bits_[0] |= 0x20000000u;
}
inline void V0LayerParameter::clear_has_beta() {
_has_bits_[0] &= ~0x20000000u;
}
inline void V0LayerParameter::clear_beta() {
beta_ = 0.75f;
clear_has_beta();
}
inline float V0LayerParameter::beta() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.beta)
return beta_;
}
inline void V0LayerParameter::set_beta(float value) {
set_has_beta();
beta_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.beta)
}
// optional float k = 22 [default = 1];
inline bool V0LayerParameter::has_k() const {
return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void V0LayerParameter::set_has_k() {
_has_bits_[0] |= 0x80000000u;
}
inline void V0LayerParameter::clear_has_k() {
_has_bits_[0] &= ~0x80000000u;
}
inline void V0LayerParameter::clear_k() {
k_ = 1;
clear_has_k();
}
inline float V0LayerParameter::k() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.k)
return k_;
}
inline void V0LayerParameter::set_k(float value) {
set_has_k();
k_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.k)
}
// optional string source = 16;
inline bool V0LayerParameter::has_source() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void V0LayerParameter::set_has_source() {
_has_bits_[0] |= 0x00000004u;
}
inline void V0LayerParameter::clear_has_source() {
_has_bits_[0] &= ~0x00000004u;
}
inline void V0LayerParameter::clear_source() {
source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_source();
}
inline const ::std::string& V0LayerParameter::source() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.source)
return source_.GetNoArena();
}
inline void V0LayerParameter::set_source(const ::std::string& value) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.source)
}
#if LANG_CXX11
inline void V0LayerParameter::set_source(::std::string&& value) {
set_has_source();
source_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.V0LayerParameter.source)
}
#endif
inline void V0LayerParameter::set_source(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.V0LayerParameter.source)
}
inline void V0LayerParameter::set_source(const char* value, size_t size) {
set_has_source();
source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V0LayerParameter.source)
}
inline ::std::string* V0LayerParameter::mutable_source() {
set_has_source();
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.source)
return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* V0LayerParameter::release_source() {
// @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.source)
clear_has_source();
return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void V0LayerParameter::set_allocated_source(::std::string* source) {
if (source != NULL) {
set_has_source();
} else {
clear_has_source();
}
source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.source)
}
// optional float scale = 17 [default = 1];
inline bool V0LayerParameter::has_scale() const {
return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void V0LayerParameter::set_has_scale() {
_has_bits_[0] |= 0x40000000u;
}
inline void V0LayerParameter::clear_has_scale() {
_has_bits_[0] &= ~0x40000000u;
}
inline void V0LayerParameter::clear_scale() {
scale_ = 1;
clear_has_scale();
}
inline float V0LayerParameter::scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.scale)
return scale_;
}
inline void V0LayerParameter::set_scale(float value) {
set_has_scale();
scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.scale)
}
// optional string meanfile = 18;
inline bool V0LayerParameter::has_meanfile() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void V0LayerParameter::set_has_meanfile() {
_has_bits_[0] |= 0x00000008u;
}
inline void V0LayerParameter::clear_has_meanfile() {
_has_bits_[0] &= ~0x00000008u;
}
inline void V0LayerParameter::clear_meanfile() {
meanfile_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_meanfile();
}
inline const ::std::string& V0LayerParameter::meanfile() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.meanfile)
return meanfile_.GetNoArena();
}
inline void V0LayerParameter::set_meanfile(const ::std::string& value) {
set_has_meanfile();
meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.meanfile)
}
#if LANG_CXX11
inline void V0LayerParameter::set_meanfile(::std::string&& value) {
set_has_meanfile();
meanfile_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.V0LayerParameter.meanfile)
}
#endif
inline void V0LayerParameter::set_meanfile(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_meanfile();
meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.V0LayerParameter.meanfile)
}
inline void V0LayerParameter::set_meanfile(const char* value, size_t size) {
set_has_meanfile();
meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V0LayerParameter.meanfile)
}
inline ::std::string* V0LayerParameter::mutable_meanfile() {
set_has_meanfile();
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.meanfile)
return meanfile_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* V0LayerParameter::release_meanfile() {
// @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.meanfile)
clear_has_meanfile();
return meanfile_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void V0LayerParameter::set_allocated_meanfile(::std::string* meanfile) {
if (meanfile != NULL) {
set_has_meanfile();
} else {
clear_has_meanfile();
}
meanfile_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), meanfile);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.meanfile)
}
// optional uint32 batchsize = 19;
inline bool V0LayerParameter::has_batchsize() const {
return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void V0LayerParameter::set_has_batchsize() {
_has_bits_[0] |= 0x00001000u;
}
inline void V0LayerParameter::clear_has_batchsize() {
_has_bits_[0] &= ~0x00001000u;
}
inline void V0LayerParameter::clear_batchsize() {
batchsize_ = 0u;
clear_has_batchsize();
}
inline ::google::protobuf::uint32 V0LayerParameter::batchsize() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.batchsize)
return batchsize_;
}
inline void V0LayerParameter::set_batchsize(::google::protobuf::uint32 value) {
set_has_batchsize();
batchsize_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.batchsize)
}
// optional uint32 cropsize = 20 [default = 0];
inline bool V0LayerParameter::has_cropsize() const {
return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void V0LayerParameter::set_has_cropsize() {
_has_bits_[0] |= 0x00002000u;
}
inline void V0LayerParameter::clear_has_cropsize() {
_has_bits_[0] &= ~0x00002000u;
}
inline void V0LayerParameter::clear_cropsize() {
cropsize_ = 0u;
clear_has_cropsize();
}
inline ::google::protobuf::uint32 V0LayerParameter::cropsize() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.cropsize)
return cropsize_;
}
inline void V0LayerParameter::set_cropsize(::google::protobuf::uint32 value) {
set_has_cropsize();
cropsize_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.cropsize)
}
// optional bool mirror = 21 [default = false];
inline bool V0LayerParameter::has_mirror() const {
return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void V0LayerParameter::set_has_mirror() {
_has_bits_[0] |= 0x00008000u;
}
inline void V0LayerParameter::clear_has_mirror() {
_has_bits_[0] &= ~0x00008000u;
}
inline void V0LayerParameter::clear_mirror() {
mirror_ = false;
clear_has_mirror();
}
inline bool V0LayerParameter::mirror() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.mirror)
return mirror_;
}
inline void V0LayerParameter::set_mirror(bool value) {
set_has_mirror();
mirror_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.mirror)
}
// repeated .opencv_caffe.BlobProto blobs = 50;
inline int V0LayerParameter::blobs_size() const {
return blobs_.size();
}
inline void V0LayerParameter::clear_blobs() {
blobs_.Clear();
}
inline const ::opencv_caffe::BlobProto& V0LayerParameter::blobs(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.blobs)
return blobs_.Get(index);
}
inline ::opencv_caffe::BlobProto* V0LayerParameter::mutable_blobs(int index) {
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.blobs)
return blobs_.Mutable(index);
}
inline ::opencv_caffe::BlobProto* V0LayerParameter::add_blobs() {
// @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.blobs)
return blobs_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >*
V0LayerParameter::mutable_blobs() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.blobs)
return &blobs_;
}
inline const ::google::protobuf::RepeatedPtrField< ::opencv_caffe::BlobProto >&
V0LayerParameter::blobs() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V0LayerParameter.blobs)
return blobs_;
}
// repeated float blobs_lr = 51;
inline int V0LayerParameter::blobs_lr_size() const {
return blobs_lr_.size();
}
inline void V0LayerParameter::clear_blobs_lr() {
blobs_lr_.Clear();
}
inline float V0LayerParameter::blobs_lr(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.blobs_lr)
return blobs_lr_.Get(index);
}
inline void V0LayerParameter::set_blobs_lr(int index, float value) {
blobs_lr_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.blobs_lr)
}
inline void V0LayerParameter::add_blobs_lr(float value) {
blobs_lr_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.blobs_lr)
}
inline const ::google::protobuf::RepeatedField< float >&
V0LayerParameter::blobs_lr() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V0LayerParameter.blobs_lr)
return blobs_lr_;
}
inline ::google::protobuf::RepeatedField< float >*
V0LayerParameter::mutable_blobs_lr() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.blobs_lr)
return &blobs_lr_;
}
// repeated float weight_decay = 52;
inline int V0LayerParameter::weight_decay_size() const {
return weight_decay_.size();
}
inline void V0LayerParameter::clear_weight_decay() {
weight_decay_.Clear();
}
inline float V0LayerParameter::weight_decay(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.weight_decay)
return weight_decay_.Get(index);
}
inline void V0LayerParameter::set_weight_decay(int index, float value) {
weight_decay_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.weight_decay)
}
inline void V0LayerParameter::add_weight_decay(float value) {
weight_decay_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.weight_decay)
}
inline const ::google::protobuf::RepeatedField< float >&
V0LayerParameter::weight_decay() const {
// @@protoc_insertion_point(field_list:opencv_caffe.V0LayerParameter.weight_decay)
return weight_decay_;
}
inline ::google::protobuf::RepeatedField< float >*
V0LayerParameter::mutable_weight_decay() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.weight_decay)
return &weight_decay_;
}
// optional uint32 rand_skip = 53 [default = 0];
inline bool V0LayerParameter::has_rand_skip() const {
return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void V0LayerParameter::set_has_rand_skip() {
_has_bits_[0] |= 0x00020000u;
}
inline void V0LayerParameter::clear_has_rand_skip() {
_has_bits_[0] &= ~0x00020000u;
}
inline void V0LayerParameter::clear_rand_skip() {
rand_skip_ = 0u;
clear_has_rand_skip();
}
inline ::google::protobuf::uint32 V0LayerParameter::rand_skip() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.rand_skip)
return rand_skip_;
}
inline void V0LayerParameter::set_rand_skip(::google::protobuf::uint32 value) {
set_has_rand_skip();
rand_skip_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.rand_skip)
}
// optional float det_fg_threshold = 54 [default = 0.5];
inline bool V0LayerParameter::has_det_fg_threshold() const {
return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void V0LayerParameter::set_has_det_fg_threshold() {
_has_bits_[1] |= 0x00000001u;
}
inline void V0LayerParameter::clear_has_det_fg_threshold() {
_has_bits_[1] &= ~0x00000001u;
}
inline void V0LayerParameter::clear_det_fg_threshold() {
det_fg_threshold_ = 0.5f;
clear_has_det_fg_threshold();
}
inline float V0LayerParameter::det_fg_threshold() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_fg_threshold)
return det_fg_threshold_;
}
inline void V0LayerParameter::set_det_fg_threshold(float value) {
set_has_det_fg_threshold();
det_fg_threshold_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_fg_threshold)
}
// optional float det_bg_threshold = 55 [default = 0.5];
inline bool V0LayerParameter::has_det_bg_threshold() const {
return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void V0LayerParameter::set_has_det_bg_threshold() {
_has_bits_[1] |= 0x00000002u;
}
inline void V0LayerParameter::clear_has_det_bg_threshold() {
_has_bits_[1] &= ~0x00000002u;
}
inline void V0LayerParameter::clear_det_bg_threshold() {
det_bg_threshold_ = 0.5f;
clear_has_det_bg_threshold();
}
inline float V0LayerParameter::det_bg_threshold() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_bg_threshold)
return det_bg_threshold_;
}
inline void V0LayerParameter::set_det_bg_threshold(float value) {
set_has_det_bg_threshold();
det_bg_threshold_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_bg_threshold)
}
// optional float det_fg_fraction = 56 [default = 0.25];
inline bool V0LayerParameter::has_det_fg_fraction() const {
return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void V0LayerParameter::set_has_det_fg_fraction() {
_has_bits_[1] |= 0x00000004u;
}
inline void V0LayerParameter::clear_has_det_fg_fraction() {
_has_bits_[1] &= ~0x00000004u;
}
inline void V0LayerParameter::clear_det_fg_fraction() {
det_fg_fraction_ = 0.25f;
clear_has_det_fg_fraction();
}
inline float V0LayerParameter::det_fg_fraction() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_fg_fraction)
return det_fg_fraction_;
}
inline void V0LayerParameter::set_det_fg_fraction(float value) {
set_has_det_fg_fraction();
det_fg_fraction_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_fg_fraction)
}
// optional uint32 det_context_pad = 58 [default = 0];
inline bool V0LayerParameter::has_det_context_pad() const {
return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void V0LayerParameter::set_has_det_context_pad() {
_has_bits_[0] |= 0x00040000u;
}
inline void V0LayerParameter::clear_has_det_context_pad() {
_has_bits_[0] &= ~0x00040000u;
}
inline void V0LayerParameter::clear_det_context_pad() {
det_context_pad_ = 0u;
clear_has_det_context_pad();
}
inline ::google::protobuf::uint32 V0LayerParameter::det_context_pad() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_context_pad)
return det_context_pad_;
}
inline void V0LayerParameter::set_det_context_pad(::google::protobuf::uint32 value) {
set_has_det_context_pad();
det_context_pad_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_context_pad)
}
// optional string det_crop_mode = 59 [default = "warp"];
inline bool V0LayerParameter::has_det_crop_mode() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void V0LayerParameter::set_has_det_crop_mode() {
_has_bits_[0] |= 0x00000010u;
}
inline void V0LayerParameter::clear_has_det_crop_mode() {
_has_bits_[0] &= ~0x00000010u;
}
inline void V0LayerParameter::clear_det_crop_mode() {
det_crop_mode_.ClearToDefaultNoArena(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get());
clear_has_det_crop_mode();
}
inline const ::std::string& V0LayerParameter::det_crop_mode() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_crop_mode)
return det_crop_mode_.GetNoArena();
}
inline void V0LayerParameter::set_det_crop_mode(const ::std::string& value) {
set_has_det_crop_mode();
det_crop_mode_.SetNoArena(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get(), value);
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_crop_mode)
}
#if LANG_CXX11
inline void V0LayerParameter::set_det_crop_mode(::std::string&& value) {
set_has_det_crop_mode();
det_crop_mode_.SetNoArena(
&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:opencv_caffe.V0LayerParameter.det_crop_mode)
}
#endif
inline void V0LayerParameter::set_det_crop_mode(const char* value) {
GOOGLE_DCHECK(value != NULL);
set_has_det_crop_mode();
det_crop_mode_.SetNoArena(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:opencv_caffe.V0LayerParameter.det_crop_mode)
}
inline void V0LayerParameter::set_det_crop_mode(const char* value, size_t size) {
set_has_det_crop_mode();
det_crop_mode_.SetNoArena(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:opencv_caffe.V0LayerParameter.det_crop_mode)
}
inline ::std::string* V0LayerParameter::mutable_det_crop_mode() {
set_has_det_crop_mode();
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.det_crop_mode)
return det_crop_mode_.MutableNoArena(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get());
}
inline ::std::string* V0LayerParameter::release_det_crop_mode() {
// @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.det_crop_mode)
clear_has_det_crop_mode();
return det_crop_mode_.ReleaseNoArena(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get());
}
inline void V0LayerParameter::set_allocated_det_crop_mode(::std::string* det_crop_mode) {
if (det_crop_mode != NULL) {
set_has_det_crop_mode();
} else {
clear_has_det_crop_mode();
}
det_crop_mode_.SetAllocatedNoArena(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get(), det_crop_mode);
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.det_crop_mode)
}
// optional int32 new_num = 60 [default = 0];
inline bool V0LayerParameter::has_new_num() const {
return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void V0LayerParameter::set_has_new_num() {
_has_bits_[0] |= 0x00080000u;
}
inline void V0LayerParameter::clear_has_new_num() {
_has_bits_[0] &= ~0x00080000u;
}
inline void V0LayerParameter::clear_new_num() {
new_num_ = 0;
clear_has_new_num();
}
inline ::google::protobuf::int32 V0LayerParameter::new_num() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_num)
return new_num_;
}
inline void V0LayerParameter::set_new_num(::google::protobuf::int32 value) {
set_has_new_num();
new_num_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_num)
}
// optional int32 new_channels = 61 [default = 0];
inline bool V0LayerParameter::has_new_channels() const {
return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void V0LayerParameter::set_has_new_channels() {
_has_bits_[0] |= 0x00100000u;
}
inline void V0LayerParameter::clear_has_new_channels() {
_has_bits_[0] &= ~0x00100000u;
}
inline void V0LayerParameter::clear_new_channels() {
new_channels_ = 0;
clear_has_new_channels();
}
inline ::google::protobuf::int32 V0LayerParameter::new_channels() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_channels)
return new_channels_;
}
inline void V0LayerParameter::set_new_channels(::google::protobuf::int32 value) {
set_has_new_channels();
new_channels_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_channels)
}
// optional int32 new_height = 62 [default = 0];
inline bool V0LayerParameter::has_new_height() const {
return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void V0LayerParameter::set_has_new_height() {
_has_bits_[0] |= 0x00200000u;
}
inline void V0LayerParameter::clear_has_new_height() {
_has_bits_[0] &= ~0x00200000u;
}
inline void V0LayerParameter::clear_new_height() {
new_height_ = 0;
clear_has_new_height();
}
inline ::google::protobuf::int32 V0LayerParameter::new_height() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_height)
return new_height_;
}
inline void V0LayerParameter::set_new_height(::google::protobuf::int32 value) {
set_has_new_height();
new_height_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_height)
}
// optional int32 new_width = 63 [default = 0];
inline bool V0LayerParameter::has_new_width() const {
return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void V0LayerParameter::set_has_new_width() {
_has_bits_[0] |= 0x00004000u;
}
inline void V0LayerParameter::clear_has_new_width() {
_has_bits_[0] &= ~0x00004000u;
}
inline void V0LayerParameter::clear_new_width() {
new_width_ = 0;
clear_has_new_width();
}
inline ::google::protobuf::int32 V0LayerParameter::new_width() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_width)
return new_width_;
}
inline void V0LayerParameter::set_new_width(::google::protobuf::int32 value) {
set_has_new_width();
new_width_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_width)
}
// optional bool shuffle_images = 64 [default = false];
inline bool V0LayerParameter::has_shuffle_images() const {
return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void V0LayerParameter::set_has_shuffle_images() {
_has_bits_[0] |= 0x00010000u;
}
inline void V0LayerParameter::clear_has_shuffle_images() {
_has_bits_[0] &= ~0x00010000u;
}
inline void V0LayerParameter::clear_shuffle_images() {
shuffle_images_ = false;
clear_has_shuffle_images();
}
inline bool V0LayerParameter::shuffle_images() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.shuffle_images)
return shuffle_images_;
}
inline void V0LayerParameter::set_shuffle_images(bool value) {
set_has_shuffle_images();
shuffle_images_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.shuffle_images)
}
// optional uint32 concat_dim = 65 [default = 1];
inline bool V0LayerParameter::has_concat_dim() const {
return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void V0LayerParameter::set_has_concat_dim() {
_has_bits_[0] |= 0x00400000u;
}
inline void V0LayerParameter::clear_has_concat_dim() {
_has_bits_[0] &= ~0x00400000u;
}
inline void V0LayerParameter::clear_concat_dim() {
concat_dim_ = 1u;
clear_has_concat_dim();
}
inline ::google::protobuf::uint32 V0LayerParameter::concat_dim() const {
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.concat_dim)
return concat_dim_;
}
inline void V0LayerParameter::set_concat_dim(::google::protobuf::uint32 value) {
set_has_concat_dim();
concat_dim_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.concat_dim)
}
// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001;
inline bool V0LayerParameter::has_hdf5_output_param() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void V0LayerParameter::set_has_hdf5_output_param() {
_has_bits_[0] |= 0x00000080u;
}
inline void V0LayerParameter::clear_has_hdf5_output_param() {
_has_bits_[0] &= ~0x00000080u;
}
inline void V0LayerParameter::clear_hdf5_output_param() {
if (hdf5_output_param_ != NULL) hdf5_output_param_->Clear();
clear_has_hdf5_output_param();
}
inline const ::opencv_caffe::HDF5OutputParameter& V0LayerParameter::hdf5_output_param() const {
const ::opencv_caffe::HDF5OutputParameter* p = hdf5_output_param_;
// @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.hdf5_output_param)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::HDF5OutputParameter*>(
&::opencv_caffe::_HDF5OutputParameter_default_instance_);
}
inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::release_hdf5_output_param() {
// @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.hdf5_output_param)
clear_has_hdf5_output_param();
::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = NULL;
return temp;
}
inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::mutable_hdf5_output_param() {
set_has_hdf5_output_param();
if (hdf5_output_param_ == NULL) {
hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.hdf5_output_param)
return hdf5_output_param_;
}
inline void V0LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete hdf5_output_param_;
}
if (hdf5_output_param) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
hdf5_output_param = ::google::protobuf::internal::GetOwnedMessage(
message_arena, hdf5_output_param, submessage_arena);
}
set_has_hdf5_output_param();
} else {
clear_has_hdf5_output_param();
}
hdf5_output_param_ = hdf5_output_param;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.hdf5_output_param)
}
// -------------------------------------------------------------------
// PReLUParameter
// optional .opencv_caffe.FillerParameter filler = 1;
inline bool PReLUParameter::has_filler() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PReLUParameter::set_has_filler() {
_has_bits_[0] |= 0x00000001u;
}
inline void PReLUParameter::clear_has_filler() {
_has_bits_[0] &= ~0x00000001u;
}
inline void PReLUParameter::clear_filler() {
if (filler_ != NULL) filler_->Clear();
clear_has_filler();
}
inline const ::opencv_caffe::FillerParameter& PReLUParameter::filler() const {
const ::opencv_caffe::FillerParameter* p = filler_;
// @@protoc_insertion_point(field_get:opencv_caffe.PReLUParameter.filler)
return p != NULL ? *p : *reinterpret_cast<const ::opencv_caffe::FillerParameter*>(
&::opencv_caffe::_FillerParameter_default_instance_);
}
inline ::opencv_caffe::FillerParameter* PReLUParameter::release_filler() {
// @@protoc_insertion_point(field_release:opencv_caffe.PReLUParameter.filler)
clear_has_filler();
::opencv_caffe::FillerParameter* temp = filler_;
filler_ = NULL;
return temp;
}
inline ::opencv_caffe::FillerParameter* PReLUParameter::mutable_filler() {
set_has_filler();
if (filler_ == NULL) {
filler_ = new ::opencv_caffe::FillerParameter;
}
// @@protoc_insertion_point(field_mutable:opencv_caffe.PReLUParameter.filler)
return filler_;
}
inline void PReLUParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) {
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == NULL) {
delete filler_;
}
if (filler) {
::google::protobuf::Arena* submessage_arena = NULL;
if (message_arena != submessage_arena) {
filler = ::google::protobuf::internal::GetOwnedMessage(
message_arena, filler, submessage_arena);
}
set_has_filler();
} else {
clear_has_filler();
}
filler_ = filler;
// @@protoc_insertion_point(field_set_allocated:opencv_caffe.PReLUParameter.filler)
}
// optional bool channel_shared = 2 [default = false];
inline bool PReLUParameter::has_channel_shared() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PReLUParameter::set_has_channel_shared() {
_has_bits_[0] |= 0x00000002u;
}
inline void PReLUParameter::clear_has_channel_shared() {
_has_bits_[0] &= ~0x00000002u;
}
inline void PReLUParameter::clear_channel_shared() {
channel_shared_ = false;
clear_has_channel_shared();
}
inline bool PReLUParameter::channel_shared() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PReLUParameter.channel_shared)
return channel_shared_;
}
inline void PReLUParameter::set_channel_shared(bool value) {
set_has_channel_shared();
channel_shared_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PReLUParameter.channel_shared)
}
// -------------------------------------------------------------------
// NormalizedBBox
// optional float xmin = 1;
inline bool NormalizedBBox::has_xmin() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NormalizedBBox::set_has_xmin() {
_has_bits_[0] |= 0x00000001u;
}
inline void NormalizedBBox::clear_has_xmin() {
_has_bits_[0] &= ~0x00000001u;
}
inline void NormalizedBBox::clear_xmin() {
xmin_ = 0;
clear_has_xmin();
}
inline float NormalizedBBox::xmin() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.xmin)
return xmin_;
}
inline void NormalizedBBox::set_xmin(float value) {
set_has_xmin();
xmin_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.xmin)
}
// optional float ymin = 2;
inline bool NormalizedBBox::has_ymin() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NormalizedBBox::set_has_ymin() {
_has_bits_[0] |= 0x00000002u;
}
inline void NormalizedBBox::clear_has_ymin() {
_has_bits_[0] &= ~0x00000002u;
}
inline void NormalizedBBox::clear_ymin() {
ymin_ = 0;
clear_has_ymin();
}
inline float NormalizedBBox::ymin() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.ymin)
return ymin_;
}
inline void NormalizedBBox::set_ymin(float value) {
set_has_ymin();
ymin_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.ymin)
}
// optional float xmax = 3;
inline bool NormalizedBBox::has_xmax() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NormalizedBBox::set_has_xmax() {
_has_bits_[0] |= 0x00000004u;
}
inline void NormalizedBBox::clear_has_xmax() {
_has_bits_[0] &= ~0x00000004u;
}
inline void NormalizedBBox::clear_xmax() {
xmax_ = 0;
clear_has_xmax();
}
inline float NormalizedBBox::xmax() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.xmax)
return xmax_;
}
inline void NormalizedBBox::set_xmax(float value) {
set_has_xmax();
xmax_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.xmax)
}
// optional float ymax = 4;
inline bool NormalizedBBox::has_ymax() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NormalizedBBox::set_has_ymax() {
_has_bits_[0] |= 0x00000008u;
}
inline void NormalizedBBox::clear_has_ymax() {
_has_bits_[0] &= ~0x00000008u;
}
inline void NormalizedBBox::clear_ymax() {
ymax_ = 0;
clear_has_ymax();
}
inline float NormalizedBBox::ymax() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.ymax)
return ymax_;
}
inline void NormalizedBBox::set_ymax(float value) {
set_has_ymax();
ymax_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.ymax)
}
// optional int32 label = 5;
inline bool NormalizedBBox::has_label() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void NormalizedBBox::set_has_label() {
_has_bits_[0] |= 0x00000010u;
}
inline void NormalizedBBox::clear_has_label() {
_has_bits_[0] &= ~0x00000010u;
}
inline void NormalizedBBox::clear_label() {
label_ = 0;
clear_has_label();
}
inline ::google::protobuf::int32 NormalizedBBox::label() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.label)
return label_;
}
inline void NormalizedBBox::set_label(::google::protobuf::int32 value) {
set_has_label();
label_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.label)
}
// optional bool difficult = 6;
inline bool NormalizedBBox::has_difficult() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void NormalizedBBox::set_has_difficult() {
_has_bits_[0] |= 0x00000020u;
}
inline void NormalizedBBox::clear_has_difficult() {
_has_bits_[0] &= ~0x00000020u;
}
inline void NormalizedBBox::clear_difficult() {
difficult_ = false;
clear_has_difficult();
}
inline bool NormalizedBBox::difficult() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.difficult)
return difficult_;
}
inline void NormalizedBBox::set_difficult(bool value) {
set_has_difficult();
difficult_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.difficult)
}
// optional float score = 7;
inline bool NormalizedBBox::has_score() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void NormalizedBBox::set_has_score() {
_has_bits_[0] |= 0x00000040u;
}
inline void NormalizedBBox::clear_has_score() {
_has_bits_[0] &= ~0x00000040u;
}
inline void NormalizedBBox::clear_score() {
score_ = 0;
clear_has_score();
}
inline float NormalizedBBox::score() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.score)
return score_;
}
inline void NormalizedBBox::set_score(float value) {
set_has_score();
score_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.score)
}
// optional float size = 8;
inline bool NormalizedBBox::has_size() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void NormalizedBBox::set_has_size() {
_has_bits_[0] |= 0x00000080u;
}
inline void NormalizedBBox::clear_has_size() {
_has_bits_[0] &= ~0x00000080u;
}
inline void NormalizedBBox::clear_size() {
size_ = 0;
clear_has_size();
}
inline float NormalizedBBox::size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.size)
return size_;
}
inline void NormalizedBBox::set_size(float value) {
set_has_size();
size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.size)
}
// -------------------------------------------------------------------
// ROIPoolingParameter
// optional uint32 pooled_h = 1 [default = 0];
inline bool ROIPoolingParameter::has_pooled_h() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ROIPoolingParameter::set_has_pooled_h() {
_has_bits_[0] |= 0x00000001u;
}
inline void ROIPoolingParameter::clear_has_pooled_h() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ROIPoolingParameter::clear_pooled_h() {
pooled_h_ = 0u;
clear_has_pooled_h();
}
inline ::google::protobuf::uint32 ROIPoolingParameter::pooled_h() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.pooled_h)
return pooled_h_;
}
inline void ROIPoolingParameter::set_pooled_h(::google::protobuf::uint32 value) {
set_has_pooled_h();
pooled_h_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.pooled_h)
}
// optional uint32 pooled_w = 2 [default = 0];
inline bool ROIPoolingParameter::has_pooled_w() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ROIPoolingParameter::set_has_pooled_w() {
_has_bits_[0] |= 0x00000002u;
}
inline void ROIPoolingParameter::clear_has_pooled_w() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ROIPoolingParameter::clear_pooled_w() {
pooled_w_ = 0u;
clear_has_pooled_w();
}
inline ::google::protobuf::uint32 ROIPoolingParameter::pooled_w() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.pooled_w)
return pooled_w_;
}
inline void ROIPoolingParameter::set_pooled_w(::google::protobuf::uint32 value) {
set_has_pooled_w();
pooled_w_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.pooled_w)
}
// optional float spatial_scale = 3 [default = 1];
inline bool ROIPoolingParameter::has_spatial_scale() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ROIPoolingParameter::set_has_spatial_scale() {
_has_bits_[0] |= 0x00000004u;
}
inline void ROIPoolingParameter::clear_has_spatial_scale() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ROIPoolingParameter::clear_spatial_scale() {
spatial_scale_ = 1;
clear_has_spatial_scale();
}
inline float ROIPoolingParameter::spatial_scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.spatial_scale)
return spatial_scale_;
}
inline void ROIPoolingParameter::set_spatial_scale(float value) {
set_has_spatial_scale();
spatial_scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.spatial_scale)
}
// -------------------------------------------------------------------
// ProposalParameter
// optional uint32 feat_stride = 1 [default = 16];
inline bool ProposalParameter::has_feat_stride() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProposalParameter::set_has_feat_stride() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProposalParameter::clear_has_feat_stride() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProposalParameter::clear_feat_stride() {
feat_stride_ = 16u;
clear_has_feat_stride();
}
inline ::google::protobuf::uint32 ProposalParameter::feat_stride() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.feat_stride)
return feat_stride_;
}
inline void ProposalParameter::set_feat_stride(::google::protobuf::uint32 value) {
set_has_feat_stride();
feat_stride_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.feat_stride)
}
// optional uint32 base_size = 2 [default = 16];
inline bool ProposalParameter::has_base_size() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProposalParameter::set_has_base_size() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProposalParameter::clear_has_base_size() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProposalParameter::clear_base_size() {
base_size_ = 16u;
clear_has_base_size();
}
inline ::google::protobuf::uint32 ProposalParameter::base_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.base_size)
return base_size_;
}
inline void ProposalParameter::set_base_size(::google::protobuf::uint32 value) {
set_has_base_size();
base_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.base_size)
}
// optional uint32 min_size = 3 [default = 16];
inline bool ProposalParameter::has_min_size() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProposalParameter::set_has_min_size() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProposalParameter::clear_has_min_size() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProposalParameter::clear_min_size() {
min_size_ = 16u;
clear_has_min_size();
}
inline ::google::protobuf::uint32 ProposalParameter::min_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.min_size)
return min_size_;
}
inline void ProposalParameter::set_min_size(::google::protobuf::uint32 value) {
set_has_min_size();
min_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.min_size)
}
// repeated float ratio = 4;
inline int ProposalParameter::ratio_size() const {
return ratio_.size();
}
inline void ProposalParameter::clear_ratio() {
ratio_.Clear();
}
inline float ProposalParameter::ratio(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.ratio)
return ratio_.Get(index);
}
inline void ProposalParameter::set_ratio(int index, float value) {
ratio_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.ratio)
}
inline void ProposalParameter::add_ratio(float value) {
ratio_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.ProposalParameter.ratio)
}
inline const ::google::protobuf::RepeatedField< float >&
ProposalParameter::ratio() const {
// @@protoc_insertion_point(field_list:opencv_caffe.ProposalParameter.ratio)
return ratio_;
}
inline ::google::protobuf::RepeatedField< float >*
ProposalParameter::mutable_ratio() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.ProposalParameter.ratio)
return &ratio_;
}
// repeated float scale = 5;
inline int ProposalParameter::scale_size() const {
return scale_.size();
}
inline void ProposalParameter::clear_scale() {
scale_.Clear();
}
inline float ProposalParameter::scale(int index) const {
// @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.scale)
return scale_.Get(index);
}
inline void ProposalParameter::set_scale(int index, float value) {
scale_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.scale)
}
inline void ProposalParameter::add_scale(float value) {
scale_.Add(value);
// @@protoc_insertion_point(field_add:opencv_caffe.ProposalParameter.scale)
}
inline const ::google::protobuf::RepeatedField< float >&
ProposalParameter::scale() const {
// @@protoc_insertion_point(field_list:opencv_caffe.ProposalParameter.scale)
return scale_;
}
inline ::google::protobuf::RepeatedField< float >*
ProposalParameter::mutable_scale() {
// @@protoc_insertion_point(field_mutable_list:opencv_caffe.ProposalParameter.scale)
return &scale_;
}
// optional uint32 pre_nms_topn = 6 [default = 6000];
inline bool ProposalParameter::has_pre_nms_topn() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProposalParameter::set_has_pre_nms_topn() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProposalParameter::clear_has_pre_nms_topn() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProposalParameter::clear_pre_nms_topn() {
pre_nms_topn_ = 6000u;
clear_has_pre_nms_topn();
}
inline ::google::protobuf::uint32 ProposalParameter::pre_nms_topn() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.pre_nms_topn)
return pre_nms_topn_;
}
inline void ProposalParameter::set_pre_nms_topn(::google::protobuf::uint32 value) {
set_has_pre_nms_topn();
pre_nms_topn_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.pre_nms_topn)
}
// optional uint32 post_nms_topn = 7 [default = 300];
inline bool ProposalParameter::has_post_nms_topn() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProposalParameter::set_has_post_nms_topn() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProposalParameter::clear_has_post_nms_topn() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProposalParameter::clear_post_nms_topn() {
post_nms_topn_ = 300u;
clear_has_post_nms_topn();
}
inline ::google::protobuf::uint32 ProposalParameter::post_nms_topn() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.post_nms_topn)
return post_nms_topn_;
}
inline void ProposalParameter::set_post_nms_topn(::google::protobuf::uint32 value) {
set_has_post_nms_topn();
post_nms_topn_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.post_nms_topn)
}
// optional float nms_thresh = 8 [default = 0.7];
inline bool ProposalParameter::has_nms_thresh() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ProposalParameter::set_has_nms_thresh() {
_has_bits_[0] |= 0x00000020u;
}
inline void ProposalParameter::clear_has_nms_thresh() {
_has_bits_[0] &= ~0x00000020u;
}
inline void ProposalParameter::clear_nms_thresh() {
nms_thresh_ = 0.7f;
clear_has_nms_thresh();
}
inline float ProposalParameter::nms_thresh() const {
// @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.nms_thresh)
return nms_thresh_;
}
inline void ProposalParameter::set_nms_thresh(float value) {
set_has_nms_thresh();
nms_thresh_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.nms_thresh)
}
// -------------------------------------------------------------------
// PSROIPoolingParameter
// required float spatial_scale = 1;
inline bool PSROIPoolingParameter::has_spatial_scale() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PSROIPoolingParameter::set_has_spatial_scale() {
_has_bits_[0] |= 0x00000001u;
}
inline void PSROIPoolingParameter::clear_has_spatial_scale() {
_has_bits_[0] &= ~0x00000001u;
}
inline void PSROIPoolingParameter::clear_spatial_scale() {
spatial_scale_ = 0;
clear_has_spatial_scale();
}
inline float PSROIPoolingParameter::spatial_scale() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.spatial_scale)
return spatial_scale_;
}
inline void PSROIPoolingParameter::set_spatial_scale(float value) {
set_has_spatial_scale();
spatial_scale_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PSROIPoolingParameter.spatial_scale)
}
// required int32 output_dim = 2;
inline bool PSROIPoolingParameter::has_output_dim() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PSROIPoolingParameter::set_has_output_dim() {
_has_bits_[0] |= 0x00000002u;
}
inline void PSROIPoolingParameter::clear_has_output_dim() {
_has_bits_[0] &= ~0x00000002u;
}
inline void PSROIPoolingParameter::clear_output_dim() {
output_dim_ = 0;
clear_has_output_dim();
}
inline ::google::protobuf::int32 PSROIPoolingParameter::output_dim() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.output_dim)
return output_dim_;
}
inline void PSROIPoolingParameter::set_output_dim(::google::protobuf::int32 value) {
set_has_output_dim();
output_dim_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PSROIPoolingParameter.output_dim)
}
// required int32 group_size = 3;
inline bool PSROIPoolingParameter::has_group_size() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PSROIPoolingParameter::set_has_group_size() {
_has_bits_[0] |= 0x00000004u;
}
inline void PSROIPoolingParameter::clear_has_group_size() {
_has_bits_[0] &= ~0x00000004u;
}
inline void PSROIPoolingParameter::clear_group_size() {
group_size_ = 0;
clear_has_group_size();
}
inline ::google::protobuf::int32 PSROIPoolingParameter::group_size() const {
// @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.group_size)
return group_size_;
}
inline void PSROIPoolingParameter::set_group_size(::google::protobuf::int32 value) {
set_has_group_size();
group_size_ = value;
// @@protoc_insertion_point(field_set:opencv_caffe.PSROIPoolingParameter.group_size)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace opencv_caffe
namespace google {
namespace protobuf {
template <> struct is_proto_enum< ::opencv_caffe::PriorBoxParameter_CodeType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::PriorBoxParameter_CodeType>() {
return ::opencv_caffe::PriorBoxParameter_CodeType_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::FillerParameter_VarianceNorm> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::FillerParameter_VarianceNorm>() {
return ::opencv_caffe::FillerParameter_VarianceNorm_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SolverParameter_SnapshotFormat> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SolverParameter_SnapshotFormat>() {
return ::opencv_caffe::SolverParameter_SnapshotFormat_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SolverParameter_SolverMode> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SolverParameter_SolverMode>() {
return ::opencv_caffe::SolverParameter_SolverMode_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SolverParameter_SolverType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SolverParameter_SolverType>() {
return ::opencv_caffe::SolverParameter_SolverType_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::ParamSpec_DimCheckMode> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::ParamSpec_DimCheckMode>() {
return ::opencv_caffe::ParamSpec_DimCheckMode_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::LossParameter_NormalizationMode> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::LossParameter_NormalizationMode>() {
return ::opencv_caffe::LossParameter_NormalizationMode_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::ConvolutionParameter_Engine> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::ConvolutionParameter_Engine>() {
return ::opencv_caffe::ConvolutionParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::DataParameter_DB> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::DataParameter_DB>() {
return ::opencv_caffe::DataParameter_DB_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::EltwiseParameter_EltwiseOp> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::EltwiseParameter_EltwiseOp>() {
return ::opencv_caffe::EltwiseParameter_EltwiseOp_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::HingeLossParameter_Norm> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::HingeLossParameter_Norm>() {
return ::opencv_caffe::HingeLossParameter_Norm_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::LRNParameter_NormRegion> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::LRNParameter_NormRegion>() {
return ::opencv_caffe::LRNParameter_NormRegion_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::LRNParameter_Engine> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::LRNParameter_Engine>() {
return ::opencv_caffe::LRNParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::PoolingParameter_PoolMethod> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::PoolingParameter_PoolMethod>() {
return ::opencv_caffe::PoolingParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::PoolingParameter_Engine> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::PoolingParameter_Engine>() {
return ::opencv_caffe::PoolingParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::ReductionParameter_ReductionOp> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::ReductionParameter_ReductionOp>() {
return ::opencv_caffe::ReductionParameter_ReductionOp_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::ReLUParameter_Engine> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::ReLUParameter_Engine>() {
return ::opencv_caffe::ReLUParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SigmoidParameter_Engine> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SigmoidParameter_Engine>() {
return ::opencv_caffe::SigmoidParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SoftmaxParameter_Engine> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SoftmaxParameter_Engine>() {
return ::opencv_caffe::SoftmaxParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::TanHParameter_Engine> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::TanHParameter_Engine>() {
return ::opencv_caffe::TanHParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SPPParameter_PoolMethod> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SPPParameter_PoolMethod>() {
return ::opencv_caffe::SPPParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SPPParameter_Engine> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SPPParameter_Engine>() {
return ::opencv_caffe::SPPParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::V1LayerParameter_LayerType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::V1LayerParameter_LayerType>() {
return ::opencv_caffe::V1LayerParameter_LayerType_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::V1LayerParameter_DimCheckMode> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::V1LayerParameter_DimCheckMode>() {
return ::opencv_caffe::V1LayerParameter_DimCheckMode_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::V0LayerParameter_PoolMethod> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::V0LayerParameter_PoolMethod>() {
return ::opencv_caffe::V0LayerParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::Type> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::Type>() {
return ::opencv_caffe::Type_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::Phase> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::Phase>() {
return ::opencv_caffe::Phase_descriptor();
}
} // namespace protobuf
} // namespace google
// @@protoc_insertion_point(global_scope)
#endif // PROTOBUF_opencv_2dcaffe_2eproto__INCLUDED
Reference in New Issue View Git Blame Copy Permalink