diff --git a/modules/dnnlegacy/CMakeLists.txt b/modules/dnnlegacy/CMakeLists.txt new file mode 100644 index 00000000000..ab856cc5500 --- /dev/null +++ b/modules/dnnlegacy/CMakeLists.txt @@ -0,0 +1,233 @@ +if(WINRT) + ocv_module_disable(dnn) +endif() + +set(the_description "Deep neural network legacy module. It allows to load models from frameworks caffe and darknet and to make forward pass using opencv5") + + +ocv_add_module(dnnlegacy opencv_core opencv_imgproc opencv_dnn WRAP python java objc js) + + +if(OPENCV_DNN_CUDA) + if(HAVE_CUDA AND HAVE_CUBLAS AND HAVE_CUDNN) + ocv_target_compile_definitions(${the_module} PRIVATE "CV_CUDA4DNN=1") + else() + if(NOT HAVE_CUDA) + message(SEND_ERROR "DNN: CUDA backend requires CUDA Toolkit. Please resolve dependency or disable OPENCV_DNN_CUDA=OFF") + elseif(NOT HAVE_CUBLAS) + message(SEND_ERROR "DNN: CUDA backend requires cuBLAS. Please resolve dependency or disable OPENCV_DNN_CUDA=OFF") + elseif(NOT HAVE_CUDNN) + message(SEND_ERROR "DNN: CUDA backend requires cuDNN. Please resolve dependency or disable OPENCV_DNN_CUDA=OFF") + endif() + endif() +endif() + + + + +if(MSVC) + add_definitions( -D_CRT_SECURE_NO_WARNINGS=1 ) + ocv_target_compile_definitions(${the_module} PRIVATE cxx_std_17) + ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4244 /wd4267 /wd4018 /wd4355 /wd4800 /wd4251 /wd4996 /wd4146 + /wd4305 /wd4127 /wd4100 /wd4512 /wd4125 /wd4389 /wd4510 /wd4610 + /wd4702 /wd4456 /wd4457 /wd4065 /wd4310 /wd4661 /wd4506 + ) + if(MSVC_VERSION LESS 1920) # MSVS 2015/2017, .pb.cc generated files + ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4309) # 'static_cast': truncation of constant value + endif() + if(MSVC_VERSION LESS 1920) # + +#endif /* OPENCV_DNNLEGACY_HPP */ diff --git a/modules/dnnlegacy/include/opencv2/dnnlegacy/dnnlegacy.hpp b/modules/dnnlegacy/include/opencv2/dnnlegacy/dnnlegacy.hpp new file mode 100644 index 00000000000..733570d1324 --- /dev/null +++ b/modules/dnnlegacy/include/opencv2/dnnlegacy/dnnlegacy.hpp @@ -0,0 +1,137 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef OPENCV_DNNLEGACY_HPP_HPP +#define OPENCV_DNNLEGACY_HPP_HPP + +#include +#include +#include +#include "opencv2/core/async.hpp" + +#include + +namespace cv { +namespace dnnlegacy { + + template + cv::dnn::Net readNet(Args&& ... args) + { + cv::dnn::Net net; + Importer importer(net, std::forward(args)...); + return net; + } +//! @addtogroup dnnlegacy +//! @{ + + /** @brief Reads a network model stored in Darknet model files. + * @param cfgFile path to the .cfg file with text description of the network architecture. + * @param darknetModel path to the .weights file with learned network. + * @returns Network object that ready to do forward, throw an exception in failure cases. + */ + CV_EXPORTS_W cv::dnn::Net readNetFromDarknet(CV_WRAP_FILE_PATH const String &cfgFile, CV_WRAP_FILE_PATH const String &darknetModel = String()); + + /** @brief Reads a network model stored in Darknet model files. + * @param bufferCfg A buffer contains a content of .cfg file with text description of the network architecture. + * @param bufferModel A buffer contains a content of .weights file with learned network. + * @returns Net object. + */ + CV_EXPORTS_W cv::dnn::Net readNetFromDarknet(const std::vector& bufferCfg, + const std::vector& bufferModel = std::vector()); + + /** @brief Reads a network model stored in Darknet model files. + * @param bufferCfg A buffer contains a content of .cfg file with text description of the network architecture. + * @param lenCfg Number of bytes to read from bufferCfg + * @param bufferModel A buffer contains a content of .weights file with learned network. + * @param lenModel Number of bytes to read from bufferModel + * @returns Net object. + */ + CV_EXPORTS cv::dnn::Net readNetFromDarknet(const char *bufferCfg, size_t lenCfg, + const char *bufferModel = NULL, size_t lenModel = 0); + + /** @brief Reads a network model stored in Caffe framework's format. + * @param prototxt path to the .prototxt file with text description of the network architecture. + * @param caffeModel path to the .caffemodel file with learned network. + * @returns Net object. + */ + CV_EXPORTS_W cv::dnn::Net readNetFromCaffe(CV_WRAP_FILE_PATH const String& prototxt, CV_WRAP_FILE_PATH const String& caffeModel = String()); + + /** @brief Reads a network model stored in Caffe model in memory. + * @param bufferProto buffer containing the content of the .prototxt file + * @param bufferModel buffer containing the content of the .caffemodel file + * @returns Net object. + */ + CV_EXPORTS_W cv::dnn::Net readNetFromCaffe(const std::vector& bufferProto, + const std::vector& bufferModel = std::vector()); + + /** @brief Reads a network model stored in Caffe model in memory. + * @details This is an overloaded member function, provided for convenience. + * It differs from the above function only in what argument(s) it accepts. + * @param bufferProto buffer containing the content of the .prototxt file + * @param lenProto length of bufferProto + * @param bufferModel buffer containing the content of the .caffemodel file + * @param lenModel length of bufferModel + * @returns Net object. + */ + CV_EXPORTS cv::dnn::Net readNetFromCaffe(const char* bufferProto, size_t lenProto, + const char* bufferModel = NULL, size_t lenModel = 0); + + /** @brief Convert all weights of Caffe network to half precision floating point. + * @param src Path to origin model from Caffe framework contains single + * precision floating point weights (usually has `.caffemodel` extension). + * @param dst Path to destination model with updated weights. + * @param layersTypes Set of layers types which parameters will be converted. + * By default, converts only Convolutional and Fully-Connected layers' + * weights. + * + * @note Shrinked model has no origin float32 weights so it can't be used + * in origin Caffe framework anymore. However the structure of data + * is taken from NVidia's Caffe fork: https://github.com/NVIDIA/caffe. + * So the resulting model may be used there. + */ + CV_EXPORTS_W void shrinkCaffeModel(CV_WRAP_FILE_PATH const String& src, CV_WRAP_FILE_PATH const String& dst, + const std::vector& layersTypes = std::vector()); +//! @} +} +} + +# +#endif /* OPENCV_DNNLEGACY_HPP_HPP */ diff --git a/modules/dnnlegacy/misc/caffe/opencv-caffe.pb.cc b/modules/dnnlegacy/misc/caffe/opencv-caffe.pb.cc new file mode 100644 index 00000000000..65feaf08867 --- /dev/null +++ b/modules/dnnlegacy/misc/caffe/opencv-caffe.pb.cc @@ -0,0 +1,34120 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: opencv-caffe.proto + +#include "opencv-caffe.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace opencv_caffe { +constexpr BlobShape::BlobShape( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : dim_() + , _dim_cached_byte_size_(0){} +struct BlobShapeDefaultTypeInternal { + constexpr BlobShapeDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BlobShapeDefaultTypeInternal() {} + union { + BlobShape _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlobShapeDefaultTypeInternal _BlobShape_default_instance_; +constexpr BlobProto::BlobProto( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : data_() + , diff_() + , double_data_() + , double_diff_() + , raw_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , shape_(nullptr) + , num_(0) + , channels_(0) + , height_(0) + , width_(0) + , raw_data_type_(0) +{} +struct BlobProtoDefaultTypeInternal { + constexpr BlobProtoDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BlobProtoDefaultTypeInternal() {} + union { + BlobProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlobProtoDefaultTypeInternal _BlobProto_default_instance_; +constexpr BlobProtoVector::BlobProtoVector( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : blobs_(){} +struct BlobProtoVectorDefaultTypeInternal { + constexpr BlobProtoVectorDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BlobProtoVectorDefaultTypeInternal() {} + union { + BlobProtoVector _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlobProtoVectorDefaultTypeInternal _BlobProtoVector_default_instance_; +constexpr PermuteParameter::PermuteParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : order_(){} +struct PermuteParameterDefaultTypeInternal { + constexpr PermuteParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PermuteParameterDefaultTypeInternal() {} + union { + PermuteParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PermuteParameterDefaultTypeInternal _PermuteParameter_default_instance_; +constexpr NormalizeBBoxParameter::NormalizeBBoxParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : scale_filler_(nullptr) + , across_spatial_(true) + , channel_shared_(true) + , eps_(1e-10f){} +struct NormalizeBBoxParameterDefaultTypeInternal { + constexpr NormalizeBBoxParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~NormalizeBBoxParameterDefaultTypeInternal() {} + union { + NormalizeBBoxParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NormalizeBBoxParameterDefaultTypeInternal _NormalizeBBoxParameter_default_instance_; +constexpr PriorBoxParameter::PriorBoxParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : min_size_() + , max_size_() + , aspect_ratio_() + , variance_() + , offset_h_() + , offset_w_() + , width_() + , height_() + , img_size_(0u) + , img_h_(0u) + , img_w_(0u) + , step_(0) + , step_h_(0) + , step_w_(0) + , flip_(true) + , clip_(true) + , offset_(0.5f){} +struct PriorBoxParameterDefaultTypeInternal { + constexpr PriorBoxParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PriorBoxParameterDefaultTypeInternal() {} + union { + PriorBoxParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PriorBoxParameterDefaultTypeInternal _PriorBoxParameter_default_instance_; +constexpr DetectionOutputParameter::DetectionOutputParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : nms_param_(nullptr) + , save_output_param_(nullptr) + , num_classes_(0u) + , background_label_id_(0) + , confidence_threshold_(0) + , variance_encoded_in_target_(false) + , clip_(false) + , keep_top_k_(-1) + , code_type_(1) + + , share_location_(true) + , normalized_bbox_(true){} +struct DetectionOutputParameterDefaultTypeInternal { + constexpr DetectionOutputParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DetectionOutputParameterDefaultTypeInternal() {} + union { + DetectionOutputParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DetectionOutputParameterDefaultTypeInternal _DetectionOutputParameter_default_instance_; +constexpr Datum::Datum( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : float_data_() + , data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , channels_(0) + , height_(0) + , width_(0) + , label_(0) + , encoded_(false){} +struct DatumDefaultTypeInternal { + constexpr DatumDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DatumDefaultTypeInternal() {} + union { + Datum _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DatumDefaultTypeInternal _Datum_default_instance_; +constexpr FillerParameter::FillerParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(nullptr) + , value_(0) + , min_(0) + , mean_(0) + , variance_norm_(0) + + , sparse_(-1) + , max_(1) + , std_(1){} +struct FillerParameterDefaultTypeInternal { + constexpr FillerParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FillerParameterDefaultTypeInternal() {} + union { + FillerParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FillerParameterDefaultTypeInternal _FillerParameter_default_instance_; +constexpr NetParameter::NetParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : layers_() + , input_() + , input_dim_() + , input_shape_() + , layer_() + , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , state_(nullptr) + , force_backward_(false) + , debug_info_(false){} +struct NetParameterDefaultTypeInternal { + constexpr NetParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~NetParameterDefaultTypeInternal() {} + union { + NetParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NetParameterDefaultTypeInternal _NetParameter_default_instance_; +constexpr SolverParameter::SolverParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : test_net_() + , test_iter_() + , test_net_param_() + , test_state_() + , stepvalue_() + , train_net_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , lr_policy_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , snapshot_prefix_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , net_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , regularization_type_(nullptr) + , type_(nullptr) + , train_net_param_(nullptr) + , net_param_(nullptr) + , train_state_(nullptr) + , test_interval_(0) + , base_lr_(0) + , display_(0) + , max_iter_(0) + , gamma_(0) + , power_(0) + , momentum_(0) + , weight_decay_(0) + , stepsize_(0) + , snapshot_(0) + , device_id_(0) + , test_compute_loss_(false) + , snapshot_diff_(false) + , debug_info_(false) + , solver_type_(0) + + , momentum2_(0.999f) + , random_seed_(int64_t{-1}) + , solver_mode_(1) + + , test_initialization_(true) + , snapshot_after_train_(true) + , delta_(1e-08f) + , average_loss_(1) + , clip_gradients_(-1) + , iter_size_(1) + , snapshot_format_(1) + + , rms_decay_(0.99f){} +struct SolverParameterDefaultTypeInternal { + constexpr SolverParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SolverParameterDefaultTypeInternal() {} + union { + SolverParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SolverParameterDefaultTypeInternal _SolverParameter_default_instance_; +constexpr SolverState::SolverState( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : history_() + , learned_net_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , iter_(0) + , current_step_(0){} +struct SolverStateDefaultTypeInternal { + constexpr SolverStateDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SolverStateDefaultTypeInternal() {} + union { + SolverState _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SolverStateDefaultTypeInternal _SolverState_default_instance_; +constexpr NetState::NetState( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : stage_() + , level_(0) + , phase_(1) +{} +struct NetStateDefaultTypeInternal { + constexpr NetStateDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~NetStateDefaultTypeInternal() {} + union { + NetState _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NetStateDefaultTypeInternal _NetState_default_instance_; +constexpr NetStateRule::NetStateRule( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : stage_() + , not_stage_() + , phase_(0) + + , min_level_(0) + , max_level_(0){} +struct NetStateRuleDefaultTypeInternal { + constexpr NetStateRuleDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~NetStateRuleDefaultTypeInternal() {} + union { + NetStateRule _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NetStateRuleDefaultTypeInternal _NetStateRule_default_instance_; +constexpr ParamSpec::ParamSpec( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , share_mode_(0) + + , lr_mult_(1) + , decay_mult_(1){} +struct ParamSpecDefaultTypeInternal { + constexpr ParamSpecDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParamSpecDefaultTypeInternal() {} + union { + ParamSpec _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParamSpecDefaultTypeInternal _ParamSpec_default_instance_; +constexpr LayerParameter::LayerParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : bottom_() + , top_() + , loss_weight_() + , param_() + , blobs_() + , include_() + , exclude_() + , propagate_down_() + , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , type_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , transform_param_(nullptr) + , loss_param_(nullptr) + , accuracy_param_(nullptr) + , argmax_param_(nullptr) + , concat_param_(nullptr) + , contrastive_loss_param_(nullptr) + , convolution_param_(nullptr) + , data_param_(nullptr) + , dropout_param_(nullptr) + , dummy_data_param_(nullptr) + , eltwise_param_(nullptr) + , exp_param_(nullptr) + , hdf5_data_param_(nullptr) + , hdf5_output_param_(nullptr) + , hinge_loss_param_(nullptr) + , image_data_param_(nullptr) + , infogain_loss_param_(nullptr) + , inner_product_param_(nullptr) + , lrn_param_(nullptr) + , memory_data_param_(nullptr) + , mvn_param_(nullptr) + , pooling_param_(nullptr) + , power_param_(nullptr) + , relu_param_(nullptr) + , sigmoid_param_(nullptr) + , softmax_param_(nullptr) + , slice_param_(nullptr) + , tanh_param_(nullptr) + , threshold_param_(nullptr) + , window_data_param_(nullptr) + , python_param_(nullptr) + , prelu_param_(nullptr) + , spp_param_(nullptr) + , reshape_param_(nullptr) + , log_param_(nullptr) + , flatten_param_(nullptr) + , reduction_param_(nullptr) + , embed_param_(nullptr) + , tile_param_(nullptr) + , batch_norm_param_(nullptr) + , elu_param_(nullptr) + , bias_param_(nullptr) + , scale_param_(nullptr) + , input_param_(nullptr) + , crop_param_(nullptr) + , parameter_param_(nullptr) + , recurrent_param_(nullptr) + , detection_output_param_(nullptr) + , permute_param_(nullptr) + , norm_param_(nullptr) + , prior_box_param_(nullptr) + , proposal_param_(nullptr) + , psroi_pooling_param_(nullptr) + , roi_pooling_param_(nullptr) + , phase_(0) +{} +struct LayerParameterDefaultTypeInternal { + constexpr LayerParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~LayerParameterDefaultTypeInternal() {} + union { + LayerParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LayerParameterDefaultTypeInternal _LayerParameter_default_instance_; +constexpr TransformationParameter::TransformationParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : mean_value_() + , mean_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , crop_size_(0u) + , mirror_(false) + , force_color_(false) + , force_gray_(false) + , scale_(1){} +struct TransformationParameterDefaultTypeInternal { + constexpr TransformationParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~TransformationParameterDefaultTypeInternal() {} + union { + TransformationParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TransformationParameterDefaultTypeInternal _TransformationParameter_default_instance_; +constexpr LossParameter::LossParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ignore_label_(0) + , normalize_(false) + , normalization_(1) +{} +struct LossParameterDefaultTypeInternal { + constexpr LossParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~LossParameterDefaultTypeInternal() {} + union { + LossParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LossParameterDefaultTypeInternal _LossParameter_default_instance_; +constexpr AccuracyParameter::AccuracyParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ignore_label_(0) + , top_k_(1u) + , axis_(1){} +struct AccuracyParameterDefaultTypeInternal { + constexpr AccuracyParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AccuracyParameterDefaultTypeInternal() {} + union { + AccuracyParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AccuracyParameterDefaultTypeInternal _AccuracyParameter_default_instance_; +constexpr ArgMaxParameter::ArgMaxParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : out_max_val_(false) + , axis_(0) + , top_k_(1u){} +struct ArgMaxParameterDefaultTypeInternal { + constexpr ArgMaxParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ArgMaxParameterDefaultTypeInternal() {} + union { + ArgMaxParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ArgMaxParameterDefaultTypeInternal _ArgMaxParameter_default_instance_; +constexpr ConcatParameter::ConcatParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : concat_dim_(1u) + , axis_(1){} +struct ConcatParameterDefaultTypeInternal { + constexpr ConcatParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ConcatParameterDefaultTypeInternal() {} + union { + ConcatParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConcatParameterDefaultTypeInternal _ConcatParameter_default_instance_; +constexpr BatchNormParameter::BatchNormParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : use_global_stats_(false) + , scale_bias_(false) + , moving_average_fraction_(0.999f) + , eps_(1e-05f){} +struct BatchNormParameterDefaultTypeInternal { + constexpr BatchNormParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BatchNormParameterDefaultTypeInternal() {} + union { + BatchNormParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BatchNormParameterDefaultTypeInternal _BatchNormParameter_default_instance_; +constexpr BiasParameter::BiasParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : filler_(nullptr) + , axis_(1) + , num_axes_(1){} +struct BiasParameterDefaultTypeInternal { + constexpr BiasParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BiasParameterDefaultTypeInternal() {} + union { + BiasParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BiasParameterDefaultTypeInternal _BiasParameter_default_instance_; +constexpr ContrastiveLossParameter::ContrastiveLossParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : legacy_version_(false) + , margin_(1){} +struct ContrastiveLossParameterDefaultTypeInternal { + constexpr ContrastiveLossParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ContrastiveLossParameterDefaultTypeInternal() {} + union { + ContrastiveLossParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ContrastiveLossParameterDefaultTypeInternal _ContrastiveLossParameter_default_instance_; +constexpr ConvolutionParameter::ConvolutionParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : pad_() + , kernel_size_() + , stride_() + , dilation_() + , weight_filler_(nullptr) + , bias_filler_(nullptr) + , num_output_(0u) + , pad_h_(0u) + , pad_w_(0u) + , kernel_h_(0u) + , kernel_w_(0u) + , stride_h_(0u) + , stride_w_(0u) + , engine_(0) + + , force_nd_im2col_(false) + , axis_(1) + , bias_term_(true) + , group_(1u){} +struct ConvolutionParameterDefaultTypeInternal { + constexpr ConvolutionParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ConvolutionParameterDefaultTypeInternal() {} + union { + ConvolutionParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConvolutionParameterDefaultTypeInternal _ConvolutionParameter_default_instance_; +constexpr CropParameter::CropParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : offset_() + , axis_(2){} +struct CropParameterDefaultTypeInternal { + constexpr CropParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CropParameterDefaultTypeInternal() {} + union { + CropParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CropParameterDefaultTypeInternal _CropParameter_default_instance_; +constexpr DataParameter::DataParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , mean_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , batch_size_(0u) + , crop_size_(0u) + , rand_skip_(0u) + , mirror_(false) + , force_encoded_color_(false) + , backend_(0) + + , scale_(1) + , prefetch_(4u){} +struct DataParameterDefaultTypeInternal { + constexpr DataParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DataParameterDefaultTypeInternal() {} + union { + DataParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DataParameterDefaultTypeInternal _DataParameter_default_instance_; +constexpr NonMaximumSuppressionParameter::NonMaximumSuppressionParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : top_k_(0) + , nms_threshold_(0.3f) + , eta_(1){} +struct NonMaximumSuppressionParameterDefaultTypeInternal { + constexpr NonMaximumSuppressionParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~NonMaximumSuppressionParameterDefaultTypeInternal() {} + union { + NonMaximumSuppressionParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NonMaximumSuppressionParameterDefaultTypeInternal _NonMaximumSuppressionParameter_default_instance_; +constexpr SaveOutputParameter::SaveOutputParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : output_directory_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , output_name_prefix_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , output_format_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , label_map_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , name_size_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , num_test_image_(0u){} +struct SaveOutputParameterDefaultTypeInternal { + constexpr SaveOutputParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SaveOutputParameterDefaultTypeInternal() {} + union { + SaveOutputParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SaveOutputParameterDefaultTypeInternal _SaveOutputParameter_default_instance_; +constexpr DropoutParameter::DropoutParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : dropout_ratio_(0.5f) + , scale_train_(true){} +struct DropoutParameterDefaultTypeInternal { + constexpr DropoutParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DropoutParameterDefaultTypeInternal() {} + union { + DropoutParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DropoutParameterDefaultTypeInternal _DropoutParameter_default_instance_; +constexpr DummyDataParameter::DummyDataParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : data_filler_() + , num_() + , channels_() + , height_() + , width_() + , shape_(){} +struct DummyDataParameterDefaultTypeInternal { + constexpr DummyDataParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DummyDataParameterDefaultTypeInternal() {} + union { + DummyDataParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DummyDataParameterDefaultTypeInternal _DummyDataParameter_default_instance_; +constexpr EltwiseParameter::EltwiseParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : coeff_() + , operation_(1) + + , stable_prod_grad_(true){} +struct EltwiseParameterDefaultTypeInternal { + constexpr EltwiseParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~EltwiseParameterDefaultTypeInternal() {} + union { + EltwiseParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT EltwiseParameterDefaultTypeInternal _EltwiseParameter_default_instance_; +constexpr ELUParameter::ELUParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : alpha_(1){} +struct ELUParameterDefaultTypeInternal { + constexpr ELUParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ELUParameterDefaultTypeInternal() {} + union { + ELUParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ELUParameterDefaultTypeInternal _ELUParameter_default_instance_; +constexpr EmbedParameter::EmbedParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : weight_filler_(nullptr) + , bias_filler_(nullptr) + , num_output_(0u) + , input_dim_(0u) + , bias_term_(true){} +struct EmbedParameterDefaultTypeInternal { + constexpr EmbedParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~EmbedParameterDefaultTypeInternal() {} + union { + EmbedParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT EmbedParameterDefaultTypeInternal _EmbedParameter_default_instance_; +constexpr ExpParameter::ExpParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : shift_(0) + , base_(-1) + , scale_(1){} +struct ExpParameterDefaultTypeInternal { + constexpr ExpParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ExpParameterDefaultTypeInternal() {} + union { + ExpParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExpParameterDefaultTypeInternal _ExpParameter_default_instance_; +constexpr FlattenParameter::FlattenParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : axis_(1) + , end_axis_(-1){} +struct FlattenParameterDefaultTypeInternal { + constexpr FlattenParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FlattenParameterDefaultTypeInternal() {} + union { + FlattenParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FlattenParameterDefaultTypeInternal _FlattenParameter_default_instance_; +constexpr HDF5DataParameter::HDF5DataParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , batch_size_(0u) + , shuffle_(false){} +struct HDF5DataParameterDefaultTypeInternal { + constexpr HDF5DataParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~HDF5DataParameterDefaultTypeInternal() {} + union { + HDF5DataParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT HDF5DataParameterDefaultTypeInternal _HDF5DataParameter_default_instance_; +constexpr HDF5OutputParameter::HDF5OutputParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : file_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct HDF5OutputParameterDefaultTypeInternal { + constexpr HDF5OutputParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~HDF5OutputParameterDefaultTypeInternal() {} + union { + HDF5OutputParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT HDF5OutputParameterDefaultTypeInternal _HDF5OutputParameter_default_instance_; +constexpr HingeLossParameter::HingeLossParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : norm_(1) +{} +struct HingeLossParameterDefaultTypeInternal { + constexpr HingeLossParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~HingeLossParameterDefaultTypeInternal() {} + union { + HingeLossParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT HingeLossParameterDefaultTypeInternal _HingeLossParameter_default_instance_; +constexpr ImageDataParameter::ImageDataParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , mean_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , root_folder_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , crop_size_(0u) + , rand_skip_(0u) + , shuffle_(false) + , mirror_(false) + , new_height_(0u) + , new_width_(0u) + , is_color_(true) + , scale_(1) + , batch_size_(1u){} +struct ImageDataParameterDefaultTypeInternal { + constexpr ImageDataParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ImageDataParameterDefaultTypeInternal() {} + union { + ImageDataParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ImageDataParameterDefaultTypeInternal _ImageDataParameter_default_instance_; +constexpr InfogainLossParameter::InfogainLossParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct InfogainLossParameterDefaultTypeInternal { + constexpr InfogainLossParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~InfogainLossParameterDefaultTypeInternal() {} + union { + InfogainLossParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InfogainLossParameterDefaultTypeInternal _InfogainLossParameter_default_instance_; +constexpr InnerProductParameter::InnerProductParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : weight_filler_(nullptr) + , bias_filler_(nullptr) + , num_output_(0u) + , transpose_(false) + , bias_term_(true) + , axis_(1){} +struct InnerProductParameterDefaultTypeInternal { + constexpr InnerProductParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~InnerProductParameterDefaultTypeInternal() {} + union { + InnerProductParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InnerProductParameterDefaultTypeInternal _InnerProductParameter_default_instance_; +constexpr InputParameter::InputParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : shape_(){} +struct InputParameterDefaultTypeInternal { + constexpr InputParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~InputParameterDefaultTypeInternal() {} + union { + InputParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InputParameterDefaultTypeInternal _InputParameter_default_instance_; +constexpr LogParameter::LogParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : shift_(0) + , base_(-1) + , scale_(1){} +struct LogParameterDefaultTypeInternal { + constexpr LogParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~LogParameterDefaultTypeInternal() {} + union { + LogParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LogParameterDefaultTypeInternal _LogParameter_default_instance_; +constexpr LRNParameter::LRNParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : norm_region_(0) + + , engine_(0) + + , local_size_(5u) + , alpha_(1) + , beta_(0.75f) + , k_(1){} +struct LRNParameterDefaultTypeInternal { + constexpr LRNParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~LRNParameterDefaultTypeInternal() {} + union { + LRNParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LRNParameterDefaultTypeInternal _LRNParameter_default_instance_; +constexpr MemoryDataParameter::MemoryDataParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : batch_size_(0u) + , channels_(0u) + , height_(0u) + , width_(0u){} +struct MemoryDataParameterDefaultTypeInternal { + constexpr MemoryDataParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MemoryDataParameterDefaultTypeInternal() {} + union { + MemoryDataParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MemoryDataParameterDefaultTypeInternal _MemoryDataParameter_default_instance_; +constexpr MVNParameter::MVNParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : across_channels_(false) + , normalize_variance_(true) + , eps_(1e-09f){} +struct MVNParameterDefaultTypeInternal { + constexpr MVNParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MVNParameterDefaultTypeInternal() {} + union { + MVNParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MVNParameterDefaultTypeInternal _MVNParameter_default_instance_; +constexpr ParameterParameter::ParameterParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : shape_(nullptr){} +struct ParameterParameterDefaultTypeInternal { + constexpr ParameterParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterParameterDefaultTypeInternal() {} + union { + ParameterParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterParameterDefaultTypeInternal _ParameterParameter_default_instance_; +constexpr PoolingParameter::PoolingParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : pool_(0) + + , kernel_size_(0u) + , pad_(0u) + , kernel_h_(0u) + , kernel_w_(0u) + , stride_h_(0u) + , stride_w_(0u) + , pad_h_(0u) + , pad_w_(0u) + , engine_(0) + + , global_pooling_(false) + , stride_(1u) + , ceil_mode_(true){} +struct PoolingParameterDefaultTypeInternal { + constexpr PoolingParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PoolingParameterDefaultTypeInternal() {} + union { + PoolingParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PoolingParameterDefaultTypeInternal _PoolingParameter_default_instance_; +constexpr PowerParameter::PowerParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : shift_(0) + , power_(1) + , scale_(1){} +struct PowerParameterDefaultTypeInternal { + constexpr PowerParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PowerParameterDefaultTypeInternal() {} + union { + PowerParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PowerParameterDefaultTypeInternal _PowerParameter_default_instance_; +constexpr PythonParameter::PythonParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : module_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , layer_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , param_str_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , share_in_parallel_(false){} +struct PythonParameterDefaultTypeInternal { + constexpr PythonParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PythonParameterDefaultTypeInternal() {} + union { + PythonParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PythonParameterDefaultTypeInternal _PythonParameter_default_instance_; +constexpr RecurrentParameter::RecurrentParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : weight_filler_(nullptr) + , bias_filler_(nullptr) + , num_output_(0u) + , debug_info_(false) + , expose_hidden_(false){} +struct RecurrentParameterDefaultTypeInternal { + constexpr RecurrentParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RecurrentParameterDefaultTypeInternal() {} + union { + RecurrentParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecurrentParameterDefaultTypeInternal _RecurrentParameter_default_instance_; +constexpr ReductionParameter::ReductionParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : axis_(0) + , operation_(1) + + , coeff_(1){} +struct ReductionParameterDefaultTypeInternal { + constexpr ReductionParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReductionParameterDefaultTypeInternal() {} + union { + ReductionParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReductionParameterDefaultTypeInternal _ReductionParameter_default_instance_; +constexpr ReLUParameter::ReLUParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : negative_slope_(0) + , engine_(0) +{} +struct ReLUParameterDefaultTypeInternal { + constexpr ReLUParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReLUParameterDefaultTypeInternal() {} + union { + ReLUParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReLUParameterDefaultTypeInternal _ReLUParameter_default_instance_; +constexpr ReshapeParameter::ReshapeParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : shape_(nullptr) + , axis_(0) + , num_axes_(-1){} +struct ReshapeParameterDefaultTypeInternal { + constexpr ReshapeParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReshapeParameterDefaultTypeInternal() {} + union { + ReshapeParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReshapeParameterDefaultTypeInternal _ReshapeParameter_default_instance_; +constexpr ScaleParameter::ScaleParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : filler_(nullptr) + , bias_filler_(nullptr) + , bias_term_(false) + , axis_(1) + , num_axes_(1){} +struct ScaleParameterDefaultTypeInternal { + constexpr ScaleParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ScaleParameterDefaultTypeInternal() {} + union { + ScaleParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ScaleParameterDefaultTypeInternal _ScaleParameter_default_instance_; +constexpr SigmoidParameter::SigmoidParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : engine_(0) +{} +struct SigmoidParameterDefaultTypeInternal { + constexpr SigmoidParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SigmoidParameterDefaultTypeInternal() {} + union { + SigmoidParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SigmoidParameterDefaultTypeInternal _SigmoidParameter_default_instance_; +constexpr SliceParameter::SliceParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : slice_point_() + , slice_dim_(1u) + , axis_(1){} +struct SliceParameterDefaultTypeInternal { + constexpr SliceParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SliceParameterDefaultTypeInternal() {} + union { + SliceParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SliceParameterDefaultTypeInternal _SliceParameter_default_instance_; +constexpr SoftmaxParameter::SoftmaxParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : engine_(0) + + , axis_(1){} +struct SoftmaxParameterDefaultTypeInternal { + constexpr SoftmaxParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SoftmaxParameterDefaultTypeInternal() {} + union { + SoftmaxParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SoftmaxParameterDefaultTypeInternal _SoftmaxParameter_default_instance_; +constexpr TanHParameter::TanHParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : engine_(0) +{} +struct TanHParameterDefaultTypeInternal { + constexpr TanHParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~TanHParameterDefaultTypeInternal() {} + union { + TanHParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TanHParameterDefaultTypeInternal _TanHParameter_default_instance_; +constexpr TileParameter::TileParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : tiles_(0) + , axis_(1){} +struct TileParameterDefaultTypeInternal { + constexpr TileParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~TileParameterDefaultTypeInternal() {} + union { + TileParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TileParameterDefaultTypeInternal _TileParameter_default_instance_; +constexpr ThresholdParameter::ThresholdParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : threshold_(0){} +struct ThresholdParameterDefaultTypeInternal { + constexpr ThresholdParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ThresholdParameterDefaultTypeInternal() {} + union { + ThresholdParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ThresholdParameterDefaultTypeInternal _ThresholdParameter_default_instance_; +constexpr WindowDataParameter::WindowDataParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , mean_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , crop_mode_(nullptr) + , root_folder_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , batch_size_(0u) + , crop_size_(0u) + , mirror_(false) + , cache_images_(false) + , context_pad_(0u) + , scale_(1) + , fg_threshold_(0.5f) + , bg_threshold_(0.5f) + , fg_fraction_(0.25f){} +struct WindowDataParameterDefaultTypeInternal { + constexpr WindowDataParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~WindowDataParameterDefaultTypeInternal() {} + union { + WindowDataParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WindowDataParameterDefaultTypeInternal _WindowDataParameter_default_instance_; +constexpr SPPParameter::SPPParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : pyramid_height_(0u) + , pool_(0) + + , engine_(0) +{} +struct SPPParameterDefaultTypeInternal { + constexpr SPPParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SPPParameterDefaultTypeInternal() {} + union { + SPPParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SPPParameterDefaultTypeInternal _SPPParameter_default_instance_; +constexpr V1LayerParameter::V1LayerParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : bottom_() + , top_() + , blobs_() + , blobs_lr_() + , weight_decay_() + , include_() + , exclude_() + , loss_weight_() + , param_() + , blob_share_mode_() + , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , layer_(nullptr) + , concat_param_(nullptr) + , convolution_param_(nullptr) + , data_param_(nullptr) + , dropout_param_(nullptr) + , hdf5_data_param_(nullptr) + , hdf5_output_param_(nullptr) + , image_data_param_(nullptr) + , infogain_loss_param_(nullptr) + , inner_product_param_(nullptr) + , lrn_param_(nullptr) + , pooling_param_(nullptr) + , window_data_param_(nullptr) + , power_param_(nullptr) + , memory_data_param_(nullptr) + , argmax_param_(nullptr) + , eltwise_param_(nullptr) + , threshold_param_(nullptr) + , dummy_data_param_(nullptr) + , accuracy_param_(nullptr) + , hinge_loss_param_(nullptr) + , relu_param_(nullptr) + , slice_param_(nullptr) + , mvn_param_(nullptr) + , transform_param_(nullptr) + , tanh_param_(nullptr) + , sigmoid_param_(nullptr) + , softmax_param_(nullptr) + , contrastive_loss_param_(nullptr) + , exp_param_(nullptr) + , loss_param_(nullptr) + , type_(0) +{} +struct V1LayerParameterDefaultTypeInternal { + constexpr V1LayerParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~V1LayerParameterDefaultTypeInternal() {} + union { + V1LayerParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT V1LayerParameterDefaultTypeInternal _V1LayerParameter_default_instance_; +constexpr V0LayerParameter::V0LayerParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : blobs_() + , blobs_lr_() + , weight_decay_() + , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , type_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , meanfile_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , det_crop_mode_(nullptr) + , weight_filler_(nullptr) + , bias_filler_(nullptr) + , hdf5_output_param_(nullptr) + , num_output_(0u) + , pad_(0u) + , kernelsize_(0u) + , pool_(0) + + , batchsize_(0u) + , cropsize_(0u) + , new_width_(0) + , mirror_(false) + , shuffle_images_(false) + , rand_skip_(0u) + , det_context_pad_(0u) + , new_num_(0) + , new_channels_(0) + , new_height_(0) + , concat_dim_(1u) + , biasterm_(true) + , group_(1u) + , stride_(1u) + , dropout_ratio_(0.5f) + , local_size_(5u) + , alpha_(1) + , beta_(0.75f) + , scale_(1) + , k_(1) + , det_fg_threshold_(0.5f) + , det_bg_threshold_(0.5f) + , det_fg_fraction_(0.25f){} +struct V0LayerParameterDefaultTypeInternal { + constexpr V0LayerParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~V0LayerParameterDefaultTypeInternal() {} + union { + V0LayerParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT V0LayerParameterDefaultTypeInternal _V0LayerParameter_default_instance_; +constexpr PReLUParameter::PReLUParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : filler_(nullptr) + , channel_shared_(false){} +struct PReLUParameterDefaultTypeInternal { + constexpr PReLUParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PReLUParameterDefaultTypeInternal() {} + union { + PReLUParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PReLUParameterDefaultTypeInternal _PReLUParameter_default_instance_; +constexpr NormalizedBBox::NormalizedBBox( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : xmin_(0) + , ymin_(0) + , xmax_(0) + , ymax_(0) + , label_(0) + , difficult_(false) + , score_(0) + , size_(0){} +struct NormalizedBBoxDefaultTypeInternal { + constexpr NormalizedBBoxDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~NormalizedBBoxDefaultTypeInternal() {} + union { + NormalizedBBox _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NormalizedBBoxDefaultTypeInternal _NormalizedBBox_default_instance_; +constexpr ROIPoolingParameter::ROIPoolingParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : pooled_h_(0u) + , pooled_w_(0u) + , spatial_scale_(1){} +struct ROIPoolingParameterDefaultTypeInternal { + constexpr ROIPoolingParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ROIPoolingParameterDefaultTypeInternal() {} + union { + ROIPoolingParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ROIPoolingParameterDefaultTypeInternal _ROIPoolingParameter_default_instance_; +constexpr ProposalParameter::ProposalParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ratio_() + , scale_() + , feat_stride_(16u) + , base_size_(16u) + , min_size_(16u) + , pre_nms_topn_(6000u) + , post_nms_topn_(300u) + , nms_thresh_(0.7f){} +struct ProposalParameterDefaultTypeInternal { + constexpr ProposalParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ProposalParameterDefaultTypeInternal() {} + union { + ProposalParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProposalParameterDefaultTypeInternal _ProposalParameter_default_instance_; +constexpr PSROIPoolingParameter::PSROIPoolingParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : spatial_scale_(0) + , output_dim_(0) + , group_size_(0){} +struct PSROIPoolingParameterDefaultTypeInternal { + constexpr PSROIPoolingParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PSROIPoolingParameterDefaultTypeInternal() {} + union { + PSROIPoolingParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PSROIPoolingParameterDefaultTypeInternal _PSROIPoolingParameter_default_instance_; +} // namespace opencv_caffe +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_opencv_2dcaffe_2eproto[71]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_opencv_2dcaffe_2eproto[27]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_opencv_2dcaffe_2eproto = nullptr; + +const uint32_t TableStruct_opencv_2dcaffe_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobShape, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobShape, dim_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, shape_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, data_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, diff_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, double_data_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, double_diff_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, raw_data_type_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, raw_data_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, num_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, channels_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, height_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, width_), + 1, + ~0u, + ~0u, + ~0u, + ~0u, + 6, + 0, + 2, + 3, + 4, + 5, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProtoVector, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProtoVector, blobs_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PermuteParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PermuteParameter, order_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, across_spatial_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, scale_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, channel_shared_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, eps_), + 1, + 0, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, min_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, max_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, aspect_ratio_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, flip_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, clip_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, variance_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, width_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, height_), + ~0u, + ~0u, + ~0u, + 6, + 7, + ~0u, + 0, + 1, + 2, + 3, + 4, + 5, + 8, + ~0u, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, num_classes_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, share_location_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, background_label_id_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, nms_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, save_output_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, code_type_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, variance_encoded_in_target_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, keep_top_k_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, confidence_threshold_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, normalized_bbox_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, clip_), + 2, + 9, + 3, + 0, + 1, + 8, + 5, + 7, + 4, + 10, + 6, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, channels_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, height_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, width_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, data_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, label_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, float_data_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, encoded_), + 1, + 2, + 3, + 0, + 4, + ~0u, + 5, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, type_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, value_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, min_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, max_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, mean_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, std_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, sparse_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, variance_norm_), + 0, + 1, + 2, + 6, + 3, + 7, + 5, + 4, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, name_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, input_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, input_shape_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, input_dim_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, force_backward_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, state_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, debug_info_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, layer_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, layers_), + 0, + ~0u, + ~0u, + ~0u, + 2, + 1, + 3, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, net_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, net_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_net_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_net_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_net_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_net_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_state_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_state_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_iter_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_interval_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_compute_loss_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_initialization_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, base_lr_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, display_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, average_loss_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, max_iter_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, iter_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, lr_policy_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, gamma_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, power_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, momentum_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, weight_decay_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, regularization_type_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, stepsize_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, stepvalue_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, clip_gradients_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_prefix_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_diff_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_format_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, solver_mode_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, device_id_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, random_seed_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, type_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, delta_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, momentum2_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, rms_decay_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, debug_info_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_after_train_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, solver_type_), + 3, + 7, + 0, + ~0u, + 6, + ~0u, + 8, + ~0u, + ~0u, + 9, + 20, + 27, + 10, + 11, + 30, + 12, + 32, + 1, + 13, + 14, + 15, + 16, + 4, + 17, + ~0u, + 31, + 18, + 2, + 21, + 33, + 26, + 19, + 25, + 5, + 29, + 24, + 34, + 22, + 28, + 23, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, iter_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, learned_net_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, history_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, current_step_), + 1, + 0, + ~0u, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, phase_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, level_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, stage_), + 1, + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, phase_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, min_level_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, max_level_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, stage_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, not_stage_), + 0, + 1, + 2, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, name_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, share_mode_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, lr_mult_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, decay_mult_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, name_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, type_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, bottom_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, top_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, phase_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, loss_weight_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, blobs_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, propagate_down_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, include_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, exclude_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, transform_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, loss_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, accuracy_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, argmax_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, batch_norm_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, bias_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, concat_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, contrastive_loss_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, convolution_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, crop_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, detection_output_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, dropout_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, dummy_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, eltwise_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, elu_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, embed_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, exp_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, flatten_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, hdf5_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, hdf5_output_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, hinge_loss_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, image_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, infogain_loss_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, inner_product_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, input_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, log_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, lrn_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, memory_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, mvn_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, norm_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, permute_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, parameter_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, pooling_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, power_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, prelu_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, prior_box_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, proposal_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, psroi_pooling_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, python_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, recurrent_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, reduction_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, relu_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, reshape_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, roi_pooling_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, scale_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, sigmoid_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, softmax_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, spp_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, slice_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, tanh_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, threshold_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, tile_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, window_data_param_), + 0, + 1, + ~0u, + ~0u, + 56, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + 2, + 3, + 4, + 5, + 41, + 43, + 6, + 7, + 8, + 46, + 9, + 49, + 10, + 11, + 12, + 42, + 39, + 13, + 37, + 14, + 15, + 16, + 17, + 18, + 19, + 45, + 36, + 20, + 21, + 22, + 51, + 50, + 47, + 23, + 24, + 33, + 52, + 53, + 54, + 32, + 48, + 38, + 25, + 35, + 55, + 44, + 26, + 27, + 34, + 28, + 29, + 30, + 40, + 31, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mirror_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, crop_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mean_file_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mean_value_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, force_color_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, force_gray_), + 5, + 2, + 1, + 0, + ~0u, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, ignore_label_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, normalization_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, normalize_), + 0, + 2, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, top_k_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, ignore_label_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, out_max_val_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, top_k_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, axis_), + 0, + 2, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConcatParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConcatParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConcatParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConcatParameter, concat_dim_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, use_global_stats_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, moving_average_fraction_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, eps_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, scale_bias_), + 0, + 2, + 3, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, num_axes_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, filler_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, margin_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, legacy_version_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, num_output_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, bias_term_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, dilation_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, group_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, weight_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, bias_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, engine_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, force_nd_im2col_), + 2, + 12, + ~0u, + ~0u, + ~0u, + ~0u, + 3, + 4, + 5, + 6, + 7, + 8, + 13, + 0, + 1, + 9, + 11, + 10, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::CropParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::CropParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::CropParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::CropParameter, offset_), + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, source_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, batch_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, rand_skip_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, backend_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, mean_file_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, crop_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, mirror_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, force_encoded_color_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, prefetch_), + 0, + 2, + 4, + 7, + 8, + 1, + 3, + 5, + 6, + 9, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, nms_threshold_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, top_k_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, eta_), + 1, + 0, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_directory_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_name_prefix_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_format_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, label_map_file_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, name_size_file_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, num_test_image_), + 0, + 1, + 2, + 3, + 4, + 5, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DropoutParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DropoutParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DropoutParameter, dropout_ratio_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DropoutParameter, scale_train_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, data_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, shape_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, num_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, channels_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, height_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, width_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, operation_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, coeff_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, stable_prod_grad_), + 0, + ~0u, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ELUParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ELUParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ELUParameter, alpha_), + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, num_output_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, input_dim_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, bias_term_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, weight_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, bias_filler_), + 2, + 3, + 4, + 0, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, base_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, shift_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FlattenParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FlattenParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FlattenParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::FlattenParameter, end_axis_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, source_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, batch_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, shuffle_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, file_name_), + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, norm_), + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, source_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, batch_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, rand_skip_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, shuffle_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, new_height_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, new_width_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, is_color_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, mean_file_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, crop_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, mirror_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, root_folder_), + 0, + 11, + 4, + 5, + 7, + 8, + 9, + 10, + 1, + 3, + 6, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, source_), + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, num_output_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, bias_term_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, weight_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, bias_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, transpose_), + 2, + 4, + 0, + 1, + 5, + 3, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InputParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::InputParameter, shape_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, base_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, shift_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, local_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, alpha_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, beta_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, norm_region_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, k_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, engine_), + 2, + 3, + 4, + 0, + 5, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, batch_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, channels_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, height_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, width_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, normalize_variance_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, across_channels_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, eps_), + 1, + 0, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParameterParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParameterParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParameterParameter, shape_), + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pool_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, engine_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, global_pooling_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, ceil_mode_), + 0, + 2, + 7, + 8, + 1, + 3, + 4, + 11, + 5, + 6, + 9, + 10, + 12, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, power_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, shift_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, module_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, layer_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, param_str_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, share_in_parallel_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, num_output_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, weight_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, bias_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, debug_info_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, expose_hidden_), + 2, + 0, + 1, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, operation_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, coeff_), + 1, + 0, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReLUParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReLUParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReLUParameter, negative_slope_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReLUParameter, engine_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, shape_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, num_axes_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, num_axes_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, bias_term_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, bias_filler_), + 3, + 4, + 0, + 2, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, engine_), + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, slice_point_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, slice_dim_), + 1, + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, engine_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, axis_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TanHParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TanHParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TanHParameter, engine_), + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TileParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TileParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TileParameter, axis_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::TileParameter, tiles_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, threshold_), + 0, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, source_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, mean_file_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, batch_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, crop_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, mirror_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, fg_threshold_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, bg_threshold_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, fg_fraction_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, context_pad_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, crop_mode_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, cache_images_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, root_folder_), + 0, + 9, + 1, + 4, + 5, + 6, + 10, + 11, + 12, + 8, + 2, + 7, + 3, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, pyramid_height_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, pool_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, engine_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, bottom_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, top_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, name_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, include_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, exclude_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, type_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blobs_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blob_share_mode_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blobs_lr_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, weight_decay_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, loss_weight_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, accuracy_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, argmax_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, concat_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, contrastive_loss_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, convolution_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, dropout_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, dummy_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, eltwise_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, exp_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hdf5_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hdf5_output_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hinge_loss_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, image_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, infogain_loss_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, inner_product_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, lrn_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, memory_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, mvn_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, pooling_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, power_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, relu_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, sigmoid_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, softmax_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, slice_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, tanh_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, threshold_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, window_data_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, transform_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, loss_param_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, layer_), + ~0u, + ~0u, + 0, + ~0u, + ~0u, + 32, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + 20, + 16, + 2, + 29, + 3, + 4, + 5, + 19, + 17, + 30, + 6, + 7, + 21, + 8, + 9, + 10, + 11, + 15, + 24, + 12, + 14, + 22, + 27, + 28, + 23, + 26, + 18, + 13, + 25, + 31, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, name_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, type_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, num_output_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, biasterm_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, weight_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, bias_filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, pad_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, kernelsize_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, group_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, stride_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, pool_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, dropout_ratio_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, local_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, alpha_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, beta_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, k_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, source_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, meanfile_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, batchsize_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, cropsize_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, mirror_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, blobs_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, blobs_lr_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, weight_decay_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, rand_skip_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_fg_threshold_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_bg_threshold_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_fg_fraction_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_context_pad_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_crop_mode_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_num_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_channels_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_height_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_width_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, shuffle_images_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, concat_dim_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, hdf5_output_param_), + 0, + 1, + 8, + 23, + 5, + 6, + 9, + 10, + 24, + 25, + 11, + 26, + 27, + 28, + 29, + 31, + 2, + 30, + 3, + 12, + 13, + 15, + ~0u, + ~0u, + ~0u, + 17, + 32, + 33, + 34, + 18, + 4, + 19, + 20, + 21, + 14, + 16, + 22, + 7, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PReLUParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PReLUParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PReLUParameter, filler_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PReLUParameter, channel_shared_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, xmin_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, ymin_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, xmax_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, ymax_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, label_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, difficult_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, score_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, size_), + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, pooled_h_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, pooled_w_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, spatial_scale_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, feat_stride_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, base_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, min_size_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, ratio_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, pre_nms_topn_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, post_nms_topn_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, nms_thresh_), + 0, + 1, + 2, + ~0u, + ~0u, + 3, + 4, + 5, + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, _has_bits_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, spatial_scale_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, output_dim_), + PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, group_size_), + 0, + 1, + 2, +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::opencv_caffe::BlobShape)}, + { 7, 24, -1, sizeof(::opencv_caffe::BlobProto)}, + { 35, -1, -1, sizeof(::opencv_caffe::BlobProtoVector)}, + { 42, -1, -1, sizeof(::opencv_caffe::PermuteParameter)}, + { 49, 59, -1, sizeof(::opencv_caffe::NormalizeBBoxParameter)}, + { 63, 86, -1, sizeof(::opencv_caffe::PriorBoxParameter)}, + { 103, 120, -1, sizeof(::opencv_caffe::DetectionOutputParameter)}, + { 131, 144, -1, sizeof(::opencv_caffe::Datum)}, + { 151, 165, -1, sizeof(::opencv_caffe::FillerParameter)}, + { 173, 188, -1, sizeof(::opencv_caffe::NetParameter)}, + { 197, 243, -1, sizeof(::opencv_caffe::SolverParameter)}, + { 283, 293, -1, sizeof(::opencv_caffe::SolverState)}, + { 297, 306, -1, sizeof(::opencv_caffe::NetState)}, + { 309, 320, -1, sizeof(::opencv_caffe::NetStateRule)}, + { 325, 335, -1, sizeof(::opencv_caffe::ParamSpec)}, + { 339, 410, -1, sizeof(::opencv_caffe::LayerParameter)}, + { 475, 488, -1, sizeof(::opencv_caffe::TransformationParameter)}, + { 495, 504, -1, sizeof(::opencv_caffe::LossParameter)}, + { 507, 516, -1, sizeof(::opencv_caffe::AccuracyParameter)}, + { 519, 528, -1, sizeof(::opencv_caffe::ArgMaxParameter)}, + { 531, 539, -1, sizeof(::opencv_caffe::ConcatParameter)}, + { 541, 551, -1, sizeof(::opencv_caffe::BatchNormParameter)}, + { 555, 564, -1, sizeof(::opencv_caffe::BiasParameter)}, + { 567, 575, -1, sizeof(::opencv_caffe::ContrastiveLossParameter)}, + { 577, 601, -1, sizeof(::opencv_caffe::ConvolutionParameter)}, + { 619, 627, -1, sizeof(::opencv_caffe::CropParameter)}, + { 629, 645, -1, sizeof(::opencv_caffe::DataParameter)}, + { 655, 664, -1, sizeof(::opencv_caffe::NonMaximumSuppressionParameter)}, + { 667, 679, -1, sizeof(::opencv_caffe::SaveOutputParameter)}, + { 685, 693, -1, sizeof(::opencv_caffe::DropoutParameter)}, + { 695, -1, -1, sizeof(::opencv_caffe::DummyDataParameter)}, + { 707, 716, -1, sizeof(::opencv_caffe::EltwiseParameter)}, + { 719, 726, -1, sizeof(::opencv_caffe::ELUParameter)}, + { 727, 738, -1, sizeof(::opencv_caffe::EmbedParameter)}, + { 743, 752, -1, sizeof(::opencv_caffe::ExpParameter)}, + { 755, 763, -1, sizeof(::opencv_caffe::FlattenParameter)}, + { 765, 774, -1, sizeof(::opencv_caffe::HDF5DataParameter)}, + { 777, 784, -1, sizeof(::opencv_caffe::HDF5OutputParameter)}, + { 785, 792, -1, sizeof(::opencv_caffe::HingeLossParameter)}, + { 793, 811, -1, sizeof(::opencv_caffe::ImageDataParameter)}, + { 823, 830, -1, sizeof(::opencv_caffe::InfogainLossParameter)}, + { 831, 843, -1, sizeof(::opencv_caffe::InnerProductParameter)}, + { 849, -1, -1, sizeof(::opencv_caffe::InputParameter)}, + { 856, 865, -1, sizeof(::opencv_caffe::LogParameter)}, + { 868, 880, -1, sizeof(::opencv_caffe::LRNParameter)}, + { 886, 896, -1, sizeof(::opencv_caffe::MemoryDataParameter)}, + { 900, 909, -1, sizeof(::opencv_caffe::MVNParameter)}, + { 912, 919, -1, sizeof(::opencv_caffe::ParameterParameter)}, + { 920, 939, -1, sizeof(::opencv_caffe::PoolingParameter)}, + { 952, 961, -1, sizeof(::opencv_caffe::PowerParameter)}, + { 964, 974, -1, sizeof(::opencv_caffe::PythonParameter)}, + { 978, 989, -1, sizeof(::opencv_caffe::RecurrentParameter)}, + { 994, 1003, -1, sizeof(::opencv_caffe::ReductionParameter)}, + { 1006, 1014, -1, sizeof(::opencv_caffe::ReLUParameter)}, + { 1016, 1025, -1, sizeof(::opencv_caffe::ReshapeParameter)}, + { 1028, 1039, -1, sizeof(::opencv_caffe::ScaleParameter)}, + { 1044, 1051, -1, sizeof(::opencv_caffe::SigmoidParameter)}, + { 1052, 1061, -1, sizeof(::opencv_caffe::SliceParameter)}, + { 1064, 1072, -1, sizeof(::opencv_caffe::SoftmaxParameter)}, + { 1074, 1081, -1, sizeof(::opencv_caffe::TanHParameter)}, + { 1082, 1090, -1, sizeof(::opencv_caffe::TileParameter)}, + { 1092, 1099, -1, sizeof(::opencv_caffe::ThresholdParameter)}, + { 1100, 1119, -1, sizeof(::opencv_caffe::WindowDataParameter)}, + { 1132, 1141, -1, sizeof(::opencv_caffe::SPPParameter)}, + { 1144, 1193, -1, sizeof(::opencv_caffe::V1LayerParameter)}, + { 1236, 1280, -1, sizeof(::opencv_caffe::V0LayerParameter)}, + { 1318, 1326, -1, sizeof(::opencv_caffe::PReLUParameter)}, + { 1328, 1342, -1, sizeof(::opencv_caffe::NormalizedBBox)}, + { 1350, 1359, -1, sizeof(::opencv_caffe::ROIPoolingParameter)}, + { 1362, 1376, -1, sizeof(::opencv_caffe::ProposalParameter)}, + { 1384, 1393, -1, sizeof(::opencv_caffe::PSROIPoolingParameter)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::opencv_caffe::_BlobShape_default_instance_), + reinterpret_cast(&::opencv_caffe::_BlobProto_default_instance_), + reinterpret_cast(&::opencv_caffe::_BlobProtoVector_default_instance_), + reinterpret_cast(&::opencv_caffe::_PermuteParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_NormalizeBBoxParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_PriorBoxParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_DetectionOutputParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_Datum_default_instance_), + reinterpret_cast(&::opencv_caffe::_FillerParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_NetParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_SolverParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_SolverState_default_instance_), + reinterpret_cast(&::opencv_caffe::_NetState_default_instance_), + reinterpret_cast(&::opencv_caffe::_NetStateRule_default_instance_), + reinterpret_cast(&::opencv_caffe::_ParamSpec_default_instance_), + reinterpret_cast(&::opencv_caffe::_LayerParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_TransformationParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_LossParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_AccuracyParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ArgMaxParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ConcatParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_BatchNormParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_BiasParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ContrastiveLossParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ConvolutionParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_CropParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_DataParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_NonMaximumSuppressionParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_SaveOutputParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_DropoutParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_DummyDataParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_EltwiseParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ELUParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_EmbedParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ExpParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_FlattenParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_HDF5DataParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_HDF5OutputParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_HingeLossParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ImageDataParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_InfogainLossParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_InnerProductParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_InputParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_LogParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_LRNParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_MemoryDataParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_MVNParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ParameterParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_PoolingParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_PowerParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_PythonParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_RecurrentParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ReductionParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ReLUParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ReshapeParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ScaleParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_SigmoidParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_SliceParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_SoftmaxParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_TanHParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_TileParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ThresholdParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_WindowDataParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_SPPParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_V1LayerParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_V0LayerParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_PReLUParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_NormalizedBBox_default_instance_), + reinterpret_cast(&::opencv_caffe::_ROIPoolingParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_ProposalParameter_default_instance_), + reinterpret_cast(&::opencv_caffe::_PSROIPoolingParameter_default_instance_), +}; + +const char descriptor_table_protodef_opencv_2dcaffe_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\022opencv-caffe.proto\022\014opencv_caffe\"\034\n\tBl" + "obShape\022\017\n\003dim\030\001 \003(\003B\002\020\001\"\224\002\n\tBlobProto\022&" + "\n\005shape\030\007 \001(\0132\027.opencv_caffe.BlobShape\022\020" + "\n\004data\030\005 \003(\002B\002\020\001\022\020\n\004diff\030\006 \003(\002B\002\020\001\022\027\n\013do" + "uble_data\030\010 \003(\001B\002\020\001\022\027\n\013double_diff\030\t \003(\001" + "B\002\020\001\022)\n\rraw_data_type\030\n \001(\0162\022.opencv_caf" + "fe.Type\022\024\n\010raw_data\030\014 \001(\014B\002\020\000\022\016\n\003num\030\001 \001" + "(\005:\0010\022\023\n\010channels\030\002 \001(\005:\0010\022\021\n\006height\030\003 \001" + "(\005:\0010\022\020\n\005width\030\004 \001(\005:\0010\"9\n\017BlobProtoVect" + "or\022&\n\005blobs\030\001 \003(\0132\027.opencv_caffe.BlobPro" + "to\"!\n\020PermuteParameter\022\r\n\005order\030\001 \003(\r\"\235\001" + "\n\026NormalizeBBoxParameter\022\034\n\016across_spati" + "al\030\001 \001(\010:\004true\0223\n\014scale_filler\030\002 \001(\0132\035.o" + "pencv_caffe.FillerParameter\022\034\n\016channel_s" + "hared\030\003 \001(\010:\004true\022\022\n\003eps\030\004 \001(\002:\0051e-10\"\346\002" + "\n\021PriorBoxParameter\022\020\n\010min_size\030\001 \003(\002\022\020\n" + "\010max_size\030\002 \003(\002\022\024\n\014aspect_ratio\030\003 \003(\002\022\022\n" + "\004flip\030\004 \001(\010:\004true\022\022\n\004clip\030\005 \001(\010:\004true\022\020\n" + "\010variance\030\006 \003(\002\022\020\n\010img_size\030\007 \001(\r\022\r\n\005img" + "_h\030\010 \001(\r\022\r\n\005img_w\030\t \001(\r\022\014\n\004step\030\n \001(\002\022\016\n" + "\006step_h\030\013 \001(\002\022\016\n\006step_w\030\014 \001(\002\022\023\n\006offset\030" + "\r \001(\002:\0030.5\022\020\n\010offset_h\030\016 \003(\002\022\020\n\010offset_w" + "\030\017 \003(\002\022\r\n\005width\030\020 \003(\002\022\016\n\006height\030\021 \003(\002\"\'\n" + "\010CodeType\022\n\n\006CORNER\020\001\022\017\n\013CENTER_SIZE\020\002\"\307" + "\003\n\030DetectionOutputParameter\022\023\n\013num_class" + "es\030\001 \001(\r\022\034\n\016share_location\030\002 \001(\010:\004true\022\036" + "\n\023background_label_id\030\003 \001(\005:\0010\022\?\n\tnms_pa" + "ram\030\004 \001(\0132,.opencv_caffe.NonMaximumSuppr" + "essionParameter\022<\n\021save_output_param\030\005 \001" + "(\0132!.opencv_caffe.SaveOutputParameter\022C\n" + "\tcode_type\030\006 \001(\0162(.opencv_caffe.PriorBox" + "Parameter.CodeType:\006CORNER\022)\n\032variance_e" + "ncoded_in_target\030\010 \001(\010:\005false\022\026\n\nkeep_to" + "p_k\030\007 \001(\005:\002-1\022\034\n\024confidence_threshold\030\t " + "\001(\002\022\035\n\017normalized_bbox\030\n \001(\010:\004true\022\024\n\004cl" + "ip\030\350\007 \001(\010:\005false\"\201\001\n\005Datum\022\020\n\010channels\030\001" + " \001(\005\022\016\n\006height\030\002 \001(\005\022\r\n\005width\030\003 \001(\005\022\014\n\004d" + "ata\030\004 \001(\014\022\r\n\005label\030\005 \001(\005\022\022\n\nfloat_data\030\006" + " \003(\002\022\026\n\007encoded\030\007 \001(\010:\005false\"\221\002\n\017FillerP" + "arameter\022\026\n\004type\030\001 \001(\t:\010constant\022\020\n\005valu" + "e\030\002 \001(\002:\0010\022\016\n\003min\030\003 \001(\002:\0010\022\016\n\003max\030\004 \001(\002:" + "\0011\022\017\n\004mean\030\005 \001(\002:\0010\022\016\n\003std\030\006 \001(\002:\0011\022\022\n\006s" + "parse\030\007 \001(\005:\002-1\022I\n\rvariance_norm\030\010 \001(\0162*" + ".opencv_caffe.FillerParameter.VarianceNo" + "rm:\006FAN_IN\"4\n\014VarianceNorm\022\n\n\006FAN_IN\020\000\022\013" + "\n\007FAN_OUT\020\001\022\013\n\007AVERAGE\020\002\"\252\002\n\014NetParamete" + "r\022\014\n\004name\030\001 \001(\t\022\r\n\005input\030\003 \003(\t\022,\n\013input_" + "shape\030\010 \003(\0132\027.opencv_caffe.BlobShape\022\021\n\t" + "input_dim\030\004 \003(\005\022\035\n\016force_backward\030\005 \001(\010:" + "\005false\022%\n\005state\030\006 \001(\0132\026.opencv_caffe.Net" + "State\022\031\n\ndebug_info\030\007 \001(\010:\005false\022+\n\005laye" + "r\030d \003(\0132\034.opencv_caffe.LayerParameter\022.\n" + "\006layers\030\002 \003(\0132\036.opencv_caffe.V1LayerPara" + "meter\"\332\n\n\017SolverParameter\022\013\n\003net\030\030 \001(\t\022-" + "\n\tnet_param\030\031 \001(\0132\032.opencv_caffe.NetPara" + "meter\022\021\n\ttrain_net\030\001 \001(\t\022\020\n\010test_net\030\002 \003" + "(\t\0223\n\017train_net_param\030\025 \001(\0132\032.opencv_caf" + "fe.NetParameter\0222\n\016test_net_param\030\026 \003(\0132" + "\032.opencv_caffe.NetParameter\022+\n\013train_sta" + "te\030\032 \001(\0132\026.opencv_caffe.NetState\022*\n\ntest" + "_state\030\033 \003(\0132\026.opencv_caffe.NetState\022\021\n\t" + "test_iter\030\003 \003(\005\022\030\n\rtest_interval\030\004 \001(\005:\001" + "0\022 \n\021test_compute_loss\030\023 \001(\010:\005false\022!\n\023t" + "est_initialization\030 \001(\010:\004true\022\017\n\007base_l" + "r\030\005 \001(\002\022\017\n\007display\030\006 \001(\005\022\027\n\014average_loss" + "\030! \001(\005:\0011\022\020\n\010max_iter\030\007 \001(\005\022\024\n\titer_size" + "\030$ \001(\005:\0011\022\021\n\tlr_policy\030\010 \001(\t\022\r\n\005gamma\030\t " + "\001(\002\022\r\n\005power\030\n \001(\002\022\020\n\010momentum\030\013 \001(\002\022\024\n\014" + "weight_decay\030\014 \001(\002\022\037\n\023regularization_typ" + "e\030\035 \001(\t:\002L2\022\020\n\010stepsize\030\r \001(\005\022\021\n\tstepval" + "ue\030\" \003(\005\022\032\n\016clip_gradients\030# \001(\002:\002-1\022\023\n\010" + "snapshot\030\016 \001(\005:\0010\022\027\n\017snapshot_prefix\030\017 \001" + "(\t\022\034\n\rsnapshot_diff\030\020 \001(\010:\005false\022R\n\017snap" + "shot_format\030% \001(\0162,.opencv_caffe.SolverP" + "arameter.SnapshotFormat:\013BINARYPROTO\022B\n\013" + "solver_mode\030\021 \001(\0162(.opencv_caffe.SolverP" + "arameter.SolverMode:\003GPU\022\024\n\tdevice_id\030\022 " + "\001(\005:\0010\022\027\n\013random_seed\030\024 \001(\003:\002-1\022\021\n\004type\030" + "( \001(\t:\003SGD\022\024\n\005delta\030\037 \001(\002:\0051e-08\022\030\n\tmome" + "ntum2\030\' \001(\002:\0050.999\022\027\n\trms_decay\030& \001(\002:\0040" + ".99\022\031\n\ndebug_info\030\027 \001(\010:\005false\022\"\n\024snapsh" + "ot_after_train\030\034 \001(\010:\004true\022B\n\013solver_typ" + "e\030\036 \001(\0162(.opencv_caffe.SolverParameter.S" + "olverType:\003SGD\"+\n\016SnapshotFormat\022\010\n\004HDF5" + "\020\000\022\017\n\013BINARYPROTO\020\001\"\036\n\nSolverMode\022\007\n\003CPU" + "\020\000\022\007\n\003GPU\020\001\"U\n\nSolverType\022\007\n\003SGD\020\000\022\014\n\010NE" + "STEROV\020\001\022\013\n\007ADAGRAD\020\002\022\013\n\007RMSPROP\020\003\022\014\n\010AD" + "ADELTA\020\004\022\010\n\004ADAM\020\005\"s\n\013SolverState\022\014\n\004ite" + "r\030\001 \001(\005\022\023\n\013learned_net\030\002 \001(\t\022(\n\007history\030" + "\003 \003(\0132\027.opencv_caffe.BlobProto\022\027\n\014curren" + "t_step\030\004 \001(\005:\0010\"U\n\010NetState\022(\n\005phase\030\001 \001" + "(\0162\023.opencv_caffe.Phase:\004TEST\022\020\n\005level\030\002" + " \001(\005:\0010\022\r\n\005stage\030\003 \003(\t\"z\n\014NetStateRule\022\"" + "\n\005phase\030\001 \001(\0162\023.opencv_caffe.Phase\022\021\n\tmi" + "n_level\030\002 \001(\005\022\021\n\tmax_level\030\003 \001(\005\022\r\n\005stag" + "e\030\004 \003(\t\022\021\n\tnot_stage\030\005 \003(\t\"\252\001\n\tParamSpec" + "\022\014\n\004name\030\001 \001(\t\0228\n\nshare_mode\030\002 \001(\0162$.ope" + "ncv_caffe.ParamSpec.DimCheckMode\022\022\n\007lr_m" + "ult\030\003 \001(\002:\0011\022\025\n\ndecay_mult\030\004 \001(\002:\0011\"*\n\014D" + "imCheckMode\022\n\n\006STRICT\020\000\022\016\n\nPERMISSIVE\020\001\"" + "\243\032\n\016LayerParameter\022\014\n\004name\030\001 \001(\t\022\014\n\004type" + "\030\002 \001(\t\022\016\n\006bottom\030\003 \003(\t\022\013\n\003top\030\004 \003(\t\022\"\n\005p" + "hase\030\n \001(\0162\023.opencv_caffe.Phase\022\023\n\013loss_" + "weight\030\005 \003(\002\022&\n\005param\030\006 \003(\0132\027.opencv_caf" + "fe.ParamSpec\022&\n\005blobs\030\007 \003(\0132\027.opencv_caf" + "fe.BlobProto\022\026\n\016propagate_down\030\013 \003(\010\022+\n\007" + "include\030\010 \003(\0132\032.opencv_caffe.NetStateRul" + "e\022+\n\007exclude\030\t \003(\0132\032.opencv_caffe.NetSta" + "teRule\022>\n\017transform_param\030d \001(\0132%.opencv" + "_caffe.TransformationParameter\022/\n\nloss_p" + "aram\030e \001(\0132\033.opencv_caffe.LossParameter\022" + "7\n\016accuracy_param\030f \001(\0132\037.opencv_caffe.A" + "ccuracyParameter\0223\n\014argmax_param\030g \001(\0132\035" + ".opencv_caffe.ArgMaxParameter\022;\n\020batch_n" + "orm_param\030\213\001 \001(\0132 .opencv_caffe.BatchNor" + "mParameter\0220\n\nbias_param\030\215\001 \001(\0132\033.opencv" + "_caffe.BiasParameter\0223\n\014concat_param\030h \001" + "(\0132\035.opencv_caffe.ConcatParameter\022F\n\026con" + "trastive_loss_param\030i \001(\0132&.opencv_caffe" + ".ContrastiveLossParameter\022=\n\021convolution" + "_param\030j \001(\0132\".opencv_caffe.ConvolutionP" + "arameter\0220\n\ncrop_param\030\220\001 \001(\0132\033.opencv_c" + "affe.CropParameter\022/\n\ndata_param\030k \001(\0132\033" + ".opencv_caffe.DataParameter\022G\n\026detection" + "_output_param\030\223\001 \001(\0132&.opencv_caffe.Dete" + "ctionOutputParameter\0225\n\rdropout_param\030l " + "\001(\0132\036.opencv_caffe.DropoutParameter\022:\n\020d" + "ummy_data_param\030m \001(\0132 .opencv_caffe.Dum" + "myDataParameter\0225\n\reltwise_param\030n \001(\0132\036" + ".opencv_caffe.EltwiseParameter\022.\n\telu_pa" + "ram\030\214\001 \001(\0132\032.opencv_caffe.ELUParameter\0222" + "\n\013embed_param\030\211\001 \001(\0132\034.opencv_caffe.Embe" + "dParameter\022-\n\texp_param\030o \001(\0132\032.opencv_c" + "affe.ExpParameter\0226\n\rflatten_param\030\207\001 \001(" + "\0132\036.opencv_caffe.FlattenParameter\0228\n\017hdf" + "5_data_param\030p \001(\0132\037.opencv_caffe.HDF5Da" + "taParameter\022<\n\021hdf5_output_param\030q \001(\0132!" + ".opencv_caffe.HDF5OutputParameter\022:\n\020hin" + "ge_loss_param\030r \001(\0132 .opencv_caffe.Hinge" + "LossParameter\022:\n\020image_data_param\030s \001(\0132" + " .opencv_caffe.ImageDataParameter\022@\n\023inf" + "ogain_loss_param\030t \001(\0132#.opencv_caffe.In" + "fogainLossParameter\022@\n\023inner_product_par" + "am\030u \001(\0132#.opencv_caffe.InnerProductPara" + "meter\0222\n\013input_param\030\217\001 \001(\0132\034.opencv_caf" + "fe.InputParameter\022.\n\tlog_param\030\206\001 \001(\0132\032." + "opencv_caffe.LogParameter\022-\n\tlrn_param\030v" + " \001(\0132\032.opencv_caffe.LRNParameter\022<\n\021memo" + "ry_data_param\030w \001(\0132!.opencv_caffe.Memor" + "yDataParameter\022-\n\tmvn_param\030x \001(\0132\032.open" + "cv_caffe.MVNParameter\0229\n\nnorm_param\030\225\001 \001" + "(\0132$.opencv_caffe.NormalizeBBoxParameter" + "\0226\n\rpermute_param\030\224\001 \001(\0132\036.opencv_caffe." + "PermuteParameter\022:\n\017parameter_param\030\221\001 \001" + "(\0132 .opencv_caffe.ParameterParameter\0225\n\r" + "pooling_param\030y \001(\0132\036.opencv_caffe.Pooli" + "ngParameter\0221\n\013power_param\030z \001(\0132\034.openc" + "v_caffe.PowerParameter\0222\n\013prelu_param\030\203\001" + " \001(\0132\034.opencv_caffe.PReLUParameter\0229\n\017pr" + "ior_box_param\030\226\001 \001(\0132\037.opencv_caffe.Prio" + "rBoxParameter\0228\n\016proposal_param\030\311\001 \001(\0132\037" + ".opencv_caffe.ProposalParameter\022A\n\023psroi" + "_pooling_param\030\222N \001(\0132#.opencv_caffe.PSR" + "OIPoolingParameter\0224\n\014python_param\030\202\001 \001(" + "\0132\035.opencv_caffe.PythonParameter\022:\n\017recu" + "rrent_param\030\222\001 \001(\0132 .opencv_caffe.Recurr" + "entParameter\022:\n\017reduction_param\030\210\001 \001(\0132 " + ".opencv_caffe.ReductionParameter\022/\n\nrelu" + "_param\030{ \001(\0132\033.opencv_caffe.ReLUParamete" + "r\0226\n\rreshape_param\030\205\001 \001(\0132\036.opencv_caffe" + ".ReshapeParameter\022\?\n\021roi_pooling_param\030\327" + "\307\370\003 \001(\0132!.opencv_caffe.ROIPoolingParamet" + "er\0222\n\013scale_param\030\216\001 \001(\0132\034.opencv_caffe." + "ScaleParameter\0225\n\rsigmoid_param\030| \001(\0132\036." + "opencv_caffe.SigmoidParameter\0225\n\rsoftmax" + "_param\030} \001(\0132\036.opencv_caffe.SoftmaxParam" + "eter\022.\n\tspp_param\030\204\001 \001(\0132\032.opencv_caffe." + "SPPParameter\0221\n\013slice_param\030~ \001(\0132\034.open" + "cv_caffe.SliceParameter\022/\n\ntanh_param\030\177 " + "\001(\0132\033.opencv_caffe.TanHParameter\022:\n\017thre" + "shold_param\030\200\001 \001(\0132 .opencv_caffe.Thresh" + "oldParameter\0220\n\ntile_param\030\212\001 \001(\0132\033.open" + "cv_caffe.TileParameter\022=\n\021window_data_pa" + "ram\030\201\001 \001(\0132!.opencv_caffe.WindowDataPara" + "meter\"\266\001\n\027TransformationParameter\022\020\n\005sca" + "le\030\001 \001(\002:\0011\022\025\n\006mirror\030\002 \001(\010:\005false\022\024\n\tcr" + "op_size\030\003 \001(\r:\0010\022\021\n\tmean_file\030\004 \001(\t\022\022\n\nm" + "ean_value\030\005 \003(\002\022\032\n\013force_color\030\006 \001(\010:\005fa" + "lse\022\031\n\nforce_gray\030\007 \001(\010:\005false\"\311\001\n\rLossP" + "arameter\022\024\n\014ignore_label\030\001 \001(\005\022K\n\rnormal" + "ization\030\003 \001(\0162-.opencv_caffe.LossParamet" + "er.NormalizationMode:\005VALID\022\021\n\tnormalize" + "\030\002 \001(\010\"B\n\021NormalizationMode\022\010\n\004FULL\020\000\022\t\n" + "\005VALID\020\001\022\016\n\nBATCH_SIZE\020\002\022\010\n\004NONE\020\003\"L\n\021Ac" + "curacyParameter\022\020\n\005top_k\030\001 \001(\r:\0011\022\017\n\004axi" + "s\030\002 \001(\005:\0011\022\024\n\014ignore_label\030\003 \001(\005\"M\n\017ArgM" + "axParameter\022\032\n\013out_max_val\030\001 \001(\010:\005false\022" + "\020\n\005top_k\030\002 \001(\r:\0011\022\014\n\004axis\030\003 \001(\005\"9\n\017Conca" + "tParameter\022\017\n\004axis\030\002 \001(\005:\0011\022\025\n\nconcat_di" + "m\030\001 \001(\r:\0011\"\205\001\n\022BatchNormParameter\022\030\n\020use" + "_global_stats\030\001 \001(\010\022&\n\027moving_average_fr" + "action\030\002 \001(\002:\0050.999\022\022\n\003eps\030\003 \001(\002:\0051e-05\022" + "\031\n\nscale_bias\030\007 \001(\010:\005false\"d\n\rBiasParame" + "ter\022\017\n\004axis\030\001 \001(\005:\0011\022\023\n\010num_axes\030\002 \001(\005:\001" + "1\022-\n\006filler\030\003 \001(\0132\035.opencv_caffe.FillerP" + "arameter\"L\n\030ContrastiveLossParameter\022\021\n\006" + "margin\030\001 \001(\002:\0011\022\035\n\016legacy_version\030\002 \001(\010:" + "\005false\"\221\004\n\024ConvolutionParameter\022\022\n\nnum_o" + "utput\030\001 \001(\r\022\027\n\tbias_term\030\002 \001(\010:\004true\022\013\n\003" + "pad\030\003 \003(\r\022\023\n\013kernel_size\030\004 \003(\r\022\016\n\006stride" + "\030\006 \003(\r\022\020\n\010dilation\030\022 \003(\r\022\020\n\005pad_h\030\t \001(\r:" + "\0010\022\020\n\005pad_w\030\n \001(\r:\0010\022\020\n\010kernel_h\030\013 \001(\r\022\020" + "\n\010kernel_w\030\014 \001(\r\022\020\n\010stride_h\030\r \001(\r\022\020\n\010st" + "ride_w\030\016 \001(\r\022\020\n\005group\030\005 \001(\r:\0011\0224\n\rweight" + "_filler\030\007 \001(\0132\035.opencv_caffe.FillerParam" + "eter\0222\n\013bias_filler\030\010 \001(\0132\035.opencv_caffe" + ".FillerParameter\022B\n\006engine\030\017 \001(\0162).openc" + "v_caffe.ConvolutionParameter.Engine:\007DEF" + "AULT\022\017\n\004axis\030\020 \001(\005:\0011\022\036\n\017force_nd_im2col" + "\030\021 \001(\010:\005false\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005" + "CAFFE\020\001\022\t\n\005CUDNN\020\002\"0\n\rCropParameter\022\017\n\004a" + "xis\030\001 \001(\005:\0012\022\016\n\006offset\030\002 \003(\r\"\253\002\n\rDataPar" + "ameter\022\016\n\006source\030\001 \001(\t\022\022\n\nbatch_size\030\004 \001" + "(\r\022\024\n\trand_skip\030\007 \001(\r:\0010\0228\n\007backend\030\010 \001(" + "\0162\036.opencv_caffe.DataParameter.DB:\007LEVEL" + "DB\022\020\n\005scale\030\002 \001(\002:\0011\022\021\n\tmean_file\030\003 \001(\t\022" + "\024\n\tcrop_size\030\005 \001(\r:\0010\022\025\n\006mirror\030\006 \001(\010:\005f" + "alse\022\"\n\023force_encoded_color\030\t \001(\010:\005false" + "\022\023\n\010prefetch\030\n \001(\r:\0014\"\033\n\002DB\022\013\n\007LEVELDB\020\000" + "\022\010\n\004LMDB\020\001\"[\n\036NonMaximumSuppressionParam" + "eter\022\032\n\rnms_threshold\030\001 \001(\002:\0030.3\022\r\n\005top_" + "k\030\002 \001(\005\022\016\n\003eta\030\003 \001(\002:\0011\"\252\001\n\023SaveOutputPa" + "rameter\022\030\n\020output_directory\030\001 \001(\t\022\032\n\022out" + "put_name_prefix\030\002 \001(\t\022\025\n\routput_format\030\003" + " \001(\t\022\026\n\016label_map_file\030\004 \001(\t\022\026\n\016name_siz" + "e_file\030\005 \001(\t\022\026\n\016num_test_image\030\006 \001(\r\"I\n\020" + "DropoutParameter\022\032\n\rdropout_ratio\030\001 \001(\002:" + "\0030.5\022\031\n\013scale_train\030\002 \001(\010:\004true\"\256\001\n\022Dumm" + "yDataParameter\0222\n\013data_filler\030\001 \003(\0132\035.op" + "encv_caffe.FillerParameter\022&\n\005shape\030\006 \003(" + "\0132\027.opencv_caffe.BlobShape\022\013\n\003num\030\002 \003(\r\022" + "\020\n\010channels\030\003 \003(\r\022\016\n\006height\030\004 \003(\r\022\r\n\005wid" + "th\030\005 \003(\r\"\254\001\n\020EltwiseParameter\022@\n\toperati" + "on\030\001 \001(\0162(.opencv_caffe.EltwiseParameter" + ".EltwiseOp:\003SUM\022\r\n\005coeff\030\002 \003(\002\022\036\n\020stable" + "_prod_grad\030\003 \001(\010:\004true\"\'\n\tEltwiseOp\022\010\n\004P" + "ROD\020\000\022\007\n\003SUM\020\001\022\007\n\003MAX\020\002\" \n\014ELUParameter\022" + "\020\n\005alpha\030\001 \001(\002:\0011\"\272\001\n\016EmbedParameter\022\022\n\n" + "num_output\030\001 \001(\r\022\021\n\tinput_dim\030\002 \001(\r\022\027\n\tb" + "ias_term\030\003 \001(\010:\004true\0224\n\rweight_filler\030\004 " + "\001(\0132\035.opencv_caffe.FillerParameter\0222\n\013bi" + "as_filler\030\005 \001(\0132\035.opencv_caffe.FillerPar" + "ameter\"D\n\014ExpParameter\022\020\n\004base\030\001 \001(\002:\002-1" + "\022\020\n\005scale\030\002 \001(\002:\0011\022\020\n\005shift\030\003 \001(\002:\0010\"9\n\020" + "FlattenParameter\022\017\n\004axis\030\001 \001(\005:\0011\022\024\n\010end" + "_axis\030\002 \001(\005:\002-1\"O\n\021HDF5DataParameter\022\016\n\006" + "source\030\001 \001(\t\022\022\n\nbatch_size\030\002 \001(\r\022\026\n\007shuf" + "fle\030\003 \001(\010:\005false\"(\n\023HDF5OutputParameter\022" + "\021\n\tfile_name\030\001 \001(\t\"e\n\022HingeLossParameter" + "\0227\n\004norm\030\001 \001(\0162%.opencv_caffe.HingeLossP" + "arameter.Norm:\002L1\"\026\n\004Norm\022\006\n\002L1\020\001\022\006\n\002L2\020" + "\002\"\227\002\n\022ImageDataParameter\022\016\n\006source\030\001 \001(\t" + "\022\025\n\nbatch_size\030\004 \001(\r:\0011\022\024\n\trand_skip\030\007 \001" + "(\r:\0010\022\026\n\007shuffle\030\010 \001(\010:\005false\022\025\n\nnew_hei" + "ght\030\t \001(\r:\0010\022\024\n\tnew_width\030\n \001(\r:\0010\022\026\n\010is" + "_color\030\013 \001(\010:\004true\022\020\n\005scale\030\002 \001(\002:\0011\022\021\n\t" + "mean_file\030\003 \001(\t\022\024\n\tcrop_size\030\005 \001(\r:\0010\022\025\n" + "\006mirror\030\006 \001(\010:\005false\022\025\n\013root_folder\030\014 \001(" + "\t:\000\"\'\n\025InfogainLossParameter\022\016\n\006source\030\001" + " \001(\t\"\331\001\n\025InnerProductParameter\022\022\n\nnum_ou" + "tput\030\001 \001(\r\022\027\n\tbias_term\030\002 \001(\010:\004true\0224\n\rw" + "eight_filler\030\003 \001(\0132\035.opencv_caffe.Filler" + "Parameter\0222\n\013bias_filler\030\004 \001(\0132\035.opencv_" + "caffe.FillerParameter\022\017\n\004axis\030\005 \001(\005:\0011\022\030" + "\n\ttranspose\030\006 \001(\010:\005false\"8\n\016InputParamet" + "er\022&\n\005shape\030\001 \003(\0132\027.opencv_caffe.BlobSha" + "pe\"D\n\014LogParameter\022\020\n\004base\030\001 \001(\002:\002-1\022\020\n\005" + "scale\030\002 \001(\002:\0011\022\020\n\005shift\030\003 \001(\002:\0010\"\306\002\n\014LRN" + "Parameter\022\025\n\nlocal_size\030\001 \001(\r:\0015\022\020\n\005alph" + "a\030\002 \001(\002:\0011\022\022\n\004beta\030\003 \001(\002:\0040.75\022K\n\013norm_r" + "egion\030\004 \001(\0162%.opencv_caffe.LRNParameter." + "NormRegion:\017ACROSS_CHANNELS\022\014\n\001k\030\005 \001(\002:\001" + "1\022:\n\006engine\030\006 \001(\0162!.opencv_caffe.LRNPara" + "meter.Engine:\007DEFAULT\"5\n\nNormRegion\022\023\n\017A" + "CROSS_CHANNELS\020\000\022\022\n\016WITHIN_CHANNEL\020\001\"+\n\006" + "Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020" + "\002\"Z\n\023MemoryDataParameter\022\022\n\nbatch_size\030\001" + " \001(\r\022\020\n\010channels\030\002 \001(\r\022\016\n\006height\030\003 \001(\r\022\r" + "\n\005width\030\004 \001(\r\"d\n\014MVNParameter\022 \n\022normali" + "ze_variance\030\001 \001(\010:\004true\022\036\n\017across_channe" + "ls\030\002 \001(\010:\005false\022\022\n\003eps\030\003 \001(\002:\0051e-09\"<\n\022P" + "arameterParameter\022&\n\005shape\030\001 \001(\0132\027.openc" + "v_caffe.BlobShape\"\311\003\n\020PoolingParameter\022<" + "\n\004pool\030\001 \001(\0162).opencv_caffe.PoolingParam" + "eter.PoolMethod:\003MAX\022\016\n\003pad\030\004 \001(\r:\0010\022\020\n\005" + "pad_h\030\t \001(\r:\0010\022\020\n\005pad_w\030\n \001(\r:\0010\022\023\n\013kern" + "el_size\030\002 \001(\r\022\020\n\010kernel_h\030\005 \001(\r\022\020\n\010kerne" + "l_w\030\006 \001(\r\022\021\n\006stride\030\003 \001(\r:\0011\022\020\n\010stride_h" + "\030\007 \001(\r\022\020\n\010stride_w\030\010 \001(\r\022>\n\006engine\030\013 \001(\016" + "2%.opencv_caffe.PoolingParameter.Engine:" + "\007DEFAULT\022\035\n\016global_pooling\030\014 \001(\010:\005false\022" + "\027\n\tceil_mode\030\r \001(\010:\004true\".\n\nPoolMethod\022\007" + "\n\003MAX\020\000\022\007\n\003AVE\020\001\022\016\n\nSTOCHASTIC\020\002\"+\n\006Engi" + "ne\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"F\n" + "\016PowerParameter\022\020\n\005power\030\001 \001(\002:\0011\022\020\n\005sca" + "le\030\002 \001(\002:\0011\022\020\n\005shift\030\003 \001(\002:\0010\"g\n\017PythonP" + "arameter\022\016\n\006module\030\001 \001(\t\022\r\n\005layer\030\002 \001(\t\022" + "\023\n\tparam_str\030\003 \001(\t:\000\022 \n\021share_in_paralle" + "l\030\004 \001(\010:\005false\"\316\001\n\022RecurrentParameter\022\025\n" + "\nnum_output\030\001 \001(\r:\0010\0224\n\rweight_filler\030\002 " + "\001(\0132\035.opencv_caffe.FillerParameter\0222\n\013bi" + "as_filler\030\003 \001(\0132\035.opencv_caffe.FillerPar" + "ameter\022\031\n\ndebug_info\030\004 \001(\010:\005false\022\034\n\rexp" + "ose_hidden\030\005 \001(\010:\005false\"\264\001\n\022ReductionPar" + "ameter\022D\n\toperation\030\001 \001(\0162,.opencv_caffe" + ".ReductionParameter.ReductionOp:\003SUM\022\017\n\004" + "axis\030\002 \001(\005:\0010\022\020\n\005coeff\030\003 \001(\002:\0011\"5\n\013Reduc" + "tionOp\022\007\n\003SUM\020\001\022\010\n\004ASUM\020\002\022\t\n\005SUMSQ\020\003\022\010\n\004" + "MEAN\020\004\"\224\001\n\rReLUParameter\022\031\n\016negative_slo" + "pe\030\001 \001(\002:\0010\022;\n\006engine\030\002 \001(\0162\".opencv_caf" + "fe.ReLUParameter.Engine:\007DEFAULT\"+\n\006Engi" + "ne\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"a\n" + "\020ReshapeParameter\022&\n\005shape\030\001 \001(\0132\027.openc" + "v_caffe.BlobShape\022\017\n\004axis\030\002 \001(\005:\0010\022\024\n\010nu" + "m_axes\030\003 \001(\005:\002-1\"\263\001\n\016ScaleParameter\022\017\n\004a" + "xis\030\001 \001(\005:\0011\022\023\n\010num_axes\030\002 \001(\005:\0011\022-\n\006fil" + "ler\030\003 \001(\0132\035.opencv_caffe.FillerParameter" + "\022\030\n\tbias_term\030\004 \001(\010:\005false\0222\n\013bias_fille" + "r\030\005 \001(\0132\035.opencv_caffe.FillerParameter\"\177" + "\n\020SigmoidParameter\022>\n\006engine\030\001 \001(\0162%.ope" + "ncv_caffe.SigmoidParameter.Engine:\007DEFAU" + "LT\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005" + "CUDNN\020\002\"L\n\016SliceParameter\022\017\n\004axis\030\003 \001(\005:" + "\0011\022\023\n\013slice_point\030\002 \003(\r\022\024\n\tslice_dim\030\001 \001" + "(\r:\0011\"\220\001\n\020SoftmaxParameter\022>\n\006engine\030\001 \001" + "(\0162%.opencv_caffe.SoftmaxParameter.Engin" + "e:\007DEFAULT\022\017\n\004axis\030\002 \001(\005:\0011\"+\n\006Engine\022\013\n" + "\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"y\n\rTanH" + "Parameter\022;\n\006engine\030\001 \001(\0162\".opencv_caffe" + ".TanHParameter.Engine:\007DEFAULT\"+\n\006Engine" + "\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"/\n\rT" + "ileParameter\022\017\n\004axis\030\001 \001(\005:\0011\022\r\n\005tiles\030\002" + " \001(\005\"*\n\022ThresholdParameter\022\024\n\tthreshold\030" + "\001 \001(\002:\0010\"\301\002\n\023WindowDataParameter\022\016\n\006sour" + "ce\030\001 \001(\t\022\020\n\005scale\030\002 \001(\002:\0011\022\021\n\tmean_file\030" + "\003 \001(\t\022\022\n\nbatch_size\030\004 \001(\r\022\024\n\tcrop_size\030\005" + " \001(\r:\0010\022\025\n\006mirror\030\006 \001(\010:\005false\022\031\n\014fg_thr" + "eshold\030\007 \001(\002:\0030.5\022\031\n\014bg_threshold\030\010 \001(\002:" + "\0030.5\022\031\n\013fg_fraction\030\t \001(\002:\0040.25\022\026\n\013conte" + "xt_pad\030\n \001(\r:\0010\022\027\n\tcrop_mode\030\013 \001(\t:\004warp" + "\022\033\n\014cache_images\030\014 \001(\010:\005false\022\025\n\013root_fo" + "lder\030\r \001(\t:\000\"\371\001\n\014SPPParameter\022\026\n\016pyramid" + "_height\030\001 \001(\r\0228\n\004pool\030\002 \001(\0162%.opencv_caf" + "fe.SPPParameter.PoolMethod:\003MAX\022:\n\006engin" + "e\030\006 \001(\0162!.opencv_caffe.SPPParameter.Engi" + "ne:\007DEFAULT\".\n\nPoolMethod\022\007\n\003MAX\020\000\022\007\n\003AV" + "E\020\001\022\016\n\nSTOCHASTIC\020\002\"+\n\006Engine\022\013\n\007DEFAULT" + "\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"\334\025\n\020V1LayerPara" + "meter\022\016\n\006bottom\030\002 \003(\t\022\013\n\003top\030\003 \003(\t\022\014\n\004na" + "me\030\004 \001(\t\022+\n\007include\030 \003(\0132\032.opencv_caffe" + ".NetStateRule\022+\n\007exclude\030! \003(\0132\032.opencv_" + "caffe.NetStateRule\0226\n\004type\030\005 \001(\0162(.openc" + "v_caffe.V1LayerParameter.LayerType\022&\n\005bl" + "obs\030\006 \003(\0132\027.opencv_caffe.BlobProto\022\016\n\005pa" + "ram\030\351\007 \003(\t\022E\n\017blob_share_mode\030\352\007 \003(\0162+.o" + "pencv_caffe.V1LayerParameter.DimCheckMod" + "e\022\020\n\010blobs_lr\030\007 \003(\002\022\024\n\014weight_decay\030\010 \003(" + "\002\022\023\n\013loss_weight\030# \003(\002\0227\n\016accuracy_param" + "\030\033 \001(\0132\037.opencv_caffe.AccuracyParameter\022" + "3\n\014argmax_param\030\027 \001(\0132\035.opencv_caffe.Arg" + "MaxParameter\0223\n\014concat_param\030\t \001(\0132\035.ope" + "ncv_caffe.ConcatParameter\022F\n\026contrastive" + "_loss_param\030( \001(\0132&.opencv_caffe.Contras" + "tiveLossParameter\022=\n\021convolution_param\030\n" + " \001(\0132\".opencv_caffe.ConvolutionParameter" + "\022/\n\ndata_param\030\013 \001(\0132\033.opencv_caffe.Data" + "Parameter\0225\n\rdropout_param\030\014 \001(\0132\036.openc" + "v_caffe.DropoutParameter\022:\n\020dummy_data_p" + "aram\030\032 \001(\0132 .opencv_caffe.DummyDataParam" + "eter\0225\n\reltwise_param\030\030 \001(\0132\036.opencv_caf" + "fe.EltwiseParameter\022-\n\texp_param\030) \001(\0132\032" + ".opencv_caffe.ExpParameter\0228\n\017hdf5_data_" + "param\030\r \001(\0132\037.opencv_caffe.HDF5DataParam" + "eter\022<\n\021hdf5_output_param\030\016 \001(\0132!.opencv" + "_caffe.HDF5OutputParameter\022:\n\020hinge_loss" + "_param\030\035 \001(\0132 .opencv_caffe.HingeLossPar" + "ameter\022:\n\020image_data_param\030\017 \001(\0132 .openc" + "v_caffe.ImageDataParameter\022@\n\023infogain_l" + "oss_param\030\020 \001(\0132#.opencv_caffe.InfogainL" + "ossParameter\022@\n\023inner_product_param\030\021 \001(" + "\0132#.opencv_caffe.InnerProductParameter\022-" + "\n\tlrn_param\030\022 \001(\0132\032.opencv_caffe.LRNPara" + "meter\022<\n\021memory_data_param\030\026 \001(\0132!.openc" + "v_caffe.MemoryDataParameter\022-\n\tmvn_param" + "\030\" \001(\0132\032.opencv_caffe.MVNParameter\0225\n\rpo" + "oling_param\030\023 \001(\0132\036.opencv_caffe.Pooling" + "Parameter\0221\n\013power_param\030\025 \001(\0132\034.opencv_" + "caffe.PowerParameter\022/\n\nrelu_param\030\036 \001(\013" + "2\033.opencv_caffe.ReLUParameter\0225\n\rsigmoid" + "_param\030& \001(\0132\036.opencv_caffe.SigmoidParam" + "eter\0225\n\rsoftmax_param\030\' \001(\0132\036.opencv_caf" + "fe.SoftmaxParameter\0221\n\013slice_param\030\037 \001(\013" + "2\034.opencv_caffe.SliceParameter\022/\n\ntanh_p" + "aram\030% \001(\0132\033.opencv_caffe.TanHParameter\022" + "9\n\017threshold_param\030\031 \001(\0132 .opencv_caffe." + "ThresholdParameter\022<\n\021window_data_param\030" + "\024 \001(\0132!.opencv_caffe.WindowDataParameter" + "\022>\n\017transform_param\030$ \001(\0132%.opencv_caffe" + ".TransformationParameter\022/\n\nloss_param\030*" + " \001(\0132\033.opencv_caffe.LossParameter\022-\n\005lay" + "er\030\001 \001(\0132\036.opencv_caffe.V0LayerParameter" + "\"\330\004\n\tLayerType\022\010\n\004NONE\020\000\022\n\n\006ABSVAL\020#\022\014\n\010" + "ACCURACY\020\001\022\n\n\006ARGMAX\020\036\022\010\n\004BNLL\020\002\022\n\n\006CONC" + "AT\020\003\022\024\n\020CONTRASTIVE_LOSS\020%\022\017\n\013CONVOLUTIO" + "N\020\004\022\010\n\004DATA\020\005\022\021\n\rDECONVOLUTION\020\'\022\013\n\007DROP" + "OUT\020\006\022\016\n\nDUMMY_DATA\020 \022\022\n\016EUCLIDEAN_LOSS\020" + "\007\022\013\n\007ELTWISE\020\031\022\007\n\003EXP\020&\022\013\n\007FLATTEN\020\010\022\r\n\t" + "HDF5_DATA\020\t\022\017\n\013HDF5_OUTPUT\020\n\022\016\n\nHINGE_LO" + "SS\020\034\022\n\n\006IM2COL\020\013\022\016\n\nIMAGE_DATA\020\014\022\021\n\rINFO" + "GAIN_LOSS\020\r\022\021\n\rINNER_PRODUCT\020\016\022\007\n\003LRN\020\017\022" + "\017\n\013MEMORY_DATA\020\035\022\035\n\031MULTINOMIAL_LOGISTIC" + "_LOSS\020\020\022\007\n\003MVN\020\"\022\013\n\007POOLING\020\021\022\t\n\005POWER\020\032" + "\022\010\n\004RELU\020\022\022\013\n\007SIGMOID\020\023\022\036\n\032SIGMOID_CROSS" + "_ENTROPY_LOSS\020\033\022\013\n\007SILENCE\020$\022\013\n\007SOFTMAX\020" + "\024\022\020\n\014SOFTMAX_LOSS\020\025\022\t\n\005SPLIT\020\026\022\t\n\005SLICE\020" + "!\022\010\n\004TANH\020\027\022\017\n\013WINDOW_DATA\020\030\022\r\n\tTHRESHOL" + "D\020\037\"*\n\014DimCheckMode\022\n\n\006STRICT\020\000\022\016\n\nPERMI" + "SSIVE\020\001\"\240\010\n\020V0LayerParameter\022\014\n\004name\030\001 \001" + "(\t\022\014\n\004type\030\002 \001(\t\022\022\n\nnum_output\030\003 \001(\r\022\026\n\010" + "biasterm\030\004 \001(\010:\004true\0224\n\rweight_filler\030\005 " + "\001(\0132\035.opencv_caffe.FillerParameter\0222\n\013bi" + "as_filler\030\006 \001(\0132\035.opencv_caffe.FillerPar" + "ameter\022\016\n\003pad\030\007 \001(\r:\0010\022\022\n\nkernelsize\030\010 \001" + "(\r\022\020\n\005group\030\t \001(\r:\0011\022\021\n\006stride\030\n \001(\r:\0011\022" + "<\n\004pool\030\013 \001(\0162).opencv_caffe.V0LayerPara" + "meter.PoolMethod:\003MAX\022\032\n\rdropout_ratio\030\014" + " \001(\002:\0030.5\022\025\n\nlocal_size\030\r \001(\r:\0015\022\020\n\005alph" + "a\030\016 \001(\002:\0011\022\022\n\004beta\030\017 \001(\002:\0040.75\022\014\n\001k\030\026 \001(" + "\002:\0011\022\016\n\006source\030\020 \001(\t\022\020\n\005scale\030\021 \001(\002:\0011\022\020" + "\n\010meanfile\030\022 \001(\t\022\021\n\tbatchsize\030\023 \001(\r\022\023\n\010c" + "ropsize\030\024 \001(\r:\0010\022\025\n\006mirror\030\025 \001(\010:\005false\022" + "&\n\005blobs\0302 \003(\0132\027.opencv_caffe.BlobProto\022" + "\020\n\010blobs_lr\0303 \003(\002\022\024\n\014weight_decay\0304 \003(\002\022" + "\024\n\trand_skip\0305 \001(\r:\0010\022\035\n\020det_fg_threshol" + "d\0306 \001(\002:\0030.5\022\035\n\020det_bg_threshold\0307 \001(\002:\003" + "0.5\022\035\n\017det_fg_fraction\0308 \001(\002:\0040.25\022\032\n\017de" + "t_context_pad\030: \001(\r:\0010\022\033\n\rdet_crop_mode\030" + "; \001(\t:\004warp\022\022\n\007new_num\030< \001(\005:\0010\022\027\n\014new_c" + "hannels\030= \001(\005:\0010\022\025\n\nnew_height\030> \001(\005:\0010\022" + "\024\n\tnew_width\030\? \001(\005:\0010\022\035\n\016shuffle_images\030" + "@ \001(\010:\005false\022\025\n\nconcat_dim\030A \001(\r:\0011\022=\n\021h" + "df5_output_param\030\351\007 \001(\0132!.opencv_caffe.H" + "DF5OutputParameter\".\n\nPoolMethod\022\007\n\003MAX\020" + "\000\022\007\n\003AVE\020\001\022\016\n\nSTOCHASTIC\020\002\"^\n\016PReLUParam" + "eter\022-\n\006filler\030\001 \001(\0132\035.opencv_caffe.Fill" + "erParameter\022\035\n\016channel_shared\030\002 \001(\010:\005fal" + "se\"\207\001\n\016NormalizedBBox\022\014\n\004xmin\030\001 \001(\002\022\014\n\004y" + "min\030\002 \001(\002\022\014\n\004xmax\030\003 \001(\002\022\014\n\004ymax\030\004 \001(\002\022\r\n" + "\005label\030\005 \001(\005\022\021\n\tdifficult\030\006 \001(\010\022\r\n\005score" + "\030\007 \001(\002\022\014\n\004size\030\010 \001(\002\"Y\n\023ROIPoolingParame" + "ter\022\023\n\010pooled_h\030\001 \001(\r:\0010\022\023\n\010pooled_w\030\002 \001" + "(\r:\0010\022\030\n\rspatial_scale\030\003 \001(\002:\0011\"\310\001\n\021Prop" + "osalParameter\022\027\n\013feat_stride\030\001 \001(\r:\00216\022\025" + "\n\tbase_size\030\002 \001(\r:\00216\022\024\n\010min_size\030\003 \001(\r:" + "\00216\022\r\n\005ratio\030\004 \003(\002\022\r\n\005scale\030\005 \003(\002\022\032\n\014pre" + "_nms_topn\030\006 \001(\r:\0046000\022\032\n\rpost_nms_topn\030\007" + " \001(\r:\003300\022\027\n\nnms_thresh\030\010 \001(\002:\0030.7\"V\n\025PS" + "ROIPoolingParameter\022\025\n\rspatial_scale\030\001 \002" + "(\002\022\022\n\noutput_dim\030\002 \002(\005\022\022\n\ngroup_size\030\003 \002" + "(\005*=\n\004Type\022\n\n\006DOUBLE\020\000\022\t\n\005FLOAT\020\001\022\013\n\007FLO" + "AT16\020\002\022\007\n\003INT\020\003\022\010\n\004UINT\020\004*\034\n\005Phase\022\t\n\005TR" + "AIN\020\000\022\010\n\004TEST\020\001" + ; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_opencv_2dcaffe_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_opencv_2dcaffe_2eproto = { + false, false, 18855, descriptor_table_protodef_opencv_2dcaffe_2eproto, "opencv-caffe.proto", + &descriptor_table_opencv_2dcaffe_2eproto_once, nullptr, 0, 71, + schemas, file_default_instances, TableStruct_opencv_2dcaffe_2eproto::offsets, + file_level_metadata_opencv_2dcaffe_2eproto, file_level_enum_descriptors_opencv_2dcaffe_2eproto, file_level_service_descriptors_opencv_2dcaffe_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_opencv_2dcaffe_2eproto_getter() { + return &descriptor_table_opencv_2dcaffe_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_opencv_2dcaffe_2eproto(&descriptor_table_opencv_2dcaffe_2eproto); +namespace opencv_caffe { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PriorBoxParameter_CodeType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[0]; +} +bool PriorBoxParameter_CodeType_IsValid(int value) { + switch (value) { + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PriorBoxParameter_CodeType PriorBoxParameter::CORNER; +constexpr PriorBoxParameter_CodeType PriorBoxParameter::CENTER_SIZE; +constexpr PriorBoxParameter_CodeType PriorBoxParameter::CodeType_MIN; +constexpr PriorBoxParameter_CodeType PriorBoxParameter::CodeType_MAX; +constexpr int PriorBoxParameter::CodeType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FillerParameter_VarianceNorm_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[1]; +} +bool FillerParameter_VarianceNorm_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr FillerParameter_VarianceNorm FillerParameter::FAN_IN; +constexpr FillerParameter_VarianceNorm FillerParameter::FAN_OUT; +constexpr FillerParameter_VarianceNorm FillerParameter::AVERAGE; +constexpr FillerParameter_VarianceNorm FillerParameter::VarianceNorm_MIN; +constexpr FillerParameter_VarianceNorm FillerParameter::VarianceNorm_MAX; +constexpr int FillerParameter::VarianceNorm_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[2]; +} +bool SolverParameter_SnapshotFormat_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr SolverParameter_SnapshotFormat SolverParameter::HDF5; +constexpr SolverParameter_SnapshotFormat SolverParameter::BINARYPROTO; +constexpr SolverParameter_SnapshotFormat SolverParameter::SnapshotFormat_MIN; +constexpr SolverParameter_SnapshotFormat SolverParameter::SnapshotFormat_MAX; +constexpr int SolverParameter::SnapshotFormat_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverMode_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[3]; +} +bool SolverParameter_SolverMode_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr SolverParameter_SolverMode SolverParameter::CPU; +constexpr SolverParameter_SolverMode SolverParameter::GPU; +constexpr SolverParameter_SolverMode SolverParameter::SolverMode_MIN; +constexpr SolverParameter_SolverMode SolverParameter::SolverMode_MAX; +constexpr int SolverParameter::SolverMode_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[4]; +} +bool SolverParameter_SolverType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr SolverParameter_SolverType SolverParameter::SGD; +constexpr SolverParameter_SolverType SolverParameter::NESTEROV; +constexpr SolverParameter_SolverType SolverParameter::ADAGRAD; +constexpr SolverParameter_SolverType SolverParameter::RMSPROP; +constexpr SolverParameter_SolverType SolverParameter::ADADELTA; +constexpr SolverParameter_SolverType SolverParameter::ADAM; +constexpr SolverParameter_SolverType SolverParameter::SolverType_MIN; +constexpr SolverParameter_SolverType SolverParameter::SolverType_MAX; +constexpr int SolverParameter::SolverType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ParamSpec_DimCheckMode_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[5]; +} +bool ParamSpec_DimCheckMode_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ParamSpec_DimCheckMode ParamSpec::STRICT; +constexpr ParamSpec_DimCheckMode ParamSpec::PERMISSIVE; +constexpr ParamSpec_DimCheckMode ParamSpec::DimCheckMode_MIN; +constexpr ParamSpec_DimCheckMode ParamSpec::DimCheckMode_MAX; +constexpr int ParamSpec::DimCheckMode_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LossParameter_NormalizationMode_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[6]; +} +bool LossParameter_NormalizationMode_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr LossParameter_NormalizationMode LossParameter::FULL; +constexpr LossParameter_NormalizationMode LossParameter::VALID; +constexpr LossParameter_NormalizationMode LossParameter::BATCH_SIZE; +constexpr LossParameter_NormalizationMode LossParameter::NONE; +constexpr LossParameter_NormalizationMode LossParameter::NormalizationMode_MIN; +constexpr LossParameter_NormalizationMode LossParameter::NormalizationMode_MAX; +constexpr int LossParameter::NormalizationMode_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConvolutionParameter_Engine_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[7]; +} +bool ConvolutionParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ConvolutionParameter_Engine ConvolutionParameter::DEFAULT; +constexpr ConvolutionParameter_Engine ConvolutionParameter::CAFFE; +constexpr ConvolutionParameter_Engine ConvolutionParameter::CUDNN; +constexpr ConvolutionParameter_Engine ConvolutionParameter::Engine_MIN; +constexpr ConvolutionParameter_Engine ConvolutionParameter::Engine_MAX; +constexpr int ConvolutionParameter::Engine_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataParameter_DB_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[8]; +} +bool DataParameter_DB_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr DataParameter_DB DataParameter::LEVELDB; +constexpr DataParameter_DB DataParameter::LMDB; +constexpr DataParameter_DB DataParameter::DB_MIN; +constexpr DataParameter_DB DataParameter::DB_MAX; +constexpr int DataParameter::DB_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[9]; +} +bool EltwiseParameter_EltwiseOp_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr EltwiseParameter_EltwiseOp EltwiseParameter::PROD; +constexpr EltwiseParameter_EltwiseOp EltwiseParameter::SUM; +constexpr EltwiseParameter_EltwiseOp EltwiseParameter::MAX; +constexpr EltwiseParameter_EltwiseOp EltwiseParameter::EltwiseOp_MIN; +constexpr EltwiseParameter_EltwiseOp EltwiseParameter::EltwiseOp_MAX; +constexpr int EltwiseParameter::EltwiseOp_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HingeLossParameter_Norm_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[10]; +} +bool HingeLossParameter_Norm_IsValid(int value) { + switch (value) { + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr HingeLossParameter_Norm HingeLossParameter::L1; +constexpr HingeLossParameter_Norm HingeLossParameter::L2; +constexpr HingeLossParameter_Norm HingeLossParameter::Norm_MIN; +constexpr HingeLossParameter_Norm HingeLossParameter::Norm_MAX; +constexpr int HingeLossParameter::Norm_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_NormRegion_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[11]; +} +bool LRNParameter_NormRegion_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr LRNParameter_NormRegion LRNParameter::ACROSS_CHANNELS; +constexpr LRNParameter_NormRegion LRNParameter::WITHIN_CHANNEL; +constexpr LRNParameter_NormRegion LRNParameter::NormRegion_MIN; +constexpr LRNParameter_NormRegion LRNParameter::NormRegion_MAX; +constexpr int LRNParameter::NormRegion_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_Engine_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[12]; +} +bool LRNParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr LRNParameter_Engine LRNParameter::DEFAULT; +constexpr LRNParameter_Engine LRNParameter::CAFFE; +constexpr LRNParameter_Engine LRNParameter::CUDNN; +constexpr LRNParameter_Engine LRNParameter::Engine_MIN; +constexpr LRNParameter_Engine LRNParameter::Engine_MAX; +constexpr int LRNParameter::Engine_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_PoolMethod_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[13]; +} +bool PoolingParameter_PoolMethod_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PoolingParameter_PoolMethod PoolingParameter::MAX; +constexpr PoolingParameter_PoolMethod PoolingParameter::AVE; +constexpr PoolingParameter_PoolMethod PoolingParameter::STOCHASTIC; +constexpr PoolingParameter_PoolMethod PoolingParameter::PoolMethod_MIN; +constexpr PoolingParameter_PoolMethod PoolingParameter::PoolMethod_MAX; +constexpr int PoolingParameter::PoolMethod_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_Engine_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[14]; +} +bool PoolingParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PoolingParameter_Engine PoolingParameter::DEFAULT; +constexpr PoolingParameter_Engine PoolingParameter::CAFFE; +constexpr PoolingParameter_Engine PoolingParameter::CUDNN; +constexpr PoolingParameter_Engine PoolingParameter::Engine_MIN; +constexpr PoolingParameter_Engine PoolingParameter::Engine_MAX; +constexpr int PoolingParameter::Engine_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReductionParameter_ReductionOp_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[15]; +} +bool ReductionParameter_ReductionOp_IsValid(int value) { + switch (value) { + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ReductionParameter_ReductionOp ReductionParameter::SUM; +constexpr ReductionParameter_ReductionOp ReductionParameter::ASUM; +constexpr ReductionParameter_ReductionOp ReductionParameter::SUMSQ; +constexpr ReductionParameter_ReductionOp ReductionParameter::MEAN; +constexpr ReductionParameter_ReductionOp ReductionParameter::ReductionOp_MIN; +constexpr ReductionParameter_ReductionOp ReductionParameter::ReductionOp_MAX; +constexpr int ReductionParameter::ReductionOp_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReLUParameter_Engine_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[16]; +} +bool ReLUParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ReLUParameter_Engine ReLUParameter::DEFAULT; +constexpr ReLUParameter_Engine ReLUParameter::CAFFE; +constexpr ReLUParameter_Engine ReLUParameter::CUDNN; +constexpr ReLUParameter_Engine ReLUParameter::Engine_MIN; +constexpr ReLUParameter_Engine ReLUParameter::Engine_MAX; +constexpr int ReLUParameter::Engine_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SigmoidParameter_Engine_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[17]; +} +bool SigmoidParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr SigmoidParameter_Engine SigmoidParameter::DEFAULT; +constexpr SigmoidParameter_Engine SigmoidParameter::CAFFE; +constexpr SigmoidParameter_Engine SigmoidParameter::CUDNN; +constexpr SigmoidParameter_Engine SigmoidParameter::Engine_MIN; +constexpr SigmoidParameter_Engine SigmoidParameter::Engine_MAX; +constexpr int SigmoidParameter::Engine_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SoftmaxParameter_Engine_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[18]; +} +bool SoftmaxParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr SoftmaxParameter_Engine SoftmaxParameter::DEFAULT; +constexpr SoftmaxParameter_Engine SoftmaxParameter::CAFFE; +constexpr SoftmaxParameter_Engine SoftmaxParameter::CUDNN; +constexpr SoftmaxParameter_Engine SoftmaxParameter::Engine_MIN; +constexpr SoftmaxParameter_Engine SoftmaxParameter::Engine_MAX; +constexpr int SoftmaxParameter::Engine_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TanHParameter_Engine_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[19]; +} +bool TanHParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr TanHParameter_Engine TanHParameter::DEFAULT; +constexpr TanHParameter_Engine TanHParameter::CAFFE; +constexpr TanHParameter_Engine TanHParameter::CUDNN; +constexpr TanHParameter_Engine TanHParameter::Engine_MIN; +constexpr TanHParameter_Engine TanHParameter::Engine_MAX; +constexpr int TanHParameter::Engine_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_PoolMethod_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[20]; +} +bool SPPParameter_PoolMethod_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr SPPParameter_PoolMethod SPPParameter::MAX; +constexpr SPPParameter_PoolMethod SPPParameter::AVE; +constexpr SPPParameter_PoolMethod SPPParameter::STOCHASTIC; +constexpr SPPParameter_PoolMethod SPPParameter::PoolMethod_MIN; +constexpr SPPParameter_PoolMethod SPPParameter::PoolMethod_MAX; +constexpr int SPPParameter::PoolMethod_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_Engine_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[21]; +} +bool SPPParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr SPPParameter_Engine SPPParameter::DEFAULT; +constexpr SPPParameter_Engine SPPParameter::CAFFE; +constexpr SPPParameter_Engine SPPParameter::CUDNN; +constexpr SPPParameter_Engine SPPParameter::Engine_MIN; +constexpr SPPParameter_Engine SPPParameter::Engine_MAX; +constexpr int SPPParameter::Engine_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_LayerType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[22]; +} +bool V1LayerParameter_LayerType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + case 38: + case 39: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr V1LayerParameter_LayerType V1LayerParameter::NONE; +constexpr V1LayerParameter_LayerType V1LayerParameter::ABSVAL; +constexpr V1LayerParameter_LayerType V1LayerParameter::ACCURACY; +constexpr V1LayerParameter_LayerType V1LayerParameter::ARGMAX; +constexpr V1LayerParameter_LayerType V1LayerParameter::BNLL; +constexpr V1LayerParameter_LayerType V1LayerParameter::CONCAT; +constexpr V1LayerParameter_LayerType V1LayerParameter::CONTRASTIVE_LOSS; +constexpr V1LayerParameter_LayerType V1LayerParameter::CONVOLUTION; +constexpr V1LayerParameter_LayerType V1LayerParameter::DATA; +constexpr V1LayerParameter_LayerType V1LayerParameter::DECONVOLUTION; +constexpr V1LayerParameter_LayerType V1LayerParameter::DROPOUT; +constexpr V1LayerParameter_LayerType V1LayerParameter::DUMMY_DATA; +constexpr V1LayerParameter_LayerType V1LayerParameter::EUCLIDEAN_LOSS; +constexpr V1LayerParameter_LayerType V1LayerParameter::ELTWISE; +constexpr V1LayerParameter_LayerType V1LayerParameter::EXP; +constexpr V1LayerParameter_LayerType V1LayerParameter::FLATTEN; +constexpr V1LayerParameter_LayerType V1LayerParameter::HDF5_DATA; +constexpr V1LayerParameter_LayerType V1LayerParameter::HDF5_OUTPUT; +constexpr V1LayerParameter_LayerType V1LayerParameter::HINGE_LOSS; +constexpr V1LayerParameter_LayerType V1LayerParameter::IM2COL; +constexpr V1LayerParameter_LayerType V1LayerParameter::IMAGE_DATA; +constexpr V1LayerParameter_LayerType V1LayerParameter::INFOGAIN_LOSS; +constexpr V1LayerParameter_LayerType V1LayerParameter::INNER_PRODUCT; +constexpr V1LayerParameter_LayerType V1LayerParameter::LRN; +constexpr V1LayerParameter_LayerType V1LayerParameter::MEMORY_DATA; +constexpr V1LayerParameter_LayerType V1LayerParameter::MULTINOMIAL_LOGISTIC_LOSS; +constexpr V1LayerParameter_LayerType V1LayerParameter::MVN; +constexpr V1LayerParameter_LayerType V1LayerParameter::POOLING; +constexpr V1LayerParameter_LayerType V1LayerParameter::POWER; +constexpr V1LayerParameter_LayerType V1LayerParameter::RELU; +constexpr V1LayerParameter_LayerType V1LayerParameter::SIGMOID; +constexpr V1LayerParameter_LayerType V1LayerParameter::SIGMOID_CROSS_ENTROPY_LOSS; +constexpr V1LayerParameter_LayerType V1LayerParameter::SILENCE; +constexpr V1LayerParameter_LayerType V1LayerParameter::SOFTMAX; +constexpr V1LayerParameter_LayerType V1LayerParameter::SOFTMAX_LOSS; +constexpr V1LayerParameter_LayerType V1LayerParameter::SPLIT; +constexpr V1LayerParameter_LayerType V1LayerParameter::SLICE; +constexpr V1LayerParameter_LayerType V1LayerParameter::TANH; +constexpr V1LayerParameter_LayerType V1LayerParameter::WINDOW_DATA; +constexpr V1LayerParameter_LayerType V1LayerParameter::THRESHOLD; +constexpr V1LayerParameter_LayerType V1LayerParameter::LayerType_MIN; +constexpr V1LayerParameter_LayerType V1LayerParameter::LayerType_MAX; +constexpr int V1LayerParameter::LayerType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[23]; +} +bool V1LayerParameter_DimCheckMode_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr V1LayerParameter_DimCheckMode V1LayerParameter::STRICT; +constexpr V1LayerParameter_DimCheckMode V1LayerParameter::PERMISSIVE; +constexpr V1LayerParameter_DimCheckMode V1LayerParameter::DimCheckMode_MIN; +constexpr V1LayerParameter_DimCheckMode V1LayerParameter::DimCheckMode_MAX; +constexpr int V1LayerParameter::DimCheckMode_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[24]; +} +bool V0LayerParameter_PoolMethod_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr V0LayerParameter_PoolMethod V0LayerParameter::MAX; +constexpr V0LayerParameter_PoolMethod V0LayerParameter::AVE; +constexpr V0LayerParameter_PoolMethod V0LayerParameter::STOCHASTIC; +constexpr V0LayerParameter_PoolMethod V0LayerParameter::PoolMethod_MIN; +constexpr V0LayerParameter_PoolMethod V0LayerParameter::PoolMethod_MAX; +constexpr int V0LayerParameter::PoolMethod_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[25]; +} +bool Type_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Phase_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); + return file_level_enum_descriptors_opencv_2dcaffe_2eproto[26]; +} +bool Phase_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + + +// =================================================================== + +class BlobShape::_Internal { + public: +}; + +BlobShape::BlobShape(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + dim_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.BlobShape) +} +BlobShape::BlobShape(const BlobShape& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + dim_(from.dim_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobShape) +} + +inline void BlobShape::SharedCtor() { +} + +BlobShape::~BlobShape() { + // @@protoc_insertion_point(destructor:opencv_caffe.BlobShape) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void BlobShape::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void BlobShape::ArenaDtor(void* object) { + BlobShape* _this = reinterpret_cast< BlobShape* >(object); + (void)_this; +} +void BlobShape::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BlobShape::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BlobShape::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobShape) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + dim_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BlobShape::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int64 dim = 1 [packed = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_dim(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 8) { + _internal_add_dim(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BlobShape::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobShape) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int64 dim = 1 [packed = true]; + { + int byte_size = _dim_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt64Packed( + 1, _internal_dim(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobShape) + return target; +} + +size_t BlobShape::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobShape) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 dim = 1 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->dim_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _dim_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BlobShape::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + BlobShape::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BlobShape::GetClassData() const { return &_class_data_; } + +void BlobShape::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void BlobShape::MergeFrom(const BlobShape& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobShape) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + dim_.MergeFrom(from.dim_); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void BlobShape::CopyFrom(const BlobShape& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobShape) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BlobShape::IsInitialized() const { + return true; +} + +void BlobShape::InternalSwap(BlobShape* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + dim_.InternalSwap(&other->dim_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BlobShape::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[0]); +} + +// =================================================================== + +class BlobProto::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::opencv_caffe::BlobShape& shape(const BlobProto* msg); + static void set_has_shape(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_raw_data_type(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_raw_data(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_num(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_channels(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +const ::opencv_caffe::BlobShape& +BlobProto::_Internal::shape(const BlobProto* msg) { + return *msg->shape_; +} +BlobProto::BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + data_(arena), + diff_(arena), + double_data_(arena), + double_diff_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.BlobProto) +} +BlobProto::BlobProto(const BlobProto& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + data_(from.data_), + diff_(from.diff_), + double_data_(from.double_data_), + double_diff_(from.double_diff_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_raw_data()) { + raw_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_raw_data(), + GetArenaForAllocation()); + } + if (from._internal_has_shape()) { + shape_ = new ::opencv_caffe::BlobShape(*from.shape_); + } else { + shape_ = nullptr; + } + ::memcpy(&num_, &from.num_, + static_cast(reinterpret_cast(&raw_data_type_) - + reinterpret_cast(&num_)) + sizeof(raw_data_type_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobProto) +} + +inline void BlobProto::SharedCtor() { +raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&shape_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&raw_data_type_) - + reinterpret_cast(&shape_)) + sizeof(raw_data_type_)); +} + +BlobProto::~BlobProto() { + // @@protoc_insertion_point(destructor:opencv_caffe.BlobProto) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void BlobProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + raw_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete shape_; +} + +void BlobProto::ArenaDtor(void* object) { + BlobProto* _this = reinterpret_cast< BlobProto* >(object); + (void)_this; +} +void BlobProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BlobProto::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BlobProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobProto) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + data_.Clear(); + diff_.Clear(); + double_data_.Clear(); + double_diff_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + raw_data_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(shape_ != nullptr); + shape_->Clear(); + } + } + if (cached_has_bits & 0x0000007cu) { + ::memset(&num_, 0, static_cast( + reinterpret_cast(&raw_data_type_) - + reinterpret_cast(&num_)) + sizeof(raw_data_type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BlobProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 num = 1 [default = 0]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_num(&has_bits); + num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 channels = 2 [default = 0]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_channels(&has_bits); + channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 height = 3 [default = 0]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_height(&has_bits); + height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 width = 4 [default = 0]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_width(&has_bits); + width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float data = 5 [packed = true]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 45) { + _internal_add_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // repeated float diff = 6 [packed = true]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_diff(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 53) { + _internal_add_diff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.BlobShape shape = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated double double_data = 8 [packed = true]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 65) { + _internal_add_double_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // repeated double double_diff = 9 [packed = true]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_diff(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 73) { + _internal_add_double_diff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.Type raw_data_type = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::Type_IsValid(val))) { + _internal_set_raw_data_type(static_cast<::opencv_caffe::Type>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bytes raw_data = 12 [packed = false]; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + auto str = _internal_mutable_raw_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BlobProto::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobProto) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 num = 1 [default = 0]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_num(), target); + } + + // optional int32 channels = 2 [default = 0]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_channels(), target); + } + + // optional int32 height = 3 [default = 0]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_height(), target); + } + + // optional int32 width = 4 [default = 0]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_width(), target); + } + + // repeated float data = 5 [packed = true]; + if (this->_internal_data_size() > 0) { + target = stream->WriteFixedPacked(5, _internal_data(), target); + } + + // repeated float diff = 6 [packed = true]; + if (this->_internal_diff_size() > 0) { + target = stream->WriteFixedPacked(6, _internal_diff(), target); + } + + // optional .opencv_caffe.BlobShape shape = 7; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::shape(this), target, stream); + } + + // repeated double double_data = 8 [packed = true]; + if (this->_internal_double_data_size() > 0) { + target = stream->WriteFixedPacked(8, _internal_double_data(), target); + } + + // repeated double double_diff = 9 [packed = true]; + if (this->_internal_double_diff_size() > 0) { + target = stream->WriteFixedPacked(9, _internal_double_diff(), target); + } + + // optional .opencv_caffe.Type raw_data_type = 10; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 10, this->_internal_raw_data_type(), target); + } + + // optional bytes raw_data = 12 [packed = false]; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 12, this->_internal_raw_data(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobProto) + return target; +} + +size_t BlobProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float data = 5 [packed = true]; + { + unsigned int count = static_cast(this->_internal_data_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + total_size += data_size; + } + + // repeated float diff = 6 [packed = true]; + { + unsigned int count = static_cast(this->_internal_diff_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + total_size += data_size; + } + + // repeated double double_data = 8 [packed = true]; + { + unsigned int count = static_cast(this->_internal_double_data_size()); + size_t data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + total_size += data_size; + } + + // repeated double double_diff = 9 [packed = true]; + { + unsigned int count = static_cast(this->_internal_double_diff_size()); + size_t data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional bytes raw_data = 12 [packed = false]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_raw_data()); + } + + // optional .opencv_caffe.BlobShape shape = 7; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *shape_); + } + + // optional int32 num = 1 [default = 0]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num()); + } + + // optional int32 channels = 2 [default = 0]; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_channels()); + } + + // optional int32 height = 3 [default = 0]; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_height()); + } + + // optional int32 width = 4 [default = 0]; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_width()); + } + + // optional .opencv_caffe.Type raw_data_type = 10; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_raw_data_type()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BlobProto::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + BlobProto::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BlobProto::GetClassData() const { return &_class_data_; } + +void BlobProto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void BlobProto::MergeFrom(const BlobProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + data_.MergeFrom(from.data_); + diff_.MergeFrom(from.diff_); + double_data_.MergeFrom(from.double_data_); + double_diff_.MergeFrom(from.double_diff_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_raw_data(from._internal_raw_data()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from._internal_shape()); + } + if (cached_has_bits & 0x00000004u) { + num_ = from.num_; + } + if (cached_has_bits & 0x00000008u) { + channels_ = from.channels_; + } + if (cached_has_bits & 0x00000010u) { + height_ = from.height_; + } + if (cached_has_bits & 0x00000020u) { + width_ = from.width_; + } + if (cached_has_bits & 0x00000040u) { + raw_data_type_ = from.raw_data_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void BlobProto::CopyFrom(const BlobProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BlobProto::IsInitialized() const { + return true; +} + +void BlobProto::InternalSwap(BlobProto* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + data_.InternalSwap(&other->data_); + diff_.InternalSwap(&other->diff_); + double_data_.InternalSwap(&other->double_data_); + double_diff_.InternalSwap(&other->double_diff_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &raw_data_, lhs_arena, + &other->raw_data_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BlobProto, raw_data_type_) + + sizeof(BlobProto::raw_data_type_) + - PROTOBUF_FIELD_OFFSET(BlobProto, shape_)>( + reinterpret_cast(&shape_), + reinterpret_cast(&other->shape_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BlobProto::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[1]); +} + +// =================================================================== + +class BlobProtoVector::_Internal { + public: +}; + +BlobProtoVector::BlobProtoVector(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + blobs_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.BlobProtoVector) +} +BlobProtoVector::BlobProtoVector(const BlobProtoVector& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + blobs_(from.blobs_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobProtoVector) +} + +inline void BlobProtoVector::SharedCtor() { +} + +BlobProtoVector::~BlobProtoVector() { + // @@protoc_insertion_point(destructor:opencv_caffe.BlobProtoVector) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void BlobProtoVector::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void BlobProtoVector::ArenaDtor(void* object) { + BlobProtoVector* _this = reinterpret_cast< BlobProtoVector* >(object); + (void)_this; +} +void BlobProtoVector::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BlobProtoVector::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BlobProtoVector::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobProtoVector) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + blobs_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BlobProtoVector::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .opencv_caffe.BlobProto blobs = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_blobs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BlobProtoVector::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobProtoVector) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .opencv_caffe.BlobProto blobs = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_blobs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_blobs(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobProtoVector) + return target; +} + +size_t BlobProtoVector::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobProtoVector) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .opencv_caffe.BlobProto blobs = 1; + total_size += 1UL * this->_internal_blobs_size(); + for (const auto& msg : this->blobs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BlobProtoVector::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + BlobProtoVector::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BlobProtoVector::GetClassData() const { return &_class_data_; } + +void BlobProtoVector::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void BlobProtoVector::MergeFrom(const BlobProtoVector& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobProtoVector) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + blobs_.MergeFrom(from.blobs_); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void BlobProtoVector::CopyFrom(const BlobProtoVector& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobProtoVector) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BlobProtoVector::IsInitialized() const { + return true; +} + +void BlobProtoVector::InternalSwap(BlobProtoVector* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + blobs_.InternalSwap(&other->blobs_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BlobProtoVector::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[2]); +} + +// =================================================================== + +class PermuteParameter::_Internal { + public: +}; + +PermuteParameter::PermuteParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + order_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.PermuteParameter) +} +PermuteParameter::PermuteParameter(const PermuteParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + order_(from.order_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.PermuteParameter) +} + +inline void PermuteParameter::SharedCtor() { +} + +PermuteParameter::~PermuteParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.PermuteParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void PermuteParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void PermuteParameter::ArenaDtor(void* object) { + PermuteParameter* _this = reinterpret_cast< PermuteParameter* >(object); + (void)_this; +} +void PermuteParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PermuteParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PermuteParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.PermuteParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + order_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PermuteParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated uint32 order = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_order(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); + } else if (static_cast(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_order(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PermuteParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PermuteParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated uint32 order = 1; + for (int i = 0, n = this->_internal_order_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_order(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PermuteParameter) + return target; +} + +size_t PermuteParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PermuteParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 order = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->order_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_order_size()); + total_size += data_size; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PermuteParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + PermuteParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PermuteParameter::GetClassData() const { return &_class_data_; } + +void PermuteParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void PermuteParameter::MergeFrom(const PermuteParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PermuteParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + order_.MergeFrom(from.order_); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PermuteParameter::CopyFrom(const PermuteParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PermuteParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PermuteParameter::IsInitialized() const { + return true; +} + +void PermuteParameter::InternalSwap(PermuteParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + order_.InternalSwap(&other->order_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PermuteParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[3]); +} + +// =================================================================== + +class NormalizeBBoxParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_across_spatial(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::opencv_caffe::FillerParameter& scale_filler(const NormalizeBBoxParameter* msg); + static void set_has_scale_filler(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_channel_shared(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_eps(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::opencv_caffe::FillerParameter& +NormalizeBBoxParameter::_Internal::scale_filler(const NormalizeBBoxParameter* msg) { + return *msg->scale_filler_; +} +NormalizeBBoxParameter::NormalizeBBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.NormalizeBBoxParameter) +} +NormalizeBBoxParameter::NormalizeBBoxParameter(const NormalizeBBoxParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_scale_filler()) { + scale_filler_ = new ::opencv_caffe::FillerParameter(*from.scale_filler_); + } else { + scale_filler_ = nullptr; + } + ::memcpy(&across_spatial_, &from.across_spatial_, + static_cast(reinterpret_cast(&eps_) - + reinterpret_cast(&across_spatial_)) + sizeof(eps_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.NormalizeBBoxParameter) +} + +inline void NormalizeBBoxParameter::SharedCtor() { +scale_filler_ = nullptr; +across_spatial_ = true; +channel_shared_ = true; +eps_ = 1e-10f; +} + +NormalizeBBoxParameter::~NormalizeBBoxParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.NormalizeBBoxParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void NormalizeBBoxParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete scale_filler_; +} + +void NormalizeBBoxParameter::ArenaDtor(void* object) { + NormalizeBBoxParameter* _this = reinterpret_cast< NormalizeBBoxParameter* >(object); + (void)_this; +} +void NormalizeBBoxParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void NormalizeBBoxParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void NormalizeBBoxParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.NormalizeBBoxParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(scale_filler_ != nullptr); + scale_filler_->Clear(); + } + across_spatial_ = true; + channel_shared_ = true; + eps_ = 1e-10f; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NormalizeBBoxParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool across_spatial = 1 [default = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_across_spatial(&has_bits); + across_spatial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter scale_filler = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_scale_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool channel_shared = 3 [default = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_channel_shared(&has_bits); + channel_shared_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float eps = 4 [default = 1e-10]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { + _Internal::set_has_eps(&has_bits); + eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NormalizeBBoxParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NormalizeBBoxParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bool across_spatial = 1 [default = true]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_across_spatial(), target); + } + + // optional .opencv_caffe.FillerParameter scale_filler = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::scale_filler(this), target, stream); + } + + // optional bool channel_shared = 3 [default = true]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_channel_shared(), target); + } + + // optional float eps = 4 [default = 1e-10]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_eps(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NormalizeBBoxParameter) + return target; +} + +size_t NormalizeBBoxParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NormalizeBBoxParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional .opencv_caffe.FillerParameter scale_filler = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *scale_filler_); + } + + // optional bool across_spatial = 1 [default = true]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional bool channel_shared = 3 [default = true]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional float eps = 4 [default = 1e-10]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NormalizeBBoxParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + NormalizeBBoxParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NormalizeBBoxParameter::GetClassData() const { return &_class_data_; } + +void NormalizeBBoxParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void NormalizeBBoxParameter::MergeFrom(const NormalizeBBoxParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NormalizeBBoxParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_scale_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_scale_filler()); + } + if (cached_has_bits & 0x00000002u) { + across_spatial_ = from.across_spatial_; + } + if (cached_has_bits & 0x00000004u) { + channel_shared_ = from.channel_shared_; + } + if (cached_has_bits & 0x00000008u) { + eps_ = from.eps_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NormalizeBBoxParameter::CopyFrom(const NormalizeBBoxParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NormalizeBBoxParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NormalizeBBoxParameter::IsInitialized() const { + return true; +} + +void NormalizeBBoxParameter::InternalSwap(NormalizeBBoxParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(scale_filler_, other->scale_filler_); + swap(across_spatial_, other->across_spatial_); + swap(channel_shared_, other->channel_shared_); + swap(eps_, other->eps_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NormalizeBBoxParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[4]); +} + +// =================================================================== + +class PriorBoxParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_flip(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_clip(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_img_size(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_img_h(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_img_w(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_step(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_step_h(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_step_w(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_offset(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } +}; + +PriorBoxParameter::PriorBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + min_size_(arena), + max_size_(arena), + aspect_ratio_(arena), + variance_(arena), + offset_h_(arena), + offset_w_(arena), + width_(arena), + height_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.PriorBoxParameter) +} +PriorBoxParameter::PriorBoxParameter(const PriorBoxParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + min_size_(from.min_size_), + max_size_(from.max_size_), + aspect_ratio_(from.aspect_ratio_), + variance_(from.variance_), + offset_h_(from.offset_h_), + offset_w_(from.offset_w_), + width_(from.width_), + height_(from.height_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&img_size_, &from.img_size_, + static_cast(reinterpret_cast(&offset_) - + reinterpret_cast(&img_size_)) + sizeof(offset_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.PriorBoxParameter) +} + +inline void PriorBoxParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&img_size_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&step_w_) - + reinterpret_cast(&img_size_)) + sizeof(step_w_)); +flip_ = true; +clip_ = true; +offset_ = 0.5f; +} + +PriorBoxParameter::~PriorBoxParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.PriorBoxParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void PriorBoxParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void PriorBoxParameter::ArenaDtor(void* object) { + PriorBoxParameter* _this = reinterpret_cast< PriorBoxParameter* >(object); + (void)_this; +} +void PriorBoxParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PriorBoxParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PriorBoxParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.PriorBoxParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + min_size_.Clear(); + max_size_.Clear(); + aspect_ratio_.Clear(); + variance_.Clear(); + offset_h_.Clear(); + offset_w_.Clear(); + width_.Clear(); + height_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + ::memset(&img_size_, 0, static_cast( + reinterpret_cast(&step_w_) - + reinterpret_cast(&img_size_)) + sizeof(step_w_)); + flip_ = true; + clip_ = true; + } + offset_ = 0.5f; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PriorBoxParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated float min_size = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_min_size(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<13>(ptr)); + } else if (static_cast(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_min_size(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float max_size = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_max_size(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<21>(ptr)); + } else if (static_cast(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_max_size(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float aspect_ratio = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_aspect_ratio(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<29>(ptr)); + } else if (static_cast(tag) == 26) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_aspect_ratio(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool flip = 4 [default = true]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_flip(&has_bits); + flip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool clip = 5 [default = true]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_clip(&has_bits); + clip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float variance = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_variance(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<53>(ptr)); + } else if (static_cast(tag) == 50) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_variance(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 img_size = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_img_size(&has_bits); + img_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 img_h = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_img_h(&has_bits); + img_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 img_w = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_img_w(&has_bits); + img_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float step = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 85)) { + _Internal::set_has_step(&has_bits); + step_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float step_h = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 93)) { + _Internal::set_has_step_h(&has_bits); + step_h_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float step_w = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 101)) { + _Internal::set_has_step_w(&has_bits); + step_w_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float offset = 13 [default = 0.5]; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 109)) { + _Internal::set_has_offset(&has_bits); + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // repeated float offset_h = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 117)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_offset_h(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<117>(ptr)); + } else if (static_cast(tag) == 114) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_offset_h(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float offset_w = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 125)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_offset_w(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<125>(ptr)); + } else if (static_cast(tag) == 122) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_offset_w(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float width = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 133)) { + ptr -= 2; + do { + ptr += 2; + _internal_add_width(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<133>(ptr)); + } else if (static_cast(tag) == 130) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_width(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float height = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 141)) { + ptr -= 2; + do { + ptr += 2; + _internal_add_height(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<141>(ptr)); + } else if (static_cast(tag) == 138) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_height(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PriorBoxParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PriorBoxParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated float min_size = 1; + for (int i = 0, n = this->_internal_min_size_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_min_size(i), target); + } + + // repeated float max_size = 2; + for (int i = 0, n = this->_internal_max_size_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_max_size(i), target); + } + + // repeated float aspect_ratio = 3; + for (int i = 0, n = this->_internal_aspect_ratio_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_aspect_ratio(i), target); + } + + cached_has_bits = _has_bits_[0]; + // optional bool flip = 4 [default = true]; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_flip(), target); + } + + // optional bool clip = 5 [default = true]; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_clip(), target); + } + + // repeated float variance = 6; + for (int i = 0, n = this->_internal_variance_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_variance(i), target); + } + + // optional uint32 img_size = 7; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_img_size(), target); + } + + // optional uint32 img_h = 8; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_img_h(), target); + } + + // optional uint32 img_w = 9; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_img_w(), target); + } + + // optional float step = 10; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_step(), target); + } + + // optional float step_h = 11; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(11, this->_internal_step_h(), target); + } + + // optional float step_w = 12; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(12, this->_internal_step_w(), target); + } + + // optional float offset = 13 [default = 0.5]; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(13, this->_internal_offset(), target); + } + + // repeated float offset_h = 14; + for (int i = 0, n = this->_internal_offset_h_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(14, this->_internal_offset_h(i), target); + } + + // repeated float offset_w = 15; + for (int i = 0, n = this->_internal_offset_w_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(15, this->_internal_offset_w(i), target); + } + + // repeated float width = 16; + for (int i = 0, n = this->_internal_width_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(16, this->_internal_width(i), target); + } + + // repeated float height = 17; + for (int i = 0, n = this->_internal_height_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(17, this->_internal_height(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PriorBoxParameter) + return target; +} + +size_t PriorBoxParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PriorBoxParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float min_size = 1; + { + unsigned int count = static_cast(this->_internal_min_size_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_min_size_size()); + total_size += data_size; + } + + // repeated float max_size = 2; + { + unsigned int count = static_cast(this->_internal_max_size_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_max_size_size()); + total_size += data_size; + } + + // repeated float aspect_ratio = 3; + { + unsigned int count = static_cast(this->_internal_aspect_ratio_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_aspect_ratio_size()); + total_size += data_size; + } + + // repeated float variance = 6; + { + unsigned int count = static_cast(this->_internal_variance_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_variance_size()); + total_size += data_size; + } + + // repeated float offset_h = 14; + { + unsigned int count = static_cast(this->_internal_offset_h_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_offset_h_size()); + total_size += data_size; + } + + // repeated float offset_w = 15; + { + unsigned int count = static_cast(this->_internal_offset_w_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_offset_w_size()); + total_size += data_size; + } + + // repeated float width = 16; + { + unsigned int count = static_cast(this->_internal_width_size()); + size_t data_size = 4UL * count; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_width_size()); + total_size += data_size; + } + + // repeated float height = 17; + { + unsigned int count = static_cast(this->_internal_height_size()); + size_t data_size = 4UL * count; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_height_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional uint32 img_size = 7; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_img_size()); + } + + // optional uint32 img_h = 8; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_img_h()); + } + + // optional uint32 img_w = 9; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_img_w()); + } + + // optional float step = 10; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + // optional float step_h = 11; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 4; + } + + // optional float step_w = 12; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 4; + } + + // optional bool flip = 4 [default = true]; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 1; + } + + // optional bool clip = 5 [default = true]; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 1; + } + + } + // optional float offset = 13 [default = 0.5]; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 4; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PriorBoxParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + PriorBoxParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PriorBoxParameter::GetClassData() const { return &_class_data_; } + +void PriorBoxParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void PriorBoxParameter::MergeFrom(const PriorBoxParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PriorBoxParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + min_size_.MergeFrom(from.min_size_); + max_size_.MergeFrom(from.max_size_); + aspect_ratio_.MergeFrom(from.aspect_ratio_); + variance_.MergeFrom(from.variance_); + offset_h_.MergeFrom(from.offset_h_); + offset_w_.MergeFrom(from.offset_w_); + width_.MergeFrom(from.width_); + height_.MergeFrom(from.height_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + img_size_ = from.img_size_; + } + if (cached_has_bits & 0x00000002u) { + img_h_ = from.img_h_; + } + if (cached_has_bits & 0x00000004u) { + img_w_ = from.img_w_; + } + if (cached_has_bits & 0x00000008u) { + step_ = from.step_; + } + if (cached_has_bits & 0x00000010u) { + step_h_ = from.step_h_; + } + if (cached_has_bits & 0x00000020u) { + step_w_ = from.step_w_; + } + if (cached_has_bits & 0x00000040u) { + flip_ = from.flip_; + } + if (cached_has_bits & 0x00000080u) { + clip_ = from.clip_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000100u) { + _internal_set_offset(from._internal_offset()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PriorBoxParameter::CopyFrom(const PriorBoxParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PriorBoxParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PriorBoxParameter::IsInitialized() const { + return true; +} + +void PriorBoxParameter::InternalSwap(PriorBoxParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + min_size_.InternalSwap(&other->min_size_); + max_size_.InternalSwap(&other->max_size_); + aspect_ratio_.InternalSwap(&other->aspect_ratio_); + variance_.InternalSwap(&other->variance_); + offset_h_.InternalSwap(&other->offset_h_); + offset_w_.InternalSwap(&other->offset_w_); + width_.InternalSwap(&other->width_); + height_.InternalSwap(&other->height_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PriorBoxParameter, step_w_) + + sizeof(PriorBoxParameter::step_w_) + - PROTOBUF_FIELD_OFFSET(PriorBoxParameter, img_size_)>( + reinterpret_cast(&img_size_), + reinterpret_cast(&other->img_size_)); + swap(flip_, other->flip_); + swap(clip_, other->clip_); + swap(offset_, other->offset_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PriorBoxParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[5]); +} + +// =================================================================== + +class DetectionOutputParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_num_classes(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_share_location(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_background_label_id(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::opencv_caffe::NonMaximumSuppressionParameter& nms_param(const DetectionOutputParameter* msg); + static void set_has_nms_param(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::opencv_caffe::SaveOutputParameter& save_output_param(const DetectionOutputParameter* msg); + static void set_has_save_output_param(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_code_type(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_variance_encoded_in_target(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_keep_top_k(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_confidence_threshold(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_normalized_bbox(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_clip(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +const ::opencv_caffe::NonMaximumSuppressionParameter& +DetectionOutputParameter::_Internal::nms_param(const DetectionOutputParameter* msg) { + return *msg->nms_param_; +} +const ::opencv_caffe::SaveOutputParameter& +DetectionOutputParameter::_Internal::save_output_param(const DetectionOutputParameter* msg) { + return *msg->save_output_param_; +} +DetectionOutputParameter::DetectionOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.DetectionOutputParameter) +} +DetectionOutputParameter::DetectionOutputParameter(const DetectionOutputParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_nms_param()) { + nms_param_ = new ::opencv_caffe::NonMaximumSuppressionParameter(*from.nms_param_); + } else { + nms_param_ = nullptr; + } + if (from._internal_has_save_output_param()) { + save_output_param_ = new ::opencv_caffe::SaveOutputParameter(*from.save_output_param_); + } else { + save_output_param_ = nullptr; + } + ::memcpy(&num_classes_, &from.num_classes_, + static_cast(reinterpret_cast(&normalized_bbox_) - + reinterpret_cast(&num_classes_)) + sizeof(normalized_bbox_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.DetectionOutputParameter) +} + +inline void DetectionOutputParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&nms_param_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&clip_) - + reinterpret_cast(&nms_param_)) + sizeof(clip_)); +keep_top_k_ = -1; +code_type_ = 1; +share_location_ = true; +normalized_bbox_ = true; +} + +DetectionOutputParameter::~DetectionOutputParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.DetectionOutputParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void DetectionOutputParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete nms_param_; + if (this != internal_default_instance()) delete save_output_param_; +} + +void DetectionOutputParameter::ArenaDtor(void* object) { + DetectionOutputParameter* _this = reinterpret_cast< DetectionOutputParameter* >(object); + (void)_this; +} +void DetectionOutputParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DetectionOutputParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DetectionOutputParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.DetectionOutputParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(nms_param_ != nullptr); + nms_param_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(save_output_param_ != nullptr); + save_output_param_->Clear(); + } + } + if (cached_has_bits & 0x000000fcu) { + ::memset(&num_classes_, 0, static_cast( + reinterpret_cast(&clip_) - + reinterpret_cast(&num_classes_)) + sizeof(clip_)); + keep_top_k_ = -1; + } + if (cached_has_bits & 0x00000700u) { + code_type_ = 1; + share_location_ = true; + normalized_bbox_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DetectionOutputParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 num_classes = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_num_classes(&has_bits); + num_classes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool share_location = 2 [default = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_share_location(&has_bits); + share_location_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 background_label_id = 3 [default = 0]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_background_label_id(&has_bits); + background_label_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_nms_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SaveOutputParameter save_output_param = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_save_output_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::PriorBoxParameter_CodeType_IsValid(val))) { + _internal_set_code_type(static_cast<::opencv_caffe::PriorBoxParameter_CodeType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int32 keep_top_k = 7 [default = -1]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_keep_top_k(&has_bits); + keep_top_k_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool variance_encoded_in_target = 8 [default = false]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_variance_encoded_in_target(&has_bits); + variance_encoded_in_target_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float confidence_threshold = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 77)) { + _Internal::set_has_confidence_threshold(&has_bits); + confidence_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional bool normalized_bbox = 10 [default = true]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_normalized_bbox(&has_bits); + normalized_bbox_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool clip = 1000 [default = false]; + case 1000: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_clip(&has_bits); + clip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DetectionOutputParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DetectionOutputParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 num_classes = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_classes(), target); + } + + // optional bool share_location = 2 [default = true]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_share_location(), target); + } + + // optional int32 background_label_id = 3 [default = 0]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_background_label_id(), target); + } + + // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::nms_param(this), target, stream); + } + + // optional .opencv_caffe.SaveOutputParameter save_output_param = 5; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::save_output_param(this), target, stream); + } + + // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 6, this->_internal_code_type(), target); + } + + // optional int32 keep_top_k = 7 [default = -1]; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_keep_top_k(), target); + } + + // optional bool variance_encoded_in_target = 8 [default = false]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_variance_encoded_in_target(), target); + } + + // optional float confidence_threshold = 9; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_confidence_threshold(), target); + } + + // optional bool normalized_bbox = 10 [default = true]; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(10, this->_internal_normalized_bbox(), target); + } + + // optional bool clip = 1000 [default = false]; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1000, this->_internal_clip(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DetectionOutputParameter) + return target; +} + +size_t DetectionOutputParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DetectionOutputParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *nms_param_); + } + + // optional .opencv_caffe.SaveOutputParameter save_output_param = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *save_output_param_); + } + + // optional uint32 num_classes = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_classes()); + } + + // optional int32 background_label_id = 3 [default = 0]; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_background_label_id()); + } + + // optional float confidence_threshold = 9; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 4; + } + + // optional bool variance_encoded_in_target = 8 [default = false]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional bool clip = 1000 [default = false]; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + 1; + } + + // optional int32 keep_top_k = 7 [default = -1]; + if (cached_has_bits & 0x00000080u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_keep_top_k()); + } + + } + if (cached_has_bits & 0x00000700u) { + // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_code_type()); + } + + // optional bool share_location = 2 [default = true]; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 1; + } + + // optional bool normalized_bbox = 10 [default = true]; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DetectionOutputParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DetectionOutputParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DetectionOutputParameter::GetClassData() const { return &_class_data_; } + +void DetectionOutputParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void DetectionOutputParameter::MergeFrom(const DetectionOutputParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DetectionOutputParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_nms_param()->::opencv_caffe::NonMaximumSuppressionParameter::MergeFrom(from._internal_nms_param()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_save_output_param()->::opencv_caffe::SaveOutputParameter::MergeFrom(from._internal_save_output_param()); + } + if (cached_has_bits & 0x00000004u) { + num_classes_ = from.num_classes_; + } + if (cached_has_bits & 0x00000008u) { + background_label_id_ = from.background_label_id_; + } + if (cached_has_bits & 0x00000010u) { + confidence_threshold_ = from.confidence_threshold_; + } + if (cached_has_bits & 0x00000020u) { + variance_encoded_in_target_ = from.variance_encoded_in_target_; + } + if (cached_has_bits & 0x00000040u) { + clip_ = from.clip_; + } + if (cached_has_bits & 0x00000080u) { + keep_top_k_ = from.keep_top_k_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + code_type_ = from.code_type_; + } + if (cached_has_bits & 0x00000200u) { + share_location_ = from.share_location_; + } + if (cached_has_bits & 0x00000400u) { + normalized_bbox_ = from.normalized_bbox_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void DetectionOutputParameter::CopyFrom(const DetectionOutputParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DetectionOutputParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DetectionOutputParameter::IsInitialized() const { + return true; +} + +void DetectionOutputParameter::InternalSwap(DetectionOutputParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DetectionOutputParameter, clip_) + + sizeof(DetectionOutputParameter::clip_) + - PROTOBUF_FIELD_OFFSET(DetectionOutputParameter, nms_param_)>( + reinterpret_cast(&nms_param_), + reinterpret_cast(&other->nms_param_)); + swap(keep_top_k_, other->keep_top_k_); + swap(code_type_, other->code_type_); + swap(share_location_, other->share_location_); + swap(normalized_bbox_, other->normalized_bbox_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DetectionOutputParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[6]); +} + +// =================================================================== + +class Datum::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_channels(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_data(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_label(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_encoded(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +Datum::Datum(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + float_data_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.Datum) +} +Datum::Datum(const Datum& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + float_data_(from.float_data_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_data()) { + data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), + GetArenaForAllocation()); + } + ::memcpy(&channels_, &from.channels_, + static_cast(reinterpret_cast(&encoded_) - + reinterpret_cast(&channels_)) + sizeof(encoded_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.Datum) +} + +inline void Datum::SharedCtor() { +data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&channels_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&encoded_) - + reinterpret_cast(&channels_)) + sizeof(encoded_)); +} + +Datum::~Datum() { + // @@protoc_insertion_point(destructor:opencv_caffe.Datum) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void Datum::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Datum::ArenaDtor(void* object) { + Datum* _this = reinterpret_cast< Datum* >(object); + (void)_this; +} +void Datum::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Datum::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Datum::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.Datum) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + float_data_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + data_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000003eu) { + ::memset(&channels_, 0, static_cast( + reinterpret_cast(&encoded_) - + reinterpret_cast(&channels_)) + sizeof(encoded_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Datum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 channels = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_channels(&has_bits); + channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 height = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_height(&has_bits); + height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 width = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_width(&has_bits); + width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes data = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 label = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_label(&has_bits); + label_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float float_data = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_float_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<53>(ptr)); + } else if (static_cast(tag) == 50) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_float_data(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool encoded = 7 [default = false]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_encoded(&has_bits); + encoded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Datum::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.Datum) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 channels = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_channels(), target); + } + + // optional int32 height = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_height(), target); + } + + // optional int32 width = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_width(), target); + } + + // optional bytes data = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_data(), target); + } + + // optional int32 label = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_label(), target); + } + + // repeated float float_data = 6; + for (int i = 0, n = this->_internal_float_data_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_float_data(i), target); + } + + // optional bool encoded = 7 [default = false]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_encoded(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.Datum) + return target; +} + +size_t Datum::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.Datum) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float float_data = 6; + { + unsigned int count = static_cast(this->_internal_float_data_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_float_data_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional bytes data = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_data()); + } + + // optional int32 channels = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_channels()); + } + + // optional int32 height = 2; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_height()); + } + + // optional int32 width = 3; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_width()); + } + + // optional int32 label = 5; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_label()); + } + + // optional bool encoded = 7 [default = false]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Datum::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Datum::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Datum::GetClassData() const { return &_class_data_; } + +void Datum::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void Datum::MergeFrom(const Datum& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.Datum) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + float_data_.MergeFrom(from.float_data_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_data(from._internal_data()); + } + if (cached_has_bits & 0x00000002u) { + channels_ = from.channels_; + } + if (cached_has_bits & 0x00000004u) { + height_ = from.height_; + } + if (cached_has_bits & 0x00000008u) { + width_ = from.width_; + } + if (cached_has_bits & 0x00000010u) { + label_ = from.label_; + } + if (cached_has_bits & 0x00000020u) { + encoded_ = from.encoded_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Datum::CopyFrom(const Datum& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.Datum) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Datum::IsInitialized() const { + return true; +} + +void Datum::InternalSwap(Datum* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + float_data_.InternalSwap(&other->float_data_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &data_, lhs_arena, + &other->data_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Datum, encoded_) + + sizeof(Datum::encoded_) + - PROTOBUF_FIELD_OFFSET(Datum, channels_)>( + reinterpret_cast(&channels_), + reinterpret_cast(&other->channels_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Datum::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[7]); +} + +// =================================================================== + +class FillerParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_value(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_min(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_max(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_mean(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_std(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_sparse(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_variance_norm(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +const ::PROTOBUF_NAMESPACE_ID::internal::LazyString FillerParameter::_i_give_permission_to_break_this_code_default_type_{{{"constant", 8}}, {nullptr}}; +FillerParameter::FillerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.FillerParameter) +} +FillerParameter::FillerParameter(const FillerParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + type_.UnsafeSetDefault(nullptr); + if (from._internal_has_type()) { + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_type(), + GetArenaForAllocation()); + } + ::memcpy(&value_, &from.value_, + static_cast(reinterpret_cast(&std_) - + reinterpret_cast(&value_)) + sizeof(std_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.FillerParameter) +} + +inline void FillerParameter::SharedCtor() { +type_.UnsafeSetDefault(nullptr); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&value_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&variance_norm_) - + reinterpret_cast(&value_)) + sizeof(variance_norm_)); +sparse_ = -1; +max_ = 1; +std_ = 1; +} + +FillerParameter::~FillerParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.FillerParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void FillerParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + type_.DestroyNoArena(nullptr); +} + +void FillerParameter::ArenaDtor(void* object) { + FillerParameter* _this = reinterpret_cast< FillerParameter* >(object); + (void)_this; +} +void FillerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FillerParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FillerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.FillerParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + type_.ClearToDefault(::opencv_caffe::FillerParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation()); + } + if (cached_has_bits & 0x000000feu) { + ::memset(&value_, 0, static_cast( + reinterpret_cast(&variance_norm_) - + reinterpret_cast(&value_)) + sizeof(variance_norm_)); + sparse_ = -1; + max_ = 1; + std_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FillerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string type = 1 [default = "constant"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_type(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.FillerParameter.type"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float value = 2 [default = 0]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_value(&has_bits); + value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float min = 3 [default = 0]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_min(&has_bits); + min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float max = 4 [default = 1]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { + _Internal::set_has_max(&has_bits); + max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float mean = 5 [default = 0]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { + _Internal::set_has_mean(&has_bits); + mean_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float std = 6 [default = 1]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { + _Internal::set_has_std(&has_bits); + std_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional int32 sparse = 7 [default = -1]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_sparse(&has_bits); + sparse_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::FillerParameter_VarianceNorm_IsValid(val))) { + _internal_set_variance_norm(static_cast<::opencv_caffe::FillerParameter_VarianceNorm>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FillerParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.FillerParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string type = 1 [default = "constant"]; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_type().data(), static_cast(this->_internal_type().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.FillerParameter.type"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_type(), target); + } + + // optional float value = 2 [default = 0]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_value(), target); + } + + // optional float min = 3 [default = 0]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_min(), target); + } + + // optional float max = 4 [default = 1]; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_max(), target); + } + + // optional float mean = 5 [default = 0]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_mean(), target); + } + + // optional float std = 6 [default = 1]; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_std(), target); + } + + // optional int32 sparse = 7 [default = -1]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_sparse(), target); + } + + // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 8, this->_internal_variance_norm(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.FillerParameter) + return target; +} + +size_t FillerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.FillerParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string type = 1 [default = "constant"]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_type()); + } + + // optional float value = 2 [default = 0]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float min = 3 [default = 0]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + // optional float mean = 5 [default = 0]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_variance_norm()); + } + + // optional int32 sparse = 7 [default = -1]; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_sparse()); + } + + // optional float max = 4 [default = 1]; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 4; + } + + // optional float std = 6 [default = 1]; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FillerParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FillerParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FillerParameter::GetClassData() const { return &_class_data_; } + +void FillerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void FillerParameter::MergeFrom(const FillerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.FillerParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_type(from._internal_type()); + } + if (cached_has_bits & 0x00000002u) { + value_ = from.value_; + } + if (cached_has_bits & 0x00000004u) { + min_ = from.min_; + } + if (cached_has_bits & 0x00000008u) { + mean_ = from.mean_; + } + if (cached_has_bits & 0x00000010u) { + variance_norm_ = from.variance_norm_; + } + if (cached_has_bits & 0x00000020u) { + sparse_ = from.sparse_; + } + if (cached_has_bits & 0x00000040u) { + max_ = from.max_; + } + if (cached_has_bits & 0x00000080u) { + std_ = from.std_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void FillerParameter::CopyFrom(const FillerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.FillerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FillerParameter::IsInitialized() const { + return true; +} + +void FillerParameter::InternalSwap(FillerParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + nullptr, + &type_, lhs_arena, + &other->type_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FillerParameter, variance_norm_) + + sizeof(FillerParameter::variance_norm_) + - PROTOBUF_FIELD_OFFSET(FillerParameter, value_)>( + reinterpret_cast(&value_), + reinterpret_cast(&other->value_)); + swap(sparse_, other->sparse_); + swap(max_, other->max_); + swap(std_, other->std_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FillerParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[8]); +} + +// =================================================================== + +class NetParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_force_backward(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::opencv_caffe::NetState& state(const NetParameter* msg); + static void set_has_state(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_debug_info(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::opencv_caffe::NetState& +NetParameter::_Internal::state(const NetParameter* msg) { + return *msg->state_; +} +NetParameter::NetParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + layers_(arena), + input_(arena), + input_dim_(arena), + input_shape_(arena), + layer_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.NetParameter) +} +NetParameter::NetParameter(const NetParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + layers_(from.layers_), + input_(from.input_), + input_dim_(from.input_dim_), + input_shape_(from.input_shape_), + layer_(from.layer_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArenaForAllocation()); + } + if (from._internal_has_state()) { + state_ = new ::opencv_caffe::NetState(*from.state_); + } else { + state_ = nullptr; + } + ::memcpy(&force_backward_, &from.force_backward_, + static_cast(reinterpret_cast(&debug_info_) - + reinterpret_cast(&force_backward_)) + sizeof(debug_info_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetParameter) +} + +inline void NetParameter::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&state_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&debug_info_) - + reinterpret_cast(&state_)) + sizeof(debug_info_)); +} + +NetParameter::~NetParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.NetParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void NetParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete state_; +} + +void NetParameter::ArenaDtor(void* object) { + NetParameter* _this = reinterpret_cast< NetParameter* >(object); + (void)_this; +} +void NetParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void NetParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void NetParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.NetParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + layers_.Clear(); + input_.Clear(); + input_dim_.Clear(); + input_shape_.Clear(); + layer_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(state_ != nullptr); + state_->Clear(); + } + } + ::memset(&force_backward_, 0, static_cast( + reinterpret_cast(&debug_info_) - + reinterpret_cast(&force_backward_)) + sizeof(debug_info_)); + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NetParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetParameter.name"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.V1LayerParameter layers = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_layers(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string input = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_input(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetParameter.input"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // repeated int32 input_dim = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_input_dim(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); + } else if (static_cast(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_input_dim(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool force_backward = 5 [default = false]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_force_backward(&has_bits); + force_backward_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.NetState state = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_state(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool debug_info = 7 [default = false]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_debug_info(&has_bits); + debug_info_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.BlobShape input_shape = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_input_shape(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.LayerParameter layer = 100; + case 100: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_layer(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<802>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NetParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.NetParameter.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // repeated .opencv_caffe.V1LayerParameter layers = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_layers_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_layers(i), target, stream); + } + + // repeated string input = 3; + for (int i = 0, n = this->_internal_input_size(); i < n; i++) { + const auto& s = this->_internal_input(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.NetParameter.input"); + target = stream->WriteString(3, s, target); + } + + // repeated int32 input_dim = 4; + for (int i = 0, n = this->_internal_input_dim_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_input_dim(i), target); + } + + // optional bool force_backward = 5 [default = false]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_force_backward(), target); + } + + // optional .opencv_caffe.NetState state = 6; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::state(this), target, stream); + } + + // optional bool debug_info = 7 [default = false]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_debug_info(), target); + } + + // repeated .opencv_caffe.BlobShape input_shape = 8; + for (unsigned int i = 0, + n = static_cast(this->_internal_input_shape_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, this->_internal_input_shape(i), target, stream); + } + + // repeated .opencv_caffe.LayerParameter layer = 100; + for (unsigned int i = 0, + n = static_cast(this->_internal_layer_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(100, this->_internal_layer(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetParameter) + return target; +} + +size_t NetParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .opencv_caffe.V1LayerParameter layers = 2; + total_size += 1UL * this->_internal_layers_size(); + for (const auto& msg : this->layers_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string input = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size()); + for (int i = 0, n = input_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + input_.Get(i)); + } + + // repeated int32 input_dim = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->input_dim_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_input_dim_size()); + total_size += data_size; + } + + // repeated .opencv_caffe.BlobShape input_shape = 8; + total_size += 1UL * this->_internal_input_shape_size(); + for (const auto& msg : this->input_shape_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .opencv_caffe.LayerParameter layer = 100; + total_size += 2UL * this->_internal_layer_size(); + for (const auto& msg : this->layer_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional .opencv_caffe.NetState state = 6; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *state_); + } + + // optional bool force_backward = 5 [default = false]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional bool debug_info = 7 [default = false]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + NetParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetParameter::GetClassData() const { return &_class_data_; } + +void NetParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void NetParameter::MergeFrom(const NetParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + layers_.MergeFrom(from.layers_); + input_.MergeFrom(from.input_); + input_dim_.MergeFrom(from.input_dim_); + input_shape_.MergeFrom(from.input_shape_); + layer_.MergeFrom(from.layer_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_state()->::opencv_caffe::NetState::MergeFrom(from._internal_state()); + } + if (cached_has_bits & 0x00000004u) { + force_backward_ = from.force_backward_; + } + if (cached_has_bits & 0x00000008u) { + debug_info_ = from.debug_info_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NetParameter::CopyFrom(const NetParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NetParameter::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(layer_)) + return false; + return true; +} + +void NetParameter::InternalSwap(NetParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + layers_.InternalSwap(&other->layers_); + input_.InternalSwap(&other->input_); + input_dim_.InternalSwap(&other->input_dim_); + input_shape_.InternalSwap(&other->input_shape_); + layer_.InternalSwap(&other->layer_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(NetParameter, debug_info_) + + sizeof(NetParameter::debug_info_) + - PROTOBUF_FIELD_OFFSET(NetParameter, state_)>( + reinterpret_cast(&state_), + reinterpret_cast(&other->state_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NetParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[9]); +} + +// =================================================================== + +class SolverParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_net(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::opencv_caffe::NetParameter& net_param(const SolverParameter* msg); + static void set_has_net_param(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_train_net(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::opencv_caffe::NetParameter& train_net_param(const SolverParameter* msg); + static void set_has_train_net_param(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::opencv_caffe::NetState& train_state(const SolverParameter* msg); + static void set_has_train_state(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_test_interval(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_test_compute_loss(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_test_initialization(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static void set_has_base_lr(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_display(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_average_loss(HasBits* has_bits) { + (*has_bits)[0] |= 1073741824u; + } + static void set_has_max_iter(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_iter_size(HasBits* has_bits) { + (*has_bits)[1] |= 1u; + } + static void set_has_lr_policy(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_gamma(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_power(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_momentum(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_weight_decay(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_regularization_type(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_stepsize(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_clip_gradients(HasBits* has_bits) { + (*has_bits)[0] |= 2147483648u; + } + static void set_has_snapshot(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_snapshot_prefix(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_snapshot_diff(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_snapshot_format(HasBits* has_bits) { + (*has_bits)[1] |= 2u; + } + static void set_has_solver_mode(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } + static void set_has_device_id(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_random_seed(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_delta(HasBits* has_bits) { + (*has_bits)[0] |= 536870912u; + } + static void set_has_momentum2(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static void set_has_rms_decay(HasBits* has_bits) { + (*has_bits)[1] |= 4u; + } + static void set_has_debug_info(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static void set_has_snapshot_after_train(HasBits* has_bits) { + (*has_bits)[0] |= 268435456u; + } + static void set_has_solver_type(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } +}; + +const ::opencv_caffe::NetParameter& +SolverParameter::_Internal::net_param(const SolverParameter* msg) { + return *msg->net_param_; +} +const ::opencv_caffe::NetParameter& +SolverParameter::_Internal::train_net_param(const SolverParameter* msg) { + return *msg->train_net_param_; +} +const ::opencv_caffe::NetState& +SolverParameter::_Internal::train_state(const SolverParameter* msg) { + return *msg->train_state_; +} +const ::PROTOBUF_NAMESPACE_ID::internal::LazyString SolverParameter::_i_give_permission_to_break_this_code_default_regularization_type_{{{"L2", 2}}, {nullptr}}; +const ::PROTOBUF_NAMESPACE_ID::internal::LazyString SolverParameter::_i_give_permission_to_break_this_code_default_type_{{{"SGD", 3}}, {nullptr}}; +SolverParameter::SolverParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + test_net_(arena), + test_iter_(arena), + test_net_param_(arena), + test_state_(arena), + stepvalue_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.SolverParameter) +} +SolverParameter::SolverParameter(const SolverParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + test_net_(from.test_net_), + test_iter_(from.test_iter_), + test_net_param_(from.test_net_param_), + test_state_(from.test_state_), + stepvalue_(from.stepvalue_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + train_net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + train_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_train_net()) { + train_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_train_net(), + GetArenaForAllocation()); + } + lr_policy_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + lr_policy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_lr_policy()) { + lr_policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_lr_policy(), + GetArenaForAllocation()); + } + snapshot_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + snapshot_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_snapshot_prefix()) { + snapshot_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_snapshot_prefix(), + GetArenaForAllocation()); + } + net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_net()) { + net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_net(), + GetArenaForAllocation()); + } + regularization_type_.UnsafeSetDefault(nullptr); + if (from._internal_has_regularization_type()) { + regularization_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_regularization_type(), + GetArenaForAllocation()); + } + type_.UnsafeSetDefault(nullptr); + if (from._internal_has_type()) { + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_type(), + GetArenaForAllocation()); + } + if (from._internal_has_train_net_param()) { + train_net_param_ = new ::opencv_caffe::NetParameter(*from.train_net_param_); + } else { + train_net_param_ = nullptr; + } + if (from._internal_has_net_param()) { + net_param_ = new ::opencv_caffe::NetParameter(*from.net_param_); + } else { + net_param_ = nullptr; + } + if (from._internal_has_train_state()) { + train_state_ = new ::opencv_caffe::NetState(*from.train_state_); + } else { + train_state_ = nullptr; + } + ::memcpy(&test_interval_, &from.test_interval_, + static_cast(reinterpret_cast(&rms_decay_) - + reinterpret_cast(&test_interval_)) + sizeof(rms_decay_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.SolverParameter) +} + +inline void SolverParameter::SharedCtor() { +train_net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + train_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +lr_policy_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + lr_policy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +snapshot_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + snapshot_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +regularization_type_.UnsafeSetDefault(nullptr); +type_.UnsafeSetDefault(nullptr); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&train_net_param_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&solver_type_) - + reinterpret_cast(&train_net_param_)) + sizeof(solver_type_)); +momentum2_ = 0.999f; +random_seed_ = int64_t{-1}; +solver_mode_ = 1; +test_initialization_ = true; +snapshot_after_train_ = true; +delta_ = 1e-08f; +average_loss_ = 1; +clip_gradients_ = -1; +iter_size_ = 1; +snapshot_format_ = 1; +rms_decay_ = 0.99f; +} + +SolverParameter::~SolverParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.SolverParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void SolverParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + train_net_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + lr_policy_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + snapshot_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + net_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + regularization_type_.DestroyNoArena(nullptr); + type_.DestroyNoArena(nullptr); + if (this != internal_default_instance()) delete train_net_param_; + if (this != internal_default_instance()) delete net_param_; + if (this != internal_default_instance()) delete train_state_; +} + +void SolverParameter::ArenaDtor(void* object) { + SolverParameter* _this = reinterpret_cast< SolverParameter* >(object); + (void)_this; +} +void SolverParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SolverParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SolverParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.SolverParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + test_net_.Clear(); + test_iter_.Clear(); + test_net_param_.Clear(); + test_state_.Clear(); + stepvalue_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + train_net_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + lr_policy_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + snapshot_prefix_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + net_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + regularization_type_.ClearToDefault(::opencv_caffe::SolverParameter::_i_give_permission_to_break_this_code_default_regularization_type_, GetArenaForAllocation()); + } + if (cached_has_bits & 0x00000020u) { + type_.ClearToDefault(::opencv_caffe::SolverParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation()); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(train_net_param_ != nullptr); + train_net_param_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(net_param_ != nullptr); + net_param_->Clear(); + } + } + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(train_state_ != nullptr); + train_state_->Clear(); + } + if (cached_has_bits & 0x0000fe00u) { + ::memset(&test_interval_, 0, static_cast( + reinterpret_cast(&momentum_) - + reinterpret_cast(&test_interval_)) + sizeof(momentum_)); + } + if (cached_has_bits & 0x00ff0000u) { + ::memset(&weight_decay_, 0, static_cast( + reinterpret_cast(&solver_type_) - + reinterpret_cast(&weight_decay_)) + sizeof(solver_type_)); + } + if (cached_has_bits & 0xff000000u) { + momentum2_ = 0.999f; + random_seed_ = int64_t{-1}; + solver_mode_ = 1; + test_initialization_ = true; + snapshot_after_train_ = true; + delta_ = 1e-08f; + average_loss_ = 1; + clip_gradients_ = -1; + } + cached_has_bits = _has_bits_[1]; + if (cached_has_bits & 0x00000007u) { + iter_size_ = 1; + snapshot_format_ = 1; + rms_decay_ = 0.99f; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SolverParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string train_net = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_train_net(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.train_net"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string test_net = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_test_net(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.test_net"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // repeated int32 test_iter = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_test_iter(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); + } else if (static_cast(tag) == 26) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_test_iter(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 test_interval = 4 [default = 0]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_test_interval(&_has_bits_); + test_interval_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float base_lr = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { + _Internal::set_has_base_lr(&_has_bits_); + base_lr_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional int32 display = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_display(&_has_bits_); + display_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 max_iter = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_max_iter(&_has_bits_); + max_iter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string lr_policy = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_lr_policy(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.lr_policy"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float gamma = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 77)) { + _Internal::set_has_gamma(&_has_bits_); + gamma_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float power = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 85)) { + _Internal::set_has_power(&_has_bits_); + power_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float momentum = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 93)) { + _Internal::set_has_momentum(&_has_bits_); + momentum_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float weight_decay = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 101)) { + _Internal::set_has_weight_decay(&_has_bits_); + weight_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional int32 stepsize = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + _Internal::set_has_stepsize(&_has_bits_); + stepsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 snapshot = 14 [default = 0]; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + _Internal::set_has_snapshot(&_has_bits_); + snapshot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string snapshot_prefix = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + auto str = _internal_mutable_snapshot_prefix(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.snapshot_prefix"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool snapshot_diff = 16 [default = false]; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _Internal::set_has_snapshot_diff(&_has_bits_); + snapshot_diff_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SolverParameter_SolverMode_IsValid(val))) { + _internal_set_solver_mode(static_cast<::opencv_caffe::SolverParameter_SolverMode>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(17, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int32 device_id = 18 [default = 0]; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { + _Internal::set_has_device_id(&_has_bits_); + device_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool test_compute_loss = 19 [default = false]; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { + _Internal::set_has_test_compute_loss(&_has_bits_); + test_compute_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 random_seed = 20 [default = -1]; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + _Internal::set_has_random_seed(&_has_bits_); + random_seed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.NetParameter train_net_param = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_train_net_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.NetParameter test_net_param = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_test_net_param(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<178>(ptr)); + } else + goto handle_unusual; + continue; + // optional bool debug_info = 23 [default = false]; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { + _Internal::set_has_debug_info(&_has_bits_); + debug_info_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string net = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + auto str = _internal_mutable_net(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.net"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.NetParameter net_param = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_net_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.NetState train_state = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { + ptr = ctx->ParseMessage(_internal_mutable_train_state(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.NetState test_state = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_test_state(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<218>(ptr)); + } else + goto handle_unusual; + continue; + // optional bool snapshot_after_train = 28 [default = true]; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { + _Internal::set_has_snapshot_after_train(&_has_bits_); + snapshot_after_train_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string regularization_type = 29 [default = "L2"]; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + auto str = _internal_mutable_regularization_type(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.regularization_type"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SolverParameter_SolverType_IsValid(val))) { + _internal_set_solver_type(static_cast<::opencv_caffe::SolverParameter_SolverType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(30, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional float delta = 31 [default = 1e-08]; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 253)) { + _Internal::set_has_delta(&_has_bits_); + delta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional bool test_initialization = 32 [default = true]; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 0)) { + _Internal::set_has_test_initialization(&_has_bits_); + test_initialization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 average_loss = 33 [default = 1]; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_average_loss(&_has_bits_); + average_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated int32 stepvalue = 34; + case 34: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + ptr -= 2; + do { + ptr += 2; + _internal_add_stepvalue(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<272>(ptr)); + } else if (static_cast(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_stepvalue(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float clip_gradients = 35 [default = -1]; + case 35: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_clip_gradients(&_has_bits_); + clip_gradients_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional int32 iter_size = 36 [default = 1]; + case 36: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_iter_size(&_has_bits_); + iter_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + case 37: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SolverParameter_SnapshotFormat_IsValid(val))) { + _internal_set_snapshot_format(static_cast<::opencv_caffe::SolverParameter_SnapshotFormat>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(37, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional float rms_decay = 38 [default = 0.99]; + case 38: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { + _Internal::set_has_rms_decay(&_has_bits_); + rms_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float momentum2 = 39 [default = 0.999]; + case 39: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { + _Internal::set_has_momentum2(&_has_bits_); + momentum2_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional string type = 40 [default = "SGD"]; + case 40: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_type(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.type"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SolverParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SolverParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string train_net = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_train_net().data(), static_cast(this->_internal_train_net().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SolverParameter.train_net"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_train_net(), target); + } + + // repeated string test_net = 2; + for (int i = 0, n = this->_internal_test_net_size(); i < n; i++) { + const auto& s = this->_internal_test_net(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SolverParameter.test_net"); + target = stream->WriteString(2, s, target); + } + + // repeated int32 test_iter = 3; + for (int i = 0, n = this->_internal_test_iter_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_test_iter(i), target); + } + + // optional int32 test_interval = 4 [default = 0]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_test_interval(), target); + } + + // optional float base_lr = 5; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_base_lr(), target); + } + + // optional int32 display = 6; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_display(), target); + } + + // optional int32 max_iter = 7; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_max_iter(), target); + } + + // optional string lr_policy = 8; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_lr_policy().data(), static_cast(this->_internal_lr_policy().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SolverParameter.lr_policy"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_lr_policy(), target); + } + + // optional float gamma = 9; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_gamma(), target); + } + + // optional float power = 10; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_power(), target); + } + + // optional float momentum = 11; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(11, this->_internal_momentum(), target); + } + + // optional float weight_decay = 12; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(12, this->_internal_weight_decay(), target); + } + + // optional int32 stepsize = 13; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(13, this->_internal_stepsize(), target); + } + + // optional int32 snapshot = 14 [default = 0]; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(14, this->_internal_snapshot(), target); + } + + // optional string snapshot_prefix = 15; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_snapshot_prefix().data(), static_cast(this->_internal_snapshot_prefix().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SolverParameter.snapshot_prefix"); + target = stream->WriteStringMaybeAliased( + 15, this->_internal_snapshot_prefix(), target); + } + + // optional bool snapshot_diff = 16 [default = false]; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(16, this->_internal_snapshot_diff(), target); + } + + // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + if (cached_has_bits & 0x04000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 17, this->_internal_solver_mode(), target); + } + + // optional int32 device_id = 18 [default = 0]; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(18, this->_internal_device_id(), target); + } + + // optional bool test_compute_loss = 19 [default = false]; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(19, this->_internal_test_compute_loss(), target); + } + + // optional int64 random_seed = 20 [default = -1]; + if (cached_has_bits & 0x02000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(20, this->_internal_random_seed(), target); + } + + // optional .opencv_caffe.NetParameter train_net_param = 21; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 21, _Internal::train_net_param(this), target, stream); + } + + // repeated .opencv_caffe.NetParameter test_net_param = 22; + for (unsigned int i = 0, + n = static_cast(this->_internal_test_net_param_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(22, this->_internal_test_net_param(i), target, stream); + } + + // optional bool debug_info = 23 [default = false]; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(23, this->_internal_debug_info(), target); + } + + // optional string net = 24; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_net().data(), static_cast(this->_internal_net().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SolverParameter.net"); + target = stream->WriteStringMaybeAliased( + 24, this->_internal_net(), target); + } + + // optional .opencv_caffe.NetParameter net_param = 25; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 25, _Internal::net_param(this), target, stream); + } + + // optional .opencv_caffe.NetState train_state = 26; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 26, _Internal::train_state(this), target, stream); + } + + // repeated .opencv_caffe.NetState test_state = 27; + for (unsigned int i = 0, + n = static_cast(this->_internal_test_state_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(27, this->_internal_test_state(i), target, stream); + } + + // optional bool snapshot_after_train = 28 [default = true]; + if (cached_has_bits & 0x10000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(28, this->_internal_snapshot_after_train(), target); + } + + // optional string regularization_type = 29 [default = "L2"]; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_regularization_type().data(), static_cast(this->_internal_regularization_type().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SolverParameter.regularization_type"); + target = stream->WriteStringMaybeAliased( + 29, this->_internal_regularization_type(), target); + } + + // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 30, this->_internal_solver_type(), target); + } + + // optional float delta = 31 [default = 1e-08]; + if (cached_has_bits & 0x20000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(31, this->_internal_delta(), target); + } + + // optional bool test_initialization = 32 [default = true]; + if (cached_has_bits & 0x08000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(32, this->_internal_test_initialization(), target); + } + + // optional int32 average_loss = 33 [default = 1]; + if (cached_has_bits & 0x40000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(33, this->_internal_average_loss(), target); + } + + // repeated int32 stepvalue = 34; + for (int i = 0, n = this->_internal_stepvalue_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(34, this->_internal_stepvalue(i), target); + } + + // optional float clip_gradients = 35 [default = -1]; + if (cached_has_bits & 0x80000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(35, this->_internal_clip_gradients(), target); + } + + cached_has_bits = _has_bits_[1]; + // optional int32 iter_size = 36 [default = 1]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(36, this->_internal_iter_size(), target); + } + + // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 37, this->_internal_snapshot_format(), target); + } + + // optional float rms_decay = 38 [default = 0.99]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(38, this->_internal_rms_decay(), target); + } + + cached_has_bits = _has_bits_[0]; + // optional float momentum2 = 39 [default = 0.999]; + if (cached_has_bits & 0x01000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(39, this->_internal_momentum2(), target); + } + + // optional string type = 40 [default = "SGD"]; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_type().data(), static_cast(this->_internal_type().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SolverParameter.type"); + target = stream->WriteStringMaybeAliased( + 40, this->_internal_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SolverParameter) + return target; +} + +size_t SolverParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SolverParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string test_net = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(test_net_.size()); + for (int i = 0, n = test_net_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + test_net_.Get(i)); + } + + // repeated int32 test_iter = 3; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->test_iter_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_test_iter_size()); + total_size += data_size; + } + + // repeated .opencv_caffe.NetParameter test_net_param = 22; + total_size += 2UL * this->_internal_test_net_param_size(); + for (const auto& msg : this->test_net_param_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .opencv_caffe.NetState test_state = 27; + total_size += 2UL * this->_internal_test_state_size(); + for (const auto& msg : this->test_state_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated int32 stepvalue = 34; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->stepvalue_); + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_stepvalue_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string train_net = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_train_net()); + } + + // optional string lr_policy = 8; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_lr_policy()); + } + + // optional string snapshot_prefix = 15; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_snapshot_prefix()); + } + + // optional string net = 24; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_net()); + } + + // optional string regularization_type = 29 [default = "L2"]; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_regularization_type()); + } + + // optional string type = 40 [default = "SGD"]; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_type()); + } + + // optional .opencv_caffe.NetParameter train_net_param = 21; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *train_net_param_); + } + + // optional .opencv_caffe.NetParameter net_param = 25; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *net_param_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .opencv_caffe.NetState train_state = 26; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *train_state_); + } + + // optional int32 test_interval = 4 [default = 0]; + if (cached_has_bits & 0x00000200u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_test_interval()); + } + + // optional float base_lr = 5; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 4; + } + + // optional int32 display = 6; + if (cached_has_bits & 0x00000800u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_display()); + } + + // optional int32 max_iter = 7; + if (cached_has_bits & 0x00001000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_max_iter()); + } + + // optional float gamma = 9; + if (cached_has_bits & 0x00002000u) { + total_size += 1 + 4; + } + + // optional float power = 10; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + 4; + } + + // optional float momentum = 11; + if (cached_has_bits & 0x00008000u) { + total_size += 1 + 4; + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional float weight_decay = 12; + if (cached_has_bits & 0x00010000u) { + total_size += 1 + 4; + } + + // optional int32 stepsize = 13; + if (cached_has_bits & 0x00020000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_stepsize()); + } + + // optional int32 snapshot = 14 [default = 0]; + if (cached_has_bits & 0x00040000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_snapshot()); + } + + // optional int32 device_id = 18 [default = 0]; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_device_id()); + } + + // optional bool test_compute_loss = 19 [default = false]; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + 1; + } + + // optional bool snapshot_diff = 16 [default = false]; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + 1; + } + + // optional bool debug_info = 23 [default = false]; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + 1; + } + + // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + if (cached_has_bits & 0x00800000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_solver_type()); + } + + } + if (cached_has_bits & 0xff000000u) { + // optional float momentum2 = 39 [default = 0.999]; + if (cached_has_bits & 0x01000000u) { + total_size += 2 + 4; + } + + // optional int64 random_seed = 20 [default = -1]; + if (cached_has_bits & 0x02000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_random_seed()); + } + + // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + if (cached_has_bits & 0x04000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_solver_mode()); + } + + // optional bool test_initialization = 32 [default = true]; + if (cached_has_bits & 0x08000000u) { + total_size += 2 + 1; + } + + // optional bool snapshot_after_train = 28 [default = true]; + if (cached_has_bits & 0x10000000u) { + total_size += 2 + 1; + } + + // optional float delta = 31 [default = 1e-08]; + if (cached_has_bits & 0x20000000u) { + total_size += 2 + 4; + } + + // optional int32 average_loss = 33 [default = 1]; + if (cached_has_bits & 0x40000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_average_loss()); + } + + // optional float clip_gradients = 35 [default = -1]; + if (cached_has_bits & 0x80000000u) { + total_size += 2 + 4; + } + + } + cached_has_bits = _has_bits_[1]; + if (cached_has_bits & 0x00000007u) { + // optional int32 iter_size = 36 [default = 1]; + if (cached_has_bits & 0x00000001u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_iter_size()); + } + + // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_snapshot_format()); + } + + // optional float rms_decay = 38 [default = 0.99]; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SolverParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SolverParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SolverParameter::GetClassData() const { return &_class_data_; } + +void SolverParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void SolverParameter::MergeFrom(const SolverParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SolverParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + test_net_.MergeFrom(from.test_net_); + test_iter_.MergeFrom(from.test_iter_); + test_net_param_.MergeFrom(from.test_net_param_); + test_state_.MergeFrom(from.test_state_); + stepvalue_.MergeFrom(from.stepvalue_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_train_net(from._internal_train_net()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_lr_policy(from._internal_lr_policy()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_snapshot_prefix(from._internal_snapshot_prefix()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_net(from._internal_net()); + } + if (cached_has_bits & 0x00000010u) { + _internal_set_regularization_type(from._internal_regularization_type()); + } + if (cached_has_bits & 0x00000020u) { + _internal_set_type(from._internal_type()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_train_net_param()->::opencv_caffe::NetParameter::MergeFrom(from._internal_train_net_param()); + } + if (cached_has_bits & 0x00000080u) { + _internal_mutable_net_param()->::opencv_caffe::NetParameter::MergeFrom(from._internal_net_param()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _internal_mutable_train_state()->::opencv_caffe::NetState::MergeFrom(from._internal_train_state()); + } + if (cached_has_bits & 0x00000200u) { + test_interval_ = from.test_interval_; + } + if (cached_has_bits & 0x00000400u) { + base_lr_ = from.base_lr_; + } + if (cached_has_bits & 0x00000800u) { + display_ = from.display_; + } + if (cached_has_bits & 0x00001000u) { + max_iter_ = from.max_iter_; + } + if (cached_has_bits & 0x00002000u) { + gamma_ = from.gamma_; + } + if (cached_has_bits & 0x00004000u) { + power_ = from.power_; + } + if (cached_has_bits & 0x00008000u) { + momentum_ = from.momentum_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + weight_decay_ = from.weight_decay_; + } + if (cached_has_bits & 0x00020000u) { + stepsize_ = from.stepsize_; + } + if (cached_has_bits & 0x00040000u) { + snapshot_ = from.snapshot_; + } + if (cached_has_bits & 0x00080000u) { + device_id_ = from.device_id_; + } + if (cached_has_bits & 0x00100000u) { + test_compute_loss_ = from.test_compute_loss_; + } + if (cached_has_bits & 0x00200000u) { + snapshot_diff_ = from.snapshot_diff_; + } + if (cached_has_bits & 0x00400000u) { + debug_info_ = from.debug_info_; + } + if (cached_has_bits & 0x00800000u) { + solver_type_ = from.solver_type_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + momentum2_ = from.momentum2_; + } + if (cached_has_bits & 0x02000000u) { + random_seed_ = from.random_seed_; + } + if (cached_has_bits & 0x04000000u) { + solver_mode_ = from.solver_mode_; + } + if (cached_has_bits & 0x08000000u) { + test_initialization_ = from.test_initialization_; + } + if (cached_has_bits & 0x10000000u) { + snapshot_after_train_ = from.snapshot_after_train_; + } + if (cached_has_bits & 0x20000000u) { + delta_ = from.delta_; + } + if (cached_has_bits & 0x40000000u) { + average_loss_ = from.average_loss_; + } + if (cached_has_bits & 0x80000000u) { + clip_gradients_ = from.clip_gradients_; + } + _has_bits_[0] |= cached_has_bits; + } + cached_has_bits = from._has_bits_[1]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + iter_size_ = from.iter_size_; + } + if (cached_has_bits & 0x00000002u) { + snapshot_format_ = from.snapshot_format_; + } + if (cached_has_bits & 0x00000004u) { + rms_decay_ = from.rms_decay_; + } + _has_bits_[1] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SolverParameter::CopyFrom(const SolverParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SolverParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SolverParameter::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(test_net_param_)) + return false; + if (_internal_has_train_net_param()) { + if (!train_net_param_->IsInitialized()) return false; + } + if (_internal_has_net_param()) { + if (!net_param_->IsInitialized()) return false; + } + return true; +} + +void SolverParameter::InternalSwap(SolverParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(_has_bits_[1], other->_has_bits_[1]); + test_net_.InternalSwap(&other->test_net_); + test_iter_.InternalSwap(&other->test_iter_); + test_net_param_.InternalSwap(&other->test_net_param_); + test_state_.InternalSwap(&other->test_state_); + stepvalue_.InternalSwap(&other->stepvalue_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &train_net_, lhs_arena, + &other->train_net_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &lr_policy_, lhs_arena, + &other->lr_policy_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &snapshot_prefix_, lhs_arena, + &other->snapshot_prefix_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &net_, lhs_arena, + &other->net_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + nullptr, + ®ularization_type_, lhs_arena, + &other->regularization_type_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + nullptr, + &type_, lhs_arena, + &other->type_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SolverParameter, solver_type_) + + sizeof(SolverParameter::solver_type_) + - PROTOBUF_FIELD_OFFSET(SolverParameter, train_net_param_)>( + reinterpret_cast(&train_net_param_), + reinterpret_cast(&other->train_net_param_)); + swap(momentum2_, other->momentum2_); + swap(random_seed_, other->random_seed_); + swap(solver_mode_, other->solver_mode_); + swap(test_initialization_, other->test_initialization_); + swap(snapshot_after_train_, other->snapshot_after_train_); + swap(delta_, other->delta_); + swap(average_loss_, other->average_loss_); + swap(clip_gradients_, other->clip_gradients_); + swap(iter_size_, other->iter_size_); + swap(snapshot_format_, other->snapshot_format_); + swap(rms_decay_, other->rms_decay_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SolverParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[10]); +} + +// =================================================================== + +class SolverState::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_iter(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_learned_net(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_current_step(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +SolverState::SolverState(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + history_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.SolverState) +} +SolverState::SolverState(const SolverState& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + history_(from.history_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + learned_net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + learned_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_learned_net()) { + learned_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_learned_net(), + GetArenaForAllocation()); + } + ::memcpy(&iter_, &from.iter_, + static_cast(reinterpret_cast(¤t_step_) - + reinterpret_cast(&iter_)) + sizeof(current_step_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.SolverState) +} + +inline void SolverState::SharedCtor() { +learned_net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + learned_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&iter_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(¤t_step_) - + reinterpret_cast(&iter_)) + sizeof(current_step_)); +} + +SolverState::~SolverState() { + // @@protoc_insertion_point(destructor:opencv_caffe.SolverState) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void SolverState::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + learned_net_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SolverState::ArenaDtor(void* object) { + SolverState* _this = reinterpret_cast< SolverState* >(object); + (void)_this; +} +void SolverState::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SolverState::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SolverState::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.SolverState) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + history_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + learned_net_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&iter_, 0, static_cast( + reinterpret_cast(¤t_step_) - + reinterpret_cast(&iter_)) + sizeof(current_step_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SolverState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 iter = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_iter(&has_bits); + iter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string learned_net = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_learned_net(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverState.learned_net"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.BlobProto history = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_history(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // optional int32 current_step = 4 [default = 0]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_current_step(&has_bits); + current_step_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SolverState::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SolverState) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 iter = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_iter(), target); + } + + // optional string learned_net = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_learned_net().data(), static_cast(this->_internal_learned_net().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SolverState.learned_net"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_learned_net(), target); + } + + // repeated .opencv_caffe.BlobProto history = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_history_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_history(i), target, stream); + } + + // optional int32 current_step = 4 [default = 0]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_current_step(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SolverState) + return target; +} + +size_t SolverState::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SolverState) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .opencv_caffe.BlobProto history = 3; + total_size += 1UL * this->_internal_history_size(); + for (const auto& msg : this->history_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string learned_net = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_learned_net()); + } + + // optional int32 iter = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_iter()); + } + + // optional int32 current_step = 4 [default = 0]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_current_step()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SolverState::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SolverState::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SolverState::GetClassData() const { return &_class_data_; } + +void SolverState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void SolverState::MergeFrom(const SolverState& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SolverState) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + history_.MergeFrom(from.history_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_learned_net(from._internal_learned_net()); + } + if (cached_has_bits & 0x00000002u) { + iter_ = from.iter_; + } + if (cached_has_bits & 0x00000004u) { + current_step_ = from.current_step_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SolverState::CopyFrom(const SolverState& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SolverState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SolverState::IsInitialized() const { + return true; +} + +void SolverState::InternalSwap(SolverState* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + history_.InternalSwap(&other->history_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &learned_net_, lhs_arena, + &other->learned_net_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SolverState, current_step_) + + sizeof(SolverState::current_step_) + - PROTOBUF_FIELD_OFFSET(SolverState, iter_)>( + reinterpret_cast(&iter_), + reinterpret_cast(&other->iter_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SolverState::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[11]); +} + +// =================================================================== + +class NetState::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_phase(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_level(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +NetState::NetState(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + stage_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.NetState) +} +NetState::NetState(const NetState& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + stage_(from.stage_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&level_, &from.level_, + static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&level_)) + sizeof(phase_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetState) +} + +inline void NetState::SharedCtor() { +level_ = 0; +phase_ = 1; +} + +NetState::~NetState() { + // @@protoc_insertion_point(destructor:opencv_caffe.NetState) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void NetState::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void NetState::ArenaDtor(void* object) { + NetState* _this = reinterpret_cast< NetState* >(object); + (void)_this; +} +void NetState::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void NetState::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void NetState::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.NetState) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + stage_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + level_ = 0; + phase_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NetState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.Phase phase = 1 [default = TEST]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::Phase_IsValid(val))) { + _internal_set_phase(static_cast<::opencv_caffe::Phase>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int32 level = 2 [default = 0]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_level(&has_bits); + level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string stage = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_stage(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetState.stage"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NetState::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetState) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.Phase phase = 1 [default = TEST]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_phase(), target); + } + + // optional int32 level = 2 [default = 0]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_level(), target); + } + + // repeated string stage = 3; + for (int i = 0, n = this->_internal_stage_size(); i < n; i++) { + const auto& s = this->_internal_stage(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.NetState.stage"); + target = stream->WriteString(3, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetState) + return target; +} + +size_t NetState::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetState) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string stage = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(stage_.size()); + for (int i = 0, n = stage_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + stage_.Get(i)); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int32 level = 2 [default = 0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_level()); + } + + // optional .opencv_caffe.Phase phase = 1 [default = TEST]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetState::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + NetState::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetState::GetClassData() const { return &_class_data_; } + +void NetState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void NetState::MergeFrom(const NetState& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetState) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + stage_.MergeFrom(from.stage_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + level_ = from.level_; + } + if (cached_has_bits & 0x00000002u) { + phase_ = from.phase_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NetState::CopyFrom(const NetState& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NetState::IsInitialized() const { + return true; +} + +void NetState::InternalSwap(NetState* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + stage_.InternalSwap(&other->stage_); + swap(level_, other->level_); + swap(phase_, other->phase_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NetState::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[12]); +} + +// =================================================================== + +class NetStateRule::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_phase(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_min_level(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_max_level(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +NetStateRule::NetStateRule(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + stage_(arena), + not_stage_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.NetStateRule) +} +NetStateRule::NetStateRule(const NetStateRule& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + stage_(from.stage_), + not_stage_(from.not_stage_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&phase_, &from.phase_, + static_cast(reinterpret_cast(&max_level_) - + reinterpret_cast(&phase_)) + sizeof(max_level_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetStateRule) +} + +inline void NetStateRule::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&phase_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&max_level_) - + reinterpret_cast(&phase_)) + sizeof(max_level_)); +} + +NetStateRule::~NetStateRule() { + // @@protoc_insertion_point(destructor:opencv_caffe.NetStateRule) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void NetStateRule::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void NetStateRule::ArenaDtor(void* object) { + NetStateRule* _this = reinterpret_cast< NetStateRule* >(object); + (void)_this; +} +void NetStateRule::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void NetStateRule::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void NetStateRule::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.NetStateRule) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + stage_.Clear(); + not_stage_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&phase_, 0, static_cast( + reinterpret_cast(&max_level_) - + reinterpret_cast(&phase_)) + sizeof(max_level_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NetStateRule::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.Phase phase = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::Phase_IsValid(val))) { + _internal_set_phase(static_cast<::opencv_caffe::Phase>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int32 min_level = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_min_level(&has_bits); + min_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 max_level = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_max_level(&has_bits); + max_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string stage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_stage(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetStateRule.stage"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string not_stage = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_not_stage(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetStateRule.not_stage"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NetStateRule::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetStateRule) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.Phase phase = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_phase(), target); + } + + // optional int32 min_level = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_min_level(), target); + } + + // optional int32 max_level = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_max_level(), target); + } + + // repeated string stage = 4; + for (int i = 0, n = this->_internal_stage_size(); i < n; i++) { + const auto& s = this->_internal_stage(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.NetStateRule.stage"); + target = stream->WriteString(4, s, target); + } + + // repeated string not_stage = 5; + for (int i = 0, n = this->_internal_not_stage_size(); i < n; i++) { + const auto& s = this->_internal_not_stage(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.NetStateRule.not_stage"); + target = stream->WriteString(5, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetStateRule) + return target; +} + +size_t NetStateRule::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetStateRule) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string stage = 4; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(stage_.size()); + for (int i = 0, n = stage_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + stage_.Get(i)); + } + + // repeated string not_stage = 5; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(not_stage_.size()); + for (int i = 0, n = not_stage_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + not_stage_.Get(i)); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .opencv_caffe.Phase phase = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); + } + + // optional int32 min_level = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_min_level()); + } + + // optional int32 max_level = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_max_level()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetStateRule::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + NetStateRule::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetStateRule::GetClassData() const { return &_class_data_; } + +void NetStateRule::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void NetStateRule::MergeFrom(const NetStateRule& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetStateRule) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + stage_.MergeFrom(from.stage_); + not_stage_.MergeFrom(from.not_stage_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + phase_ = from.phase_; + } + if (cached_has_bits & 0x00000002u) { + min_level_ = from.min_level_; + } + if (cached_has_bits & 0x00000004u) { + max_level_ = from.max_level_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NetStateRule::CopyFrom(const NetStateRule& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetStateRule) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NetStateRule::IsInitialized() const { + return true; +} + +void NetStateRule::InternalSwap(NetStateRule* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + stage_.InternalSwap(&other->stage_); + not_stage_.InternalSwap(&other->not_stage_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(NetStateRule, max_level_) + + sizeof(NetStateRule::max_level_) + - PROTOBUF_FIELD_OFFSET(NetStateRule, phase_)>( + reinterpret_cast(&phase_), + reinterpret_cast(&other->phase_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NetStateRule::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[13]); +} + +// =================================================================== + +class ParamSpec::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_share_mode(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_lr_mult(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_decay_mult(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +ParamSpec::ParamSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ParamSpec) +} +ParamSpec::ParamSpec(const ParamSpec& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArenaForAllocation()); + } + ::memcpy(&share_mode_, &from.share_mode_, + static_cast(reinterpret_cast(&decay_mult_) - + reinterpret_cast(&share_mode_)) + sizeof(decay_mult_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ParamSpec) +} + +inline void ParamSpec::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +share_mode_ = 0; +lr_mult_ = 1; +decay_mult_ = 1; +} + +ParamSpec::~ParamSpec() { + // @@protoc_insertion_point(destructor:opencv_caffe.ParamSpec) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ParamSpec::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ParamSpec::ArenaDtor(void* object) { + ParamSpec* _this = reinterpret_cast< ParamSpec* >(object); + (void)_this; +} +void ParamSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParamSpec::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParamSpec::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ParamSpec) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000000eu) { + share_mode_ = 0; + lr_mult_ = 1; + decay_mult_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParamSpec::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.ParamSpec.name"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::ParamSpec_DimCheckMode_IsValid(val))) { + _internal_set_share_mode(static_cast<::opencv_caffe::ParamSpec_DimCheckMode>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional float lr_mult = 3 [default = 1]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_lr_mult(&has_bits); + lr_mult_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float decay_mult = 4 [default = 1]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { + _Internal::set_has_decay_mult(&has_bits); + decay_mult_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ParamSpec::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ParamSpec) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.ParamSpec.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_share_mode(), target); + } + + // optional float lr_mult = 3 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_lr_mult(), target); + } + + // optional float decay_mult = 4 [default = 1]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_decay_mult(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ParamSpec) + return target; +} + +size_t ParamSpec::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ParamSpec) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_share_mode()); + } + + // optional float lr_mult = 3 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + // optional float decay_mult = 4 [default = 1]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParamSpec::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParamSpec::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParamSpec::GetClassData() const { return &_class_data_; } + +void ParamSpec::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ParamSpec::MergeFrom(const ParamSpec& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ParamSpec) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + share_mode_ = from.share_mode_; + } + if (cached_has_bits & 0x00000004u) { + lr_mult_ = from.lr_mult_; + } + if (cached_has_bits & 0x00000008u) { + decay_mult_ = from.decay_mult_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ParamSpec::CopyFrom(const ParamSpec& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ParamSpec) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParamSpec::IsInitialized() const { + return true; +} + +void ParamSpec::InternalSwap(ParamSpec* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); + swap(share_mode_, other->share_mode_); + swap(lr_mult_, other->lr_mult_); + swap(decay_mult_, other->decay_mult_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParamSpec::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[14]); +} + +// =================================================================== + +class LayerParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_phase(HasBits* has_bits) { + (*has_bits)[1] |= 16777216u; + } + static const ::opencv_caffe::TransformationParameter& transform_param(const LayerParameter* msg); + static void set_has_transform_param(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::opencv_caffe::LossParameter& loss_param(const LayerParameter* msg); + static void set_has_loss_param(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::opencv_caffe::AccuracyParameter& accuracy_param(const LayerParameter* msg); + static void set_has_accuracy_param(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::opencv_caffe::ArgMaxParameter& argmax_param(const LayerParameter* msg); + static void set_has_argmax_param(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::opencv_caffe::BatchNormParameter& batch_norm_param(const LayerParameter* msg); + static void set_has_batch_norm_param(HasBits* has_bits) { + (*has_bits)[1] |= 512u; + } + static const ::opencv_caffe::BiasParameter& bias_param(const LayerParameter* msg); + static void set_has_bias_param(HasBits* has_bits) { + (*has_bits)[1] |= 2048u; + } + static const ::opencv_caffe::ConcatParameter& concat_param(const LayerParameter* msg); + static void set_has_concat_param(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param(const LayerParameter* msg); + static void set_has_contrastive_loss_param(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::opencv_caffe::ConvolutionParameter& convolution_param(const LayerParameter* msg); + static void set_has_convolution_param(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::opencv_caffe::CropParameter& crop_param(const LayerParameter* msg); + static void set_has_crop_param(HasBits* has_bits) { + (*has_bits)[1] |= 16384u; + } + static const ::opencv_caffe::DataParameter& data_param(const LayerParameter* msg); + static void set_has_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static const ::opencv_caffe::DetectionOutputParameter& detection_output_param(const LayerParameter* msg); + static void set_has_detection_output_param(HasBits* has_bits) { + (*has_bits)[1] |= 131072u; + } + static const ::opencv_caffe::DropoutParameter& dropout_param(const LayerParameter* msg); + static void set_has_dropout_param(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static const ::opencv_caffe::DummyDataParameter& dummy_data_param(const LayerParameter* msg); + static void set_has_dummy_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::opencv_caffe::EltwiseParameter& eltwise_param(const LayerParameter* msg); + static void set_has_eltwise_param(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static const ::opencv_caffe::ELUParameter& elu_param(const LayerParameter* msg); + static void set_has_elu_param(HasBits* has_bits) { + (*has_bits)[1] |= 1024u; + } + static const ::opencv_caffe::EmbedParameter& embed_param(const LayerParameter* msg); + static void set_has_embed_param(HasBits* has_bits) { + (*has_bits)[1] |= 128u; + } + static const ::opencv_caffe::ExpParameter& exp_param(const LayerParameter* msg); + static void set_has_exp_param(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static const ::opencv_caffe::FlattenParameter& flatten_param(const LayerParameter* msg); + static void set_has_flatten_param(HasBits* has_bits) { + (*has_bits)[1] |= 32u; + } + static const ::opencv_caffe::HDF5DataParameter& hdf5_data_param(const LayerParameter* msg); + static void set_has_hdf5_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param(const LayerParameter* msg); + static void set_has_hdf5_output_param(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static const ::opencv_caffe::HingeLossParameter& hinge_loss_param(const LayerParameter* msg); + static void set_has_hinge_loss_param(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static const ::opencv_caffe::ImageDataParameter& image_data_param(const LayerParameter* msg); + static void set_has_image_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static const ::opencv_caffe::InfogainLossParameter& infogain_loss_param(const LayerParameter* msg); + static void set_has_infogain_loss_param(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static const ::opencv_caffe::InnerProductParameter& inner_product_param(const LayerParameter* msg); + static void set_has_inner_product_param(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static const ::opencv_caffe::InputParameter& input_param(const LayerParameter* msg); + static void set_has_input_param(HasBits* has_bits) { + (*has_bits)[1] |= 8192u; + } + static const ::opencv_caffe::LogParameter& log_param(const LayerParameter* msg); + static void set_has_log_param(HasBits* has_bits) { + (*has_bits)[1] |= 16u; + } + static const ::opencv_caffe::LRNParameter& lrn_param(const LayerParameter* msg); + static void set_has_lrn_param(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static const ::opencv_caffe::MemoryDataParameter& memory_data_param(const LayerParameter* msg); + static void set_has_memory_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static const ::opencv_caffe::MVNParameter& mvn_param(const LayerParameter* msg); + static void set_has_mvn_param(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static const ::opencv_caffe::NormalizeBBoxParameter& norm_param(const LayerParameter* msg); + static void set_has_norm_param(HasBits* has_bits) { + (*has_bits)[1] |= 524288u; + } + static const ::opencv_caffe::PermuteParameter& permute_param(const LayerParameter* msg); + static void set_has_permute_param(HasBits* has_bits) { + (*has_bits)[1] |= 262144u; + } + static const ::opencv_caffe::ParameterParameter& parameter_param(const LayerParameter* msg); + static void set_has_parameter_param(HasBits* has_bits) { + (*has_bits)[1] |= 32768u; + } + static const ::opencv_caffe::PoolingParameter& pooling_param(const LayerParameter* msg); + static void set_has_pooling_param(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static const ::opencv_caffe::PowerParameter& power_param(const LayerParameter* msg); + static void set_has_power_param(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static const ::opencv_caffe::PReLUParameter& prelu_param(const LayerParameter* msg); + static void set_has_prelu_param(HasBits* has_bits) { + (*has_bits)[1] |= 2u; + } + static const ::opencv_caffe::PriorBoxParameter& prior_box_param(const LayerParameter* msg); + static void set_has_prior_box_param(HasBits* has_bits) { + (*has_bits)[1] |= 1048576u; + } + static const ::opencv_caffe::ProposalParameter& proposal_param(const LayerParameter* msg); + static void set_has_proposal_param(HasBits* has_bits) { + (*has_bits)[1] |= 2097152u; + } + static const ::opencv_caffe::PSROIPoolingParameter& psroi_pooling_param(const LayerParameter* msg); + static void set_has_psroi_pooling_param(HasBits* has_bits) { + (*has_bits)[1] |= 4194304u; + } + static const ::opencv_caffe::PythonParameter& python_param(const LayerParameter* msg); + static void set_has_python_param(HasBits* has_bits) { + (*has_bits)[1] |= 1u; + } + static const ::opencv_caffe::RecurrentParameter& recurrent_param(const LayerParameter* msg); + static void set_has_recurrent_param(HasBits* has_bits) { + (*has_bits)[1] |= 65536u; + } + static const ::opencv_caffe::ReductionParameter& reduction_param(const LayerParameter* msg); + static void set_has_reduction_param(HasBits* has_bits) { + (*has_bits)[1] |= 64u; + } + static const ::opencv_caffe::ReLUParameter& relu_param(const LayerParameter* msg); + static void set_has_relu_param(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static const ::opencv_caffe::ReshapeParameter& reshape_param(const LayerParameter* msg); + static void set_has_reshape_param(HasBits* has_bits) { + (*has_bits)[1] |= 8u; + } + static const ::opencv_caffe::ROIPoolingParameter& roi_pooling_param(const LayerParameter* msg); + static void set_has_roi_pooling_param(HasBits* has_bits) { + (*has_bits)[1] |= 8388608u; + } + static const ::opencv_caffe::ScaleParameter& scale_param(const LayerParameter* msg); + static void set_has_scale_param(HasBits* has_bits) { + (*has_bits)[1] |= 4096u; + } + static const ::opencv_caffe::SigmoidParameter& sigmoid_param(const LayerParameter* msg); + static void set_has_sigmoid_param(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } + static const ::opencv_caffe::SoftmaxParameter& softmax_param(const LayerParameter* msg); + static void set_has_softmax_param(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static const ::opencv_caffe::SPPParameter& spp_param(const LayerParameter* msg); + static void set_has_spp_param(HasBits* has_bits) { + (*has_bits)[1] |= 4u; + } + static const ::opencv_caffe::SliceParameter& slice_param(const LayerParameter* msg); + static void set_has_slice_param(HasBits* has_bits) { + (*has_bits)[0] |= 268435456u; + } + static const ::opencv_caffe::TanHParameter& tanh_param(const LayerParameter* msg); + static void set_has_tanh_param(HasBits* has_bits) { + (*has_bits)[0] |= 536870912u; + } + static const ::opencv_caffe::ThresholdParameter& threshold_param(const LayerParameter* msg); + static void set_has_threshold_param(HasBits* has_bits) { + (*has_bits)[0] |= 1073741824u; + } + static const ::opencv_caffe::TileParameter& tile_param(const LayerParameter* msg); + static void set_has_tile_param(HasBits* has_bits) { + (*has_bits)[1] |= 256u; + } + static const ::opencv_caffe::WindowDataParameter& window_data_param(const LayerParameter* msg); + static void set_has_window_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 2147483648u; + } +}; + +const ::opencv_caffe::TransformationParameter& +LayerParameter::_Internal::transform_param(const LayerParameter* msg) { + return *msg->transform_param_; +} +const ::opencv_caffe::LossParameter& +LayerParameter::_Internal::loss_param(const LayerParameter* msg) { + return *msg->loss_param_; +} +const ::opencv_caffe::AccuracyParameter& +LayerParameter::_Internal::accuracy_param(const LayerParameter* msg) { + return *msg->accuracy_param_; +} +const ::opencv_caffe::ArgMaxParameter& +LayerParameter::_Internal::argmax_param(const LayerParameter* msg) { + return *msg->argmax_param_; +} +const ::opencv_caffe::BatchNormParameter& +LayerParameter::_Internal::batch_norm_param(const LayerParameter* msg) { + return *msg->batch_norm_param_; +} +const ::opencv_caffe::BiasParameter& +LayerParameter::_Internal::bias_param(const LayerParameter* msg) { + return *msg->bias_param_; +} +const ::opencv_caffe::ConcatParameter& +LayerParameter::_Internal::concat_param(const LayerParameter* msg) { + return *msg->concat_param_; +} +const ::opencv_caffe::ContrastiveLossParameter& +LayerParameter::_Internal::contrastive_loss_param(const LayerParameter* msg) { + return *msg->contrastive_loss_param_; +} +const ::opencv_caffe::ConvolutionParameter& +LayerParameter::_Internal::convolution_param(const LayerParameter* msg) { + return *msg->convolution_param_; +} +const ::opencv_caffe::CropParameter& +LayerParameter::_Internal::crop_param(const LayerParameter* msg) { + return *msg->crop_param_; +} +const ::opencv_caffe::DataParameter& +LayerParameter::_Internal::data_param(const LayerParameter* msg) { + return *msg->data_param_; +} +const ::opencv_caffe::DetectionOutputParameter& +LayerParameter::_Internal::detection_output_param(const LayerParameter* msg) { + return *msg->detection_output_param_; +} +const ::opencv_caffe::DropoutParameter& +LayerParameter::_Internal::dropout_param(const LayerParameter* msg) { + return *msg->dropout_param_; +} +const ::opencv_caffe::DummyDataParameter& +LayerParameter::_Internal::dummy_data_param(const LayerParameter* msg) { + return *msg->dummy_data_param_; +} +const ::opencv_caffe::EltwiseParameter& +LayerParameter::_Internal::eltwise_param(const LayerParameter* msg) { + return *msg->eltwise_param_; +} +const ::opencv_caffe::ELUParameter& +LayerParameter::_Internal::elu_param(const LayerParameter* msg) { + return *msg->elu_param_; +} +const ::opencv_caffe::EmbedParameter& +LayerParameter::_Internal::embed_param(const LayerParameter* msg) { + return *msg->embed_param_; +} +const ::opencv_caffe::ExpParameter& +LayerParameter::_Internal::exp_param(const LayerParameter* msg) { + return *msg->exp_param_; +} +const ::opencv_caffe::FlattenParameter& +LayerParameter::_Internal::flatten_param(const LayerParameter* msg) { + return *msg->flatten_param_; +} +const ::opencv_caffe::HDF5DataParameter& +LayerParameter::_Internal::hdf5_data_param(const LayerParameter* msg) { + return *msg->hdf5_data_param_; +} +const ::opencv_caffe::HDF5OutputParameter& +LayerParameter::_Internal::hdf5_output_param(const LayerParameter* msg) { + return *msg->hdf5_output_param_; +} +const ::opencv_caffe::HingeLossParameter& +LayerParameter::_Internal::hinge_loss_param(const LayerParameter* msg) { + return *msg->hinge_loss_param_; +} +const ::opencv_caffe::ImageDataParameter& +LayerParameter::_Internal::image_data_param(const LayerParameter* msg) { + return *msg->image_data_param_; +} +const ::opencv_caffe::InfogainLossParameter& +LayerParameter::_Internal::infogain_loss_param(const LayerParameter* msg) { + return *msg->infogain_loss_param_; +} +const ::opencv_caffe::InnerProductParameter& +LayerParameter::_Internal::inner_product_param(const LayerParameter* msg) { + return *msg->inner_product_param_; +} +const ::opencv_caffe::InputParameter& +LayerParameter::_Internal::input_param(const LayerParameter* msg) { + return *msg->input_param_; +} +const ::opencv_caffe::LogParameter& +LayerParameter::_Internal::log_param(const LayerParameter* msg) { + return *msg->log_param_; +} +const ::opencv_caffe::LRNParameter& +LayerParameter::_Internal::lrn_param(const LayerParameter* msg) { + return *msg->lrn_param_; +} +const ::opencv_caffe::MemoryDataParameter& +LayerParameter::_Internal::memory_data_param(const LayerParameter* msg) { + return *msg->memory_data_param_; +} +const ::opencv_caffe::MVNParameter& +LayerParameter::_Internal::mvn_param(const LayerParameter* msg) { + return *msg->mvn_param_; +} +const ::opencv_caffe::NormalizeBBoxParameter& +LayerParameter::_Internal::norm_param(const LayerParameter* msg) { + return *msg->norm_param_; +} +const ::opencv_caffe::PermuteParameter& +LayerParameter::_Internal::permute_param(const LayerParameter* msg) { + return *msg->permute_param_; +} +const ::opencv_caffe::ParameterParameter& +LayerParameter::_Internal::parameter_param(const LayerParameter* msg) { + return *msg->parameter_param_; +} +const ::opencv_caffe::PoolingParameter& +LayerParameter::_Internal::pooling_param(const LayerParameter* msg) { + return *msg->pooling_param_; +} +const ::opencv_caffe::PowerParameter& +LayerParameter::_Internal::power_param(const LayerParameter* msg) { + return *msg->power_param_; +} +const ::opencv_caffe::PReLUParameter& +LayerParameter::_Internal::prelu_param(const LayerParameter* msg) { + return *msg->prelu_param_; +} +const ::opencv_caffe::PriorBoxParameter& +LayerParameter::_Internal::prior_box_param(const LayerParameter* msg) { + return *msg->prior_box_param_; +} +const ::opencv_caffe::ProposalParameter& +LayerParameter::_Internal::proposal_param(const LayerParameter* msg) { + return *msg->proposal_param_; +} +const ::opencv_caffe::PSROIPoolingParameter& +LayerParameter::_Internal::psroi_pooling_param(const LayerParameter* msg) { + return *msg->psroi_pooling_param_; +} +const ::opencv_caffe::PythonParameter& +LayerParameter::_Internal::python_param(const LayerParameter* msg) { + return *msg->python_param_; +} +const ::opencv_caffe::RecurrentParameter& +LayerParameter::_Internal::recurrent_param(const LayerParameter* msg) { + return *msg->recurrent_param_; +} +const ::opencv_caffe::ReductionParameter& +LayerParameter::_Internal::reduction_param(const LayerParameter* msg) { + return *msg->reduction_param_; +} +const ::opencv_caffe::ReLUParameter& +LayerParameter::_Internal::relu_param(const LayerParameter* msg) { + return *msg->relu_param_; +} +const ::opencv_caffe::ReshapeParameter& +LayerParameter::_Internal::reshape_param(const LayerParameter* msg) { + return *msg->reshape_param_; +} +const ::opencv_caffe::ROIPoolingParameter& +LayerParameter::_Internal::roi_pooling_param(const LayerParameter* msg) { + return *msg->roi_pooling_param_; +} +const ::opencv_caffe::ScaleParameter& +LayerParameter::_Internal::scale_param(const LayerParameter* msg) { + return *msg->scale_param_; +} +const ::opencv_caffe::SigmoidParameter& +LayerParameter::_Internal::sigmoid_param(const LayerParameter* msg) { + return *msg->sigmoid_param_; +} +const ::opencv_caffe::SoftmaxParameter& +LayerParameter::_Internal::softmax_param(const LayerParameter* msg) { + return *msg->softmax_param_; +} +const ::opencv_caffe::SPPParameter& +LayerParameter::_Internal::spp_param(const LayerParameter* msg) { + return *msg->spp_param_; +} +const ::opencv_caffe::SliceParameter& +LayerParameter::_Internal::slice_param(const LayerParameter* msg) { + return *msg->slice_param_; +} +const ::opencv_caffe::TanHParameter& +LayerParameter::_Internal::tanh_param(const LayerParameter* msg) { + return *msg->tanh_param_; +} +const ::opencv_caffe::ThresholdParameter& +LayerParameter::_Internal::threshold_param(const LayerParameter* msg) { + return *msg->threshold_param_; +} +const ::opencv_caffe::TileParameter& +LayerParameter::_Internal::tile_param(const LayerParameter* msg) { + return *msg->tile_param_; +} +const ::opencv_caffe::WindowDataParameter& +LayerParameter::_Internal::window_data_param(const LayerParameter* msg) { + return *msg->window_data_param_; +} +LayerParameter::LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + bottom_(arena), + top_(arena), + loss_weight_(arena), + param_(arena), + blobs_(arena), + include_(arena), + exclude_(arena), + propagate_down_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.LayerParameter) +} +LayerParameter::LayerParameter(const LayerParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + bottom_(from.bottom_), + top_(from.top_), + loss_weight_(from.loss_weight_), + param_(from.param_), + blobs_(from.blobs_), + include_(from.include_), + exclude_(from.exclude_), + propagate_down_(from.propagate_down_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArenaForAllocation()); + } + type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_type()) { + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_type(), + GetArenaForAllocation()); + } + if (from._internal_has_transform_param()) { + transform_param_ = new ::opencv_caffe::TransformationParameter(*from.transform_param_); + } else { + transform_param_ = nullptr; + } + if (from._internal_has_loss_param()) { + loss_param_ = new ::opencv_caffe::LossParameter(*from.loss_param_); + } else { + loss_param_ = nullptr; + } + if (from._internal_has_accuracy_param()) { + accuracy_param_ = new ::opencv_caffe::AccuracyParameter(*from.accuracy_param_); + } else { + accuracy_param_ = nullptr; + } + if (from._internal_has_argmax_param()) { + argmax_param_ = new ::opencv_caffe::ArgMaxParameter(*from.argmax_param_); + } else { + argmax_param_ = nullptr; + } + if (from._internal_has_concat_param()) { + concat_param_ = new ::opencv_caffe::ConcatParameter(*from.concat_param_); + } else { + concat_param_ = nullptr; + } + if (from._internal_has_contrastive_loss_param()) { + contrastive_loss_param_ = new ::opencv_caffe::ContrastiveLossParameter(*from.contrastive_loss_param_); + } else { + contrastive_loss_param_ = nullptr; + } + if (from._internal_has_convolution_param()) { + convolution_param_ = new ::opencv_caffe::ConvolutionParameter(*from.convolution_param_); + } else { + convolution_param_ = nullptr; + } + if (from._internal_has_data_param()) { + data_param_ = new ::opencv_caffe::DataParameter(*from.data_param_); + } else { + data_param_ = nullptr; + } + if (from._internal_has_dropout_param()) { + dropout_param_ = new ::opencv_caffe::DropoutParameter(*from.dropout_param_); + } else { + dropout_param_ = nullptr; + } + if (from._internal_has_dummy_data_param()) { + dummy_data_param_ = new ::opencv_caffe::DummyDataParameter(*from.dummy_data_param_); + } else { + dummy_data_param_ = nullptr; + } + if (from._internal_has_eltwise_param()) { + eltwise_param_ = new ::opencv_caffe::EltwiseParameter(*from.eltwise_param_); + } else { + eltwise_param_ = nullptr; + } + if (from._internal_has_exp_param()) { + exp_param_ = new ::opencv_caffe::ExpParameter(*from.exp_param_); + } else { + exp_param_ = nullptr; + } + if (from._internal_has_hdf5_data_param()) { + hdf5_data_param_ = new ::opencv_caffe::HDF5DataParameter(*from.hdf5_data_param_); + } else { + hdf5_data_param_ = nullptr; + } + if (from._internal_has_hdf5_output_param()) { + hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_); + } else { + hdf5_output_param_ = nullptr; + } + if (from._internal_has_hinge_loss_param()) { + hinge_loss_param_ = new ::opencv_caffe::HingeLossParameter(*from.hinge_loss_param_); + } else { + hinge_loss_param_ = nullptr; + } + if (from._internal_has_image_data_param()) { + image_data_param_ = new ::opencv_caffe::ImageDataParameter(*from.image_data_param_); + } else { + image_data_param_ = nullptr; + } + if (from._internal_has_infogain_loss_param()) { + infogain_loss_param_ = new ::opencv_caffe::InfogainLossParameter(*from.infogain_loss_param_); + } else { + infogain_loss_param_ = nullptr; + } + if (from._internal_has_inner_product_param()) { + inner_product_param_ = new ::opencv_caffe::InnerProductParameter(*from.inner_product_param_); + } else { + inner_product_param_ = nullptr; + } + if (from._internal_has_lrn_param()) { + lrn_param_ = new ::opencv_caffe::LRNParameter(*from.lrn_param_); + } else { + lrn_param_ = nullptr; + } + if (from._internal_has_memory_data_param()) { + memory_data_param_ = new ::opencv_caffe::MemoryDataParameter(*from.memory_data_param_); + } else { + memory_data_param_ = nullptr; + } + if (from._internal_has_mvn_param()) { + mvn_param_ = new ::opencv_caffe::MVNParameter(*from.mvn_param_); + } else { + mvn_param_ = nullptr; + } + if (from._internal_has_pooling_param()) { + pooling_param_ = new ::opencv_caffe::PoolingParameter(*from.pooling_param_); + } else { + pooling_param_ = nullptr; + } + if (from._internal_has_power_param()) { + power_param_ = new ::opencv_caffe::PowerParameter(*from.power_param_); + } else { + power_param_ = nullptr; + } + if (from._internal_has_relu_param()) { + relu_param_ = new ::opencv_caffe::ReLUParameter(*from.relu_param_); + } else { + relu_param_ = nullptr; + } + if (from._internal_has_sigmoid_param()) { + sigmoid_param_ = new ::opencv_caffe::SigmoidParameter(*from.sigmoid_param_); + } else { + sigmoid_param_ = nullptr; + } + if (from._internal_has_softmax_param()) { + softmax_param_ = new ::opencv_caffe::SoftmaxParameter(*from.softmax_param_); + } else { + softmax_param_ = nullptr; + } + if (from._internal_has_slice_param()) { + slice_param_ = new ::opencv_caffe::SliceParameter(*from.slice_param_); + } else { + slice_param_ = nullptr; + } + if (from._internal_has_tanh_param()) { + tanh_param_ = new ::opencv_caffe::TanHParameter(*from.tanh_param_); + } else { + tanh_param_ = nullptr; + } + if (from._internal_has_threshold_param()) { + threshold_param_ = new ::opencv_caffe::ThresholdParameter(*from.threshold_param_); + } else { + threshold_param_ = nullptr; + } + if (from._internal_has_window_data_param()) { + window_data_param_ = new ::opencv_caffe::WindowDataParameter(*from.window_data_param_); + } else { + window_data_param_ = nullptr; + } + if (from._internal_has_python_param()) { + python_param_ = new ::opencv_caffe::PythonParameter(*from.python_param_); + } else { + python_param_ = nullptr; + } + if (from._internal_has_prelu_param()) { + prelu_param_ = new ::opencv_caffe::PReLUParameter(*from.prelu_param_); + } else { + prelu_param_ = nullptr; + } + if (from._internal_has_spp_param()) { + spp_param_ = new ::opencv_caffe::SPPParameter(*from.spp_param_); + } else { + spp_param_ = nullptr; + } + if (from._internal_has_reshape_param()) { + reshape_param_ = new ::opencv_caffe::ReshapeParameter(*from.reshape_param_); + } else { + reshape_param_ = nullptr; + } + if (from._internal_has_log_param()) { + log_param_ = new ::opencv_caffe::LogParameter(*from.log_param_); + } else { + log_param_ = nullptr; + } + if (from._internal_has_flatten_param()) { + flatten_param_ = new ::opencv_caffe::FlattenParameter(*from.flatten_param_); + } else { + flatten_param_ = nullptr; + } + if (from._internal_has_reduction_param()) { + reduction_param_ = new ::opencv_caffe::ReductionParameter(*from.reduction_param_); + } else { + reduction_param_ = nullptr; + } + if (from._internal_has_embed_param()) { + embed_param_ = new ::opencv_caffe::EmbedParameter(*from.embed_param_); + } else { + embed_param_ = nullptr; + } + if (from._internal_has_tile_param()) { + tile_param_ = new ::opencv_caffe::TileParameter(*from.tile_param_); + } else { + tile_param_ = nullptr; + } + if (from._internal_has_batch_norm_param()) { + batch_norm_param_ = new ::opencv_caffe::BatchNormParameter(*from.batch_norm_param_); + } else { + batch_norm_param_ = nullptr; + } + if (from._internal_has_elu_param()) { + elu_param_ = new ::opencv_caffe::ELUParameter(*from.elu_param_); + } else { + elu_param_ = nullptr; + } + if (from._internal_has_bias_param()) { + bias_param_ = new ::opencv_caffe::BiasParameter(*from.bias_param_); + } else { + bias_param_ = nullptr; + } + if (from._internal_has_scale_param()) { + scale_param_ = new ::opencv_caffe::ScaleParameter(*from.scale_param_); + } else { + scale_param_ = nullptr; + } + if (from._internal_has_input_param()) { + input_param_ = new ::opencv_caffe::InputParameter(*from.input_param_); + } else { + input_param_ = nullptr; + } + if (from._internal_has_crop_param()) { + crop_param_ = new ::opencv_caffe::CropParameter(*from.crop_param_); + } else { + crop_param_ = nullptr; + } + if (from._internal_has_parameter_param()) { + parameter_param_ = new ::opencv_caffe::ParameterParameter(*from.parameter_param_); + } else { + parameter_param_ = nullptr; + } + if (from._internal_has_recurrent_param()) { + recurrent_param_ = new ::opencv_caffe::RecurrentParameter(*from.recurrent_param_); + } else { + recurrent_param_ = nullptr; + } + if (from._internal_has_detection_output_param()) { + detection_output_param_ = new ::opencv_caffe::DetectionOutputParameter(*from.detection_output_param_); + } else { + detection_output_param_ = nullptr; + } + if (from._internal_has_permute_param()) { + permute_param_ = new ::opencv_caffe::PermuteParameter(*from.permute_param_); + } else { + permute_param_ = nullptr; + } + if (from._internal_has_norm_param()) { + norm_param_ = new ::opencv_caffe::NormalizeBBoxParameter(*from.norm_param_); + } else { + norm_param_ = nullptr; + } + if (from._internal_has_prior_box_param()) { + prior_box_param_ = new ::opencv_caffe::PriorBoxParameter(*from.prior_box_param_); + } else { + prior_box_param_ = nullptr; + } + if (from._internal_has_proposal_param()) { + proposal_param_ = new ::opencv_caffe::ProposalParameter(*from.proposal_param_); + } else { + proposal_param_ = nullptr; + } + if (from._internal_has_psroi_pooling_param()) { + psroi_pooling_param_ = new ::opencv_caffe::PSROIPoolingParameter(*from.psroi_pooling_param_); + } else { + psroi_pooling_param_ = nullptr; + } + if (from._internal_has_roi_pooling_param()) { + roi_pooling_param_ = new ::opencv_caffe::ROIPoolingParameter(*from.roi_pooling_param_); + } else { + roi_pooling_param_ = nullptr; + } + phase_ = from.phase_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.LayerParameter) +} + +inline void LayerParameter::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&transform_param_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&transform_param_)) + sizeof(phase_)); +} + +LayerParameter::~LayerParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.LayerParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void LayerParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete transform_param_; + if (this != internal_default_instance()) delete loss_param_; + if (this != internal_default_instance()) delete accuracy_param_; + if (this != internal_default_instance()) delete argmax_param_; + if (this != internal_default_instance()) delete concat_param_; + if (this != internal_default_instance()) delete contrastive_loss_param_; + if (this != internal_default_instance()) delete convolution_param_; + if (this != internal_default_instance()) delete data_param_; + if (this != internal_default_instance()) delete dropout_param_; + if (this != internal_default_instance()) delete dummy_data_param_; + if (this != internal_default_instance()) delete eltwise_param_; + if (this != internal_default_instance()) delete exp_param_; + if (this != internal_default_instance()) delete hdf5_data_param_; + if (this != internal_default_instance()) delete hdf5_output_param_; + if (this != internal_default_instance()) delete hinge_loss_param_; + if (this != internal_default_instance()) delete image_data_param_; + if (this != internal_default_instance()) delete infogain_loss_param_; + if (this != internal_default_instance()) delete inner_product_param_; + if (this != internal_default_instance()) delete lrn_param_; + if (this != internal_default_instance()) delete memory_data_param_; + if (this != internal_default_instance()) delete mvn_param_; + if (this != internal_default_instance()) delete pooling_param_; + if (this != internal_default_instance()) delete power_param_; + if (this != internal_default_instance()) delete relu_param_; + if (this != internal_default_instance()) delete sigmoid_param_; + if (this != internal_default_instance()) delete softmax_param_; + if (this != internal_default_instance()) delete slice_param_; + if (this != internal_default_instance()) delete tanh_param_; + if (this != internal_default_instance()) delete threshold_param_; + if (this != internal_default_instance()) delete window_data_param_; + if (this != internal_default_instance()) delete python_param_; + if (this != internal_default_instance()) delete prelu_param_; + if (this != internal_default_instance()) delete spp_param_; + if (this != internal_default_instance()) delete reshape_param_; + if (this != internal_default_instance()) delete log_param_; + if (this != internal_default_instance()) delete flatten_param_; + if (this != internal_default_instance()) delete reduction_param_; + if (this != internal_default_instance()) delete embed_param_; + if (this != internal_default_instance()) delete tile_param_; + if (this != internal_default_instance()) delete batch_norm_param_; + if (this != internal_default_instance()) delete elu_param_; + if (this != internal_default_instance()) delete bias_param_; + if (this != internal_default_instance()) delete scale_param_; + if (this != internal_default_instance()) delete input_param_; + if (this != internal_default_instance()) delete crop_param_; + if (this != internal_default_instance()) delete parameter_param_; + if (this != internal_default_instance()) delete recurrent_param_; + if (this != internal_default_instance()) delete detection_output_param_; + if (this != internal_default_instance()) delete permute_param_; + if (this != internal_default_instance()) delete norm_param_; + if (this != internal_default_instance()) delete prior_box_param_; + if (this != internal_default_instance()) delete proposal_param_; + if (this != internal_default_instance()) delete psroi_pooling_param_; + if (this != internal_default_instance()) delete roi_pooling_param_; +} + +void LayerParameter::ArenaDtor(void* object) { + LayerParameter* _this = reinterpret_cast< LayerParameter* >(object); + (void)_this; +} +void LayerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void LayerParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void LayerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.LayerParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + bottom_.Clear(); + top_.Clear(); + loss_weight_.Clear(); + param_.Clear(); + blobs_.Clear(); + include_.Clear(); + exclude_.Clear(); + propagate_down_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + type_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(transform_param_ != nullptr); + transform_param_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(loss_param_ != nullptr); + loss_param_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(accuracy_param_ != nullptr); + accuracy_param_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(argmax_param_ != nullptr); + argmax_param_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(concat_param_ != nullptr); + concat_param_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(contrastive_loss_param_ != nullptr); + contrastive_loss_param_->Clear(); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(convolution_param_ != nullptr); + convolution_param_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(data_param_ != nullptr); + data_param_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(dropout_param_ != nullptr); + dropout_param_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(dummy_data_param_ != nullptr); + dummy_data_param_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(eltwise_param_ != nullptr); + eltwise_param_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(exp_param_ != nullptr); + exp_param_->Clear(); + } + if (cached_has_bits & 0x00004000u) { + GOOGLE_DCHECK(hdf5_data_param_ != nullptr); + hdf5_data_param_->Clear(); + } + if (cached_has_bits & 0x00008000u) { + GOOGLE_DCHECK(hdf5_output_param_ != nullptr); + hdf5_output_param_->Clear(); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + GOOGLE_DCHECK(hinge_loss_param_ != nullptr); + hinge_loss_param_->Clear(); + } + if (cached_has_bits & 0x00020000u) { + GOOGLE_DCHECK(image_data_param_ != nullptr); + image_data_param_->Clear(); + } + if (cached_has_bits & 0x00040000u) { + GOOGLE_DCHECK(infogain_loss_param_ != nullptr); + infogain_loss_param_->Clear(); + } + if (cached_has_bits & 0x00080000u) { + GOOGLE_DCHECK(inner_product_param_ != nullptr); + inner_product_param_->Clear(); + } + if (cached_has_bits & 0x00100000u) { + GOOGLE_DCHECK(lrn_param_ != nullptr); + lrn_param_->Clear(); + } + if (cached_has_bits & 0x00200000u) { + GOOGLE_DCHECK(memory_data_param_ != nullptr); + memory_data_param_->Clear(); + } + if (cached_has_bits & 0x00400000u) { + GOOGLE_DCHECK(mvn_param_ != nullptr); + mvn_param_->Clear(); + } + if (cached_has_bits & 0x00800000u) { + GOOGLE_DCHECK(pooling_param_ != nullptr); + pooling_param_->Clear(); + } + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + GOOGLE_DCHECK(power_param_ != nullptr); + power_param_->Clear(); + } + if (cached_has_bits & 0x02000000u) { + GOOGLE_DCHECK(relu_param_ != nullptr); + relu_param_->Clear(); + } + if (cached_has_bits & 0x04000000u) { + GOOGLE_DCHECK(sigmoid_param_ != nullptr); + sigmoid_param_->Clear(); + } + if (cached_has_bits & 0x08000000u) { + GOOGLE_DCHECK(softmax_param_ != nullptr); + softmax_param_->Clear(); + } + if (cached_has_bits & 0x10000000u) { + GOOGLE_DCHECK(slice_param_ != nullptr); + slice_param_->Clear(); + } + if (cached_has_bits & 0x20000000u) { + GOOGLE_DCHECK(tanh_param_ != nullptr); + tanh_param_->Clear(); + } + if (cached_has_bits & 0x40000000u) { + GOOGLE_DCHECK(threshold_param_ != nullptr); + threshold_param_->Clear(); + } + if (cached_has_bits & 0x80000000u) { + GOOGLE_DCHECK(window_data_param_ != nullptr); + window_data_param_->Clear(); + } + } + cached_has_bits = _has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(python_param_ != nullptr); + python_param_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(prelu_param_ != nullptr); + prelu_param_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(spp_param_ != nullptr); + spp_param_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(reshape_param_ != nullptr); + reshape_param_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(log_param_ != nullptr); + log_param_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(flatten_param_ != nullptr); + flatten_param_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(reduction_param_ != nullptr); + reduction_param_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(embed_param_ != nullptr); + embed_param_->Clear(); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(tile_param_ != nullptr); + tile_param_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(batch_norm_param_ != nullptr); + batch_norm_param_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(elu_param_ != nullptr); + elu_param_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(bias_param_ != nullptr); + bias_param_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(scale_param_ != nullptr); + scale_param_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(input_param_ != nullptr); + input_param_->Clear(); + } + if (cached_has_bits & 0x00004000u) { + GOOGLE_DCHECK(crop_param_ != nullptr); + crop_param_->Clear(); + } + if (cached_has_bits & 0x00008000u) { + GOOGLE_DCHECK(parameter_param_ != nullptr); + parameter_param_->Clear(); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + GOOGLE_DCHECK(recurrent_param_ != nullptr); + recurrent_param_->Clear(); + } + if (cached_has_bits & 0x00020000u) { + GOOGLE_DCHECK(detection_output_param_ != nullptr); + detection_output_param_->Clear(); + } + if (cached_has_bits & 0x00040000u) { + GOOGLE_DCHECK(permute_param_ != nullptr); + permute_param_->Clear(); + } + if (cached_has_bits & 0x00080000u) { + GOOGLE_DCHECK(norm_param_ != nullptr); + norm_param_->Clear(); + } + if (cached_has_bits & 0x00100000u) { + GOOGLE_DCHECK(prior_box_param_ != nullptr); + prior_box_param_->Clear(); + } + if (cached_has_bits & 0x00200000u) { + GOOGLE_DCHECK(proposal_param_ != nullptr); + proposal_param_->Clear(); + } + if (cached_has_bits & 0x00400000u) { + GOOGLE_DCHECK(psroi_pooling_param_ != nullptr); + psroi_pooling_param_->Clear(); + } + if (cached_has_bits & 0x00800000u) { + GOOGLE_DCHECK(roi_pooling_param_ != nullptr); + roi_pooling_param_->Clear(); + } + } + phase_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LayerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.LayerParameter.name"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_type(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.LayerParameter.type"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string bottom = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_bottom(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.LayerParameter.bottom"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string top = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_top(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.LayerParameter.top"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + // repeated float loss_weight = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_loss_weight(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr)); + } else if (static_cast(tag) == 42) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_loss_weight(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.ParamSpec param = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_param(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.BlobProto blobs = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_blobs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.NetStateRule include = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_include(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.NetStateRule exclude = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_exclude(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.Phase phase = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::Phase_IsValid(val))) { + _internal_set_phase(static_cast<::opencv_caffe::Phase>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // repeated bool propagate_down = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_propagate_down(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<88>(ptr)); + } else if (static_cast(tag) == 90) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedBoolParser(_internal_mutable_propagate_down(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.TransformationParameter transform_param = 100; + case 100: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_transform_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.LossParameter loss_param = 101; + case 101: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_loss_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.AccuracyParameter accuracy_param = 102; + case 102: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_accuracy_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ArgMaxParameter argmax_param = 103; + case 103: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_argmax_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ConcatParameter concat_param = 104; + case 104: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_concat_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105; + case 105: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_contrastive_loss_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ConvolutionParameter convolution_param = 106; + case 106: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_convolution_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.DataParameter data_param = 107; + case 107: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.DropoutParameter dropout_param = 108; + case 108: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_dropout_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109; + case 109: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_dummy_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.EltwiseParameter eltwise_param = 110; + case 110: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_eltwise_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ExpParameter exp_param = 111; + case 111: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_exp_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112; + case 112: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_hdf5_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113; + case 113: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_hdf5_output_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114; + case 114: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_hinge_loss_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ImageDataParameter image_data_param = 115; + case 115: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_image_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116; + case 116: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_infogain_loss_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.InnerProductParameter inner_product_param = 117; + case 117: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_inner_product_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.LRNParameter lrn_param = 118; + case 118: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_lrn_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119; + case 119: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_memory_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.MVNParameter mvn_param = 120; + case 120: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_mvn_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PoolingParameter pooling_param = 121; + case 121: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_pooling_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PowerParameter power_param = 122; + case 122: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { + ptr = ctx->ParseMessage(_internal_mutable_power_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ReLUParameter relu_param = 123; + case 123: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + ptr = ctx->ParseMessage(_internal_mutable_relu_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124; + case 124: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { + ptr = ctx->ParseMessage(_internal_mutable_sigmoid_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SoftmaxParameter softmax_param = 125; + case 125: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_softmax_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SliceParameter slice_param = 126; + case 126: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { + ptr = ctx->ParseMessage(_internal_mutable_slice_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.TanHParameter tanh_param = 127; + case 127: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_tanh_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ThresholdParameter threshold_param = 128; + case 128: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { + ptr = ctx->ParseMessage(_internal_mutable_threshold_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.WindowDataParameter window_data_param = 129; + case 129: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_window_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PythonParameter python_param = 130; + case 130: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_python_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PReLUParameter prelu_param = 131; + case 131: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_prelu_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SPPParameter spp_param = 132; + case 132: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_spp_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ReshapeParameter reshape_param = 133; + case 133: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_reshape_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.LogParameter log_param = 134; + case 134: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_log_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FlattenParameter flatten_param = 135; + case 135: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_flatten_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ReductionParameter reduction_param = 136; + case 136: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_reduction_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.EmbedParameter embed_param = 137; + case 137: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_embed_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.TileParameter tile_param = 138; + case 138: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_tile_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139; + case 139: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_batch_norm_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ELUParameter elu_param = 140; + case 140: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_elu_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.BiasParameter bias_param = 141; + case 141: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_bias_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ScaleParameter scale_param = 142; + case 142: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_scale_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.InputParameter input_param = 143; + case 143: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_input_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.CropParameter crop_param = 144; + case 144: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_crop_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ParameterParameter parameter_param = 145; + case 145: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_parameter_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.RecurrentParameter recurrent_param = 146; + case 146: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_recurrent_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147; + case 147: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_detection_output_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PermuteParameter permute_param = 148; + case 148: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_permute_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149; + case 149: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_norm_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150; + case 150: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_prior_box_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ProposalParameter proposal_param = 201; + case 201: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_proposal_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002; + case 10002: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_psroi_pooling_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711; + case 8266711: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_roi_pooling_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* LayerParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LayerParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.LayerParameter.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional string type = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_type().data(), static_cast(this->_internal_type().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.LayerParameter.type"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_type(), target); + } + + // repeated string bottom = 3; + for (int i = 0, n = this->_internal_bottom_size(); i < n; i++) { + const auto& s = this->_internal_bottom(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.LayerParameter.bottom"); + target = stream->WriteString(3, s, target); + } + + // repeated string top = 4; + for (int i = 0, n = this->_internal_top_size(); i < n; i++) { + const auto& s = this->_internal_top(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.LayerParameter.top"); + target = stream->WriteString(4, s, target); + } + + // repeated float loss_weight = 5; + for (int i = 0, n = this->_internal_loss_weight_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_loss_weight(i), target); + } + + // repeated .opencv_caffe.ParamSpec param = 6; + for (unsigned int i = 0, + n = static_cast(this->_internal_param_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, this->_internal_param(i), target, stream); + } + + // repeated .opencv_caffe.BlobProto blobs = 7; + for (unsigned int i = 0, + n = static_cast(this->_internal_blobs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, this->_internal_blobs(i), target, stream); + } + + // repeated .opencv_caffe.NetStateRule include = 8; + for (unsigned int i = 0, + n = static_cast(this->_internal_include_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, this->_internal_include(i), target, stream); + } + + // repeated .opencv_caffe.NetStateRule exclude = 9; + for (unsigned int i = 0, + n = static_cast(this->_internal_exclude_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(9, this->_internal_exclude(i), target, stream); + } + + cached_has_bits = _has_bits_[1]; + // optional .opencv_caffe.Phase phase = 10; + if (cached_has_bits & 0x01000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 10, this->_internal_phase(), target); + } + + // repeated bool propagate_down = 11; + for (int i = 0, n = this->_internal_propagate_down_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_propagate_down(i), target); + } + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.TransformationParameter transform_param = 100; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 100, _Internal::transform_param(this), target, stream); + } + + // optional .opencv_caffe.LossParameter loss_param = 101; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 101, _Internal::loss_param(this), target, stream); + } + + // optional .opencv_caffe.AccuracyParameter accuracy_param = 102; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 102, _Internal::accuracy_param(this), target, stream); + } + + // optional .opencv_caffe.ArgMaxParameter argmax_param = 103; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 103, _Internal::argmax_param(this), target, stream); + } + + // optional .opencv_caffe.ConcatParameter concat_param = 104; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 104, _Internal::concat_param(this), target, stream); + } + + // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 105, _Internal::contrastive_loss_param(this), target, stream); + } + + // optional .opencv_caffe.ConvolutionParameter convolution_param = 106; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 106, _Internal::convolution_param(this), target, stream); + } + + // optional .opencv_caffe.DataParameter data_param = 107; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 107, _Internal::data_param(this), target, stream); + } + + // optional .opencv_caffe.DropoutParameter dropout_param = 108; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 108, _Internal::dropout_param(this), target, stream); + } + + // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 109, _Internal::dummy_data_param(this), target, stream); + } + + // optional .opencv_caffe.EltwiseParameter eltwise_param = 110; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 110, _Internal::eltwise_param(this), target, stream); + } + + // optional .opencv_caffe.ExpParameter exp_param = 111; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 111, _Internal::exp_param(this), target, stream); + } + + // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 112, _Internal::hdf5_data_param(this), target, stream); + } + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 113, _Internal::hdf5_output_param(this), target, stream); + } + + // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 114, _Internal::hinge_loss_param(this), target, stream); + } + + // optional .opencv_caffe.ImageDataParameter image_data_param = 115; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 115, _Internal::image_data_param(this), target, stream); + } + + // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 116, _Internal::infogain_loss_param(this), target, stream); + } + + // optional .opencv_caffe.InnerProductParameter inner_product_param = 117; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 117, _Internal::inner_product_param(this), target, stream); + } + + // optional .opencv_caffe.LRNParameter lrn_param = 118; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 118, _Internal::lrn_param(this), target, stream); + } + + // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 119, _Internal::memory_data_param(this), target, stream); + } + + // optional .opencv_caffe.MVNParameter mvn_param = 120; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 120, _Internal::mvn_param(this), target, stream); + } + + // optional .opencv_caffe.PoolingParameter pooling_param = 121; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 121, _Internal::pooling_param(this), target, stream); + } + + // optional .opencv_caffe.PowerParameter power_param = 122; + if (cached_has_bits & 0x01000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 122, _Internal::power_param(this), target, stream); + } + + // optional .opencv_caffe.ReLUParameter relu_param = 123; + if (cached_has_bits & 0x02000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 123, _Internal::relu_param(this), target, stream); + } + + // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124; + if (cached_has_bits & 0x04000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 124, _Internal::sigmoid_param(this), target, stream); + } + + // optional .opencv_caffe.SoftmaxParameter softmax_param = 125; + if (cached_has_bits & 0x08000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 125, _Internal::softmax_param(this), target, stream); + } + + // optional .opencv_caffe.SliceParameter slice_param = 126; + if (cached_has_bits & 0x10000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 126, _Internal::slice_param(this), target, stream); + } + + // optional .opencv_caffe.TanHParameter tanh_param = 127; + if (cached_has_bits & 0x20000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 127, _Internal::tanh_param(this), target, stream); + } + + // optional .opencv_caffe.ThresholdParameter threshold_param = 128; + if (cached_has_bits & 0x40000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 128, _Internal::threshold_param(this), target, stream); + } + + // optional .opencv_caffe.WindowDataParameter window_data_param = 129; + if (cached_has_bits & 0x80000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 129, _Internal::window_data_param(this), target, stream); + } + + cached_has_bits = _has_bits_[1]; + // optional .opencv_caffe.PythonParameter python_param = 130; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 130, _Internal::python_param(this), target, stream); + } + + // optional .opencv_caffe.PReLUParameter prelu_param = 131; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 131, _Internal::prelu_param(this), target, stream); + } + + // optional .opencv_caffe.SPPParameter spp_param = 132; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 132, _Internal::spp_param(this), target, stream); + } + + // optional .opencv_caffe.ReshapeParameter reshape_param = 133; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 133, _Internal::reshape_param(this), target, stream); + } + + // optional .opencv_caffe.LogParameter log_param = 134; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 134, _Internal::log_param(this), target, stream); + } + + // optional .opencv_caffe.FlattenParameter flatten_param = 135; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 135, _Internal::flatten_param(this), target, stream); + } + + // optional .opencv_caffe.ReductionParameter reduction_param = 136; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 136, _Internal::reduction_param(this), target, stream); + } + + // optional .opencv_caffe.EmbedParameter embed_param = 137; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 137, _Internal::embed_param(this), target, stream); + } + + // optional .opencv_caffe.TileParameter tile_param = 138; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 138, _Internal::tile_param(this), target, stream); + } + + // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 139, _Internal::batch_norm_param(this), target, stream); + } + + // optional .opencv_caffe.ELUParameter elu_param = 140; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 140, _Internal::elu_param(this), target, stream); + } + + // optional .opencv_caffe.BiasParameter bias_param = 141; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 141, _Internal::bias_param(this), target, stream); + } + + // optional .opencv_caffe.ScaleParameter scale_param = 142; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 142, _Internal::scale_param(this), target, stream); + } + + // optional .opencv_caffe.InputParameter input_param = 143; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 143, _Internal::input_param(this), target, stream); + } + + // optional .opencv_caffe.CropParameter crop_param = 144; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 144, _Internal::crop_param(this), target, stream); + } + + // optional .opencv_caffe.ParameterParameter parameter_param = 145; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 145, _Internal::parameter_param(this), target, stream); + } + + // optional .opencv_caffe.RecurrentParameter recurrent_param = 146; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 146, _Internal::recurrent_param(this), target, stream); + } + + // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 147, _Internal::detection_output_param(this), target, stream); + } + + // optional .opencv_caffe.PermuteParameter permute_param = 148; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 148, _Internal::permute_param(this), target, stream); + } + + // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 149, _Internal::norm_param(this), target, stream); + } + + // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 150, _Internal::prior_box_param(this), target, stream); + } + + // optional .opencv_caffe.ProposalParameter proposal_param = 201; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 201, _Internal::proposal_param(this), target, stream); + } + + // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10002, _Internal::psroi_pooling_param(this), target, stream); + } + + // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8266711, _Internal::roi_pooling_param(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LayerParameter) + return target; +} + +size_t LayerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LayerParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string bottom = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(bottom_.size()); + for (int i = 0, n = bottom_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + bottom_.Get(i)); + } + + // repeated string top = 4; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(top_.size()); + for (int i = 0, n = top_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + top_.Get(i)); + } + + // repeated float loss_weight = 5; + { + unsigned int count = static_cast(this->_internal_loss_weight_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_loss_weight_size()); + total_size += data_size; + } + + // repeated .opencv_caffe.ParamSpec param = 6; + total_size += 1UL * this->_internal_param_size(); + for (const auto& msg : this->param_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .opencv_caffe.BlobProto blobs = 7; + total_size += 1UL * this->_internal_blobs_size(); + for (const auto& msg : this->blobs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .opencv_caffe.NetStateRule include = 8; + total_size += 1UL * this->_internal_include_size(); + for (const auto& msg : this->include_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .opencv_caffe.NetStateRule exclude = 9; + total_size += 1UL * this->_internal_exclude_size(); + for (const auto& msg : this->exclude_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated bool propagate_down = 11; + { + unsigned int count = static_cast(this->_internal_propagate_down_size()); + size_t data_size = 1UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_propagate_down_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string type = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_type()); + } + + // optional .opencv_caffe.TransformationParameter transform_param = 100; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *transform_param_); + } + + // optional .opencv_caffe.LossParameter loss_param = 101; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *loss_param_); + } + + // optional .opencv_caffe.AccuracyParameter accuracy_param = 102; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *accuracy_param_); + } + + // optional .opencv_caffe.ArgMaxParameter argmax_param = 103; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *argmax_param_); + } + + // optional .opencv_caffe.ConcatParameter concat_param = 104; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *concat_param_); + } + + // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *contrastive_loss_param_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .opencv_caffe.ConvolutionParameter convolution_param = 106; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *convolution_param_); + } + + // optional .opencv_caffe.DataParameter data_param = 107; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *data_param_); + } + + // optional .opencv_caffe.DropoutParameter dropout_param = 108; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *dropout_param_); + } + + // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *dummy_data_param_); + } + + // optional .opencv_caffe.EltwiseParameter eltwise_param = 110; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *eltwise_param_); + } + + // optional .opencv_caffe.ExpParameter exp_param = 111; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *exp_param_); + } + + // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hdf5_data_param_); + } + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hdf5_output_param_); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hinge_loss_param_); + } + + // optional .opencv_caffe.ImageDataParameter image_data_param = 115; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *image_data_param_); + } + + // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *infogain_loss_param_); + } + + // optional .opencv_caffe.InnerProductParameter inner_product_param = 117; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *inner_product_param_); + } + + // optional .opencv_caffe.LRNParameter lrn_param = 118; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *lrn_param_); + } + + // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *memory_data_param_); + } + + // optional .opencv_caffe.MVNParameter mvn_param = 120; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mvn_param_); + } + + // optional .opencv_caffe.PoolingParameter pooling_param = 121; + if (cached_has_bits & 0x00800000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *pooling_param_); + } + + } + if (cached_has_bits & 0xff000000u) { + // optional .opencv_caffe.PowerParameter power_param = 122; + if (cached_has_bits & 0x01000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *power_param_); + } + + // optional .opencv_caffe.ReLUParameter relu_param = 123; + if (cached_has_bits & 0x02000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *relu_param_); + } + + // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124; + if (cached_has_bits & 0x04000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *sigmoid_param_); + } + + // optional .opencv_caffe.SoftmaxParameter softmax_param = 125; + if (cached_has_bits & 0x08000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *softmax_param_); + } + + // optional .opencv_caffe.SliceParameter slice_param = 126; + if (cached_has_bits & 0x10000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *slice_param_); + } + + // optional .opencv_caffe.TanHParameter tanh_param = 127; + if (cached_has_bits & 0x20000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *tanh_param_); + } + + // optional .opencv_caffe.ThresholdParameter threshold_param = 128; + if (cached_has_bits & 0x40000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *threshold_param_); + } + + // optional .opencv_caffe.WindowDataParameter window_data_param = 129; + if (cached_has_bits & 0x80000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *window_data_param_); + } + + } + cached_has_bits = _has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + // optional .opencv_caffe.PythonParameter python_param = 130; + if (cached_has_bits & 0x00000001u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *python_param_); + } + + // optional .opencv_caffe.PReLUParameter prelu_param = 131; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *prelu_param_); + } + + // optional .opencv_caffe.SPPParameter spp_param = 132; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *spp_param_); + } + + // optional .opencv_caffe.ReshapeParameter reshape_param = 133; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reshape_param_); + } + + // optional .opencv_caffe.LogParameter log_param = 134; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *log_param_); + } + + // optional .opencv_caffe.FlattenParameter flatten_param = 135; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *flatten_param_); + } + + // optional .opencv_caffe.ReductionParameter reduction_param = 136; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reduction_param_); + } + + // optional .opencv_caffe.EmbedParameter embed_param = 137; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *embed_param_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .opencv_caffe.TileParameter tile_param = 138; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *tile_param_); + } + + // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *batch_norm_param_); + } + + // optional .opencv_caffe.ELUParameter elu_param = 140; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *elu_param_); + } + + // optional .opencv_caffe.BiasParameter bias_param = 141; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bias_param_); + } + + // optional .opencv_caffe.ScaleParameter scale_param = 142; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *scale_param_); + } + + // optional .opencv_caffe.InputParameter input_param = 143; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *input_param_); + } + + // optional .opencv_caffe.CropParameter crop_param = 144; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *crop_param_); + } + + // optional .opencv_caffe.ParameterParameter parameter_param = 145; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *parameter_param_); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .opencv_caffe.RecurrentParameter recurrent_param = 146; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *recurrent_param_); + } + + // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *detection_output_param_); + } + + // optional .opencv_caffe.PermuteParameter permute_param = 148; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *permute_param_); + } + + // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *norm_param_); + } + + // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *prior_box_param_); + } + + // optional .opencv_caffe.ProposalParameter proposal_param = 201; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *proposal_param_); + } + + // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002; + if (cached_has_bits & 0x00400000u) { + total_size += 3 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *psroi_pooling_param_); + } + + // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711; + if (cached_has_bits & 0x00800000u) { + total_size += 4 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *roi_pooling_param_); + } + + } + // optional .opencv_caffe.Phase phase = 10; + if (cached_has_bits & 0x01000000u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LayerParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + LayerParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LayerParameter::GetClassData() const { return &_class_data_; } + +void LayerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void LayerParameter::MergeFrom(const LayerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LayerParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + bottom_.MergeFrom(from.bottom_); + top_.MergeFrom(from.top_); + loss_weight_.MergeFrom(from.loss_weight_); + param_.MergeFrom(from.param_); + blobs_.MergeFrom(from.blobs_); + include_.MergeFrom(from.include_); + exclude_.MergeFrom(from.exclude_); + propagate_down_.MergeFrom(from.propagate_down_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_type(from._internal_type()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_transform_param()->::opencv_caffe::TransformationParameter::MergeFrom(from._internal_transform_param()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_loss_param()->::opencv_caffe::LossParameter::MergeFrom(from._internal_loss_param()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_accuracy_param()->::opencv_caffe::AccuracyParameter::MergeFrom(from._internal_accuracy_param()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_argmax_param()->::opencv_caffe::ArgMaxParameter::MergeFrom(from._internal_argmax_param()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_concat_param()->::opencv_caffe::ConcatParameter::MergeFrom(from._internal_concat_param()); + } + if (cached_has_bits & 0x00000080u) { + _internal_mutable_contrastive_loss_param()->::opencv_caffe::ContrastiveLossParameter::MergeFrom(from._internal_contrastive_loss_param()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _internal_mutable_convolution_param()->::opencv_caffe::ConvolutionParameter::MergeFrom(from._internal_convolution_param()); + } + if (cached_has_bits & 0x00000200u) { + _internal_mutable_data_param()->::opencv_caffe::DataParameter::MergeFrom(from._internal_data_param()); + } + if (cached_has_bits & 0x00000400u) { + _internal_mutable_dropout_param()->::opencv_caffe::DropoutParameter::MergeFrom(from._internal_dropout_param()); + } + if (cached_has_bits & 0x00000800u) { + _internal_mutable_dummy_data_param()->::opencv_caffe::DummyDataParameter::MergeFrom(from._internal_dummy_data_param()); + } + if (cached_has_bits & 0x00001000u) { + _internal_mutable_eltwise_param()->::opencv_caffe::EltwiseParameter::MergeFrom(from._internal_eltwise_param()); + } + if (cached_has_bits & 0x00002000u) { + _internal_mutable_exp_param()->::opencv_caffe::ExpParameter::MergeFrom(from._internal_exp_param()); + } + if (cached_has_bits & 0x00004000u) { + _internal_mutable_hdf5_data_param()->::opencv_caffe::HDF5DataParameter::MergeFrom(from._internal_hdf5_data_param()); + } + if (cached_has_bits & 0x00008000u) { + _internal_mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from._internal_hdf5_output_param()); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _internal_mutable_hinge_loss_param()->::opencv_caffe::HingeLossParameter::MergeFrom(from._internal_hinge_loss_param()); + } + if (cached_has_bits & 0x00020000u) { + _internal_mutable_image_data_param()->::opencv_caffe::ImageDataParameter::MergeFrom(from._internal_image_data_param()); + } + if (cached_has_bits & 0x00040000u) { + _internal_mutable_infogain_loss_param()->::opencv_caffe::InfogainLossParameter::MergeFrom(from._internal_infogain_loss_param()); + } + if (cached_has_bits & 0x00080000u) { + _internal_mutable_inner_product_param()->::opencv_caffe::InnerProductParameter::MergeFrom(from._internal_inner_product_param()); + } + if (cached_has_bits & 0x00100000u) { + _internal_mutable_lrn_param()->::opencv_caffe::LRNParameter::MergeFrom(from._internal_lrn_param()); + } + if (cached_has_bits & 0x00200000u) { + _internal_mutable_memory_data_param()->::opencv_caffe::MemoryDataParameter::MergeFrom(from._internal_memory_data_param()); + } + if (cached_has_bits & 0x00400000u) { + _internal_mutable_mvn_param()->::opencv_caffe::MVNParameter::MergeFrom(from._internal_mvn_param()); + } + if (cached_has_bits & 0x00800000u) { + _internal_mutable_pooling_param()->::opencv_caffe::PoolingParameter::MergeFrom(from._internal_pooling_param()); + } + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + _internal_mutable_power_param()->::opencv_caffe::PowerParameter::MergeFrom(from._internal_power_param()); + } + if (cached_has_bits & 0x02000000u) { + _internal_mutable_relu_param()->::opencv_caffe::ReLUParameter::MergeFrom(from._internal_relu_param()); + } + if (cached_has_bits & 0x04000000u) { + _internal_mutable_sigmoid_param()->::opencv_caffe::SigmoidParameter::MergeFrom(from._internal_sigmoid_param()); + } + if (cached_has_bits & 0x08000000u) { + _internal_mutable_softmax_param()->::opencv_caffe::SoftmaxParameter::MergeFrom(from._internal_softmax_param()); + } + if (cached_has_bits & 0x10000000u) { + _internal_mutable_slice_param()->::opencv_caffe::SliceParameter::MergeFrom(from._internal_slice_param()); + } + if (cached_has_bits & 0x20000000u) { + _internal_mutable_tanh_param()->::opencv_caffe::TanHParameter::MergeFrom(from._internal_tanh_param()); + } + if (cached_has_bits & 0x40000000u) { + _internal_mutable_threshold_param()->::opencv_caffe::ThresholdParameter::MergeFrom(from._internal_threshold_param()); + } + if (cached_has_bits & 0x80000000u) { + _internal_mutable_window_data_param()->::opencv_caffe::WindowDataParameter::MergeFrom(from._internal_window_data_param()); + } + } + cached_has_bits = from._has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_python_param()->::opencv_caffe::PythonParameter::MergeFrom(from._internal_python_param()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_prelu_param()->::opencv_caffe::PReLUParameter::MergeFrom(from._internal_prelu_param()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_spp_param()->::opencv_caffe::SPPParameter::MergeFrom(from._internal_spp_param()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_reshape_param()->::opencv_caffe::ReshapeParameter::MergeFrom(from._internal_reshape_param()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_log_param()->::opencv_caffe::LogParameter::MergeFrom(from._internal_log_param()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_flatten_param()->::opencv_caffe::FlattenParameter::MergeFrom(from._internal_flatten_param()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_reduction_param()->::opencv_caffe::ReductionParameter::MergeFrom(from._internal_reduction_param()); + } + if (cached_has_bits & 0x00000080u) { + _internal_mutable_embed_param()->::opencv_caffe::EmbedParameter::MergeFrom(from._internal_embed_param()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _internal_mutable_tile_param()->::opencv_caffe::TileParameter::MergeFrom(from._internal_tile_param()); + } + if (cached_has_bits & 0x00000200u) { + _internal_mutable_batch_norm_param()->::opencv_caffe::BatchNormParameter::MergeFrom(from._internal_batch_norm_param()); + } + if (cached_has_bits & 0x00000400u) { + _internal_mutable_elu_param()->::opencv_caffe::ELUParameter::MergeFrom(from._internal_elu_param()); + } + if (cached_has_bits & 0x00000800u) { + _internal_mutable_bias_param()->::opencv_caffe::BiasParameter::MergeFrom(from._internal_bias_param()); + } + if (cached_has_bits & 0x00001000u) { + _internal_mutable_scale_param()->::opencv_caffe::ScaleParameter::MergeFrom(from._internal_scale_param()); + } + if (cached_has_bits & 0x00002000u) { + _internal_mutable_input_param()->::opencv_caffe::InputParameter::MergeFrom(from._internal_input_param()); + } + if (cached_has_bits & 0x00004000u) { + _internal_mutable_crop_param()->::opencv_caffe::CropParameter::MergeFrom(from._internal_crop_param()); + } + if (cached_has_bits & 0x00008000u) { + _internal_mutable_parameter_param()->::opencv_caffe::ParameterParameter::MergeFrom(from._internal_parameter_param()); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _internal_mutable_recurrent_param()->::opencv_caffe::RecurrentParameter::MergeFrom(from._internal_recurrent_param()); + } + if (cached_has_bits & 0x00020000u) { + _internal_mutable_detection_output_param()->::opencv_caffe::DetectionOutputParameter::MergeFrom(from._internal_detection_output_param()); + } + if (cached_has_bits & 0x00040000u) { + _internal_mutable_permute_param()->::opencv_caffe::PermuteParameter::MergeFrom(from._internal_permute_param()); + } + if (cached_has_bits & 0x00080000u) { + _internal_mutable_norm_param()->::opencv_caffe::NormalizeBBoxParameter::MergeFrom(from._internal_norm_param()); + } + if (cached_has_bits & 0x00100000u) { + _internal_mutable_prior_box_param()->::opencv_caffe::PriorBoxParameter::MergeFrom(from._internal_prior_box_param()); + } + if (cached_has_bits & 0x00200000u) { + _internal_mutable_proposal_param()->::opencv_caffe::ProposalParameter::MergeFrom(from._internal_proposal_param()); + } + if (cached_has_bits & 0x00400000u) { + _internal_mutable_psroi_pooling_param()->::opencv_caffe::PSROIPoolingParameter::MergeFrom(from._internal_psroi_pooling_param()); + } + if (cached_has_bits & 0x00800000u) { + _internal_mutable_roi_pooling_param()->::opencv_caffe::ROIPoolingParameter::MergeFrom(from._internal_roi_pooling_param()); + } + } + if (cached_has_bits & 0x01000000u) { + _internal_set_phase(from._internal_phase()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LayerParameter::CopyFrom(const LayerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LayerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LayerParameter::IsInitialized() const { + if (_internal_has_psroi_pooling_param()) { + if (!psroi_pooling_param_->IsInitialized()) return false; + } + return true; +} + +void LayerParameter::InternalSwap(LayerParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(_has_bits_[1], other->_has_bits_[1]); + bottom_.InternalSwap(&other->bottom_); + top_.InternalSwap(&other->top_); + loss_weight_.InternalSwap(&other->loss_weight_); + param_.InternalSwap(&other->param_); + blobs_.InternalSwap(&other->blobs_); + include_.InternalSwap(&other->include_); + exclude_.InternalSwap(&other->exclude_); + propagate_down_.InternalSwap(&other->propagate_down_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &type_, lhs_arena, + &other->type_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(LayerParameter, phase_) + + sizeof(LayerParameter::phase_) + - PROTOBUF_FIELD_OFFSET(LayerParameter, transform_param_)>( + reinterpret_cast(&transform_param_), + reinterpret_cast(&other->transform_param_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LayerParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[15]); +} + +// =================================================================== + +class TransformationParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_mirror(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_crop_size(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_mean_file(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_force_color(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_force_gray(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +TransformationParameter::TransformationParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + mean_value_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.TransformationParameter) +} +TransformationParameter::TransformationParameter(const TransformationParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + mean_value_(from.mean_value_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mean_file()) { + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mean_file(), + GetArenaForAllocation()); + } + ::memcpy(&crop_size_, &from.crop_size_, + static_cast(reinterpret_cast(&scale_) - + reinterpret_cast(&crop_size_)) + sizeof(scale_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.TransformationParameter) +} + +inline void TransformationParameter::SharedCtor() { +mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&crop_size_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&force_gray_) - + reinterpret_cast(&crop_size_)) + sizeof(force_gray_)); +scale_ = 1; +} + +TransformationParameter::~TransformationParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.TransformationParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void TransformationParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + mean_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void TransformationParameter::ArenaDtor(void* object) { + TransformationParameter* _this = reinterpret_cast< TransformationParameter* >(object); + (void)_this; +} +void TransformationParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void TransformationParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TransformationParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.TransformationParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + mean_value_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + mean_file_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000003eu) { + ::memset(&crop_size_, 0, static_cast( + reinterpret_cast(&force_gray_) - + reinterpret_cast(&crop_size_)) + sizeof(force_gray_)); + scale_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TransformationParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float scale = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_scale(&has_bits); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional bool mirror = 2 [default = false]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_mirror(&has_bits); + mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 crop_size = 3 [default = 0]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_crop_size(&has_bits); + crop_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string mean_file = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_mean_file(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.TransformationParameter.mean_file"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float mean_value = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_mean_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr)); + } else if (static_cast(tag) == 42) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_mean_value(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool force_color = 6 [default = false]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_force_color(&has_bits); + force_color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool force_gray = 7 [default = false]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_force_gray(&has_bits); + force_gray_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* TransformationParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TransformationParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float scale = 1 [default = 1]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_scale(), target); + } + + // optional bool mirror = 2 [default = false]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_mirror(), target); + } + + // optional uint32 crop_size = 3 [default = 0]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_crop_size(), target); + } + + // optional string mean_file = 4; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mean_file().data(), static_cast(this->_internal_mean_file().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.TransformationParameter.mean_file"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_mean_file(), target); + } + + // repeated float mean_value = 5; + for (int i = 0, n = this->_internal_mean_value_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_mean_value(i), target); + } + + // optional bool force_color = 6 [default = false]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_force_color(), target); + } + + // optional bool force_gray = 7 [default = false]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_force_gray(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TransformationParameter) + return target; +} + +size_t TransformationParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TransformationParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float mean_value = 5; + { + unsigned int count = static_cast(this->_internal_mean_value_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_mean_value_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional string mean_file = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mean_file()); + } + + // optional uint32 crop_size = 3 [default = 0]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_crop_size()); + } + + // optional bool mirror = 2 [default = false]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional bool force_color = 6 [default = false]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + // optional bool force_gray = 7 [default = false]; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 1; + } + + // optional float scale = 1 [default = 1]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TransformationParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + TransformationParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TransformationParameter::GetClassData() const { return &_class_data_; } + +void TransformationParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void TransformationParameter::MergeFrom(const TransformationParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TransformationParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + mean_value_.MergeFrom(from.mean_value_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_mean_file(from._internal_mean_file()); + } + if (cached_has_bits & 0x00000002u) { + crop_size_ = from.crop_size_; + } + if (cached_has_bits & 0x00000004u) { + mirror_ = from.mirror_; + } + if (cached_has_bits & 0x00000008u) { + force_color_ = from.force_color_; + } + if (cached_has_bits & 0x00000010u) { + force_gray_ = from.force_gray_; + } + if (cached_has_bits & 0x00000020u) { + scale_ = from.scale_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void TransformationParameter::CopyFrom(const TransformationParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TransformationParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TransformationParameter::IsInitialized() const { + return true; +} + +void TransformationParameter::InternalSwap(TransformationParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + mean_value_.InternalSwap(&other->mean_value_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &mean_file_, lhs_arena, + &other->mean_file_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TransformationParameter, force_gray_) + + sizeof(TransformationParameter::force_gray_) + - PROTOBUF_FIELD_OFFSET(TransformationParameter, crop_size_)>( + reinterpret_cast(&crop_size_), + reinterpret_cast(&other->crop_size_)); + swap(scale_, other->scale_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TransformationParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[16]); +} + +// =================================================================== + +class LossParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_ignore_label(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_normalization(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_normalize(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +LossParameter::LossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.LossParameter) +} +LossParameter::LossParameter(const LossParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&ignore_label_, &from.ignore_label_, + static_cast(reinterpret_cast(&normalization_) - + reinterpret_cast(&ignore_label_)) + sizeof(normalization_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.LossParameter) +} + +inline void LossParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&ignore_label_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&normalize_) - + reinterpret_cast(&ignore_label_)) + sizeof(normalize_)); +normalization_ = 1; +} + +LossParameter::~LossParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.LossParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void LossParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void LossParameter::ArenaDtor(void* object) { + LossParameter* _this = reinterpret_cast< LossParameter* >(object); + (void)_this; +} +void LossParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void LossParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void LossParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.LossParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&ignore_label_, 0, static_cast( + reinterpret_cast(&normalize_) - + reinterpret_cast(&ignore_label_)) + sizeof(normalize_)); + normalization_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LossParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 ignore_label = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_ignore_label(&has_bits); + ignore_label_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool normalize = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_normalize(&has_bits); + normalize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::LossParameter_NormalizationMode_IsValid(val))) { + _internal_set_normalization(static_cast<::opencv_caffe::LossParameter_NormalizationMode>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* LossParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LossParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 ignore_label = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_ignore_label(), target); + } + + // optional bool normalize = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_normalize(), target); + } + + // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_normalization(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LossParameter) + return target; +} + +size_t LossParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LossParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional int32 ignore_label = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_ignore_label()); + } + + // optional bool normalize = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_normalization()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LossParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + LossParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LossParameter::GetClassData() const { return &_class_data_; } + +void LossParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void LossParameter::MergeFrom(const LossParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LossParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + ignore_label_ = from.ignore_label_; + } + if (cached_has_bits & 0x00000002u) { + normalize_ = from.normalize_; + } + if (cached_has_bits & 0x00000004u) { + normalization_ = from.normalization_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LossParameter::CopyFrom(const LossParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LossParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LossParameter::IsInitialized() const { + return true; +} + +void LossParameter::InternalSwap(LossParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(LossParameter, normalize_) + + sizeof(LossParameter::normalize_) + - PROTOBUF_FIELD_OFFSET(LossParameter, ignore_label_)>( + reinterpret_cast(&ignore_label_), + reinterpret_cast(&other->ignore_label_)); + swap(normalization_, other->normalization_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LossParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[17]); +} + +// =================================================================== + +class AccuracyParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_top_k(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_ignore_label(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +AccuracyParameter::AccuracyParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.AccuracyParameter) +} +AccuracyParameter::AccuracyParameter(const AccuracyParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&ignore_label_, &from.ignore_label_, + static_cast(reinterpret_cast(&axis_) - + reinterpret_cast(&ignore_label_)) + sizeof(axis_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.AccuracyParameter) +} + +inline void AccuracyParameter::SharedCtor() { +ignore_label_ = 0; +top_k_ = 1u; +axis_ = 1; +} + +AccuracyParameter::~AccuracyParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.AccuracyParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void AccuracyParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void AccuracyParameter::ArenaDtor(void* object) { + AccuracyParameter* _this = reinterpret_cast< AccuracyParameter* >(object); + (void)_this; +} +void AccuracyParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AccuracyParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AccuracyParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.AccuracyParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ignore_label_ = 0; + top_k_ = 1u; + axis_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* AccuracyParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 top_k = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_top_k(&has_bits); + top_k_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 axis = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 ignore_label = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_ignore_label(&has_bits); + ignore_label_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* AccuracyParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.AccuracyParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 top_k = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_top_k(), target); + } + + // optional int32 axis = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); + } + + // optional int32 ignore_label = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_ignore_label(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.AccuracyParameter) + return target; +} + +size_t AccuracyParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.AccuracyParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional int32 ignore_label = 3; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_ignore_label()); + } + + // optional uint32 top_k = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_top_k()); + } + + // optional int32 axis = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AccuracyParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + AccuracyParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AccuracyParameter::GetClassData() const { return &_class_data_; } + +void AccuracyParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void AccuracyParameter::MergeFrom(const AccuracyParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.AccuracyParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + ignore_label_ = from.ignore_label_; + } + if (cached_has_bits & 0x00000002u) { + top_k_ = from.top_k_; + } + if (cached_has_bits & 0x00000004u) { + axis_ = from.axis_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void AccuracyParameter::CopyFrom(const AccuracyParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.AccuracyParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccuracyParameter::IsInitialized() const { + return true; +} + +void AccuracyParameter::InternalSwap(AccuracyParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(ignore_label_, other->ignore_label_); + swap(top_k_, other->top_k_); + swap(axis_, other->axis_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AccuracyParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[18]); +} + +// =================================================================== + +class ArgMaxParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_out_max_val(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_top_k(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ArgMaxParameter::ArgMaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ArgMaxParameter) +} +ArgMaxParameter::ArgMaxParameter(const ArgMaxParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&out_max_val_, &from.out_max_val_, + static_cast(reinterpret_cast(&top_k_) - + reinterpret_cast(&out_max_val_)) + sizeof(top_k_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ArgMaxParameter) +} + +inline void ArgMaxParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&out_max_val_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&axis_) - + reinterpret_cast(&out_max_val_)) + sizeof(axis_)); +top_k_ = 1u; +} + +ArgMaxParameter::~ArgMaxParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ArgMaxParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ArgMaxParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ArgMaxParameter::ArenaDtor(void* object) { + ArgMaxParameter* _this = reinterpret_cast< ArgMaxParameter* >(object); + (void)_this; +} +void ArgMaxParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ArgMaxParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ArgMaxParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ArgMaxParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&out_max_val_, 0, static_cast( + reinterpret_cast(&axis_) - + reinterpret_cast(&out_max_val_)) + sizeof(axis_)); + top_k_ = 1u; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ArgMaxParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool out_max_val = 1 [default = false]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_out_max_val(&has_bits); + out_max_val_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 top_k = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_top_k(&has_bits); + top_k_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 axis = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ArgMaxParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ArgMaxParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bool out_max_val = 1 [default = false]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_out_max_val(), target); + } + + // optional uint32 top_k = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_top_k(), target); + } + + // optional int32 axis = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_axis(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ArgMaxParameter) + return target; +} + +size_t ArgMaxParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ArgMaxParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bool out_max_val = 1 [default = false]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + // optional int32 axis = 3; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + // optional uint32 top_k = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_top_k()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ArgMaxParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ArgMaxParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ArgMaxParameter::GetClassData() const { return &_class_data_; } + +void ArgMaxParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ArgMaxParameter::MergeFrom(const ArgMaxParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ArgMaxParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + out_max_val_ = from.out_max_val_; + } + if (cached_has_bits & 0x00000002u) { + axis_ = from.axis_; + } + if (cached_has_bits & 0x00000004u) { + top_k_ = from.top_k_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ArgMaxParameter::CopyFrom(const ArgMaxParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ArgMaxParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ArgMaxParameter::IsInitialized() const { + return true; +} + +void ArgMaxParameter::InternalSwap(ArgMaxParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ArgMaxParameter, axis_) + + sizeof(ArgMaxParameter::axis_) + - PROTOBUF_FIELD_OFFSET(ArgMaxParameter, out_max_val_)>( + reinterpret_cast(&out_max_val_), + reinterpret_cast(&other->out_max_val_)); + swap(top_k_, other->top_k_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ArgMaxParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[19]); +} + +// =================================================================== + +class ConcatParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_concat_dim(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ConcatParameter::ConcatParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ConcatParameter) +} +ConcatParameter::ConcatParameter(const ConcatParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&concat_dim_, &from.concat_dim_, + static_cast(reinterpret_cast(&axis_) - + reinterpret_cast(&concat_dim_)) + sizeof(axis_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ConcatParameter) +} + +inline void ConcatParameter::SharedCtor() { +concat_dim_ = 1u; +axis_ = 1; +} + +ConcatParameter::~ConcatParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ConcatParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ConcatParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ConcatParameter::ArenaDtor(void* object) { + ConcatParameter* _this = reinterpret_cast< ConcatParameter* >(object); + (void)_this; +} +void ConcatParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ConcatParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ConcatParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ConcatParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + concat_dim_ = 1u; + axis_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ConcatParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 concat_dim = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_concat_dim(&has_bits); + concat_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 axis = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ConcatParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ConcatParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 concat_dim = 1 [default = 1]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_concat_dim(), target); + } + + // optional int32 axis = 2 [default = 1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ConcatParameter) + return target; +} + +size_t ConcatParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ConcatParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional uint32 concat_dim = 1 [default = 1]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_concat_dim()); + } + + // optional int32 axis = 2 [default = 1]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ConcatParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ConcatParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ConcatParameter::GetClassData() const { return &_class_data_; } + +void ConcatParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ConcatParameter::MergeFrom(const ConcatParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ConcatParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + concat_dim_ = from.concat_dim_; + } + if (cached_has_bits & 0x00000002u) { + axis_ = from.axis_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ConcatParameter::CopyFrom(const ConcatParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ConcatParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConcatParameter::IsInitialized() const { + return true; +} + +void ConcatParameter::InternalSwap(ConcatParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(concat_dim_, other->concat_dim_); + swap(axis_, other->axis_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ConcatParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[20]); +} + +// =================================================================== + +class BatchNormParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_use_global_stats(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_moving_average_fraction(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_eps(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_scale_bias(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +BatchNormParameter::BatchNormParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.BatchNormParameter) +} +BatchNormParameter::BatchNormParameter(const BatchNormParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&use_global_stats_, &from.use_global_stats_, + static_cast(reinterpret_cast(&eps_) - + reinterpret_cast(&use_global_stats_)) + sizeof(eps_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.BatchNormParameter) +} + +inline void BatchNormParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&use_global_stats_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&scale_bias_) - + reinterpret_cast(&use_global_stats_)) + sizeof(scale_bias_)); +moving_average_fraction_ = 0.999f; +eps_ = 1e-05f; +} + +BatchNormParameter::~BatchNormParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.BatchNormParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void BatchNormParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void BatchNormParameter::ArenaDtor(void* object) { + BatchNormParameter* _this = reinterpret_cast< BatchNormParameter* >(object); + (void)_this; +} +void BatchNormParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BatchNormParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BatchNormParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.BatchNormParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&use_global_stats_, 0, static_cast( + reinterpret_cast(&scale_bias_) - + reinterpret_cast(&use_global_stats_)) + sizeof(scale_bias_)); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000cu) { + moving_average_fraction_ = 0.999f; + eps_ = 1e-05f; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BatchNormParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool use_global_stats = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_use_global_stats(&has_bits); + use_global_stats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float moving_average_fraction = 2 [default = 0.999]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_moving_average_fraction(&has_bits); + moving_average_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float eps = 3 [default = 1e-05]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_eps(&has_bits); + eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional bool scale_bias = 7 [default = false]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_scale_bias(&has_bits); + scale_bias_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BatchNormParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BatchNormParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bool use_global_stats = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_use_global_stats(), target); + } + + // optional float moving_average_fraction = 2 [default = 0.999]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_moving_average_fraction(), target); + } + + // optional float eps = 3 [default = 1e-05]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_eps(), target); + } + + // optional bool scale_bias = 7 [default = false]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_scale_bias(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BatchNormParameter) + return target; +} + +size_t BatchNormParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BatchNormParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bool use_global_stats = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + // optional bool scale_bias = 7 [default = false]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional float moving_average_fraction = 2 [default = 0.999]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + // optional float eps = 3 [default = 1e-05]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BatchNormParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + BatchNormParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BatchNormParameter::GetClassData() const { return &_class_data_; } + +void BatchNormParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void BatchNormParameter::MergeFrom(const BatchNormParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BatchNormParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + use_global_stats_ = from.use_global_stats_; + } + if (cached_has_bits & 0x00000002u) { + scale_bias_ = from.scale_bias_; + } + if (cached_has_bits & 0x00000004u) { + moving_average_fraction_ = from.moving_average_fraction_; + } + if (cached_has_bits & 0x00000008u) { + eps_ = from.eps_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void BatchNormParameter::CopyFrom(const BatchNormParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BatchNormParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BatchNormParameter::IsInitialized() const { + return true; +} + +void BatchNormParameter::InternalSwap(BatchNormParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BatchNormParameter, scale_bias_) + + sizeof(BatchNormParameter::scale_bias_) + - PROTOBUF_FIELD_OFFSET(BatchNormParameter, use_global_stats_)>( + reinterpret_cast(&use_global_stats_), + reinterpret_cast(&other->use_global_stats_)); + swap(moving_average_fraction_, other->moving_average_fraction_); + swap(eps_, other->eps_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BatchNormParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[21]); +} + +// =================================================================== + +class BiasParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_num_axes(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::opencv_caffe::FillerParameter& filler(const BiasParameter* msg); + static void set_has_filler(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::opencv_caffe::FillerParameter& +BiasParameter::_Internal::filler(const BiasParameter* msg) { + return *msg->filler_; +} +BiasParameter::BiasParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.BiasParameter) +} +BiasParameter::BiasParameter(const BiasParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_filler()) { + filler_ = new ::opencv_caffe::FillerParameter(*from.filler_); + } else { + filler_ = nullptr; + } + ::memcpy(&axis_, &from.axis_, + static_cast(reinterpret_cast(&num_axes_) - + reinterpret_cast(&axis_)) + sizeof(num_axes_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.BiasParameter) +} + +inline void BiasParameter::SharedCtor() { +filler_ = nullptr; +axis_ = 1; +num_axes_ = 1; +} + +BiasParameter::~BiasParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.BiasParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void BiasParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete filler_; +} + +void BiasParameter::ArenaDtor(void* object) { + BiasParameter* _this = reinterpret_cast< BiasParameter* >(object); + (void)_this; +} +void BiasParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BiasParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BiasParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.BiasParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(filler_ != nullptr); + filler_->Clear(); + } + axis_ = 1; + num_axes_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BiasParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 axis = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 num_axes = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_num_axes(&has_bits); + num_axes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter filler = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BiasParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BiasParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 axis = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); + } + + // optional int32 num_axes = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_num_axes(), target); + } + + // optional .opencv_caffe.FillerParameter filler = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::filler(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BiasParameter) + return target; +} + +size_t BiasParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BiasParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .opencv_caffe.FillerParameter filler = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *filler_); + } + + // optional int32 axis = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + // optional int32 num_axes = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_axes()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BiasParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + BiasParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BiasParameter::GetClassData() const { return &_class_data_; } + +void BiasParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void BiasParameter::MergeFrom(const BiasParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BiasParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_filler()); + } + if (cached_has_bits & 0x00000002u) { + axis_ = from.axis_; + } + if (cached_has_bits & 0x00000004u) { + num_axes_ = from.num_axes_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void BiasParameter::CopyFrom(const BiasParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BiasParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BiasParameter::IsInitialized() const { + return true; +} + +void BiasParameter::InternalSwap(BiasParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(filler_, other->filler_); + swap(axis_, other->axis_); + swap(num_axes_, other->num_axes_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BiasParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[22]); +} + +// =================================================================== + +class ContrastiveLossParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_margin(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_legacy_version(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ContrastiveLossParameter::ContrastiveLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ContrastiveLossParameter) +} +ContrastiveLossParameter::ContrastiveLossParameter(const ContrastiveLossParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&legacy_version_, &from.legacy_version_, + static_cast(reinterpret_cast(&margin_) - + reinterpret_cast(&legacy_version_)) + sizeof(margin_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ContrastiveLossParameter) +} + +inline void ContrastiveLossParameter::SharedCtor() { +legacy_version_ = false; +margin_ = 1; +} + +ContrastiveLossParameter::~ContrastiveLossParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ContrastiveLossParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ContrastiveLossParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ContrastiveLossParameter::ArenaDtor(void* object) { + ContrastiveLossParameter* _this = reinterpret_cast< ContrastiveLossParameter* >(object); + (void)_this; +} +void ContrastiveLossParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ContrastiveLossParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ContrastiveLossParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ContrastiveLossParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + legacy_version_ = false; + margin_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ContrastiveLossParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float margin = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_margin(&has_bits); + margin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional bool legacy_version = 2 [default = false]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_legacy_version(&has_bits); + legacy_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ContrastiveLossParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ContrastiveLossParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float margin = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_margin(), target); + } + + // optional bool legacy_version = 2 [default = false]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_legacy_version(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ContrastiveLossParameter) + return target; +} + +size_t ContrastiveLossParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ContrastiveLossParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bool legacy_version = 2 [default = false]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + // optional float margin = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContrastiveLossParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ContrastiveLossParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContrastiveLossParameter::GetClassData() const { return &_class_data_; } + +void ContrastiveLossParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ContrastiveLossParameter::MergeFrom(const ContrastiveLossParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ContrastiveLossParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + legacy_version_ = from.legacy_version_; + } + if (cached_has_bits & 0x00000002u) { + margin_ = from.margin_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ContrastiveLossParameter::CopyFrom(const ContrastiveLossParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ContrastiveLossParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContrastiveLossParameter::IsInitialized() const { + return true; +} + +void ContrastiveLossParameter::InternalSwap(ContrastiveLossParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(legacy_version_, other->legacy_version_); + swap(margin_, other->margin_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ContrastiveLossParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[23]); +} + +// =================================================================== + +class ConvolutionParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_num_output(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_bias_term(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_pad_h(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_pad_w(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_kernel_h(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_kernel_w(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_stride_h(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_stride_w(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_group(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static const ::opencv_caffe::FillerParameter& weight_filler(const ConvolutionParameter* msg); + static void set_has_weight_filler(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::opencv_caffe::FillerParameter& bias_filler(const ConvolutionParameter* msg); + static void set_has_bias_filler(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_engine(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_force_nd_im2col(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } +}; + +const ::opencv_caffe::FillerParameter& +ConvolutionParameter::_Internal::weight_filler(const ConvolutionParameter* msg) { + return *msg->weight_filler_; +} +const ::opencv_caffe::FillerParameter& +ConvolutionParameter::_Internal::bias_filler(const ConvolutionParameter* msg) { + return *msg->bias_filler_; +} +ConvolutionParameter::ConvolutionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + pad_(arena), + kernel_size_(arena), + stride_(arena), + dilation_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ConvolutionParameter) +} +ConvolutionParameter::ConvolutionParameter(const ConvolutionParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + pad_(from.pad_), + kernel_size_(from.kernel_size_), + stride_(from.stride_), + dilation_(from.dilation_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_weight_filler()) { + weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); + } else { + weight_filler_ = nullptr; + } + if (from._internal_has_bias_filler()) { + bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); + } else { + bias_filler_ = nullptr; + } + ::memcpy(&num_output_, &from.num_output_, + static_cast(reinterpret_cast(&group_) - + reinterpret_cast(&num_output_)) + sizeof(group_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ConvolutionParameter) +} + +inline void ConvolutionParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&force_nd_im2col_) - + reinterpret_cast(&weight_filler_)) + sizeof(force_nd_im2col_)); +axis_ = 1; +bias_term_ = true; +group_ = 1u; +} + +ConvolutionParameter::~ConvolutionParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ConvolutionParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ConvolutionParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete weight_filler_; + if (this != internal_default_instance()) delete bias_filler_; +} + +void ConvolutionParameter::ArenaDtor(void* object) { + ConvolutionParameter* _this = reinterpret_cast< ConvolutionParameter* >(object); + (void)_this; +} +void ConvolutionParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ConvolutionParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ConvolutionParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ConvolutionParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + pad_.Clear(); + kernel_size_.Clear(); + stride_.Clear(); + dilation_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(weight_filler_ != nullptr); + weight_filler_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(bias_filler_ != nullptr); + bias_filler_->Clear(); + } + } + if (cached_has_bits & 0x000000fcu) { + ::memset(&num_output_, 0, static_cast( + reinterpret_cast(&stride_h_) - + reinterpret_cast(&num_output_)) + sizeof(stride_h_)); + } + if (cached_has_bits & 0x00003f00u) { + ::memset(&stride_w_, 0, static_cast( + reinterpret_cast(&force_nd_im2col_) - + reinterpret_cast(&stride_w_)) + sizeof(force_nd_im2col_)); + axis_ = 1; + bias_term_ = true; + group_ = 1u; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ConvolutionParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 num_output = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_num_output(&has_bits); + num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool bias_term = 2 [default = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_bias_term(&has_bits); + bias_term_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 pad = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_pad(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); + } else if (static_cast(tag) == 26) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_pad(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 kernel_size = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_kernel_size(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); + } else if (static_cast(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_kernel_size(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 group = 5 [default = 1]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_group(&has_bits); + group_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 stride = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_stride(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr)); + } else if (static_cast(tag) == 50) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_stride(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter weight_filler = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter bias_filler = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pad_h = 9 [default = 0]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_pad_h(&has_bits); + pad_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pad_w = 10 [default = 0]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_pad_w(&has_bits); + pad_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 kernel_h = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + _Internal::set_has_kernel_h(&has_bits); + kernel_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 kernel_w = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_kernel_w(&has_bits); + kernel_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 stride_h = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + _Internal::set_has_stride_h(&has_bits); + stride_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 stride_w = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + _Internal::set_has_stride_w(&has_bits); + stride_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::ConvolutionParameter_Engine_IsValid(val))) { + _internal_set_engine(static_cast<::opencv_caffe::ConvolutionParameter_Engine>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int32 axis = 16 [default = 1]; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool force_nd_im2col = 17 [default = false]; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { + _Internal::set_has_force_nd_im2col(&has_bits); + force_nd_im2col_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 dilation = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { + ptr -= 2; + do { + ptr += 2; + _internal_add_dilation(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<144>(ptr)); + } else if (static_cast(tag) == 146) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_dilation(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ConvolutionParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ConvolutionParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 num_output = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_output(), target); + } + + // optional bool bias_term = 2 [default = true]; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_bias_term(), target); + } + + // repeated uint32 pad = 3; + for (int i = 0, n = this->_internal_pad_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_pad(i), target); + } + + // repeated uint32 kernel_size = 4; + for (int i = 0, n = this->_internal_kernel_size_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_kernel_size(i), target); + } + + // optional uint32 group = 5 [default = 1]; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_group(), target); + } + + // repeated uint32 stride = 6; + for (int i = 0, n = this->_internal_stride_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_stride(i), target); + } + + // optional .opencv_caffe.FillerParameter weight_filler = 7; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::weight_filler(this), target, stream); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 8; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::bias_filler(this), target, stream); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_pad_h(), target); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_pad_w(), target); + } + + // optional uint32 kernel_h = 11; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(11, this->_internal_kernel_h(), target); + } + + // optional uint32 kernel_w = 12; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(12, this->_internal_kernel_w(), target); + } + + // optional uint32 stride_h = 13; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(13, this->_internal_stride_h(), target); + } + + // optional uint32 stride_w = 14; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(14, this->_internal_stride_w(), target); + } + + // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 15, this->_internal_engine(), target); + } + + // optional int32 axis = 16 [default = 1]; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_axis(), target); + } + + // optional bool force_nd_im2col = 17 [default = false]; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(17, this->_internal_force_nd_im2col(), target); + } + + // repeated uint32 dilation = 18; + for (int i = 0, n = this->_internal_dilation_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(18, this->_internal_dilation(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ConvolutionParameter) + return target; +} + +size_t ConvolutionParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ConvolutionParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 pad = 3; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->pad_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_pad_size()); + total_size += data_size; + } + + // repeated uint32 kernel_size = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->kernel_size_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_kernel_size_size()); + total_size += data_size; + } + + // repeated uint32 stride = 6; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->stride_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_stride_size()); + total_size += data_size; + } + + // repeated uint32 dilation = 18; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->dilation_); + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_dilation_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .opencv_caffe.FillerParameter weight_filler = 7; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *weight_filler_); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 8; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bias_filler_); + } + + // optional uint32 num_output = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad_h()); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad_w()); + } + + // optional uint32 kernel_h = 11; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_h()); + } + + // optional uint32 kernel_w = 12; + if (cached_has_bits & 0x00000040u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_w()); + } + + // optional uint32 stride_h = 13; + if (cached_has_bits & 0x00000080u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride_h()); + } + + } + if (cached_has_bits & 0x00003f00u) { + // optional uint32 stride_w = 14; + if (cached_has_bits & 0x00000100u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride_w()); + } + + // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); + } + + // optional bool force_nd_im2col = 17 [default = false]; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + 1; + } + + // optional int32 axis = 16 [default = 1]; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_axis()); + } + + // optional bool bias_term = 2 [default = true]; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + 1; + } + + // optional uint32 group = 5 [default = 1]; + if (cached_has_bits & 0x00002000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_group()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ConvolutionParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ConvolutionParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ConvolutionParameter::GetClassData() const { return &_class_data_; } + +void ConvolutionParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ConvolutionParameter::MergeFrom(const ConvolutionParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ConvolutionParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + pad_.MergeFrom(from.pad_); + kernel_size_.MergeFrom(from.kernel_size_); + stride_.MergeFrom(from.stride_); + dilation_.MergeFrom(from.dilation_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); + } + if (cached_has_bits & 0x00000004u) { + num_output_ = from.num_output_; + } + if (cached_has_bits & 0x00000008u) { + pad_h_ = from.pad_h_; + } + if (cached_has_bits & 0x00000010u) { + pad_w_ = from.pad_w_; + } + if (cached_has_bits & 0x00000020u) { + kernel_h_ = from.kernel_h_; + } + if (cached_has_bits & 0x00000040u) { + kernel_w_ = from.kernel_w_; + } + if (cached_has_bits & 0x00000080u) { + stride_h_ = from.stride_h_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00003f00u) { + if (cached_has_bits & 0x00000100u) { + stride_w_ = from.stride_w_; + } + if (cached_has_bits & 0x00000200u) { + engine_ = from.engine_; + } + if (cached_has_bits & 0x00000400u) { + force_nd_im2col_ = from.force_nd_im2col_; + } + if (cached_has_bits & 0x00000800u) { + axis_ = from.axis_; + } + if (cached_has_bits & 0x00001000u) { + bias_term_ = from.bias_term_; + } + if (cached_has_bits & 0x00002000u) { + group_ = from.group_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ConvolutionParameter::CopyFrom(const ConvolutionParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ConvolutionParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConvolutionParameter::IsInitialized() const { + return true; +} + +void ConvolutionParameter::InternalSwap(ConvolutionParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + pad_.InternalSwap(&other->pad_); + kernel_size_.InternalSwap(&other->kernel_size_); + stride_.InternalSwap(&other->stride_); + dilation_.InternalSwap(&other->dilation_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ConvolutionParameter, force_nd_im2col_) + + sizeof(ConvolutionParameter::force_nd_im2col_) + - PROTOBUF_FIELD_OFFSET(ConvolutionParameter, weight_filler_)>( + reinterpret_cast(&weight_filler_), + reinterpret_cast(&other->weight_filler_)); + swap(axis_, other->axis_); + swap(bias_term_, other->bias_term_); + swap(group_, other->group_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ConvolutionParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[24]); +} + +// =================================================================== + +class CropParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +CropParameter::CropParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + offset_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.CropParameter) +} +CropParameter::CropParameter(const CropParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + offset_(from.offset_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + axis_ = from.axis_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.CropParameter) +} + +inline void CropParameter::SharedCtor() { +axis_ = 2; +} + +CropParameter::~CropParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.CropParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void CropParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void CropParameter::ArenaDtor(void* object) { + CropParameter* _this = reinterpret_cast< CropParameter* >(object); + (void)_this; +} +void CropParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CropParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CropParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.CropParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + offset_.Clear(); + axis_ = 2; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CropParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 axis = 1 [default = 2]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 offset = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_offset(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); + } else if (static_cast(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_offset(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* CropParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.CropParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 axis = 1 [default = 2]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); + } + + // repeated uint32 offset = 2; + for (int i = 0, n = this->_internal_offset_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_offset(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.CropParameter) + return target; +} + +size_t CropParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.CropParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 offset = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->offset_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_offset_size()); + total_size += data_size; + } + + // optional int32 axis = 1 [default = 2]; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CropParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + CropParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CropParameter::GetClassData() const { return &_class_data_; } + +void CropParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void CropParameter::MergeFrom(const CropParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.CropParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + offset_.MergeFrom(from.offset_); + if (from._internal_has_axis()) { + _internal_set_axis(from._internal_axis()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CropParameter::CopyFrom(const CropParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.CropParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CropParameter::IsInitialized() const { + return true; +} + +void CropParameter::InternalSwap(CropParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + offset_.InternalSwap(&other->offset_); + swap(axis_, other->axis_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CropParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[25]); +} + +// =================================================================== + +class DataParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_source(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_batch_size(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_rand_skip(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_backend(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_mean_file(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_crop_size(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_mirror(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_force_encoded_color(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_prefetch(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } +}; + +DataParameter::DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.DataParameter) +} +DataParameter::DataParameter(const DataParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_source()) { + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), + GetArenaForAllocation()); + } + mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mean_file()) { + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mean_file(), + GetArenaForAllocation()); + } + ::memcpy(&batch_size_, &from.batch_size_, + static_cast(reinterpret_cast(&prefetch_) - + reinterpret_cast(&batch_size_)) + sizeof(prefetch_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.DataParameter) +} + +inline void DataParameter::SharedCtor() { +source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&batch_size_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&backend_) - + reinterpret_cast(&batch_size_)) + sizeof(backend_)); +scale_ = 1; +prefetch_ = 4u; +} + +DataParameter::~DataParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.DataParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void DataParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + mean_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void DataParameter::ArenaDtor(void* object) { + DataParameter* _this = reinterpret_cast< DataParameter* >(object); + (void)_this; +} +void DataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DataParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.DataParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + source_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + mean_file_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000fcu) { + ::memset(&batch_size_, 0, static_cast( + reinterpret_cast(&backend_) - + reinterpret_cast(&batch_size_)) + sizeof(backend_)); + } + if (cached_has_bits & 0x00000300u) { + scale_ = 1; + prefetch_ = 4u; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string source = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_source(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.DataParameter.source"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float scale = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_scale(&has_bits); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional string mean_file = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_mean_file(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.DataParameter.mean_file"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 batch_size = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_batch_size(&has_bits); + batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 crop_size = 5 [default = 0]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_crop_size(&has_bits); + crop_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool mirror = 6 [default = false]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_mirror(&has_bits); + mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 rand_skip = 7 [default = 0]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_rand_skip(&has_bits); + rand_skip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::DataParameter_DB_IsValid(val))) { + _internal_set_backend(static_cast<::opencv_caffe::DataParameter_DB>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool force_encoded_color = 9 [default = false]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_force_encoded_color(&has_bits); + force_encoded_color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 prefetch = 10 [default = 4]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_prefetch(&has_bits); + prefetch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DataParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DataParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_source().data(), static_cast(this->_internal_source().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.DataParameter.source"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_source(), target); + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); + } + + // optional string mean_file = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mean_file().data(), static_cast(this->_internal_mean_file().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.DataParameter.mean_file"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_mean_file(), target); + } + + // optional uint32 batch_size = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_batch_size(), target); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_crop_size(), target); + } + + // optional bool mirror = 6 [default = false]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_mirror(), target); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_rand_skip(), target); + } + + // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 8, this->_internal_backend(), target); + } + + // optional bool force_encoded_color = 9 [default = false]; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->_internal_force_encoded_color(), target); + } + + // optional uint32 prefetch = 10 [default = 4]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_prefetch(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DataParameter) + return target; +} + +size_t DataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DataParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_source()); + } + + // optional string mean_file = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mean_file()); + } + + // optional uint32 batch_size = 4; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_crop_size()); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_rand_skip()); + } + + // optional bool mirror = 6 [default = false]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional bool force_encoded_color = 9 [default = false]; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 1; + } + + // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_backend()); + } + + } + if (cached_has_bits & 0x00000300u) { + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 4; + } + + // optional uint32 prefetch = 10 [default = 4]; + if (cached_has_bits & 0x00000200u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_prefetch()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DataParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DataParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DataParameter::GetClassData() const { return &_class_data_; } + +void DataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void DataParameter::MergeFrom(const DataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DataParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_source(from._internal_source()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_mean_file(from._internal_mean_file()); + } + if (cached_has_bits & 0x00000004u) { + batch_size_ = from.batch_size_; + } + if (cached_has_bits & 0x00000008u) { + crop_size_ = from.crop_size_; + } + if (cached_has_bits & 0x00000010u) { + rand_skip_ = from.rand_skip_; + } + if (cached_has_bits & 0x00000020u) { + mirror_ = from.mirror_; + } + if (cached_has_bits & 0x00000040u) { + force_encoded_color_ = from.force_encoded_color_; + } + if (cached_has_bits & 0x00000080u) { + backend_ = from.backend_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + scale_ = from.scale_; + } + if (cached_has_bits & 0x00000200u) { + prefetch_ = from.prefetch_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void DataParameter::CopyFrom(const DataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DataParameter::IsInitialized() const { + return true; +} + +void DataParameter::InternalSwap(DataParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &source_, lhs_arena, + &other->source_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &mean_file_, lhs_arena, + &other->mean_file_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DataParameter, backend_) + + sizeof(DataParameter::backend_) + - PROTOBUF_FIELD_OFFSET(DataParameter, batch_size_)>( + reinterpret_cast(&batch_size_), + reinterpret_cast(&other->batch_size_)); + swap(scale_, other->scale_); + swap(prefetch_, other->prefetch_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DataParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[26]); +} + +// =================================================================== + +class NonMaximumSuppressionParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_nms_threshold(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_top_k(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_eta(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +NonMaximumSuppressionParameter::NonMaximumSuppressionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.NonMaximumSuppressionParameter) +} +NonMaximumSuppressionParameter::NonMaximumSuppressionParameter(const NonMaximumSuppressionParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&top_k_, &from.top_k_, + static_cast(reinterpret_cast(&eta_) - + reinterpret_cast(&top_k_)) + sizeof(eta_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.NonMaximumSuppressionParameter) +} + +inline void NonMaximumSuppressionParameter::SharedCtor() { +top_k_ = 0; +nms_threshold_ = 0.3f; +eta_ = 1; +} + +NonMaximumSuppressionParameter::~NonMaximumSuppressionParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.NonMaximumSuppressionParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void NonMaximumSuppressionParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void NonMaximumSuppressionParameter::ArenaDtor(void* object) { + NonMaximumSuppressionParameter* _this = reinterpret_cast< NonMaximumSuppressionParameter* >(object); + (void)_this; +} +void NonMaximumSuppressionParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void NonMaximumSuppressionParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void NonMaximumSuppressionParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.NonMaximumSuppressionParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + top_k_ = 0; + nms_threshold_ = 0.3f; + eta_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NonMaximumSuppressionParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float nms_threshold = 1 [default = 0.3]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_nms_threshold(&has_bits); + nms_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional int32 top_k = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_top_k(&has_bits); + top_k_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float eta = 3 [default = 1]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_eta(&has_bits); + eta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NonMaximumSuppressionParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NonMaximumSuppressionParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float nms_threshold = 1 [default = 0.3]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_nms_threshold(), target); + } + + // optional int32 top_k = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_top_k(), target); + } + + // optional float eta = 3 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_eta(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NonMaximumSuppressionParameter) + return target; +} + +size_t NonMaximumSuppressionParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NonMaximumSuppressionParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional int32 top_k = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_top_k()); + } + + // optional float nms_threshold = 1 [default = 0.3]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float eta = 3 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NonMaximumSuppressionParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + NonMaximumSuppressionParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NonMaximumSuppressionParameter::GetClassData() const { return &_class_data_; } + +void NonMaximumSuppressionParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void NonMaximumSuppressionParameter::MergeFrom(const NonMaximumSuppressionParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NonMaximumSuppressionParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + top_k_ = from.top_k_; + } + if (cached_has_bits & 0x00000002u) { + nms_threshold_ = from.nms_threshold_; + } + if (cached_has_bits & 0x00000004u) { + eta_ = from.eta_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NonMaximumSuppressionParameter::CopyFrom(const NonMaximumSuppressionParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NonMaximumSuppressionParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NonMaximumSuppressionParameter::IsInitialized() const { + return true; +} + +void NonMaximumSuppressionParameter::InternalSwap(NonMaximumSuppressionParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(top_k_, other->top_k_); + swap(nms_threshold_, other->nms_threshold_); + swap(eta_, other->eta_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NonMaximumSuppressionParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[27]); +} + +// =================================================================== + +class SaveOutputParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_output_directory(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_output_name_prefix(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_output_format(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_label_map_file(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_name_size_file(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_num_test_image(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +SaveOutputParameter::SaveOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.SaveOutputParameter) +} +SaveOutputParameter::SaveOutputParameter(const SaveOutputParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + output_directory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + output_directory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_output_directory()) { + output_directory_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_output_directory(), + GetArenaForAllocation()); + } + output_name_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + output_name_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_output_name_prefix()) { + output_name_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_output_name_prefix(), + GetArenaForAllocation()); + } + output_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + output_format_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_output_format()) { + output_format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_output_format(), + GetArenaForAllocation()); + } + label_map_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_label_map_file()) { + label_map_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_label_map_file(), + GetArenaForAllocation()); + } + name_size_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name_size_file()) { + name_size_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name_size_file(), + GetArenaForAllocation()); + } + num_test_image_ = from.num_test_image_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.SaveOutputParameter) +} + +inline void SaveOutputParameter::SharedCtor() { +output_directory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + output_directory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +output_name_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + output_name_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +output_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + output_format_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +label_map_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +name_size_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +num_test_image_ = 0u; +} + +SaveOutputParameter::~SaveOutputParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.SaveOutputParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void SaveOutputParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + output_directory_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + output_name_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + output_format_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + label_map_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_size_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SaveOutputParameter::ArenaDtor(void* object) { + SaveOutputParameter* _this = reinterpret_cast< SaveOutputParameter* >(object); + (void)_this; +} +void SaveOutputParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SaveOutputParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SaveOutputParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.SaveOutputParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + output_directory_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + output_name_prefix_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + output_format_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + label_map_file_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + name_size_file_.ClearNonDefaultToEmpty(); + } + } + num_test_image_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SaveOutputParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string output_directory = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_output_directory(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.output_directory"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string output_name_prefix = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_output_name_prefix(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.output_name_prefix"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string output_format = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_output_format(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.output_format"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string label_map_file = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_label_map_file(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.label_map_file"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string name_size_file = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_name_size_file(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.name_size_file"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 num_test_image = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_num_test_image(&has_bits); + num_test_image_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SaveOutputParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SaveOutputParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string output_directory = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_output_directory().data(), static_cast(this->_internal_output_directory().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SaveOutputParameter.output_directory"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_output_directory(), target); + } + + // optional string output_name_prefix = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_output_name_prefix().data(), static_cast(this->_internal_output_name_prefix().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SaveOutputParameter.output_name_prefix"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_output_name_prefix(), target); + } + + // optional string output_format = 3; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_output_format().data(), static_cast(this->_internal_output_format().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SaveOutputParameter.output_format"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_output_format(), target); + } + + // optional string label_map_file = 4; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_label_map_file().data(), static_cast(this->_internal_label_map_file().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SaveOutputParameter.label_map_file"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_label_map_file(), target); + } + + // optional string name_size_file = 5; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name_size_file().data(), static_cast(this->_internal_name_size_file().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.SaveOutputParameter.name_size_file"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_name_size_file(), target); + } + + // optional uint32 num_test_image = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_num_test_image(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SaveOutputParameter) + return target; +} + +size_t SaveOutputParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SaveOutputParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional string output_directory = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_output_directory()); + } + + // optional string output_name_prefix = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_output_name_prefix()); + } + + // optional string output_format = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_output_format()); + } + + // optional string label_map_file = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_label_map_file()); + } + + // optional string name_size_file = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name_size_file()); + } + + // optional uint32 num_test_image = 6; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_test_image()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SaveOutputParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SaveOutputParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SaveOutputParameter::GetClassData() const { return &_class_data_; } + +void SaveOutputParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void SaveOutputParameter::MergeFrom(const SaveOutputParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SaveOutputParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_output_directory(from._internal_output_directory()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_output_name_prefix(from._internal_output_name_prefix()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_output_format(from._internal_output_format()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_label_map_file(from._internal_label_map_file()); + } + if (cached_has_bits & 0x00000010u) { + _internal_set_name_size_file(from._internal_name_size_file()); + } + if (cached_has_bits & 0x00000020u) { + num_test_image_ = from.num_test_image_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SaveOutputParameter::CopyFrom(const SaveOutputParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SaveOutputParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SaveOutputParameter::IsInitialized() const { + return true; +} + +void SaveOutputParameter::InternalSwap(SaveOutputParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &output_directory_, lhs_arena, + &other->output_directory_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &output_name_prefix_, lhs_arena, + &other->output_name_prefix_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &output_format_, lhs_arena, + &other->output_format_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &label_map_file_, lhs_arena, + &other->label_map_file_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_size_file_, lhs_arena, + &other->name_size_file_, rhs_arena + ); + swap(num_test_image_, other->num_test_image_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SaveOutputParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[28]); +} + +// =================================================================== + +class DropoutParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_dropout_ratio(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_scale_train(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +DropoutParameter::DropoutParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.DropoutParameter) +} +DropoutParameter::DropoutParameter(const DropoutParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&dropout_ratio_, &from.dropout_ratio_, + static_cast(reinterpret_cast(&scale_train_) - + reinterpret_cast(&dropout_ratio_)) + sizeof(scale_train_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.DropoutParameter) +} + +inline void DropoutParameter::SharedCtor() { +dropout_ratio_ = 0.5f; +scale_train_ = true; +} + +DropoutParameter::~DropoutParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.DropoutParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void DropoutParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void DropoutParameter::ArenaDtor(void* object) { + DropoutParameter* _this = reinterpret_cast< DropoutParameter* >(object); + (void)_this; +} +void DropoutParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DropoutParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DropoutParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.DropoutParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + dropout_ratio_ = 0.5f; + scale_train_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DropoutParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float dropout_ratio = 1 [default = 0.5]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_dropout_ratio(&has_bits); + dropout_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional bool scale_train = 2 [default = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_scale_train(&has_bits); + scale_train_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DropoutParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DropoutParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float dropout_ratio = 1 [default = 0.5]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_dropout_ratio(), target); + } + + // optional bool scale_train = 2 [default = true]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_scale_train(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DropoutParameter) + return target; +} + +size_t DropoutParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DropoutParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional float dropout_ratio = 1 [default = 0.5]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional bool scale_train = 2 [default = true]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DropoutParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DropoutParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DropoutParameter::GetClassData() const { return &_class_data_; } + +void DropoutParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void DropoutParameter::MergeFrom(const DropoutParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DropoutParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + dropout_ratio_ = from.dropout_ratio_; + } + if (cached_has_bits & 0x00000002u) { + scale_train_ = from.scale_train_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void DropoutParameter::CopyFrom(const DropoutParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DropoutParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DropoutParameter::IsInitialized() const { + return true; +} + +void DropoutParameter::InternalSwap(DropoutParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(dropout_ratio_, other->dropout_ratio_); + swap(scale_train_, other->scale_train_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DropoutParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[29]); +} + +// =================================================================== + +class DummyDataParameter::_Internal { + public: +}; + +DummyDataParameter::DummyDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + data_filler_(arena), + num_(arena), + channels_(arena), + height_(arena), + width_(arena), + shape_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.DummyDataParameter) +} +DummyDataParameter::DummyDataParameter(const DummyDataParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + data_filler_(from.data_filler_), + num_(from.num_), + channels_(from.channels_), + height_(from.height_), + width_(from.width_), + shape_(from.shape_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.DummyDataParameter) +} + +inline void DummyDataParameter::SharedCtor() { +} + +DummyDataParameter::~DummyDataParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.DummyDataParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void DummyDataParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void DummyDataParameter::ArenaDtor(void* object) { + DummyDataParameter* _this = reinterpret_cast< DummyDataParameter* >(object); + (void)_this; +} +void DummyDataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DummyDataParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DummyDataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.DummyDataParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + data_filler_.Clear(); + num_.Clear(); + channels_.Clear(); + height_.Clear(); + width_.Clear(); + shape_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DummyDataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .opencv_caffe.FillerParameter data_filler = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_data_filler(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // repeated uint32 num = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_num(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); + } else if (static_cast(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_num(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 channels = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_channels(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); + } else if (static_cast(tag) == 26) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_channels(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 height = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_height(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); + } else if (static_cast(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_height(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 width = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_width(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<40>(ptr)); + } else if (static_cast(tag) == 42) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_width(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.BlobShape shape = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_shape(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DummyDataParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DummyDataParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .opencv_caffe.FillerParameter data_filler = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_data_filler_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_data_filler(i), target, stream); + } + + // repeated uint32 num = 2; + for (int i = 0, n = this->_internal_num_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_num(i), target); + } + + // repeated uint32 channels = 3; + for (int i = 0, n = this->_internal_channels_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_channels(i), target); + } + + // repeated uint32 height = 4; + for (int i = 0, n = this->_internal_height_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_height(i), target); + } + + // repeated uint32 width = 5; + for (int i = 0, n = this->_internal_width_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_width(i), target); + } + + // repeated .opencv_caffe.BlobShape shape = 6; + for (unsigned int i = 0, + n = static_cast(this->_internal_shape_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, this->_internal_shape(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DummyDataParameter) + return target; +} + +size_t DummyDataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DummyDataParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .opencv_caffe.FillerParameter data_filler = 1; + total_size += 1UL * this->_internal_data_filler_size(); + for (const auto& msg : this->data_filler_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated uint32 num = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->num_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_num_size()); + total_size += data_size; + } + + // repeated uint32 channels = 3; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->channels_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_channels_size()); + total_size += data_size; + } + + // repeated uint32 height = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->height_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_height_size()); + total_size += data_size; + } + + // repeated uint32 width = 5; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->width_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_width_size()); + total_size += data_size; + } + + // repeated .opencv_caffe.BlobShape shape = 6; + total_size += 1UL * this->_internal_shape_size(); + for (const auto& msg : this->shape_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DummyDataParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DummyDataParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DummyDataParameter::GetClassData() const { return &_class_data_; } + +void DummyDataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void DummyDataParameter::MergeFrom(const DummyDataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DummyDataParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + data_filler_.MergeFrom(from.data_filler_); + num_.MergeFrom(from.num_); + channels_.MergeFrom(from.channels_); + height_.MergeFrom(from.height_); + width_.MergeFrom(from.width_); + shape_.MergeFrom(from.shape_); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void DummyDataParameter::CopyFrom(const DummyDataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DummyDataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DummyDataParameter::IsInitialized() const { + return true; +} + +void DummyDataParameter::InternalSwap(DummyDataParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + data_filler_.InternalSwap(&other->data_filler_); + num_.InternalSwap(&other->num_); + channels_.InternalSwap(&other->channels_); + height_.InternalSwap(&other->height_); + width_.InternalSwap(&other->width_); + shape_.InternalSwap(&other->shape_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DummyDataParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[30]); +} + +// =================================================================== + +class EltwiseParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_operation(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_stable_prod_grad(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +EltwiseParameter::EltwiseParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + coeff_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.EltwiseParameter) +} +EltwiseParameter::EltwiseParameter(const EltwiseParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + coeff_(from.coeff_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&operation_, &from.operation_, + static_cast(reinterpret_cast(&stable_prod_grad_) - + reinterpret_cast(&operation_)) + sizeof(stable_prod_grad_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.EltwiseParameter) +} + +inline void EltwiseParameter::SharedCtor() { +operation_ = 1; +stable_prod_grad_ = true; +} + +EltwiseParameter::~EltwiseParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.EltwiseParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void EltwiseParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void EltwiseParameter::ArenaDtor(void* object) { + EltwiseParameter* _this = reinterpret_cast< EltwiseParameter* >(object); + (void)_this; +} +void EltwiseParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void EltwiseParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void EltwiseParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.EltwiseParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + coeff_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + operation_ = 1; + stable_prod_grad_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* EltwiseParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::EltwiseParameter_EltwiseOp_IsValid(val))) { + _internal_set_operation(static_cast<::opencv_caffe::EltwiseParameter_EltwiseOp>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // repeated float coeff = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_coeff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<21>(ptr)); + } else if (static_cast(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_coeff(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool stable_prod_grad = 3 [default = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_stable_prod_grad(&has_bits); + stable_prod_grad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* EltwiseParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.EltwiseParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_operation(), target); + } + + // repeated float coeff = 2; + for (int i = 0, n = this->_internal_coeff_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_coeff(i), target); + } + + // optional bool stable_prod_grad = 3 [default = true]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_stable_prod_grad(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.EltwiseParameter) + return target; +} + +size_t EltwiseParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.EltwiseParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float coeff = 2; + { + unsigned int count = static_cast(this->_internal_coeff_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_coeff_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_operation()); + } + + // optional bool stable_prod_grad = 3 [default = true]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData EltwiseParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + EltwiseParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*EltwiseParameter::GetClassData() const { return &_class_data_; } + +void EltwiseParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void EltwiseParameter::MergeFrom(const EltwiseParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.EltwiseParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + coeff_.MergeFrom(from.coeff_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + operation_ = from.operation_; + } + if (cached_has_bits & 0x00000002u) { + stable_prod_grad_ = from.stable_prod_grad_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void EltwiseParameter::CopyFrom(const EltwiseParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.EltwiseParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EltwiseParameter::IsInitialized() const { + return true; +} + +void EltwiseParameter::InternalSwap(EltwiseParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + coeff_.InternalSwap(&other->coeff_); + swap(operation_, other->operation_); + swap(stable_prod_grad_, other->stable_prod_grad_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata EltwiseParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[31]); +} + +// =================================================================== + +class ELUParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_alpha(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ELUParameter::ELUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ELUParameter) +} +ELUParameter::ELUParameter(const ELUParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + alpha_ = from.alpha_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ELUParameter) +} + +inline void ELUParameter::SharedCtor() { +alpha_ = 1; +} + +ELUParameter::~ELUParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ELUParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ELUParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ELUParameter::ArenaDtor(void* object) { + ELUParameter* _this = reinterpret_cast< ELUParameter* >(object); + (void)_this; +} +void ELUParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ELUParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ELUParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ELUParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + alpha_ = 1; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ELUParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float alpha = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_alpha(&has_bits); + alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ELUParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ELUParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float alpha = 1 [default = 1]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_alpha(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ELUParameter) + return target; +} + +size_t ELUParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ELUParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional float alpha = 1 [default = 1]; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ELUParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ELUParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ELUParameter::GetClassData() const { return &_class_data_; } + +void ELUParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ELUParameter::MergeFrom(const ELUParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ELUParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_alpha()) { + _internal_set_alpha(from._internal_alpha()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ELUParameter::CopyFrom(const ELUParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ELUParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ELUParameter::IsInitialized() const { + return true; +} + +void ELUParameter::InternalSwap(ELUParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(alpha_, other->alpha_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ELUParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[32]); +} + +// =================================================================== + +class EmbedParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_num_output(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_input_dim(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_bias_term(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::opencv_caffe::FillerParameter& weight_filler(const EmbedParameter* msg); + static void set_has_weight_filler(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::opencv_caffe::FillerParameter& bias_filler(const EmbedParameter* msg); + static void set_has_bias_filler(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::opencv_caffe::FillerParameter& +EmbedParameter::_Internal::weight_filler(const EmbedParameter* msg) { + return *msg->weight_filler_; +} +const ::opencv_caffe::FillerParameter& +EmbedParameter::_Internal::bias_filler(const EmbedParameter* msg) { + return *msg->bias_filler_; +} +EmbedParameter::EmbedParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.EmbedParameter) +} +EmbedParameter::EmbedParameter(const EmbedParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_weight_filler()) { + weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); + } else { + weight_filler_ = nullptr; + } + if (from._internal_has_bias_filler()) { + bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); + } else { + bias_filler_ = nullptr; + } + ::memcpy(&num_output_, &from.num_output_, + static_cast(reinterpret_cast(&bias_term_) - + reinterpret_cast(&num_output_)) + sizeof(bias_term_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.EmbedParameter) +} + +inline void EmbedParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&input_dim_) - + reinterpret_cast(&weight_filler_)) + sizeof(input_dim_)); +bias_term_ = true; +} + +EmbedParameter::~EmbedParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.EmbedParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void EmbedParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete weight_filler_; + if (this != internal_default_instance()) delete bias_filler_; +} + +void EmbedParameter::ArenaDtor(void* object) { + EmbedParameter* _this = reinterpret_cast< EmbedParameter* >(object); + (void)_this; +} +void EmbedParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void EmbedParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void EmbedParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.EmbedParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(weight_filler_ != nullptr); + weight_filler_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(bias_filler_ != nullptr); + bias_filler_->Clear(); + } + } + if (cached_has_bits & 0x0000001cu) { + ::memset(&num_output_, 0, static_cast( + reinterpret_cast(&input_dim_) - + reinterpret_cast(&num_output_)) + sizeof(input_dim_)); + bias_term_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* EmbedParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 num_output = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_num_output(&has_bits); + num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 input_dim = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_input_dim(&has_bits); + input_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool bias_term = 3 [default = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_bias_term(&has_bits); + bias_term_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter weight_filler = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter bias_filler = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* EmbedParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.EmbedParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 num_output = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_output(), target); + } + + // optional uint32 input_dim = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_input_dim(), target); + } + + // optional bool bias_term = 3 [default = true]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_bias_term(), target); + } + + // optional .opencv_caffe.FillerParameter weight_filler = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::weight_filler(this), target, stream); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 5; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::bias_filler(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.EmbedParameter) + return target; +} + +size_t EmbedParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.EmbedParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional .opencv_caffe.FillerParameter weight_filler = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *weight_filler_); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bias_filler_); + } + + // optional uint32 num_output = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); + } + + // optional uint32 input_dim = 2; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_input_dim()); + } + + // optional bool bias_term = 3 [default = true]; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData EmbedParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + EmbedParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*EmbedParameter::GetClassData() const { return &_class_data_; } + +void EmbedParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void EmbedParameter::MergeFrom(const EmbedParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.EmbedParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); + } + if (cached_has_bits & 0x00000004u) { + num_output_ = from.num_output_; + } + if (cached_has_bits & 0x00000008u) { + input_dim_ = from.input_dim_; + } + if (cached_has_bits & 0x00000010u) { + bias_term_ = from.bias_term_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void EmbedParameter::CopyFrom(const EmbedParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.EmbedParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EmbedParameter::IsInitialized() const { + return true; +} + +void EmbedParameter::InternalSwap(EmbedParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(EmbedParameter, input_dim_) + + sizeof(EmbedParameter::input_dim_) + - PROTOBUF_FIELD_OFFSET(EmbedParameter, weight_filler_)>( + reinterpret_cast(&weight_filler_), + reinterpret_cast(&other->weight_filler_)); + swap(bias_term_, other->bias_term_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata EmbedParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[33]); +} + +// =================================================================== + +class ExpParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_base(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_shift(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ExpParameter::ExpParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ExpParameter) +} +ExpParameter::ExpParameter(const ExpParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&shift_, &from.shift_, + static_cast(reinterpret_cast(&scale_) - + reinterpret_cast(&shift_)) + sizeof(scale_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ExpParameter) +} + +inline void ExpParameter::SharedCtor() { +shift_ = 0; +base_ = -1; +scale_ = 1; +} + +ExpParameter::~ExpParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ExpParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ExpParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ExpParameter::ArenaDtor(void* object) { + ExpParameter* _this = reinterpret_cast< ExpParameter* >(object); + (void)_this; +} +void ExpParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ExpParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ExpParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ExpParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + shift_ = 0; + base_ = -1; + scale_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ExpParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float base = 1 [default = -1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_base(&has_bits); + base_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float scale = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_scale(&has_bits); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float shift = 3 [default = 0]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_shift(&has_bits); + shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ExpParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ExpParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float base = 1 [default = -1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_base(), target); + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); + } + + // optional float shift = 3 [default = 0]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_shift(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ExpParameter) + return target; +} + +size_t ExpParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ExpParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional float shift = 3 [default = 0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float base = 1 [default = -1]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExpParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ExpParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExpParameter::GetClassData() const { return &_class_data_; } + +void ExpParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ExpParameter::MergeFrom(const ExpParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ExpParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + shift_ = from.shift_; + } + if (cached_has_bits & 0x00000002u) { + base_ = from.base_; + } + if (cached_has_bits & 0x00000004u) { + scale_ = from.scale_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ExpParameter::CopyFrom(const ExpParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ExpParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ExpParameter::IsInitialized() const { + return true; +} + +void ExpParameter::InternalSwap(ExpParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(shift_, other->shift_); + swap(base_, other->base_); + swap(scale_, other->scale_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ExpParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[34]); +} + +// =================================================================== + +class FlattenParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_end_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +FlattenParameter::FlattenParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.FlattenParameter) +} +FlattenParameter::FlattenParameter(const FlattenParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&axis_, &from.axis_, + static_cast(reinterpret_cast(&end_axis_) - + reinterpret_cast(&axis_)) + sizeof(end_axis_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.FlattenParameter) +} + +inline void FlattenParameter::SharedCtor() { +axis_ = 1; +end_axis_ = -1; +} + +FlattenParameter::~FlattenParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.FlattenParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void FlattenParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void FlattenParameter::ArenaDtor(void* object) { + FlattenParameter* _this = reinterpret_cast< FlattenParameter* >(object); + (void)_this; +} +void FlattenParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FlattenParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FlattenParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.FlattenParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + axis_ = 1; + end_axis_ = -1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FlattenParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 axis = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 end_axis = 2 [default = -1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_end_axis(&has_bits); + end_axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FlattenParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.FlattenParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 axis = 1 [default = 1]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); + } + + // optional int32 end_axis = 2 [default = -1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end_axis(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.FlattenParameter) + return target; +} + +size_t FlattenParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.FlattenParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int32 axis = 1 [default = 1]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + // optional int32 end_axis = 2 [default = -1]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_end_axis()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FlattenParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FlattenParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FlattenParameter::GetClassData() const { return &_class_data_; } + +void FlattenParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void FlattenParameter::MergeFrom(const FlattenParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.FlattenParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + axis_ = from.axis_; + } + if (cached_has_bits & 0x00000002u) { + end_axis_ = from.end_axis_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void FlattenParameter::CopyFrom(const FlattenParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.FlattenParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FlattenParameter::IsInitialized() const { + return true; +} + +void FlattenParameter::InternalSwap(FlattenParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(axis_, other->axis_); + swap(end_axis_, other->end_axis_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FlattenParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[35]); +} + +// =================================================================== + +class HDF5DataParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_source(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_batch_size(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_shuffle(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +HDF5DataParameter::HDF5DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.HDF5DataParameter) +} +HDF5DataParameter::HDF5DataParameter(const HDF5DataParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_source()) { + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), + GetArenaForAllocation()); + } + ::memcpy(&batch_size_, &from.batch_size_, + static_cast(reinterpret_cast(&shuffle_) - + reinterpret_cast(&batch_size_)) + sizeof(shuffle_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.HDF5DataParameter) +} + +inline void HDF5DataParameter::SharedCtor() { +source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&batch_size_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&shuffle_) - + reinterpret_cast(&batch_size_)) + sizeof(shuffle_)); +} + +HDF5DataParameter::~HDF5DataParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.HDF5DataParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void HDF5DataParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HDF5DataParameter::ArenaDtor(void* object) { + HDF5DataParameter* _this = reinterpret_cast< HDF5DataParameter* >(object); + (void)_this; +} +void HDF5DataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void HDF5DataParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void HDF5DataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.HDF5DataParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + source_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&batch_size_, 0, static_cast( + reinterpret_cast(&shuffle_) - + reinterpret_cast(&batch_size_)) + sizeof(shuffle_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HDF5DataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string source = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_source(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.HDF5DataParameter.source"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 batch_size = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_batch_size(&has_bits); + batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool shuffle = 3 [default = false]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_shuffle(&has_bits); + shuffle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HDF5DataParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HDF5DataParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_source().data(), static_cast(this->_internal_source().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.HDF5DataParameter.source"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_source(), target); + } + + // optional uint32 batch_size = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_batch_size(), target); + } + + // optional bool shuffle = 3 [default = false]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_shuffle(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HDF5DataParameter) + return target; +} + +size_t HDF5DataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HDF5DataParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_source()); + } + + // optional uint32 batch_size = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); + } + + // optional bool shuffle = 3 [default = false]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HDF5DataParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + HDF5DataParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HDF5DataParameter::GetClassData() const { return &_class_data_; } + +void HDF5DataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void HDF5DataParameter::MergeFrom(const HDF5DataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HDF5DataParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_source(from._internal_source()); + } + if (cached_has_bits & 0x00000002u) { + batch_size_ = from.batch_size_; + } + if (cached_has_bits & 0x00000004u) { + shuffle_ = from.shuffle_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HDF5DataParameter::CopyFrom(const HDF5DataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HDF5DataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HDF5DataParameter::IsInitialized() const { + return true; +} + +void HDF5DataParameter::InternalSwap(HDF5DataParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &source_, lhs_arena, + &other->source_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(HDF5DataParameter, shuffle_) + + sizeof(HDF5DataParameter::shuffle_) + - PROTOBUF_FIELD_OFFSET(HDF5DataParameter, batch_size_)>( + reinterpret_cast(&batch_size_), + reinterpret_cast(&other->batch_size_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HDF5DataParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[36]); +} + +// =================================================================== + +class HDF5OutputParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_file_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +HDF5OutputParameter::HDF5OutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.HDF5OutputParameter) +} +HDF5OutputParameter::HDF5OutputParameter(const HDF5OutputParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_file_name()) { + file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_file_name(), + GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:opencv_caffe.HDF5OutputParameter) +} + +inline void HDF5OutputParameter::SharedCtor() { +file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +HDF5OutputParameter::~HDF5OutputParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.HDF5OutputParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void HDF5OutputParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + file_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HDF5OutputParameter::ArenaDtor(void* object) { + HDF5OutputParameter* _this = reinterpret_cast< HDF5OutputParameter* >(object); + (void)_this; +} +void HDF5OutputParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void HDF5OutputParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void HDF5OutputParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.HDF5OutputParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + file_name_.ClearNonDefaultToEmpty(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HDF5OutputParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string file_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_file_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.HDF5OutputParameter.file_name"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HDF5OutputParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HDF5OutputParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string file_name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_file_name().data(), static_cast(this->_internal_file_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.HDF5OutputParameter.file_name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_file_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HDF5OutputParameter) + return target; +} + +size_t HDF5OutputParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HDF5OutputParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string file_name = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_file_name()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HDF5OutputParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + HDF5OutputParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HDF5OutputParameter::GetClassData() const { return &_class_data_; } + +void HDF5OutputParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void HDF5OutputParameter::MergeFrom(const HDF5OutputParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HDF5OutputParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_file_name()) { + _internal_set_file_name(from._internal_file_name()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HDF5OutputParameter::CopyFrom(const HDF5OutputParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HDF5OutputParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HDF5OutputParameter::IsInitialized() const { + return true; +} + +void HDF5OutputParameter::InternalSwap(HDF5OutputParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &file_name_, lhs_arena, + &other->file_name_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HDF5OutputParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[37]); +} + +// =================================================================== + +class HingeLossParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_norm(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +HingeLossParameter::HingeLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.HingeLossParameter) +} +HingeLossParameter::HingeLossParameter(const HingeLossParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + norm_ = from.norm_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.HingeLossParameter) +} + +inline void HingeLossParameter::SharedCtor() { +norm_ = 1; +} + +HingeLossParameter::~HingeLossParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.HingeLossParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void HingeLossParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void HingeLossParameter::ArenaDtor(void* object) { + HingeLossParameter* _this = reinterpret_cast< HingeLossParameter* >(object); + (void)_this; +} +void HingeLossParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void HingeLossParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void HingeLossParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.HingeLossParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + norm_ = 1; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HingeLossParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::HingeLossParameter_Norm_IsValid(val))) { + _internal_set_norm(static_cast<::opencv_caffe::HingeLossParameter_Norm>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HingeLossParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HingeLossParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_norm(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HingeLossParameter) + return target; +} + +size_t HingeLossParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HingeLossParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_norm()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HingeLossParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + HingeLossParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HingeLossParameter::GetClassData() const { return &_class_data_; } + +void HingeLossParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void HingeLossParameter::MergeFrom(const HingeLossParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HingeLossParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_norm()) { + _internal_set_norm(from._internal_norm()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HingeLossParameter::CopyFrom(const HingeLossParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HingeLossParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HingeLossParameter::IsInitialized() const { + return true; +} + +void HingeLossParameter::InternalSwap(HingeLossParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(norm_, other->norm_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HingeLossParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[38]); +} + +// =================================================================== + +class ImageDataParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_source(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_batch_size(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_rand_skip(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_shuffle(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_new_height(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_new_width(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_is_color(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_mean_file(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_crop_size(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_mirror(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_root_folder(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ImageDataParameter::ImageDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ImageDataParameter) +} +ImageDataParameter::ImageDataParameter(const ImageDataParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_source()) { + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), + GetArenaForAllocation()); + } + mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mean_file()) { + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mean_file(), + GetArenaForAllocation()); + } + root_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_root_folder()) { + root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_root_folder(), + GetArenaForAllocation()); + } + ::memcpy(&crop_size_, &from.crop_size_, + static_cast(reinterpret_cast(&batch_size_) - + reinterpret_cast(&crop_size_)) + sizeof(batch_size_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ImageDataParameter) +} + +inline void ImageDataParameter::SharedCtor() { +source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +root_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&crop_size_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&new_width_) - + reinterpret_cast(&crop_size_)) + sizeof(new_width_)); +is_color_ = true; +scale_ = 1; +batch_size_ = 1u; +} + +ImageDataParameter::~ImageDataParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ImageDataParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ImageDataParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + mean_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + root_folder_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ImageDataParameter::ArenaDtor(void* object) { + ImageDataParameter* _this = reinterpret_cast< ImageDataParameter* >(object); + (void)_this; +} +void ImageDataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ImageDataParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ImageDataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ImageDataParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + source_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + mean_file_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + root_folder_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000f8u) { + ::memset(&crop_size_, 0, static_cast( + reinterpret_cast(&new_height_) - + reinterpret_cast(&crop_size_)) + sizeof(new_height_)); + } + if (cached_has_bits & 0x00000f00u) { + new_width_ = 0u; + is_color_ = true; + scale_ = 1; + batch_size_ = 1u; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ImageDataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string source = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_source(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.ImageDataParameter.source"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float scale = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_scale(&has_bits); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional string mean_file = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_mean_file(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.ImageDataParameter.mean_file"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 batch_size = 4 [default = 1]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_batch_size(&has_bits); + batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 crop_size = 5 [default = 0]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_crop_size(&has_bits); + crop_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool mirror = 6 [default = false]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_mirror(&has_bits); + mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 rand_skip = 7 [default = 0]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_rand_skip(&has_bits); + rand_skip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool shuffle = 8 [default = false]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_shuffle(&has_bits); + shuffle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 new_height = 9 [default = 0]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_new_height(&has_bits); + new_height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 new_width = 10 [default = 0]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_new_width(&has_bits); + new_width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool is_color = 11 [default = true]; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + _Internal::set_has_is_color(&has_bits); + is_color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string root_folder = 12 [default = ""]; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + auto str = _internal_mutable_root_folder(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.ImageDataParameter.root_folder"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ImageDataParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ImageDataParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_source().data(), static_cast(this->_internal_source().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.ImageDataParameter.source"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_source(), target); + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); + } + + // optional string mean_file = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mean_file().data(), static_cast(this->_internal_mean_file().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.ImageDataParameter.mean_file"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_mean_file(), target); + } + + // optional uint32 batch_size = 4 [default = 1]; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_batch_size(), target); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_crop_size(), target); + } + + // optional bool mirror = 6 [default = false]; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_mirror(), target); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_rand_skip(), target); + } + + // optional bool shuffle = 8 [default = false]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_shuffle(), target); + } + + // optional uint32 new_height = 9 [default = 0]; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_new_height(), target); + } + + // optional uint32 new_width = 10 [default = 0]; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_new_width(), target); + } + + // optional bool is_color = 11 [default = true]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_is_color(), target); + } + + // optional string root_folder = 12 [default = ""]; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_root_folder().data(), static_cast(this->_internal_root_folder().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.ImageDataParameter.root_folder"); + target = stream->WriteStringMaybeAliased( + 12, this->_internal_root_folder(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ImageDataParameter) + return target; +} + +size_t ImageDataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ImageDataParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_source()); + } + + // optional string mean_file = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mean_file()); + } + + // optional string root_folder = 12 [default = ""]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_root_folder()); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_crop_size()); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_rand_skip()); + } + + // optional bool shuffle = 8 [default = false]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional bool mirror = 6 [default = false]; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 1; + } + + // optional uint32 new_height = 9 [default = 0]; + if (cached_has_bits & 0x00000080u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_new_height()); + } + + } + if (cached_has_bits & 0x00000f00u) { + // optional uint32 new_width = 10 [default = 0]; + if (cached_has_bits & 0x00000100u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_new_width()); + } + + // optional bool is_color = 11 [default = true]; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 1; + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 4; + } + + // optional uint32 batch_size = 4 [default = 1]; + if (cached_has_bits & 0x00000800u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ImageDataParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ImageDataParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ImageDataParameter::GetClassData() const { return &_class_data_; } + +void ImageDataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ImageDataParameter::MergeFrom(const ImageDataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ImageDataParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_source(from._internal_source()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_mean_file(from._internal_mean_file()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_root_folder(from._internal_root_folder()); + } + if (cached_has_bits & 0x00000008u) { + crop_size_ = from.crop_size_; + } + if (cached_has_bits & 0x00000010u) { + rand_skip_ = from.rand_skip_; + } + if (cached_has_bits & 0x00000020u) { + shuffle_ = from.shuffle_; + } + if (cached_has_bits & 0x00000040u) { + mirror_ = from.mirror_; + } + if (cached_has_bits & 0x00000080u) { + new_height_ = from.new_height_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00000100u) { + new_width_ = from.new_width_; + } + if (cached_has_bits & 0x00000200u) { + is_color_ = from.is_color_; + } + if (cached_has_bits & 0x00000400u) { + scale_ = from.scale_; + } + if (cached_has_bits & 0x00000800u) { + batch_size_ = from.batch_size_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ImageDataParameter::CopyFrom(const ImageDataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ImageDataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ImageDataParameter::IsInitialized() const { + return true; +} + +void ImageDataParameter::InternalSwap(ImageDataParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &source_, lhs_arena, + &other->source_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &mean_file_, lhs_arena, + &other->mean_file_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &root_folder_, lhs_arena, + &other->root_folder_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ImageDataParameter, new_width_) + + sizeof(ImageDataParameter::new_width_) + - PROTOBUF_FIELD_OFFSET(ImageDataParameter, crop_size_)>( + reinterpret_cast(&crop_size_), + reinterpret_cast(&other->crop_size_)); + swap(is_color_, other->is_color_); + swap(scale_, other->scale_); + swap(batch_size_, other->batch_size_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ImageDataParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[39]); +} + +// =================================================================== + +class InfogainLossParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_source(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +InfogainLossParameter::InfogainLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.InfogainLossParameter) +} +InfogainLossParameter::InfogainLossParameter(const InfogainLossParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_source()) { + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), + GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:opencv_caffe.InfogainLossParameter) +} + +inline void InfogainLossParameter::SharedCtor() { +source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +InfogainLossParameter::~InfogainLossParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.InfogainLossParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void InfogainLossParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void InfogainLossParameter::ArenaDtor(void* object) { + InfogainLossParameter* _this = reinterpret_cast< InfogainLossParameter* >(object); + (void)_this; +} +void InfogainLossParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void InfogainLossParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void InfogainLossParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.InfogainLossParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + source_.ClearNonDefaultToEmpty(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* InfogainLossParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string source = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_source(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.InfogainLossParameter.source"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* InfogainLossParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InfogainLossParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_source().data(), static_cast(this->_internal_source().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.InfogainLossParameter.source"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_source(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InfogainLossParameter) + return target; +} + +size_t InfogainLossParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InfogainLossParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string source = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_source()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InfogainLossParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + InfogainLossParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InfogainLossParameter::GetClassData() const { return &_class_data_; } + +void InfogainLossParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void InfogainLossParameter::MergeFrom(const InfogainLossParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InfogainLossParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_source()) { + _internal_set_source(from._internal_source()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void InfogainLossParameter::CopyFrom(const InfogainLossParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InfogainLossParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InfogainLossParameter::IsInitialized() const { + return true; +} + +void InfogainLossParameter::InternalSwap(InfogainLossParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &source_, lhs_arena, + &other->source_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata InfogainLossParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[40]); +} + +// =================================================================== + +class InnerProductParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_num_output(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_bias_term(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::opencv_caffe::FillerParameter& weight_filler(const InnerProductParameter* msg); + static void set_has_weight_filler(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::opencv_caffe::FillerParameter& bias_filler(const InnerProductParameter* msg); + static void set_has_bias_filler(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_transpose(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::opencv_caffe::FillerParameter& +InnerProductParameter::_Internal::weight_filler(const InnerProductParameter* msg) { + return *msg->weight_filler_; +} +const ::opencv_caffe::FillerParameter& +InnerProductParameter::_Internal::bias_filler(const InnerProductParameter* msg) { + return *msg->bias_filler_; +} +InnerProductParameter::InnerProductParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.InnerProductParameter) +} +InnerProductParameter::InnerProductParameter(const InnerProductParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_weight_filler()) { + weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); + } else { + weight_filler_ = nullptr; + } + if (from._internal_has_bias_filler()) { + bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); + } else { + bias_filler_ = nullptr; + } + ::memcpy(&num_output_, &from.num_output_, + static_cast(reinterpret_cast(&axis_) - + reinterpret_cast(&num_output_)) + sizeof(axis_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.InnerProductParameter) +} + +inline void InnerProductParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&transpose_) - + reinterpret_cast(&weight_filler_)) + sizeof(transpose_)); +bias_term_ = true; +axis_ = 1; +} + +InnerProductParameter::~InnerProductParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.InnerProductParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void InnerProductParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete weight_filler_; + if (this != internal_default_instance()) delete bias_filler_; +} + +void InnerProductParameter::ArenaDtor(void* object) { + InnerProductParameter* _this = reinterpret_cast< InnerProductParameter* >(object); + (void)_this; +} +void InnerProductParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void InnerProductParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void InnerProductParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.InnerProductParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(weight_filler_ != nullptr); + weight_filler_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(bias_filler_ != nullptr); + bias_filler_->Clear(); + } + } + if (cached_has_bits & 0x0000003cu) { + ::memset(&num_output_, 0, static_cast( + reinterpret_cast(&transpose_) - + reinterpret_cast(&num_output_)) + sizeof(transpose_)); + bias_term_ = true; + axis_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* InnerProductParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 num_output = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_num_output(&has_bits); + num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool bias_term = 2 [default = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_bias_term(&has_bits); + bias_term_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter weight_filler = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter bias_filler = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 axis = 5 [default = 1]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool transpose = 6 [default = false]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_transpose(&has_bits); + transpose_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* InnerProductParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InnerProductParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 num_output = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_output(), target); + } + + // optional bool bias_term = 2 [default = true]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_bias_term(), target); + } + + // optional .opencv_caffe.FillerParameter weight_filler = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::weight_filler(this), target, stream); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::bias_filler(this), target, stream); + } + + // optional int32 axis = 5 [default = 1]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_axis(), target); + } + + // optional bool transpose = 6 [default = false]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_transpose(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InnerProductParameter) + return target; +} + +size_t InnerProductParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InnerProductParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional .opencv_caffe.FillerParameter weight_filler = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *weight_filler_); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bias_filler_); + } + + // optional uint32 num_output = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); + } + + // optional bool transpose = 6 [default = false]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + // optional bool bias_term = 2 [default = true]; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 1; + } + + // optional int32 axis = 5 [default = 1]; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InnerProductParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + InnerProductParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InnerProductParameter::GetClassData() const { return &_class_data_; } + +void InnerProductParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void InnerProductParameter::MergeFrom(const InnerProductParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InnerProductParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); + } + if (cached_has_bits & 0x00000004u) { + num_output_ = from.num_output_; + } + if (cached_has_bits & 0x00000008u) { + transpose_ = from.transpose_; + } + if (cached_has_bits & 0x00000010u) { + bias_term_ = from.bias_term_; + } + if (cached_has_bits & 0x00000020u) { + axis_ = from.axis_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void InnerProductParameter::CopyFrom(const InnerProductParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InnerProductParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InnerProductParameter::IsInitialized() const { + return true; +} + +void InnerProductParameter::InternalSwap(InnerProductParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(InnerProductParameter, transpose_) + + sizeof(InnerProductParameter::transpose_) + - PROTOBUF_FIELD_OFFSET(InnerProductParameter, weight_filler_)>( + reinterpret_cast(&weight_filler_), + reinterpret_cast(&other->weight_filler_)); + swap(bias_term_, other->bias_term_); + swap(axis_, other->axis_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata InnerProductParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[41]); +} + +// =================================================================== + +class InputParameter::_Internal { + public: +}; + +InputParameter::InputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + shape_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.InputParameter) +} +InputParameter::InputParameter(const InputParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + shape_(from.shape_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.InputParameter) +} + +inline void InputParameter::SharedCtor() { +} + +InputParameter::~InputParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.InputParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void InputParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void InputParameter::ArenaDtor(void* object) { + InputParameter* _this = reinterpret_cast< InputParameter* >(object); + (void)_this; +} +void InputParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void InputParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void InputParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.InputParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + shape_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* InputParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .opencv_caffe.BlobShape shape = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_shape(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* InputParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InputParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .opencv_caffe.BlobShape shape = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_shape_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_shape(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InputParameter) + return target; +} + +size_t InputParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InputParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .opencv_caffe.BlobShape shape = 1; + total_size += 1UL * this->_internal_shape_size(); + for (const auto& msg : this->shape_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InputParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + InputParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InputParameter::GetClassData() const { return &_class_data_; } + +void InputParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void InputParameter::MergeFrom(const InputParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InputParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + shape_.MergeFrom(from.shape_); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void InputParameter::CopyFrom(const InputParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InputParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InputParameter::IsInitialized() const { + return true; +} + +void InputParameter::InternalSwap(InputParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + shape_.InternalSwap(&other->shape_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata InputParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[42]); +} + +// =================================================================== + +class LogParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_base(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_shift(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +LogParameter::LogParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.LogParameter) +} +LogParameter::LogParameter(const LogParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&shift_, &from.shift_, + static_cast(reinterpret_cast(&scale_) - + reinterpret_cast(&shift_)) + sizeof(scale_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.LogParameter) +} + +inline void LogParameter::SharedCtor() { +shift_ = 0; +base_ = -1; +scale_ = 1; +} + +LogParameter::~LogParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.LogParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void LogParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void LogParameter::ArenaDtor(void* object) { + LogParameter* _this = reinterpret_cast< LogParameter* >(object); + (void)_this; +} +void LogParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void LogParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void LogParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.LogParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + shift_ = 0; + base_ = -1; + scale_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LogParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float base = 1 [default = -1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_base(&has_bits); + base_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float scale = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_scale(&has_bits); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float shift = 3 [default = 0]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_shift(&has_bits); + shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* LogParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LogParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float base = 1 [default = -1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_base(), target); + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); + } + + // optional float shift = 3 [default = 0]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_shift(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LogParameter) + return target; +} + +size_t LogParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LogParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional float shift = 3 [default = 0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float base = 1 [default = -1]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LogParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + LogParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LogParameter::GetClassData() const { return &_class_data_; } + +void LogParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void LogParameter::MergeFrom(const LogParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LogParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + shift_ = from.shift_; + } + if (cached_has_bits & 0x00000002u) { + base_ = from.base_; + } + if (cached_has_bits & 0x00000004u) { + scale_ = from.scale_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LogParameter::CopyFrom(const LogParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LogParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LogParameter::IsInitialized() const { + return true; +} + +void LogParameter::InternalSwap(LogParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(shift_, other->shift_); + swap(base_, other->base_); + swap(scale_, other->scale_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LogParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[43]); +} + +// =================================================================== + +class LRNParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_local_size(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_alpha(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_beta(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_norm_region(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_k(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_engine(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +LRNParameter::LRNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.LRNParameter) +} +LRNParameter::LRNParameter(const LRNParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&norm_region_, &from.norm_region_, + static_cast(reinterpret_cast(&k_) - + reinterpret_cast(&norm_region_)) + sizeof(k_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.LRNParameter) +} + +inline void LRNParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&norm_region_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&engine_) - + reinterpret_cast(&norm_region_)) + sizeof(engine_)); +local_size_ = 5u; +alpha_ = 1; +beta_ = 0.75f; +k_ = 1; +} + +LRNParameter::~LRNParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.LRNParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void LRNParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void LRNParameter::ArenaDtor(void* object) { + LRNParameter* _this = reinterpret_cast< LRNParameter* >(object); + (void)_this; +} +void LRNParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void LRNParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void LRNParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.LRNParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + ::memset(&norm_region_, 0, static_cast( + reinterpret_cast(&engine_) - + reinterpret_cast(&norm_region_)) + sizeof(engine_)); + local_size_ = 5u; + alpha_ = 1; + beta_ = 0.75f; + k_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LRNParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 local_size = 1 [default = 5]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_local_size(&has_bits); + local_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float alpha = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_alpha(&has_bits); + alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float beta = 3 [default = 0.75]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_beta(&has_bits); + beta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::LRNParameter_NormRegion_IsValid(val))) { + _internal_set_norm_region(static_cast<::opencv_caffe::LRNParameter_NormRegion>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional float k = 5 [default = 1]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { + _Internal::set_has_k(&has_bits); + k_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::LRNParameter_Engine_IsValid(val))) { + _internal_set_engine(static_cast<::opencv_caffe::LRNParameter_Engine>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* LRNParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LRNParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 local_size = 1 [default = 5]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_local_size(), target); + } + + // optional float alpha = 2 [default = 1]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_alpha(), target); + } + + // optional float beta = 3 [default = 0.75]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_beta(), target); + } + + // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_norm_region(), target); + } + + // optional float k = 5 [default = 1]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_k(), target); + } + + // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 6, this->_internal_engine(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LRNParameter) + return target; +} + +size_t LRNParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LRNParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_norm_region()); + } + + // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); + } + + // optional uint32 local_size = 1 [default = 5]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_local_size()); + } + + // optional float alpha = 2 [default = 1]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + // optional float beta = 3 [default = 0.75]; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 4; + } + + // optional float k = 5 [default = 1]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LRNParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + LRNParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LRNParameter::GetClassData() const { return &_class_data_; } + +void LRNParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void LRNParameter::MergeFrom(const LRNParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LRNParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + norm_region_ = from.norm_region_; + } + if (cached_has_bits & 0x00000002u) { + engine_ = from.engine_; + } + if (cached_has_bits & 0x00000004u) { + local_size_ = from.local_size_; + } + if (cached_has_bits & 0x00000008u) { + alpha_ = from.alpha_; + } + if (cached_has_bits & 0x00000010u) { + beta_ = from.beta_; + } + if (cached_has_bits & 0x00000020u) { + k_ = from.k_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LRNParameter::CopyFrom(const LRNParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LRNParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LRNParameter::IsInitialized() const { + return true; +} + +void LRNParameter::InternalSwap(LRNParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(LRNParameter, engine_) + + sizeof(LRNParameter::engine_) + - PROTOBUF_FIELD_OFFSET(LRNParameter, norm_region_)>( + reinterpret_cast(&norm_region_), + reinterpret_cast(&other->norm_region_)); + swap(local_size_, other->local_size_); + swap(alpha_, other->alpha_); + swap(beta_, other->beta_); + swap(k_, other->k_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LRNParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[44]); +} + +// =================================================================== + +class MemoryDataParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_batch_size(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_channels(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +MemoryDataParameter::MemoryDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.MemoryDataParameter) +} +MemoryDataParameter::MemoryDataParameter(const MemoryDataParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&batch_size_, &from.batch_size_, + static_cast(reinterpret_cast(&width_) - + reinterpret_cast(&batch_size_)) + sizeof(width_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.MemoryDataParameter) +} + +inline void MemoryDataParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&batch_size_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&width_) - + reinterpret_cast(&batch_size_)) + sizeof(width_)); +} + +MemoryDataParameter::~MemoryDataParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.MemoryDataParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void MemoryDataParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void MemoryDataParameter::ArenaDtor(void* object) { + MemoryDataParameter* _this = reinterpret_cast< MemoryDataParameter* >(object); + (void)_this; +} +void MemoryDataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MemoryDataParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MemoryDataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.MemoryDataParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + ::memset(&batch_size_, 0, static_cast( + reinterpret_cast(&width_) - + reinterpret_cast(&batch_size_)) + sizeof(width_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MemoryDataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 batch_size = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_batch_size(&has_bits); + batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 channels = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_channels(&has_bits); + channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 height = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_height(&has_bits); + height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 width = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_width(&has_bits); + width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MemoryDataParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.MemoryDataParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 batch_size = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_batch_size(), target); + } + + // optional uint32 channels = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_channels(), target); + } + + // optional uint32 height = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_height(), target); + } + + // optional uint32 width = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_width(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.MemoryDataParameter) + return target; +} + +size_t MemoryDataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.MemoryDataParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional uint32 batch_size = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); + } + + // optional uint32 channels = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_channels()); + } + + // optional uint32 height = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); + } + + // optional uint32 width = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MemoryDataParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + MemoryDataParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MemoryDataParameter::GetClassData() const { return &_class_data_; } + +void MemoryDataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void MemoryDataParameter::MergeFrom(const MemoryDataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.MemoryDataParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + batch_size_ = from.batch_size_; + } + if (cached_has_bits & 0x00000002u) { + channels_ = from.channels_; + } + if (cached_has_bits & 0x00000004u) { + height_ = from.height_; + } + if (cached_has_bits & 0x00000008u) { + width_ = from.width_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MemoryDataParameter::CopyFrom(const MemoryDataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.MemoryDataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MemoryDataParameter::IsInitialized() const { + return true; +} + +void MemoryDataParameter::InternalSwap(MemoryDataParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MemoryDataParameter, width_) + + sizeof(MemoryDataParameter::width_) + - PROTOBUF_FIELD_OFFSET(MemoryDataParameter, batch_size_)>( + reinterpret_cast(&batch_size_), + reinterpret_cast(&other->batch_size_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MemoryDataParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[45]); +} + +// =================================================================== + +class MVNParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_normalize_variance(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_across_channels(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_eps(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +MVNParameter::MVNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.MVNParameter) +} +MVNParameter::MVNParameter(const MVNParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&across_channels_, &from.across_channels_, + static_cast(reinterpret_cast(&eps_) - + reinterpret_cast(&across_channels_)) + sizeof(eps_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.MVNParameter) +} + +inline void MVNParameter::SharedCtor() { +across_channels_ = false; +normalize_variance_ = true; +eps_ = 1e-09f; +} + +MVNParameter::~MVNParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.MVNParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void MVNParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void MVNParameter::ArenaDtor(void* object) { + MVNParameter* _this = reinterpret_cast< MVNParameter* >(object); + (void)_this; +} +void MVNParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MVNParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MVNParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.MVNParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + across_channels_ = false; + normalize_variance_ = true; + eps_ = 1e-09f; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MVNParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool normalize_variance = 1 [default = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_normalize_variance(&has_bits); + normalize_variance_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool across_channels = 2 [default = false]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_across_channels(&has_bits); + across_channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float eps = 3 [default = 1e-09]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_eps(&has_bits); + eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MVNParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.MVNParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bool normalize_variance = 1 [default = true]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_normalize_variance(), target); + } + + // optional bool across_channels = 2 [default = false]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_across_channels(), target); + } + + // optional float eps = 3 [default = 1e-09]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_eps(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.MVNParameter) + return target; +} + +size_t MVNParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.MVNParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bool across_channels = 2 [default = false]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + // optional bool normalize_variance = 1 [default = true]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional float eps = 3 [default = 1e-09]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MVNParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + MVNParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MVNParameter::GetClassData() const { return &_class_data_; } + +void MVNParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void MVNParameter::MergeFrom(const MVNParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.MVNParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + across_channels_ = from.across_channels_; + } + if (cached_has_bits & 0x00000002u) { + normalize_variance_ = from.normalize_variance_; + } + if (cached_has_bits & 0x00000004u) { + eps_ = from.eps_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MVNParameter::CopyFrom(const MVNParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.MVNParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MVNParameter::IsInitialized() const { + return true; +} + +void MVNParameter::InternalSwap(MVNParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(across_channels_, other->across_channels_); + swap(normalize_variance_, other->normalize_variance_); + swap(eps_, other->eps_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MVNParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[46]); +} + +// =================================================================== + +class ParameterParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::opencv_caffe::BlobShape& shape(const ParameterParameter* msg); + static void set_has_shape(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::opencv_caffe::BlobShape& +ParameterParameter::_Internal::shape(const ParameterParameter* msg) { + return *msg->shape_; +} +ParameterParameter::ParameterParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ParameterParameter) +} +ParameterParameter::ParameterParameter(const ParameterParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_shape()) { + shape_ = new ::opencv_caffe::BlobShape(*from.shape_); + } else { + shape_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ParameterParameter) +} + +inline void ParameterParameter::SharedCtor() { +shape_ = nullptr; +} + +ParameterParameter::~ParameterParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ParameterParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ParameterParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete shape_; +} + +void ParameterParameter::ArenaDtor(void* object) { + ParameterParameter* _this = reinterpret_cast< ParameterParameter* >(object); + (void)_this; +} +void ParameterParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ParameterParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(shape_ != nullptr); + shape_->Clear(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.BlobShape shape = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ParameterParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ParameterParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.BlobShape shape = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::shape(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ParameterParameter) + return target; +} + +size_t ParameterParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ParameterParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .opencv_caffe.BlobShape shape = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *shape_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterParameter::GetClassData() const { return &_class_data_; } + +void ParameterParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ParameterParameter::MergeFrom(const ParameterParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ParameterParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_shape()) { + _internal_mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from._internal_shape()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ParameterParameter::CopyFrom(const ParameterParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ParameterParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterParameter::IsInitialized() const { + return true; +} + +void ParameterParameter::InternalSwap(ParameterParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(shape_, other->shape_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[47]); +} + +// =================================================================== + +class PoolingParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_pool(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_pad(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_pad_h(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_pad_w(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_kernel_size(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_kernel_h(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_kernel_w(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_stride(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_stride_h(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_stride_w(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_engine(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_global_pooling(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_ceil_mode(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } +}; + +PoolingParameter::PoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.PoolingParameter) +} +PoolingParameter::PoolingParameter(const PoolingParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&pool_, &from.pool_, + static_cast(reinterpret_cast(&ceil_mode_) - + reinterpret_cast(&pool_)) + sizeof(ceil_mode_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.PoolingParameter) +} + +inline void PoolingParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&pool_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&global_pooling_) - + reinterpret_cast(&pool_)) + sizeof(global_pooling_)); +stride_ = 1u; +ceil_mode_ = true; +} + +PoolingParameter::~PoolingParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.PoolingParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void PoolingParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void PoolingParameter::ArenaDtor(void* object) { + PoolingParameter* _this = reinterpret_cast< PoolingParameter* >(object); + (void)_this; +} +void PoolingParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PoolingParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PoolingParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.PoolingParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + ::memset(&pool_, 0, static_cast( + reinterpret_cast(&pad_h_) - + reinterpret_cast(&pool_)) + sizeof(pad_h_)); + } + if (cached_has_bits & 0x00001f00u) { + ::memset(&pad_w_, 0, static_cast( + reinterpret_cast(&global_pooling_) - + reinterpret_cast(&pad_w_)) + sizeof(global_pooling_)); + stride_ = 1u; + ceil_mode_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PoolingParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::PoolingParameter_PoolMethod_IsValid(val))) { + _internal_set_pool(static_cast<::opencv_caffe::PoolingParameter_PoolMethod>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint32 kernel_size = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_kernel_size(&has_bits); + kernel_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 stride = 3 [default = 1]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_stride(&has_bits); + stride_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pad = 4 [default = 0]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_pad(&has_bits); + pad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 kernel_h = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_kernel_h(&has_bits); + kernel_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 kernel_w = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_kernel_w(&has_bits); + kernel_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 stride_h = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_stride_h(&has_bits); + stride_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 stride_w = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_stride_w(&has_bits); + stride_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pad_h = 9 [default = 0]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_pad_h(&has_bits); + pad_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pad_w = 10 [default = 0]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_pad_w(&has_bits); + pad_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::PoolingParameter_Engine_IsValid(val))) { + _internal_set_engine(static_cast<::opencv_caffe::PoolingParameter_Engine>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool global_pooling = 12 [default = false]; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_global_pooling(&has_bits); + global_pooling_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool ceil_mode = 13 [default = true]; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + _Internal::set_has_ceil_mode(&has_bits); + ceil_mode_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PoolingParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PoolingParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_pool(), target); + } + + // optional uint32 kernel_size = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_kernel_size(), target); + } + + // optional uint32 stride = 3 [default = 1]; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_stride(), target); + } + + // optional uint32 pad = 4 [default = 0]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_pad(), target); + } + + // optional uint32 kernel_h = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_kernel_h(), target); + } + + // optional uint32 kernel_w = 6; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_kernel_w(), target); + } + + // optional uint32 stride_h = 7; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_stride_h(), target); + } + + // optional uint32 stride_w = 8; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_stride_w(), target); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_pad_h(), target); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_pad_w(), target); + } + + // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 11, this->_internal_engine(), target); + } + + // optional bool global_pooling = 12 [default = false]; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(12, this->_internal_global_pooling(), target); + } + + // optional bool ceil_mode = 13 [default = true]; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(13, this->_internal_ceil_mode(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PoolingParameter) + return target; +} + +size_t PoolingParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PoolingParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_pool()); + } + + // optional uint32 kernel_size = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_size()); + } + + // optional uint32 pad = 4 [default = 0]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad()); + } + + // optional uint32 kernel_h = 5; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_h()); + } + + // optional uint32 kernel_w = 6; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_w()); + } + + // optional uint32 stride_h = 7; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride_h()); + } + + // optional uint32 stride_w = 8; + if (cached_has_bits & 0x00000040u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride_w()); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (cached_has_bits & 0x00000080u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad_h()); + } + + } + if (cached_has_bits & 0x00001f00u) { + // optional uint32 pad_w = 10 [default = 0]; + if (cached_has_bits & 0x00000100u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad_w()); + } + + // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); + } + + // optional bool global_pooling = 12 [default = false]; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 1; + } + + // optional uint32 stride = 3 [default = 1]; + if (cached_has_bits & 0x00000800u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride()); + } + + // optional bool ceil_mode = 13 [default = true]; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PoolingParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + PoolingParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PoolingParameter::GetClassData() const { return &_class_data_; } + +void PoolingParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void PoolingParameter::MergeFrom(const PoolingParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PoolingParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + pool_ = from.pool_; + } + if (cached_has_bits & 0x00000002u) { + kernel_size_ = from.kernel_size_; + } + if (cached_has_bits & 0x00000004u) { + pad_ = from.pad_; + } + if (cached_has_bits & 0x00000008u) { + kernel_h_ = from.kernel_h_; + } + if (cached_has_bits & 0x00000010u) { + kernel_w_ = from.kernel_w_; + } + if (cached_has_bits & 0x00000020u) { + stride_h_ = from.stride_h_; + } + if (cached_has_bits & 0x00000040u) { + stride_w_ = from.stride_w_; + } + if (cached_has_bits & 0x00000080u) { + pad_h_ = from.pad_h_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00001f00u) { + if (cached_has_bits & 0x00000100u) { + pad_w_ = from.pad_w_; + } + if (cached_has_bits & 0x00000200u) { + engine_ = from.engine_; + } + if (cached_has_bits & 0x00000400u) { + global_pooling_ = from.global_pooling_; + } + if (cached_has_bits & 0x00000800u) { + stride_ = from.stride_; + } + if (cached_has_bits & 0x00001000u) { + ceil_mode_ = from.ceil_mode_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PoolingParameter::CopyFrom(const PoolingParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PoolingParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PoolingParameter::IsInitialized() const { + return true; +} + +void PoolingParameter::InternalSwap(PoolingParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PoolingParameter, global_pooling_) + + sizeof(PoolingParameter::global_pooling_) + - PROTOBUF_FIELD_OFFSET(PoolingParameter, pool_)>( + reinterpret_cast(&pool_), + reinterpret_cast(&other->pool_)); + swap(stride_, other->stride_); + swap(ceil_mode_, other->ceil_mode_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PoolingParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[48]); +} + +// =================================================================== + +class PowerParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_power(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_shift(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +PowerParameter::PowerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.PowerParameter) +} +PowerParameter::PowerParameter(const PowerParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&shift_, &from.shift_, + static_cast(reinterpret_cast(&scale_) - + reinterpret_cast(&shift_)) + sizeof(scale_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.PowerParameter) +} + +inline void PowerParameter::SharedCtor() { +shift_ = 0; +power_ = 1; +scale_ = 1; +} + +PowerParameter::~PowerParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.PowerParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void PowerParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void PowerParameter::ArenaDtor(void* object) { + PowerParameter* _this = reinterpret_cast< PowerParameter* >(object); + (void)_this; +} +void PowerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PowerParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PowerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.PowerParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + shift_ = 0; + power_ = 1; + scale_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PowerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float power = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_power(&has_bits); + power_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float scale = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_scale(&has_bits); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float shift = 3 [default = 0]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_shift(&has_bits); + shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PowerParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PowerParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float power = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_power(), target); + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); + } + + // optional float shift = 3 [default = 0]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_shift(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PowerParameter) + return target; +} + +size_t PowerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PowerParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional float shift = 3 [default = 0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float power = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PowerParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + PowerParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PowerParameter::GetClassData() const { return &_class_data_; } + +void PowerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void PowerParameter::MergeFrom(const PowerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PowerParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + shift_ = from.shift_; + } + if (cached_has_bits & 0x00000002u) { + power_ = from.power_; + } + if (cached_has_bits & 0x00000004u) { + scale_ = from.scale_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PowerParameter::CopyFrom(const PowerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PowerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PowerParameter::IsInitialized() const { + return true; +} + +void PowerParameter::InternalSwap(PowerParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(shift_, other->shift_); + swap(power_, other->power_); + swap(scale_, other->scale_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PowerParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[49]); +} + +// =================================================================== + +class PythonParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_module(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_layer(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_param_str(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_share_in_parallel(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +PythonParameter::PythonParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.PythonParameter) +} +PythonParameter::PythonParameter(const PythonParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + module_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_module()) { + module_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_module(), + GetArenaForAllocation()); + } + layer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + layer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_layer()) { + layer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_layer(), + GetArenaForAllocation()); + } + param_str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + param_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_param_str()) { + param_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_param_str(), + GetArenaForAllocation()); + } + share_in_parallel_ = from.share_in_parallel_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.PythonParameter) +} + +inline void PythonParameter::SharedCtor() { +module_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +layer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + layer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +param_str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + param_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +share_in_parallel_ = false; +} + +PythonParameter::~PythonParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.PythonParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void PythonParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + module_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + layer_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + param_str_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void PythonParameter::ArenaDtor(void* object) { + PythonParameter* _this = reinterpret_cast< PythonParameter* >(object); + (void)_this; +} +void PythonParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PythonParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PythonParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.PythonParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + module_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + layer_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + param_str_.ClearNonDefaultToEmpty(); + } + } + share_in_parallel_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PythonParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string module = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_module(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.PythonParameter.module"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string layer = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_layer(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.PythonParameter.layer"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string param_str = 3 [default = ""]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_param_str(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.PythonParameter.param_str"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool share_in_parallel = 4 [default = false]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_share_in_parallel(&has_bits); + share_in_parallel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PythonParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PythonParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string module = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_module().data(), static_cast(this->_internal_module().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.PythonParameter.module"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_module(), target); + } + + // optional string layer = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_layer().data(), static_cast(this->_internal_layer().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.PythonParameter.layer"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_layer(), target); + } + + // optional string param_str = 3 [default = ""]; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_param_str().data(), static_cast(this->_internal_param_str().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.PythonParameter.param_str"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_param_str(), target); + } + + // optional bool share_in_parallel = 4 [default = false]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_share_in_parallel(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PythonParameter) + return target; +} + +size_t PythonParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PythonParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string module = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_module()); + } + + // optional string layer = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_layer()); + } + + // optional string param_str = 3 [default = ""]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_param_str()); + } + + // optional bool share_in_parallel = 4 [default = false]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PythonParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + PythonParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PythonParameter::GetClassData() const { return &_class_data_; } + +void PythonParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void PythonParameter::MergeFrom(const PythonParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PythonParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_module(from._internal_module()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_layer(from._internal_layer()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_param_str(from._internal_param_str()); + } + if (cached_has_bits & 0x00000008u) { + share_in_parallel_ = from.share_in_parallel_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PythonParameter::CopyFrom(const PythonParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PythonParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PythonParameter::IsInitialized() const { + return true; +} + +void PythonParameter::InternalSwap(PythonParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &module_, lhs_arena, + &other->module_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &layer_, lhs_arena, + &other->layer_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ¶m_str_, lhs_arena, + &other->param_str_, rhs_arena + ); + swap(share_in_parallel_, other->share_in_parallel_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PythonParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[50]); +} + +// =================================================================== + +class RecurrentParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_num_output(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::opencv_caffe::FillerParameter& weight_filler(const RecurrentParameter* msg); + static void set_has_weight_filler(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::opencv_caffe::FillerParameter& bias_filler(const RecurrentParameter* msg); + static void set_has_bias_filler(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_debug_info(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_expose_hidden(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +const ::opencv_caffe::FillerParameter& +RecurrentParameter::_Internal::weight_filler(const RecurrentParameter* msg) { + return *msg->weight_filler_; +} +const ::opencv_caffe::FillerParameter& +RecurrentParameter::_Internal::bias_filler(const RecurrentParameter* msg) { + return *msg->bias_filler_; +} +RecurrentParameter::RecurrentParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.RecurrentParameter) +} +RecurrentParameter::RecurrentParameter(const RecurrentParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_weight_filler()) { + weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); + } else { + weight_filler_ = nullptr; + } + if (from._internal_has_bias_filler()) { + bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); + } else { + bias_filler_ = nullptr; + } + ::memcpy(&num_output_, &from.num_output_, + static_cast(reinterpret_cast(&expose_hidden_) - + reinterpret_cast(&num_output_)) + sizeof(expose_hidden_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.RecurrentParameter) +} + +inline void RecurrentParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&expose_hidden_) - + reinterpret_cast(&weight_filler_)) + sizeof(expose_hidden_)); +} + +RecurrentParameter::~RecurrentParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.RecurrentParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void RecurrentParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete weight_filler_; + if (this != internal_default_instance()) delete bias_filler_; +} + +void RecurrentParameter::ArenaDtor(void* object) { + RecurrentParameter* _this = reinterpret_cast< RecurrentParameter* >(object); + (void)_this; +} +void RecurrentParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RecurrentParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void RecurrentParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.RecurrentParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(weight_filler_ != nullptr); + weight_filler_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(bias_filler_ != nullptr); + bias_filler_->Clear(); + } + } + if (cached_has_bits & 0x0000001cu) { + ::memset(&num_output_, 0, static_cast( + reinterpret_cast(&expose_hidden_) - + reinterpret_cast(&num_output_)) + sizeof(expose_hidden_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RecurrentParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 num_output = 1 [default = 0]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_num_output(&has_bits); + num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter weight_filler = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter bias_filler = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool debug_info = 4 [default = false]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_debug_info(&has_bits); + debug_info_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool expose_hidden = 5 [default = false]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_expose_hidden(&has_bits); + expose_hidden_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* RecurrentParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.RecurrentParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 num_output = 1 [default = 0]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_output(), target); + } + + // optional .opencv_caffe.FillerParameter weight_filler = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::weight_filler(this), target, stream); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::bias_filler(this), target, stream); + } + + // optional bool debug_info = 4 [default = false]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_debug_info(), target); + } + + // optional bool expose_hidden = 5 [default = false]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_expose_hidden(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.RecurrentParameter) + return target; +} + +size_t RecurrentParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.RecurrentParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional .opencv_caffe.FillerParameter weight_filler = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *weight_filler_); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bias_filler_); + } + + // optional uint32 num_output = 1 [default = 0]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); + } + + // optional bool debug_info = 4 [default = false]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + // optional bool expose_hidden = 5 [default = false]; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecurrentParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + RecurrentParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecurrentParameter::GetClassData() const { return &_class_data_; } + +void RecurrentParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void RecurrentParameter::MergeFrom(const RecurrentParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.RecurrentParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); + } + if (cached_has_bits & 0x00000004u) { + num_output_ = from.num_output_; + } + if (cached_has_bits & 0x00000008u) { + debug_info_ = from.debug_info_; + } + if (cached_has_bits & 0x00000010u) { + expose_hidden_ = from.expose_hidden_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void RecurrentParameter::CopyFrom(const RecurrentParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.RecurrentParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RecurrentParameter::IsInitialized() const { + return true; +} + +void RecurrentParameter::InternalSwap(RecurrentParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(RecurrentParameter, expose_hidden_) + + sizeof(RecurrentParameter::expose_hidden_) + - PROTOBUF_FIELD_OFFSET(RecurrentParameter, weight_filler_)>( + reinterpret_cast(&weight_filler_), + reinterpret_cast(&other->weight_filler_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RecurrentParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[51]); +} + +// =================================================================== + +class ReductionParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_operation(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_coeff(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ReductionParameter::ReductionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ReductionParameter) +} +ReductionParameter::ReductionParameter(const ReductionParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&axis_, &from.axis_, + static_cast(reinterpret_cast(&coeff_) - + reinterpret_cast(&axis_)) + sizeof(coeff_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReductionParameter) +} + +inline void ReductionParameter::SharedCtor() { +axis_ = 0; +operation_ = 1; +coeff_ = 1; +} + +ReductionParameter::~ReductionParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ReductionParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ReductionParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ReductionParameter::ArenaDtor(void* object) { + ReductionParameter* _this = reinterpret_cast< ReductionParameter* >(object); + (void)_this; +} +void ReductionParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReductionParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReductionParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ReductionParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + axis_ = 0; + operation_ = 1; + coeff_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReductionParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::ReductionParameter_ReductionOp_IsValid(val))) { + _internal_set_operation(static_cast<::opencv_caffe::ReductionParameter_ReductionOp>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int32 axis = 2 [default = 0]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float coeff = 3 [default = 1]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_coeff(&has_bits); + coeff_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ReductionParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReductionParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_operation(), target); + } + + // optional int32 axis = 2 [default = 0]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); + } + + // optional float coeff = 3 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_coeff(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReductionParameter) + return target; +} + +size_t ReductionParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReductionParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional int32 axis = 2 [default = 0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_operation()); + } + + // optional float coeff = 3 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReductionParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReductionParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReductionParameter::GetClassData() const { return &_class_data_; } + +void ReductionParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ReductionParameter::MergeFrom(const ReductionParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReductionParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + axis_ = from.axis_; + } + if (cached_has_bits & 0x00000002u) { + operation_ = from.operation_; + } + if (cached_has_bits & 0x00000004u) { + coeff_ = from.coeff_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ReductionParameter::CopyFrom(const ReductionParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReductionParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReductionParameter::IsInitialized() const { + return true; +} + +void ReductionParameter::InternalSwap(ReductionParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(axis_, other->axis_); + swap(operation_, other->operation_); + swap(coeff_, other->coeff_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReductionParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[52]); +} + +// =================================================================== + +class ReLUParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_negative_slope(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_engine(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ReLUParameter::ReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ReLUParameter) +} +ReLUParameter::ReLUParameter(const ReLUParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&negative_slope_, &from.negative_slope_, + static_cast(reinterpret_cast(&engine_) - + reinterpret_cast(&negative_slope_)) + sizeof(engine_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReLUParameter) +} + +inline void ReLUParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&negative_slope_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&engine_) - + reinterpret_cast(&negative_slope_)) + sizeof(engine_)); +} + +ReLUParameter::~ReLUParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ReLUParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ReLUParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ReLUParameter::ArenaDtor(void* object) { + ReLUParameter* _this = reinterpret_cast< ReLUParameter* >(object); + (void)_this; +} +void ReLUParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReLUParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReLUParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ReLUParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&negative_slope_, 0, static_cast( + reinterpret_cast(&engine_) - + reinterpret_cast(&negative_slope_)) + sizeof(engine_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReLUParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float negative_slope = 1 [default = 0]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_negative_slope(&has_bits); + negative_slope_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::ReLUParameter_Engine_IsValid(val))) { + _internal_set_engine(static_cast<::opencv_caffe::ReLUParameter_Engine>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ReLUParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReLUParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float negative_slope = 1 [default = 0]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_negative_slope(), target); + } + + // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_engine(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReLUParameter) + return target; +} + +size_t ReLUParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReLUParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional float negative_slope = 1 [default = 0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReLUParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReLUParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReLUParameter::GetClassData() const { return &_class_data_; } + +void ReLUParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ReLUParameter::MergeFrom(const ReLUParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReLUParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + negative_slope_ = from.negative_slope_; + } + if (cached_has_bits & 0x00000002u) { + engine_ = from.engine_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ReLUParameter::CopyFrom(const ReLUParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReLUParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReLUParameter::IsInitialized() const { + return true; +} + +void ReLUParameter::InternalSwap(ReLUParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ReLUParameter, engine_) + + sizeof(ReLUParameter::engine_) + - PROTOBUF_FIELD_OFFSET(ReLUParameter, negative_slope_)>( + reinterpret_cast(&negative_slope_), + reinterpret_cast(&other->negative_slope_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReLUParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[53]); +} + +// =================================================================== + +class ReshapeParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::opencv_caffe::BlobShape& shape(const ReshapeParameter* msg); + static void set_has_shape(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_num_axes(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::opencv_caffe::BlobShape& +ReshapeParameter::_Internal::shape(const ReshapeParameter* msg) { + return *msg->shape_; +} +ReshapeParameter::ReshapeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ReshapeParameter) +} +ReshapeParameter::ReshapeParameter(const ReshapeParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_shape()) { + shape_ = new ::opencv_caffe::BlobShape(*from.shape_); + } else { + shape_ = nullptr; + } + ::memcpy(&axis_, &from.axis_, + static_cast(reinterpret_cast(&num_axes_) - + reinterpret_cast(&axis_)) + sizeof(num_axes_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReshapeParameter) +} + +inline void ReshapeParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&shape_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&axis_) - + reinterpret_cast(&shape_)) + sizeof(axis_)); +num_axes_ = -1; +} + +ReshapeParameter::~ReshapeParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ReshapeParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ReshapeParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete shape_; +} + +void ReshapeParameter::ArenaDtor(void* object) { + ReshapeParameter* _this = reinterpret_cast< ReshapeParameter* >(object); + (void)_this; +} +void ReshapeParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReshapeParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReshapeParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ReshapeParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(shape_ != nullptr); + shape_->Clear(); + } + if (cached_has_bits & 0x00000006u) { + axis_ = 0; + num_axes_ = -1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReshapeParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.BlobShape shape = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 axis = 2 [default = 0]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 num_axes = 3 [default = -1]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_num_axes(&has_bits); + num_axes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ReshapeParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReshapeParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.BlobShape shape = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::shape(this), target, stream); + } + + // optional int32 axis = 2 [default = 0]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); + } + + // optional int32 num_axes = 3 [default = -1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_num_axes(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReshapeParameter) + return target; +} + +size_t ReshapeParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReshapeParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .opencv_caffe.BlobShape shape = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *shape_); + } + + // optional int32 axis = 2 [default = 0]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + // optional int32 num_axes = 3 [default = -1]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_axes()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReshapeParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReshapeParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReshapeParameter::GetClassData() const { return &_class_data_; } + +void ReshapeParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ReshapeParameter::MergeFrom(const ReshapeParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReshapeParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from._internal_shape()); + } + if (cached_has_bits & 0x00000002u) { + axis_ = from.axis_; + } + if (cached_has_bits & 0x00000004u) { + num_axes_ = from.num_axes_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ReshapeParameter::CopyFrom(const ReshapeParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReshapeParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReshapeParameter::IsInitialized() const { + return true; +} + +void ReshapeParameter::InternalSwap(ReshapeParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ReshapeParameter, axis_) + + sizeof(ReshapeParameter::axis_) + - PROTOBUF_FIELD_OFFSET(ReshapeParameter, shape_)>( + reinterpret_cast(&shape_), + reinterpret_cast(&other->shape_)); + swap(num_axes_, other->num_axes_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReshapeParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[54]); +} + +// =================================================================== + +class ScaleParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_num_axes(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::opencv_caffe::FillerParameter& filler(const ScaleParameter* msg); + static void set_has_filler(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_bias_term(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::opencv_caffe::FillerParameter& bias_filler(const ScaleParameter* msg); + static void set_has_bias_filler(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::opencv_caffe::FillerParameter& +ScaleParameter::_Internal::filler(const ScaleParameter* msg) { + return *msg->filler_; +} +const ::opencv_caffe::FillerParameter& +ScaleParameter::_Internal::bias_filler(const ScaleParameter* msg) { + return *msg->bias_filler_; +} +ScaleParameter::ScaleParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ScaleParameter) +} +ScaleParameter::ScaleParameter(const ScaleParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_filler()) { + filler_ = new ::opencv_caffe::FillerParameter(*from.filler_); + } else { + filler_ = nullptr; + } + if (from._internal_has_bias_filler()) { + bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); + } else { + bias_filler_ = nullptr; + } + ::memcpy(&bias_term_, &from.bias_term_, + static_cast(reinterpret_cast(&num_axes_) - + reinterpret_cast(&bias_term_)) + sizeof(num_axes_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ScaleParameter) +} + +inline void ScaleParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&filler_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&bias_term_) - + reinterpret_cast(&filler_)) + sizeof(bias_term_)); +axis_ = 1; +num_axes_ = 1; +} + +ScaleParameter::~ScaleParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ScaleParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ScaleParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete filler_; + if (this != internal_default_instance()) delete bias_filler_; +} + +void ScaleParameter::ArenaDtor(void* object) { + ScaleParameter* _this = reinterpret_cast< ScaleParameter* >(object); + (void)_this; +} +void ScaleParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ScaleParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ScaleParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ScaleParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(filler_ != nullptr); + filler_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(bias_filler_ != nullptr); + bias_filler_->Clear(); + } + } + if (cached_has_bits & 0x0000001cu) { + bias_term_ = false; + axis_ = 1; + num_axes_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ScaleParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 axis = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 num_axes = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_num_axes(&has_bits); + num_axes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter filler = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool bias_term = 4 [default = false]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_bias_term(&has_bits); + bias_term_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter bias_filler = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ScaleParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ScaleParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 axis = 1 [default = 1]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); + } + + // optional int32 num_axes = 2 [default = 1]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_num_axes(), target); + } + + // optional .opencv_caffe.FillerParameter filler = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::filler(this), target, stream); + } + + // optional bool bias_term = 4 [default = false]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_bias_term(), target); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 5; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::bias_filler(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ScaleParameter) + return target; +} + +size_t ScaleParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ScaleParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional .opencv_caffe.FillerParameter filler = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *filler_); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bias_filler_); + } + + // optional bool bias_term = 4 [default = false]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional int32 axis = 1 [default = 1]; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + // optional int32 num_axes = 2 [default = 1]; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_axes()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ScaleParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ScaleParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ScaleParameter::GetClassData() const { return &_class_data_; } + +void ScaleParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ScaleParameter::MergeFrom(const ScaleParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ScaleParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_filler()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); + } + if (cached_has_bits & 0x00000004u) { + bias_term_ = from.bias_term_; + } + if (cached_has_bits & 0x00000008u) { + axis_ = from.axis_; + } + if (cached_has_bits & 0x00000010u) { + num_axes_ = from.num_axes_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ScaleParameter::CopyFrom(const ScaleParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ScaleParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ScaleParameter::IsInitialized() const { + return true; +} + +void ScaleParameter::InternalSwap(ScaleParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ScaleParameter, bias_term_) + + sizeof(ScaleParameter::bias_term_) + - PROTOBUF_FIELD_OFFSET(ScaleParameter, filler_)>( + reinterpret_cast(&filler_), + reinterpret_cast(&other->filler_)); + swap(axis_, other->axis_); + swap(num_axes_, other->num_axes_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ScaleParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[55]); +} + +// =================================================================== + +class SigmoidParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_engine(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SigmoidParameter::SigmoidParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.SigmoidParameter) +} +SigmoidParameter::SigmoidParameter(const SigmoidParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + engine_ = from.engine_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.SigmoidParameter) +} + +inline void SigmoidParameter::SharedCtor() { +engine_ = 0; +} + +SigmoidParameter::~SigmoidParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.SigmoidParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void SigmoidParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SigmoidParameter::ArenaDtor(void* object) { + SigmoidParameter* _this = reinterpret_cast< SigmoidParameter* >(object); + (void)_this; +} +void SigmoidParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SigmoidParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SigmoidParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.SigmoidParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + engine_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SigmoidParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SigmoidParameter_Engine_IsValid(val))) { + _internal_set_engine(static_cast<::opencv_caffe::SigmoidParameter_Engine>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SigmoidParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SigmoidParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_engine(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SigmoidParameter) + return target; +} + +size_t SigmoidParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SigmoidParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SigmoidParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SigmoidParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SigmoidParameter::GetClassData() const { return &_class_data_; } + +void SigmoidParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void SigmoidParameter::MergeFrom(const SigmoidParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SigmoidParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_engine()) { + _internal_set_engine(from._internal_engine()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SigmoidParameter::CopyFrom(const SigmoidParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SigmoidParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SigmoidParameter::IsInitialized() const { + return true; +} + +void SigmoidParameter::InternalSwap(SigmoidParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(engine_, other->engine_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SigmoidParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[56]); +} + +// =================================================================== + +class SliceParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_slice_dim(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SliceParameter::SliceParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + slice_point_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.SliceParameter) +} +SliceParameter::SliceParameter(const SliceParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + slice_point_(from.slice_point_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&slice_dim_, &from.slice_dim_, + static_cast(reinterpret_cast(&axis_) - + reinterpret_cast(&slice_dim_)) + sizeof(axis_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.SliceParameter) +} + +inline void SliceParameter::SharedCtor() { +slice_dim_ = 1u; +axis_ = 1; +} + +SliceParameter::~SliceParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.SliceParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void SliceParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SliceParameter::ArenaDtor(void* object) { + SliceParameter* _this = reinterpret_cast< SliceParameter* >(object); + (void)_this; +} +void SliceParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SliceParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SliceParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.SliceParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + slice_point_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + slice_dim_ = 1u; + axis_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SliceParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 slice_dim = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_slice_dim(&has_bits); + slice_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 slice_point = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_slice_point(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); + } else if (static_cast(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_slice_point(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 axis = 3 [default = 1]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SliceParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SliceParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 slice_dim = 1 [default = 1]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_slice_dim(), target); + } + + // repeated uint32 slice_point = 2; + for (int i = 0, n = this->_internal_slice_point_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_slice_point(i), target); + } + + // optional int32 axis = 3 [default = 1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_axis(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SliceParameter) + return target; +} + +size_t SliceParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SliceParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 slice_point = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->slice_point_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_slice_point_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional uint32 slice_dim = 1 [default = 1]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_slice_dim()); + } + + // optional int32 axis = 3 [default = 1]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SliceParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SliceParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SliceParameter::GetClassData() const { return &_class_data_; } + +void SliceParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void SliceParameter::MergeFrom(const SliceParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SliceParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + slice_point_.MergeFrom(from.slice_point_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + slice_dim_ = from.slice_dim_; + } + if (cached_has_bits & 0x00000002u) { + axis_ = from.axis_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SliceParameter::CopyFrom(const SliceParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SliceParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SliceParameter::IsInitialized() const { + return true; +} + +void SliceParameter::InternalSwap(SliceParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + slice_point_.InternalSwap(&other->slice_point_); + swap(slice_dim_, other->slice_dim_); + swap(axis_, other->axis_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SliceParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[57]); +} + +// =================================================================== + +class SoftmaxParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_engine(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +SoftmaxParameter::SoftmaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.SoftmaxParameter) +} +SoftmaxParameter::SoftmaxParameter(const SoftmaxParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&engine_, &from.engine_, + static_cast(reinterpret_cast(&axis_) - + reinterpret_cast(&engine_)) + sizeof(axis_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.SoftmaxParameter) +} + +inline void SoftmaxParameter::SharedCtor() { +engine_ = 0; +axis_ = 1; +} + +SoftmaxParameter::~SoftmaxParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.SoftmaxParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void SoftmaxParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SoftmaxParameter::ArenaDtor(void* object) { + SoftmaxParameter* _this = reinterpret_cast< SoftmaxParameter* >(object); + (void)_this; +} +void SoftmaxParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SoftmaxParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SoftmaxParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.SoftmaxParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + engine_ = 0; + axis_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SoftmaxParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SoftmaxParameter_Engine_IsValid(val))) { + _internal_set_engine(static_cast<::opencv_caffe::SoftmaxParameter_Engine>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int32 axis = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SoftmaxParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SoftmaxParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_engine(), target); + } + + // optional int32 axis = 2 [default = 1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SoftmaxParameter) + return target; +} + +size_t SoftmaxParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SoftmaxParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); + } + + // optional int32 axis = 2 [default = 1]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SoftmaxParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SoftmaxParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SoftmaxParameter::GetClassData() const { return &_class_data_; } + +void SoftmaxParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void SoftmaxParameter::MergeFrom(const SoftmaxParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SoftmaxParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + engine_ = from.engine_; + } + if (cached_has_bits & 0x00000002u) { + axis_ = from.axis_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SoftmaxParameter::CopyFrom(const SoftmaxParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SoftmaxParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SoftmaxParameter::IsInitialized() const { + return true; +} + +void SoftmaxParameter::InternalSwap(SoftmaxParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(engine_, other->engine_); + swap(axis_, other->axis_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SoftmaxParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[58]); +} + +// =================================================================== + +class TanHParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_engine(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +TanHParameter::TanHParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.TanHParameter) +} +TanHParameter::TanHParameter(const TanHParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + engine_ = from.engine_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.TanHParameter) +} + +inline void TanHParameter::SharedCtor() { +engine_ = 0; +} + +TanHParameter::~TanHParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.TanHParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void TanHParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void TanHParameter::ArenaDtor(void* object) { + TanHParameter* _this = reinterpret_cast< TanHParameter* >(object); + (void)_this; +} +void TanHParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void TanHParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TanHParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.TanHParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + engine_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TanHParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::TanHParameter_Engine_IsValid(val))) { + _internal_set_engine(static_cast<::opencv_caffe::TanHParameter_Engine>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* TanHParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TanHParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_engine(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TanHParameter) + return target; +} + +size_t TanHParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TanHParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TanHParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + TanHParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TanHParameter::GetClassData() const { return &_class_data_; } + +void TanHParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void TanHParameter::MergeFrom(const TanHParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TanHParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_engine()) { + _internal_set_engine(from._internal_engine()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void TanHParameter::CopyFrom(const TanHParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TanHParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TanHParameter::IsInitialized() const { + return true; +} + +void TanHParameter::InternalSwap(TanHParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(engine_, other->engine_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TanHParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[59]); +} + +// =================================================================== + +class TileParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_axis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_tiles(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +TileParameter::TileParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.TileParameter) +} +TileParameter::TileParameter(const TileParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&tiles_, &from.tiles_, + static_cast(reinterpret_cast(&axis_) - + reinterpret_cast(&tiles_)) + sizeof(axis_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.TileParameter) +} + +inline void TileParameter::SharedCtor() { +tiles_ = 0; +axis_ = 1; +} + +TileParameter::~TileParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.TileParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void TileParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void TileParameter::ArenaDtor(void* object) { + TileParameter* _this = reinterpret_cast< TileParameter* >(object); + (void)_this; +} +void TileParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void TileParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TileParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.TileParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + tiles_ = 0; + axis_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TileParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 axis = 1 [default = 1]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_axis(&has_bits); + axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 tiles = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_tiles(&has_bits); + tiles_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* TileParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TileParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 axis = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); + } + + // optional int32 tiles = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_tiles(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TileParameter) + return target; +} + +size_t TileParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TileParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int32 tiles = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_tiles()); + } + + // optional int32 axis = 1 [default = 1]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TileParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + TileParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TileParameter::GetClassData() const { return &_class_data_; } + +void TileParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void TileParameter::MergeFrom(const TileParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TileParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + tiles_ = from.tiles_; + } + if (cached_has_bits & 0x00000002u) { + axis_ = from.axis_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void TileParameter::CopyFrom(const TileParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TileParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TileParameter::IsInitialized() const { + return true; +} + +void TileParameter::InternalSwap(TileParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(tiles_, other->tiles_); + swap(axis_, other->axis_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TileParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[60]); +} + +// =================================================================== + +class ThresholdParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_threshold(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ThresholdParameter::ThresholdParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ThresholdParameter) +} +ThresholdParameter::ThresholdParameter(const ThresholdParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + threshold_ = from.threshold_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ThresholdParameter) +} + +inline void ThresholdParameter::SharedCtor() { +threshold_ = 0; +} + +ThresholdParameter::~ThresholdParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ThresholdParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ThresholdParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ThresholdParameter::ArenaDtor(void* object) { + ThresholdParameter* _this = reinterpret_cast< ThresholdParameter* >(object); + (void)_this; +} +void ThresholdParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ThresholdParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ThresholdParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ThresholdParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + threshold_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ThresholdParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float threshold = 1 [default = 0]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_threshold(&has_bits); + threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThresholdParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ThresholdParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float threshold = 1 [default = 0]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_threshold(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ThresholdParameter) + return target; +} + +size_t ThresholdParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ThresholdParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional float threshold = 1 [default = 0]; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ThresholdParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ThresholdParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ThresholdParameter::GetClassData() const { return &_class_data_; } + +void ThresholdParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ThresholdParameter::MergeFrom(const ThresholdParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ThresholdParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_threshold()) { + _internal_set_threshold(from._internal_threshold()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ThresholdParameter::CopyFrom(const ThresholdParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ThresholdParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThresholdParameter::IsInitialized() const { + return true; +} + +void ThresholdParameter::InternalSwap(ThresholdParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(threshold_, other->threshold_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ThresholdParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[61]); +} + +// =================================================================== + +class WindowDataParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_source(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_mean_file(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_batch_size(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_crop_size(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_mirror(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_fg_threshold(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_bg_threshold(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_fg_fraction(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_context_pad(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_crop_mode(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_cache_images(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_root_folder(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::PROTOBUF_NAMESPACE_ID::internal::LazyString WindowDataParameter::_i_give_permission_to_break_this_code_default_crop_mode_{{{"warp", 4}}, {nullptr}}; +WindowDataParameter::WindowDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.WindowDataParameter) +} +WindowDataParameter::WindowDataParameter(const WindowDataParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_source()) { + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), + GetArenaForAllocation()); + } + mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mean_file()) { + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mean_file(), + GetArenaForAllocation()); + } + crop_mode_.UnsafeSetDefault(nullptr); + if (from._internal_has_crop_mode()) { + crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_crop_mode(), + GetArenaForAllocation()); + } + root_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_root_folder()) { + root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_root_folder(), + GetArenaForAllocation()); + } + ::memcpy(&batch_size_, &from.batch_size_, + static_cast(reinterpret_cast(&fg_fraction_) - + reinterpret_cast(&batch_size_)) + sizeof(fg_fraction_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.WindowDataParameter) +} + +inline void WindowDataParameter::SharedCtor() { +source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +crop_mode_.UnsafeSetDefault(nullptr); +root_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&batch_size_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&context_pad_) - + reinterpret_cast(&batch_size_)) + sizeof(context_pad_)); +scale_ = 1; +fg_threshold_ = 0.5f; +bg_threshold_ = 0.5f; +fg_fraction_ = 0.25f; +} + +WindowDataParameter::~WindowDataParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.WindowDataParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void WindowDataParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + mean_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + crop_mode_.DestroyNoArena(nullptr); + root_folder_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void WindowDataParameter::ArenaDtor(void* object) { + WindowDataParameter* _this = reinterpret_cast< WindowDataParameter* >(object); + (void)_this; +} +void WindowDataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void WindowDataParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void WindowDataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.WindowDataParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + source_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + mean_file_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + crop_mode_.ClearToDefault(::opencv_caffe::WindowDataParameter::_i_give_permission_to_break_this_code_default_crop_mode_, GetArenaForAllocation()); + } + if (cached_has_bits & 0x00000008u) { + root_folder_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000f0u) { + ::memset(&batch_size_, 0, static_cast( + reinterpret_cast(&cache_images_) - + reinterpret_cast(&batch_size_)) + sizeof(cache_images_)); + } + if (cached_has_bits & 0x00001f00u) { + context_pad_ = 0u; + scale_ = 1; + fg_threshold_ = 0.5f; + bg_threshold_ = 0.5f; + fg_fraction_ = 0.25f; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* WindowDataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string source = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_source(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.WindowDataParameter.source"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float scale = 2 [default = 1]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_scale(&has_bits); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional string mean_file = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_mean_file(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.WindowDataParameter.mean_file"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 batch_size = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_batch_size(&has_bits); + batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 crop_size = 5 [default = 0]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_crop_size(&has_bits); + crop_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool mirror = 6 [default = false]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_mirror(&has_bits); + mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float fg_threshold = 7 [default = 0.5]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { + _Internal::set_has_fg_threshold(&has_bits); + fg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float bg_threshold = 8 [default = 0.5]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { + _Internal::set_has_bg_threshold(&has_bits); + bg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float fg_fraction = 9 [default = 0.25]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 77)) { + _Internal::set_has_fg_fraction(&has_bits); + fg_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional uint32 context_pad = 10 [default = 0]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_context_pad(&has_bits); + context_pad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string crop_mode = 11 [default = "warp"]; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_crop_mode(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.WindowDataParameter.crop_mode"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool cache_images = 12 [default = false]; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_cache_images(&has_bits); + cache_images_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string root_folder = 13 [default = ""]; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_root_folder(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.WindowDataParameter.root_folder"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WindowDataParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.WindowDataParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_source().data(), static_cast(this->_internal_source().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.WindowDataParameter.source"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_source(), target); + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); + } + + // optional string mean_file = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mean_file().data(), static_cast(this->_internal_mean_file().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.WindowDataParameter.mean_file"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_mean_file(), target); + } + + // optional uint32 batch_size = 4; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_batch_size(), target); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_crop_size(), target); + } + + // optional bool mirror = 6 [default = false]; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_mirror(), target); + } + + // optional float fg_threshold = 7 [default = 0.5]; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_fg_threshold(), target); + } + + // optional float bg_threshold = 8 [default = 0.5]; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_bg_threshold(), target); + } + + // optional float fg_fraction = 9 [default = 0.25]; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_fg_fraction(), target); + } + + // optional uint32 context_pad = 10 [default = 0]; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_context_pad(), target); + } + + // optional string crop_mode = 11 [default = "warp"]; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_crop_mode().data(), static_cast(this->_internal_crop_mode().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.WindowDataParameter.crop_mode"); + target = stream->WriteStringMaybeAliased( + 11, this->_internal_crop_mode(), target); + } + + // optional bool cache_images = 12 [default = false]; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(12, this->_internal_cache_images(), target); + } + + // optional string root_folder = 13 [default = ""]; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_root_folder().data(), static_cast(this->_internal_root_folder().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.WindowDataParameter.root_folder"); + target = stream->WriteStringMaybeAliased( + 13, this->_internal_root_folder(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.WindowDataParameter) + return target; +} + +size_t WindowDataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.WindowDataParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string source = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_source()); + } + + // optional string mean_file = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mean_file()); + } + + // optional string crop_mode = 11 [default = "warp"]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_crop_mode()); + } + + // optional string root_folder = 13 [default = ""]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_root_folder()); + } + + // optional uint32 batch_size = 4; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_crop_size()); + } + + // optional bool mirror = 6 [default = false]; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 1; + } + + // optional bool cache_images = 12 [default = false]; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 1; + } + + } + if (cached_has_bits & 0x00001f00u) { + // optional uint32 context_pad = 10 [default = 0]; + if (cached_has_bits & 0x00000100u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_context_pad()); + } + + // optional float scale = 2 [default = 1]; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 4; + } + + // optional float fg_threshold = 7 [default = 0.5]; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 4; + } + + // optional float bg_threshold = 8 [default = 0.5]; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + 4; + } + + // optional float fg_fraction = 9 [default = 0.25]; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WindowDataParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + WindowDataParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WindowDataParameter::GetClassData() const { return &_class_data_; } + +void WindowDataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void WindowDataParameter::MergeFrom(const WindowDataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.WindowDataParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_source(from._internal_source()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_mean_file(from._internal_mean_file()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_crop_mode(from._internal_crop_mode()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_root_folder(from._internal_root_folder()); + } + if (cached_has_bits & 0x00000010u) { + batch_size_ = from.batch_size_; + } + if (cached_has_bits & 0x00000020u) { + crop_size_ = from.crop_size_; + } + if (cached_has_bits & 0x00000040u) { + mirror_ = from.mirror_; + } + if (cached_has_bits & 0x00000080u) { + cache_images_ = from.cache_images_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00001f00u) { + if (cached_has_bits & 0x00000100u) { + context_pad_ = from.context_pad_; + } + if (cached_has_bits & 0x00000200u) { + scale_ = from.scale_; + } + if (cached_has_bits & 0x00000400u) { + fg_threshold_ = from.fg_threshold_; + } + if (cached_has_bits & 0x00000800u) { + bg_threshold_ = from.bg_threshold_; + } + if (cached_has_bits & 0x00001000u) { + fg_fraction_ = from.fg_fraction_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void WindowDataParameter::CopyFrom(const WindowDataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.WindowDataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WindowDataParameter::IsInitialized() const { + return true; +} + +void WindowDataParameter::InternalSwap(WindowDataParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &source_, lhs_arena, + &other->source_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &mean_file_, lhs_arena, + &other->mean_file_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + nullptr, + &crop_mode_, lhs_arena, + &other->crop_mode_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &root_folder_, lhs_arena, + &other->root_folder_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(WindowDataParameter, context_pad_) + + sizeof(WindowDataParameter::context_pad_) + - PROTOBUF_FIELD_OFFSET(WindowDataParameter, batch_size_)>( + reinterpret_cast(&batch_size_), + reinterpret_cast(&other->batch_size_)); + swap(scale_, other->scale_); + swap(fg_threshold_, other->fg_threshold_); + swap(bg_threshold_, other->bg_threshold_); + swap(fg_fraction_, other->fg_fraction_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata WindowDataParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[62]); +} + +// =================================================================== + +class SPPParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_pyramid_height(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_pool(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_engine(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +SPPParameter::SPPParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.SPPParameter) +} +SPPParameter::SPPParameter(const SPPParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&pyramid_height_, &from.pyramid_height_, + static_cast(reinterpret_cast(&engine_) - + reinterpret_cast(&pyramid_height_)) + sizeof(engine_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.SPPParameter) +} + +inline void SPPParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&pyramid_height_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&engine_) - + reinterpret_cast(&pyramid_height_)) + sizeof(engine_)); +} + +SPPParameter::~SPPParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.SPPParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void SPPParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SPPParameter::ArenaDtor(void* object) { + SPPParameter* _this = reinterpret_cast< SPPParameter* >(object); + (void)_this; +} +void SPPParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SPPParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SPPParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.SPPParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&pyramid_height_, 0, static_cast( + reinterpret_cast(&engine_) - + reinterpret_cast(&pyramid_height_)) + sizeof(engine_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SPPParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 pyramid_height = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_pyramid_height(&has_bits); + pyramid_height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SPPParameter_PoolMethod_IsValid(val))) { + _internal_set_pool(static_cast<::opencv_caffe::SPPParameter_PoolMethod>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SPPParameter_Engine_IsValid(val))) { + _internal_set_engine(static_cast<::opencv_caffe::SPPParameter_Engine>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SPPParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SPPParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 pyramid_height = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pyramid_height(), target); + } + + // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_pool(), target); + } + + // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 6, this->_internal_engine(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SPPParameter) + return target; +} + +size_t SPPParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SPPParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional uint32 pyramid_height = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pyramid_height()); + } + + // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_pool()); + } + + // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SPPParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SPPParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SPPParameter::GetClassData() const { return &_class_data_; } + +void SPPParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void SPPParameter::MergeFrom(const SPPParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SPPParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + pyramid_height_ = from.pyramid_height_; + } + if (cached_has_bits & 0x00000002u) { + pool_ = from.pool_; + } + if (cached_has_bits & 0x00000004u) { + engine_ = from.engine_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SPPParameter::CopyFrom(const SPPParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SPPParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SPPParameter::IsInitialized() const { + return true; +} + +void SPPParameter::InternalSwap(SPPParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SPPParameter, engine_) + + sizeof(SPPParameter::engine_) + - PROTOBUF_FIELD_OFFSET(SPPParameter, pyramid_height_)>( + reinterpret_cast(&pyramid_height_), + reinterpret_cast(&other->pyramid_height_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SPPParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[63]); +} + +// =================================================================== + +class V1LayerParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[1] |= 1u; + } + static const ::opencv_caffe::AccuracyParameter& accuracy_param(const V1LayerParameter* msg); + static void set_has_accuracy_param(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static const ::opencv_caffe::ArgMaxParameter& argmax_param(const V1LayerParameter* msg); + static void set_has_argmax_param(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static const ::opencv_caffe::ConcatParameter& concat_param(const V1LayerParameter* msg); + static void set_has_concat_param(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param(const V1LayerParameter* msg); + static void set_has_contrastive_loss_param(HasBits* has_bits) { + (*has_bits)[0] |= 536870912u; + } + static const ::opencv_caffe::ConvolutionParameter& convolution_param(const V1LayerParameter* msg); + static void set_has_convolution_param(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::opencv_caffe::DataParameter& data_param(const V1LayerParameter* msg); + static void set_has_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::opencv_caffe::DropoutParameter& dropout_param(const V1LayerParameter* msg); + static void set_has_dropout_param(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::opencv_caffe::DummyDataParameter& dummy_data_param(const V1LayerParameter* msg); + static void set_has_dummy_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static const ::opencv_caffe::EltwiseParameter& eltwise_param(const V1LayerParameter* msg); + static void set_has_eltwise_param(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static const ::opencv_caffe::ExpParameter& exp_param(const V1LayerParameter* msg); + static void set_has_exp_param(HasBits* has_bits) { + (*has_bits)[0] |= 1073741824u; + } + static const ::opencv_caffe::HDF5DataParameter& hdf5_data_param(const V1LayerParameter* msg); + static void set_has_hdf5_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param(const V1LayerParameter* msg); + static void set_has_hdf5_output_param(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::opencv_caffe::HingeLossParameter& hinge_loss_param(const V1LayerParameter* msg); + static void set_has_hinge_loss_param(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static const ::opencv_caffe::ImageDataParameter& image_data_param(const V1LayerParameter* msg); + static void set_has_image_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::opencv_caffe::InfogainLossParameter& infogain_loss_param(const V1LayerParameter* msg); + static void set_has_infogain_loss_param(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static const ::opencv_caffe::InnerProductParameter& inner_product_param(const V1LayerParameter* msg); + static void set_has_inner_product_param(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static const ::opencv_caffe::LRNParameter& lrn_param(const V1LayerParameter* msg); + static void set_has_lrn_param(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::opencv_caffe::MemoryDataParameter& memory_data_param(const V1LayerParameter* msg); + static void set_has_memory_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static const ::opencv_caffe::MVNParameter& mvn_param(const V1LayerParameter* msg); + static void set_has_mvn_param(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static const ::opencv_caffe::PoolingParameter& pooling_param(const V1LayerParameter* msg); + static void set_has_pooling_param(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static const ::opencv_caffe::PowerParameter& power_param(const V1LayerParameter* msg); + static void set_has_power_param(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static const ::opencv_caffe::ReLUParameter& relu_param(const V1LayerParameter* msg); + static void set_has_relu_param(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static const ::opencv_caffe::SigmoidParameter& sigmoid_param(const V1LayerParameter* msg); + static void set_has_sigmoid_param(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static const ::opencv_caffe::SoftmaxParameter& softmax_param(const V1LayerParameter* msg); + static void set_has_softmax_param(HasBits* has_bits) { + (*has_bits)[0] |= 268435456u; + } + static const ::opencv_caffe::SliceParameter& slice_param(const V1LayerParameter* msg); + static void set_has_slice_param(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static const ::opencv_caffe::TanHParameter& tanh_param(const V1LayerParameter* msg); + static void set_has_tanh_param(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } + static const ::opencv_caffe::ThresholdParameter& threshold_param(const V1LayerParameter* msg); + static void set_has_threshold_param(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static const ::opencv_caffe::WindowDataParameter& window_data_param(const V1LayerParameter* msg); + static void set_has_window_data_param(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static const ::opencv_caffe::TransformationParameter& transform_param(const V1LayerParameter* msg); + static void set_has_transform_param(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static const ::opencv_caffe::LossParameter& loss_param(const V1LayerParameter* msg); + static void set_has_loss_param(HasBits* has_bits) { + (*has_bits)[0] |= 2147483648u; + } + static const ::opencv_caffe::V0LayerParameter& layer(const V1LayerParameter* msg); + static void set_has_layer(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::opencv_caffe::AccuracyParameter& +V1LayerParameter::_Internal::accuracy_param(const V1LayerParameter* msg) { + return *msg->accuracy_param_; +} +const ::opencv_caffe::ArgMaxParameter& +V1LayerParameter::_Internal::argmax_param(const V1LayerParameter* msg) { + return *msg->argmax_param_; +} +const ::opencv_caffe::ConcatParameter& +V1LayerParameter::_Internal::concat_param(const V1LayerParameter* msg) { + return *msg->concat_param_; +} +const ::opencv_caffe::ContrastiveLossParameter& +V1LayerParameter::_Internal::contrastive_loss_param(const V1LayerParameter* msg) { + return *msg->contrastive_loss_param_; +} +const ::opencv_caffe::ConvolutionParameter& +V1LayerParameter::_Internal::convolution_param(const V1LayerParameter* msg) { + return *msg->convolution_param_; +} +const ::opencv_caffe::DataParameter& +V1LayerParameter::_Internal::data_param(const V1LayerParameter* msg) { + return *msg->data_param_; +} +const ::opencv_caffe::DropoutParameter& +V1LayerParameter::_Internal::dropout_param(const V1LayerParameter* msg) { + return *msg->dropout_param_; +} +const ::opencv_caffe::DummyDataParameter& +V1LayerParameter::_Internal::dummy_data_param(const V1LayerParameter* msg) { + return *msg->dummy_data_param_; +} +const ::opencv_caffe::EltwiseParameter& +V1LayerParameter::_Internal::eltwise_param(const V1LayerParameter* msg) { + return *msg->eltwise_param_; +} +const ::opencv_caffe::ExpParameter& +V1LayerParameter::_Internal::exp_param(const V1LayerParameter* msg) { + return *msg->exp_param_; +} +const ::opencv_caffe::HDF5DataParameter& +V1LayerParameter::_Internal::hdf5_data_param(const V1LayerParameter* msg) { + return *msg->hdf5_data_param_; +} +const ::opencv_caffe::HDF5OutputParameter& +V1LayerParameter::_Internal::hdf5_output_param(const V1LayerParameter* msg) { + return *msg->hdf5_output_param_; +} +const ::opencv_caffe::HingeLossParameter& +V1LayerParameter::_Internal::hinge_loss_param(const V1LayerParameter* msg) { + return *msg->hinge_loss_param_; +} +const ::opencv_caffe::ImageDataParameter& +V1LayerParameter::_Internal::image_data_param(const V1LayerParameter* msg) { + return *msg->image_data_param_; +} +const ::opencv_caffe::InfogainLossParameter& +V1LayerParameter::_Internal::infogain_loss_param(const V1LayerParameter* msg) { + return *msg->infogain_loss_param_; +} +const ::opencv_caffe::InnerProductParameter& +V1LayerParameter::_Internal::inner_product_param(const V1LayerParameter* msg) { + return *msg->inner_product_param_; +} +const ::opencv_caffe::LRNParameter& +V1LayerParameter::_Internal::lrn_param(const V1LayerParameter* msg) { + return *msg->lrn_param_; +} +const ::opencv_caffe::MemoryDataParameter& +V1LayerParameter::_Internal::memory_data_param(const V1LayerParameter* msg) { + return *msg->memory_data_param_; +} +const ::opencv_caffe::MVNParameter& +V1LayerParameter::_Internal::mvn_param(const V1LayerParameter* msg) { + return *msg->mvn_param_; +} +const ::opencv_caffe::PoolingParameter& +V1LayerParameter::_Internal::pooling_param(const V1LayerParameter* msg) { + return *msg->pooling_param_; +} +const ::opencv_caffe::PowerParameter& +V1LayerParameter::_Internal::power_param(const V1LayerParameter* msg) { + return *msg->power_param_; +} +const ::opencv_caffe::ReLUParameter& +V1LayerParameter::_Internal::relu_param(const V1LayerParameter* msg) { + return *msg->relu_param_; +} +const ::opencv_caffe::SigmoidParameter& +V1LayerParameter::_Internal::sigmoid_param(const V1LayerParameter* msg) { + return *msg->sigmoid_param_; +} +const ::opencv_caffe::SoftmaxParameter& +V1LayerParameter::_Internal::softmax_param(const V1LayerParameter* msg) { + return *msg->softmax_param_; +} +const ::opencv_caffe::SliceParameter& +V1LayerParameter::_Internal::slice_param(const V1LayerParameter* msg) { + return *msg->slice_param_; +} +const ::opencv_caffe::TanHParameter& +V1LayerParameter::_Internal::tanh_param(const V1LayerParameter* msg) { + return *msg->tanh_param_; +} +const ::opencv_caffe::ThresholdParameter& +V1LayerParameter::_Internal::threshold_param(const V1LayerParameter* msg) { + return *msg->threshold_param_; +} +const ::opencv_caffe::WindowDataParameter& +V1LayerParameter::_Internal::window_data_param(const V1LayerParameter* msg) { + return *msg->window_data_param_; +} +const ::opencv_caffe::TransformationParameter& +V1LayerParameter::_Internal::transform_param(const V1LayerParameter* msg) { + return *msg->transform_param_; +} +const ::opencv_caffe::LossParameter& +V1LayerParameter::_Internal::loss_param(const V1LayerParameter* msg) { + return *msg->loss_param_; +} +const ::opencv_caffe::V0LayerParameter& +V1LayerParameter::_Internal::layer(const V1LayerParameter* msg) { + return *msg->layer_; +} +V1LayerParameter::V1LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + bottom_(arena), + top_(arena), + blobs_(arena), + blobs_lr_(arena), + weight_decay_(arena), + include_(arena), + exclude_(arena), + loss_weight_(arena), + param_(arena), + blob_share_mode_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.V1LayerParameter) +} +V1LayerParameter::V1LayerParameter(const V1LayerParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + bottom_(from.bottom_), + top_(from.top_), + blobs_(from.blobs_), + blobs_lr_(from.blobs_lr_), + weight_decay_(from.weight_decay_), + include_(from.include_), + exclude_(from.exclude_), + loss_weight_(from.loss_weight_), + param_(from.param_), + blob_share_mode_(from.blob_share_mode_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArenaForAllocation()); + } + if (from._internal_has_layer()) { + layer_ = new ::opencv_caffe::V0LayerParameter(*from.layer_); + } else { + layer_ = nullptr; + } + if (from._internal_has_concat_param()) { + concat_param_ = new ::opencv_caffe::ConcatParameter(*from.concat_param_); + } else { + concat_param_ = nullptr; + } + if (from._internal_has_convolution_param()) { + convolution_param_ = new ::opencv_caffe::ConvolutionParameter(*from.convolution_param_); + } else { + convolution_param_ = nullptr; + } + if (from._internal_has_data_param()) { + data_param_ = new ::opencv_caffe::DataParameter(*from.data_param_); + } else { + data_param_ = nullptr; + } + if (from._internal_has_dropout_param()) { + dropout_param_ = new ::opencv_caffe::DropoutParameter(*from.dropout_param_); + } else { + dropout_param_ = nullptr; + } + if (from._internal_has_hdf5_data_param()) { + hdf5_data_param_ = new ::opencv_caffe::HDF5DataParameter(*from.hdf5_data_param_); + } else { + hdf5_data_param_ = nullptr; + } + if (from._internal_has_hdf5_output_param()) { + hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_); + } else { + hdf5_output_param_ = nullptr; + } + if (from._internal_has_image_data_param()) { + image_data_param_ = new ::opencv_caffe::ImageDataParameter(*from.image_data_param_); + } else { + image_data_param_ = nullptr; + } + if (from._internal_has_infogain_loss_param()) { + infogain_loss_param_ = new ::opencv_caffe::InfogainLossParameter(*from.infogain_loss_param_); + } else { + infogain_loss_param_ = nullptr; + } + if (from._internal_has_inner_product_param()) { + inner_product_param_ = new ::opencv_caffe::InnerProductParameter(*from.inner_product_param_); + } else { + inner_product_param_ = nullptr; + } + if (from._internal_has_lrn_param()) { + lrn_param_ = new ::opencv_caffe::LRNParameter(*from.lrn_param_); + } else { + lrn_param_ = nullptr; + } + if (from._internal_has_pooling_param()) { + pooling_param_ = new ::opencv_caffe::PoolingParameter(*from.pooling_param_); + } else { + pooling_param_ = nullptr; + } + if (from._internal_has_window_data_param()) { + window_data_param_ = new ::opencv_caffe::WindowDataParameter(*from.window_data_param_); + } else { + window_data_param_ = nullptr; + } + if (from._internal_has_power_param()) { + power_param_ = new ::opencv_caffe::PowerParameter(*from.power_param_); + } else { + power_param_ = nullptr; + } + if (from._internal_has_memory_data_param()) { + memory_data_param_ = new ::opencv_caffe::MemoryDataParameter(*from.memory_data_param_); + } else { + memory_data_param_ = nullptr; + } + if (from._internal_has_argmax_param()) { + argmax_param_ = new ::opencv_caffe::ArgMaxParameter(*from.argmax_param_); + } else { + argmax_param_ = nullptr; + } + if (from._internal_has_eltwise_param()) { + eltwise_param_ = new ::opencv_caffe::EltwiseParameter(*from.eltwise_param_); + } else { + eltwise_param_ = nullptr; + } + if (from._internal_has_threshold_param()) { + threshold_param_ = new ::opencv_caffe::ThresholdParameter(*from.threshold_param_); + } else { + threshold_param_ = nullptr; + } + if (from._internal_has_dummy_data_param()) { + dummy_data_param_ = new ::opencv_caffe::DummyDataParameter(*from.dummy_data_param_); + } else { + dummy_data_param_ = nullptr; + } + if (from._internal_has_accuracy_param()) { + accuracy_param_ = new ::opencv_caffe::AccuracyParameter(*from.accuracy_param_); + } else { + accuracy_param_ = nullptr; + } + if (from._internal_has_hinge_loss_param()) { + hinge_loss_param_ = new ::opencv_caffe::HingeLossParameter(*from.hinge_loss_param_); + } else { + hinge_loss_param_ = nullptr; + } + if (from._internal_has_relu_param()) { + relu_param_ = new ::opencv_caffe::ReLUParameter(*from.relu_param_); + } else { + relu_param_ = nullptr; + } + if (from._internal_has_slice_param()) { + slice_param_ = new ::opencv_caffe::SliceParameter(*from.slice_param_); + } else { + slice_param_ = nullptr; + } + if (from._internal_has_mvn_param()) { + mvn_param_ = new ::opencv_caffe::MVNParameter(*from.mvn_param_); + } else { + mvn_param_ = nullptr; + } + if (from._internal_has_transform_param()) { + transform_param_ = new ::opencv_caffe::TransformationParameter(*from.transform_param_); + } else { + transform_param_ = nullptr; + } + if (from._internal_has_tanh_param()) { + tanh_param_ = new ::opencv_caffe::TanHParameter(*from.tanh_param_); + } else { + tanh_param_ = nullptr; + } + if (from._internal_has_sigmoid_param()) { + sigmoid_param_ = new ::opencv_caffe::SigmoidParameter(*from.sigmoid_param_); + } else { + sigmoid_param_ = nullptr; + } + if (from._internal_has_softmax_param()) { + softmax_param_ = new ::opencv_caffe::SoftmaxParameter(*from.softmax_param_); + } else { + softmax_param_ = nullptr; + } + if (from._internal_has_contrastive_loss_param()) { + contrastive_loss_param_ = new ::opencv_caffe::ContrastiveLossParameter(*from.contrastive_loss_param_); + } else { + contrastive_loss_param_ = nullptr; + } + if (from._internal_has_exp_param()) { + exp_param_ = new ::opencv_caffe::ExpParameter(*from.exp_param_); + } else { + exp_param_ = nullptr; + } + if (from._internal_has_loss_param()) { + loss_param_ = new ::opencv_caffe::LossParameter(*from.loss_param_); + } else { + loss_param_ = nullptr; + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.V1LayerParameter) +} + +inline void V1LayerParameter::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&layer_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&layer_)) + sizeof(type_)); +} + +V1LayerParameter::~V1LayerParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.V1LayerParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void V1LayerParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete layer_; + if (this != internal_default_instance()) delete concat_param_; + if (this != internal_default_instance()) delete convolution_param_; + if (this != internal_default_instance()) delete data_param_; + if (this != internal_default_instance()) delete dropout_param_; + if (this != internal_default_instance()) delete hdf5_data_param_; + if (this != internal_default_instance()) delete hdf5_output_param_; + if (this != internal_default_instance()) delete image_data_param_; + if (this != internal_default_instance()) delete infogain_loss_param_; + if (this != internal_default_instance()) delete inner_product_param_; + if (this != internal_default_instance()) delete lrn_param_; + if (this != internal_default_instance()) delete pooling_param_; + if (this != internal_default_instance()) delete window_data_param_; + if (this != internal_default_instance()) delete power_param_; + if (this != internal_default_instance()) delete memory_data_param_; + if (this != internal_default_instance()) delete argmax_param_; + if (this != internal_default_instance()) delete eltwise_param_; + if (this != internal_default_instance()) delete threshold_param_; + if (this != internal_default_instance()) delete dummy_data_param_; + if (this != internal_default_instance()) delete accuracy_param_; + if (this != internal_default_instance()) delete hinge_loss_param_; + if (this != internal_default_instance()) delete relu_param_; + if (this != internal_default_instance()) delete slice_param_; + if (this != internal_default_instance()) delete mvn_param_; + if (this != internal_default_instance()) delete transform_param_; + if (this != internal_default_instance()) delete tanh_param_; + if (this != internal_default_instance()) delete sigmoid_param_; + if (this != internal_default_instance()) delete softmax_param_; + if (this != internal_default_instance()) delete contrastive_loss_param_; + if (this != internal_default_instance()) delete exp_param_; + if (this != internal_default_instance()) delete loss_param_; +} + +void V1LayerParameter::ArenaDtor(void* object) { + V1LayerParameter* _this = reinterpret_cast< V1LayerParameter* >(object); + (void)_this; +} +void V1LayerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void V1LayerParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void V1LayerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.V1LayerParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + bottom_.Clear(); + top_.Clear(); + blobs_.Clear(); + blobs_lr_.Clear(); + weight_decay_.Clear(); + include_.Clear(); + exclude_.Clear(); + loss_weight_.Clear(); + param_.Clear(); + blob_share_mode_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(layer_ != nullptr); + layer_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(concat_param_ != nullptr); + concat_param_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(convolution_param_ != nullptr); + convolution_param_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(data_param_ != nullptr); + data_param_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(dropout_param_ != nullptr); + dropout_param_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(hdf5_data_param_ != nullptr); + hdf5_data_param_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(hdf5_output_param_ != nullptr); + hdf5_output_param_->Clear(); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(image_data_param_ != nullptr); + image_data_param_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(infogain_loss_param_ != nullptr); + infogain_loss_param_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(inner_product_param_ != nullptr); + inner_product_param_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(lrn_param_ != nullptr); + lrn_param_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(pooling_param_ != nullptr); + pooling_param_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(window_data_param_ != nullptr); + window_data_param_->Clear(); + } + if (cached_has_bits & 0x00004000u) { + GOOGLE_DCHECK(power_param_ != nullptr); + power_param_->Clear(); + } + if (cached_has_bits & 0x00008000u) { + GOOGLE_DCHECK(memory_data_param_ != nullptr); + memory_data_param_->Clear(); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + GOOGLE_DCHECK(argmax_param_ != nullptr); + argmax_param_->Clear(); + } + if (cached_has_bits & 0x00020000u) { + GOOGLE_DCHECK(eltwise_param_ != nullptr); + eltwise_param_->Clear(); + } + if (cached_has_bits & 0x00040000u) { + GOOGLE_DCHECK(threshold_param_ != nullptr); + threshold_param_->Clear(); + } + if (cached_has_bits & 0x00080000u) { + GOOGLE_DCHECK(dummy_data_param_ != nullptr); + dummy_data_param_->Clear(); + } + if (cached_has_bits & 0x00100000u) { + GOOGLE_DCHECK(accuracy_param_ != nullptr); + accuracy_param_->Clear(); + } + if (cached_has_bits & 0x00200000u) { + GOOGLE_DCHECK(hinge_loss_param_ != nullptr); + hinge_loss_param_->Clear(); + } + if (cached_has_bits & 0x00400000u) { + GOOGLE_DCHECK(relu_param_ != nullptr); + relu_param_->Clear(); + } + if (cached_has_bits & 0x00800000u) { + GOOGLE_DCHECK(slice_param_ != nullptr); + slice_param_->Clear(); + } + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + GOOGLE_DCHECK(mvn_param_ != nullptr); + mvn_param_->Clear(); + } + if (cached_has_bits & 0x02000000u) { + GOOGLE_DCHECK(transform_param_ != nullptr); + transform_param_->Clear(); + } + if (cached_has_bits & 0x04000000u) { + GOOGLE_DCHECK(tanh_param_ != nullptr); + tanh_param_->Clear(); + } + if (cached_has_bits & 0x08000000u) { + GOOGLE_DCHECK(sigmoid_param_ != nullptr); + sigmoid_param_->Clear(); + } + if (cached_has_bits & 0x10000000u) { + GOOGLE_DCHECK(softmax_param_ != nullptr); + softmax_param_->Clear(); + } + if (cached_has_bits & 0x20000000u) { + GOOGLE_DCHECK(contrastive_loss_param_ != nullptr); + contrastive_loss_param_->Clear(); + } + if (cached_has_bits & 0x40000000u) { + GOOGLE_DCHECK(exp_param_ != nullptr); + exp_param_->Clear(); + } + if (cached_has_bits & 0x80000000u) { + GOOGLE_DCHECK(loss_param_ != nullptr); + loss_param_->Clear(); + } + } + type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* V1LayerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.V0LayerParameter layer = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_layer(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string bottom = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_bottom(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V1LayerParameter.bottom"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string top = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_top(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V1LayerParameter.top"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // optional string name = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V1LayerParameter.name"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.V1LayerParameter.LayerType type = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::V1LayerParameter_LayerType_IsValid(val))) { + _internal_set_type(static_cast<::opencv_caffe::V1LayerParameter_LayerType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.BlobProto blobs = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_blobs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + // repeated float blobs_lr = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_blobs_lr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<61>(ptr)); + } else if (static_cast(tag) == 58) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_blobs_lr(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float weight_decay = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_weight_decay(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<69>(ptr)); + } else if (static_cast(tag) == 66) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_weight_decay(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ConcatParameter concat_param = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_concat_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ConvolutionParameter convolution_param = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_convolution_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.DataParameter data_param = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.DropoutParameter dropout_param = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_dropout_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_hdf5_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_hdf5_output_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ImageDataParameter image_data_param = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_image_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_infogain_loss_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.InnerProductParameter inner_product_param = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_inner_product_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.LRNParameter lrn_param = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_lrn_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PoolingParameter pooling_param = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_pooling_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.WindowDataParameter window_data_param = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_window_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.PowerParameter power_param = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_power_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_memory_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ArgMaxParameter argmax_param = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_argmax_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.EltwiseParameter eltwise_param = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_eltwise_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ThresholdParameter threshold_param = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_threshold_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { + ptr = ctx->ParseMessage(_internal_mutable_dummy_data_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.AccuracyParameter accuracy_param = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + ptr = ctx->ParseMessage(_internal_mutable_accuracy_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_hinge_loss_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ReLUParameter relu_param = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { + ptr = ctx->ParseMessage(_internal_mutable_relu_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SliceParameter slice_param = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_slice_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.NetStateRule include = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_include(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<258>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.NetStateRule exclude = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_exclude(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<266>(ptr)); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.MVNParameter mvn_param = 34; + case 34: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_mvn_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float loss_weight = 35; + case 35: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + ptr -= 2; + do { + ptr += 2; + _internal_add_loss_weight(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<285>(ptr)); + } else if (static_cast(tag) == 26) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_loss_weight(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.TransformationParameter transform_param = 36; + case 36: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_transform_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.TanHParameter tanh_param = 37; + case 37: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_tanh_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38; + case 38: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_sigmoid_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.SoftmaxParameter softmax_param = 39; + case 39: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_softmax_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40; + case 40: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_contrastive_loss_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.ExpParameter exp_param = 41; + case 41: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_exp_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.LossParameter loss_param = 42; + case 42: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_loss_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string param = 1001; + case 1001: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr -= 2; + do { + ptr += 2; + auto str = _internal_add_param(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V1LayerParameter.param"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8010>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + case 1002: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + ptr -= 2; + do { + ptr += 2; + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid(val))) { + _internal_add_blob_share_mode(static_cast<::opencv_caffe::V1LayerParameter_DimCheckMode>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1002, val, mutable_unknown_fields()); + } + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8016>(ptr)); + } else if (static_cast(tag) == 82) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_blob_share_mode(), ptr, ctx, ::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid, &_internal_metadata_, 1002); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* V1LayerParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.V1LayerParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.V0LayerParameter layer = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::layer(this), target, stream); + } + + // repeated string bottom = 2; + for (int i = 0, n = this->_internal_bottom_size(); i < n; i++) { + const auto& s = this->_internal_bottom(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V1LayerParameter.bottom"); + target = stream->WriteString(2, s, target); + } + + // repeated string top = 3; + for (int i = 0, n = this->_internal_top_size(); i < n; i++) { + const auto& s = this->_internal_top(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V1LayerParameter.top"); + target = stream->WriteString(3, s, target); + } + + // optional string name = 4; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V1LayerParameter.name"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_name(), target); + } + + cached_has_bits = _has_bits_[1]; + // optional .opencv_caffe.V1LayerParameter.LayerType type = 5; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 5, this->_internal_type(), target); + } + + // repeated .opencv_caffe.BlobProto blobs = 6; + for (unsigned int i = 0, + n = static_cast(this->_internal_blobs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, this->_internal_blobs(i), target, stream); + } + + // repeated float blobs_lr = 7; + for (int i = 0, n = this->_internal_blobs_lr_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_blobs_lr(i), target); + } + + // repeated float weight_decay = 8; + for (int i = 0, n = this->_internal_weight_decay_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_weight_decay(i), target); + } + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.ConcatParameter concat_param = 9; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::concat_param(this), target, stream); + } + + // optional .opencv_caffe.ConvolutionParameter convolution_param = 10; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::convolution_param(this), target, stream); + } + + // optional .opencv_caffe.DataParameter data_param = 11; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::data_param(this), target, stream); + } + + // optional .opencv_caffe.DropoutParameter dropout_param = 12; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 12, _Internal::dropout_param(this), target, stream); + } + + // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 13, _Internal::hdf5_data_param(this), target, stream); + } + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 14, _Internal::hdf5_output_param(this), target, stream); + } + + // optional .opencv_caffe.ImageDataParameter image_data_param = 15; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 15, _Internal::image_data_param(this), target, stream); + } + + // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 16, _Internal::infogain_loss_param(this), target, stream); + } + + // optional .opencv_caffe.InnerProductParameter inner_product_param = 17; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 17, _Internal::inner_product_param(this), target, stream); + } + + // optional .opencv_caffe.LRNParameter lrn_param = 18; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 18, _Internal::lrn_param(this), target, stream); + } + + // optional .opencv_caffe.PoolingParameter pooling_param = 19; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 19, _Internal::pooling_param(this), target, stream); + } + + // optional .opencv_caffe.WindowDataParameter window_data_param = 20; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 20, _Internal::window_data_param(this), target, stream); + } + + // optional .opencv_caffe.PowerParameter power_param = 21; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 21, _Internal::power_param(this), target, stream); + } + + // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 22, _Internal::memory_data_param(this), target, stream); + } + + // optional .opencv_caffe.ArgMaxParameter argmax_param = 23; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 23, _Internal::argmax_param(this), target, stream); + } + + // optional .opencv_caffe.EltwiseParameter eltwise_param = 24; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 24, _Internal::eltwise_param(this), target, stream); + } + + // optional .opencv_caffe.ThresholdParameter threshold_param = 25; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 25, _Internal::threshold_param(this), target, stream); + } + + // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 26, _Internal::dummy_data_param(this), target, stream); + } + + // optional .opencv_caffe.AccuracyParameter accuracy_param = 27; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 27, _Internal::accuracy_param(this), target, stream); + } + + // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 29, _Internal::hinge_loss_param(this), target, stream); + } + + // optional .opencv_caffe.ReLUParameter relu_param = 30; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 30, _Internal::relu_param(this), target, stream); + } + + // optional .opencv_caffe.SliceParameter slice_param = 31; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 31, _Internal::slice_param(this), target, stream); + } + + // repeated .opencv_caffe.NetStateRule include = 32; + for (unsigned int i = 0, + n = static_cast(this->_internal_include_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(32, this->_internal_include(i), target, stream); + } + + // repeated .opencv_caffe.NetStateRule exclude = 33; + for (unsigned int i = 0, + n = static_cast(this->_internal_exclude_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(33, this->_internal_exclude(i), target, stream); + } + + // optional .opencv_caffe.MVNParameter mvn_param = 34; + if (cached_has_bits & 0x01000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 34, _Internal::mvn_param(this), target, stream); + } + + // repeated float loss_weight = 35; + for (int i = 0, n = this->_internal_loss_weight_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(35, this->_internal_loss_weight(i), target); + } + + // optional .opencv_caffe.TransformationParameter transform_param = 36; + if (cached_has_bits & 0x02000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 36, _Internal::transform_param(this), target, stream); + } + + // optional .opencv_caffe.TanHParameter tanh_param = 37; + if (cached_has_bits & 0x04000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 37, _Internal::tanh_param(this), target, stream); + } + + // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38; + if (cached_has_bits & 0x08000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 38, _Internal::sigmoid_param(this), target, stream); + } + + // optional .opencv_caffe.SoftmaxParameter softmax_param = 39; + if (cached_has_bits & 0x10000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 39, _Internal::softmax_param(this), target, stream); + } + + // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40; + if (cached_has_bits & 0x20000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 40, _Internal::contrastive_loss_param(this), target, stream); + } + + // optional .opencv_caffe.ExpParameter exp_param = 41; + if (cached_has_bits & 0x40000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 41, _Internal::exp_param(this), target, stream); + } + + // optional .opencv_caffe.LossParameter loss_param = 42; + if (cached_has_bits & 0x80000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 42, _Internal::loss_param(this), target, stream); + } + + // repeated string param = 1001; + for (int i = 0, n = this->_internal_param_size(); i < n; i++) { + const auto& s = this->_internal_param(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V1LayerParameter.param"); + target = stream->WriteString(1001, s, target); + } + + // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + for (int i = 0, n = this->_internal_blob_share_mode_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1002, this->_internal_blob_share_mode(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.V1LayerParameter) + return target; +} + +size_t V1LayerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.V1LayerParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string bottom = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(bottom_.size()); + for (int i = 0, n = bottom_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + bottom_.Get(i)); + } + + // repeated string top = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(top_.size()); + for (int i = 0, n = top_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + top_.Get(i)); + } + + // repeated .opencv_caffe.BlobProto blobs = 6; + total_size += 1UL * this->_internal_blobs_size(); + for (const auto& msg : this->blobs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated float blobs_lr = 7; + { + unsigned int count = static_cast(this->_internal_blobs_lr_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_blobs_lr_size()); + total_size += data_size; + } + + // repeated float weight_decay = 8; + { + unsigned int count = static_cast(this->_internal_weight_decay_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_weight_decay_size()); + total_size += data_size; + } + + // repeated .opencv_caffe.NetStateRule include = 32; + total_size += 2UL * this->_internal_include_size(); + for (const auto& msg : this->include_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .opencv_caffe.NetStateRule exclude = 33; + total_size += 2UL * this->_internal_exclude_size(); + for (const auto& msg : this->exclude_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated float loss_weight = 35; + { + unsigned int count = static_cast(this->_internal_loss_weight_size()); + size_t data_size = 4UL * count; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_loss_weight_size()); + total_size += data_size; + } + + // repeated string param = 1001; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(param_.size()); + for (int i = 0, n = param_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + param_.Get(i)); + } + + // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + { + size_t data_size = 0; + unsigned int count = static_cast(this->_internal_blob_share_mode_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize( + this->_internal_blob_share_mode(static_cast(i))); + } + total_size += (2UL * count) + data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string name = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional .opencv_caffe.V0LayerParameter layer = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *layer_); + } + + // optional .opencv_caffe.ConcatParameter concat_param = 9; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *concat_param_); + } + + // optional .opencv_caffe.ConvolutionParameter convolution_param = 10; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *convolution_param_); + } + + // optional .opencv_caffe.DataParameter data_param = 11; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *data_param_); + } + + // optional .opencv_caffe.DropoutParameter dropout_param = 12; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *dropout_param_); + } + + // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hdf5_data_param_); + } + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hdf5_output_param_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .opencv_caffe.ImageDataParameter image_data_param = 15; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *image_data_param_); + } + + // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *infogain_loss_param_); + } + + // optional .opencv_caffe.InnerProductParameter inner_product_param = 17; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *inner_product_param_); + } + + // optional .opencv_caffe.LRNParameter lrn_param = 18; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *lrn_param_); + } + + // optional .opencv_caffe.PoolingParameter pooling_param = 19; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *pooling_param_); + } + + // optional .opencv_caffe.WindowDataParameter window_data_param = 20; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *window_data_param_); + } + + // optional .opencv_caffe.PowerParameter power_param = 21; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *power_param_); + } + + // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *memory_data_param_); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .opencv_caffe.ArgMaxParameter argmax_param = 23; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *argmax_param_); + } + + // optional .opencv_caffe.EltwiseParameter eltwise_param = 24; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *eltwise_param_); + } + + // optional .opencv_caffe.ThresholdParameter threshold_param = 25; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *threshold_param_); + } + + // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *dummy_data_param_); + } + + // optional .opencv_caffe.AccuracyParameter accuracy_param = 27; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *accuracy_param_); + } + + // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hinge_loss_param_); + } + + // optional .opencv_caffe.ReLUParameter relu_param = 30; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *relu_param_); + } + + // optional .opencv_caffe.SliceParameter slice_param = 31; + if (cached_has_bits & 0x00800000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *slice_param_); + } + + } + if (cached_has_bits & 0xff000000u) { + // optional .opencv_caffe.MVNParameter mvn_param = 34; + if (cached_has_bits & 0x01000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mvn_param_); + } + + // optional .opencv_caffe.TransformationParameter transform_param = 36; + if (cached_has_bits & 0x02000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *transform_param_); + } + + // optional .opencv_caffe.TanHParameter tanh_param = 37; + if (cached_has_bits & 0x04000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *tanh_param_); + } + + // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38; + if (cached_has_bits & 0x08000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *sigmoid_param_); + } + + // optional .opencv_caffe.SoftmaxParameter softmax_param = 39; + if (cached_has_bits & 0x10000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *softmax_param_); + } + + // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40; + if (cached_has_bits & 0x20000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *contrastive_loss_param_); + } + + // optional .opencv_caffe.ExpParameter exp_param = 41; + if (cached_has_bits & 0x40000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *exp_param_); + } + + // optional .opencv_caffe.LossParameter loss_param = 42; + if (cached_has_bits & 0x80000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *loss_param_); + } + + } + // optional .opencv_caffe.V1LayerParameter.LayerType type = 5; + cached_has_bits = _has_bits_[1]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData V1LayerParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + V1LayerParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*V1LayerParameter::GetClassData() const { return &_class_data_; } + +void V1LayerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void V1LayerParameter::MergeFrom(const V1LayerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.V1LayerParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + bottom_.MergeFrom(from.bottom_); + top_.MergeFrom(from.top_); + blobs_.MergeFrom(from.blobs_); + blobs_lr_.MergeFrom(from.blobs_lr_); + weight_decay_.MergeFrom(from.weight_decay_); + include_.MergeFrom(from.include_); + exclude_.MergeFrom(from.exclude_); + loss_weight_.MergeFrom(from.loss_weight_); + param_.MergeFrom(from.param_); + blob_share_mode_.MergeFrom(from.blob_share_mode_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_layer()->::opencv_caffe::V0LayerParameter::MergeFrom(from._internal_layer()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_concat_param()->::opencv_caffe::ConcatParameter::MergeFrom(from._internal_concat_param()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_convolution_param()->::opencv_caffe::ConvolutionParameter::MergeFrom(from._internal_convolution_param()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_data_param()->::opencv_caffe::DataParameter::MergeFrom(from._internal_data_param()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_dropout_param()->::opencv_caffe::DropoutParameter::MergeFrom(from._internal_dropout_param()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_hdf5_data_param()->::opencv_caffe::HDF5DataParameter::MergeFrom(from._internal_hdf5_data_param()); + } + if (cached_has_bits & 0x00000080u) { + _internal_mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from._internal_hdf5_output_param()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _internal_mutable_image_data_param()->::opencv_caffe::ImageDataParameter::MergeFrom(from._internal_image_data_param()); + } + if (cached_has_bits & 0x00000200u) { + _internal_mutable_infogain_loss_param()->::opencv_caffe::InfogainLossParameter::MergeFrom(from._internal_infogain_loss_param()); + } + if (cached_has_bits & 0x00000400u) { + _internal_mutable_inner_product_param()->::opencv_caffe::InnerProductParameter::MergeFrom(from._internal_inner_product_param()); + } + if (cached_has_bits & 0x00000800u) { + _internal_mutable_lrn_param()->::opencv_caffe::LRNParameter::MergeFrom(from._internal_lrn_param()); + } + if (cached_has_bits & 0x00001000u) { + _internal_mutable_pooling_param()->::opencv_caffe::PoolingParameter::MergeFrom(from._internal_pooling_param()); + } + if (cached_has_bits & 0x00002000u) { + _internal_mutable_window_data_param()->::opencv_caffe::WindowDataParameter::MergeFrom(from._internal_window_data_param()); + } + if (cached_has_bits & 0x00004000u) { + _internal_mutable_power_param()->::opencv_caffe::PowerParameter::MergeFrom(from._internal_power_param()); + } + if (cached_has_bits & 0x00008000u) { + _internal_mutable_memory_data_param()->::opencv_caffe::MemoryDataParameter::MergeFrom(from._internal_memory_data_param()); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _internal_mutable_argmax_param()->::opencv_caffe::ArgMaxParameter::MergeFrom(from._internal_argmax_param()); + } + if (cached_has_bits & 0x00020000u) { + _internal_mutable_eltwise_param()->::opencv_caffe::EltwiseParameter::MergeFrom(from._internal_eltwise_param()); + } + if (cached_has_bits & 0x00040000u) { + _internal_mutable_threshold_param()->::opencv_caffe::ThresholdParameter::MergeFrom(from._internal_threshold_param()); + } + if (cached_has_bits & 0x00080000u) { + _internal_mutable_dummy_data_param()->::opencv_caffe::DummyDataParameter::MergeFrom(from._internal_dummy_data_param()); + } + if (cached_has_bits & 0x00100000u) { + _internal_mutable_accuracy_param()->::opencv_caffe::AccuracyParameter::MergeFrom(from._internal_accuracy_param()); + } + if (cached_has_bits & 0x00200000u) { + _internal_mutable_hinge_loss_param()->::opencv_caffe::HingeLossParameter::MergeFrom(from._internal_hinge_loss_param()); + } + if (cached_has_bits & 0x00400000u) { + _internal_mutable_relu_param()->::opencv_caffe::ReLUParameter::MergeFrom(from._internal_relu_param()); + } + if (cached_has_bits & 0x00800000u) { + _internal_mutable_slice_param()->::opencv_caffe::SliceParameter::MergeFrom(from._internal_slice_param()); + } + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + _internal_mutable_mvn_param()->::opencv_caffe::MVNParameter::MergeFrom(from._internal_mvn_param()); + } + if (cached_has_bits & 0x02000000u) { + _internal_mutable_transform_param()->::opencv_caffe::TransformationParameter::MergeFrom(from._internal_transform_param()); + } + if (cached_has_bits & 0x04000000u) { + _internal_mutable_tanh_param()->::opencv_caffe::TanHParameter::MergeFrom(from._internal_tanh_param()); + } + if (cached_has_bits & 0x08000000u) { + _internal_mutable_sigmoid_param()->::opencv_caffe::SigmoidParameter::MergeFrom(from._internal_sigmoid_param()); + } + if (cached_has_bits & 0x10000000u) { + _internal_mutable_softmax_param()->::opencv_caffe::SoftmaxParameter::MergeFrom(from._internal_softmax_param()); + } + if (cached_has_bits & 0x20000000u) { + _internal_mutable_contrastive_loss_param()->::opencv_caffe::ContrastiveLossParameter::MergeFrom(from._internal_contrastive_loss_param()); + } + if (cached_has_bits & 0x40000000u) { + _internal_mutable_exp_param()->::opencv_caffe::ExpParameter::MergeFrom(from._internal_exp_param()); + } + if (cached_has_bits & 0x80000000u) { + _internal_mutable_loss_param()->::opencv_caffe::LossParameter::MergeFrom(from._internal_loss_param()); + } + } + if (from._internal_has_type()) { + _internal_set_type(from._internal_type()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void V1LayerParameter::CopyFrom(const V1LayerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.V1LayerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool V1LayerParameter::IsInitialized() const { + return true; +} + +void V1LayerParameter::InternalSwap(V1LayerParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(_has_bits_[1], other->_has_bits_[1]); + bottom_.InternalSwap(&other->bottom_); + top_.InternalSwap(&other->top_); + blobs_.InternalSwap(&other->blobs_); + blobs_lr_.InternalSwap(&other->blobs_lr_); + weight_decay_.InternalSwap(&other->weight_decay_); + include_.InternalSwap(&other->include_); + exclude_.InternalSwap(&other->exclude_); + loss_weight_.InternalSwap(&other->loss_weight_); + param_.InternalSwap(&other->param_); + blob_share_mode_.InternalSwap(&other->blob_share_mode_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(V1LayerParameter, type_) + + sizeof(V1LayerParameter::type_) + - PROTOBUF_FIELD_OFFSET(V1LayerParameter, layer_)>( + reinterpret_cast(&layer_), + reinterpret_cast(&other->layer_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata V1LayerParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[64]); +} + +// =================================================================== + +class V0LayerParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_num_output(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_biasterm(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static const ::opencv_caffe::FillerParameter& weight_filler(const V0LayerParameter* msg); + static void set_has_weight_filler(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::opencv_caffe::FillerParameter& bias_filler(const V0LayerParameter* msg); + static void set_has_bias_filler(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_pad(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_kernelsize(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_group(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static void set_has_stride(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static void set_has_pool(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_dropout_ratio(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } + static void set_has_local_size(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static void set_has_alpha(HasBits* has_bits) { + (*has_bits)[0] |= 268435456u; + } + static void set_has_beta(HasBits* has_bits) { + (*has_bits)[0] |= 536870912u; + } + static void set_has_k(HasBits* has_bits) { + (*has_bits)[0] |= 2147483648u; + } + static void set_has_source(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 1073741824u; + } + static void set_has_meanfile(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_batchsize(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_cropsize(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_mirror(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_rand_skip(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_det_fg_threshold(HasBits* has_bits) { + (*has_bits)[1] |= 1u; + } + static void set_has_det_bg_threshold(HasBits* has_bits) { + (*has_bits)[1] |= 2u; + } + static void set_has_det_fg_fraction(HasBits* has_bits) { + (*has_bits)[1] |= 4u; + } + static void set_has_det_context_pad(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_det_crop_mode(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_new_num(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_new_channels(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_new_height(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_new_width(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_shuffle_images(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_concat_dim(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param(const V0LayerParameter* msg); + static void set_has_hdf5_output_param(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +const ::opencv_caffe::FillerParameter& +V0LayerParameter::_Internal::weight_filler(const V0LayerParameter* msg) { + return *msg->weight_filler_; +} +const ::opencv_caffe::FillerParameter& +V0LayerParameter::_Internal::bias_filler(const V0LayerParameter* msg) { + return *msg->bias_filler_; +} +const ::opencv_caffe::HDF5OutputParameter& +V0LayerParameter::_Internal::hdf5_output_param(const V0LayerParameter* msg) { + return *msg->hdf5_output_param_; +} +const ::PROTOBUF_NAMESPACE_ID::internal::LazyString V0LayerParameter::_i_give_permission_to_break_this_code_default_det_crop_mode_{{{"warp", 4}}, {nullptr}}; +V0LayerParameter::V0LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + blobs_(arena), + blobs_lr_(arena), + weight_decay_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.V0LayerParameter) +} +V0LayerParameter::V0LayerParameter(const V0LayerParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + blobs_(from.blobs_), + blobs_lr_(from.blobs_lr_), + weight_decay_(from.weight_decay_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArenaForAllocation()); + } + type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_type()) { + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_type(), + GetArenaForAllocation()); + } + source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_source()) { + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), + GetArenaForAllocation()); + } + meanfile_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + meanfile_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_meanfile()) { + meanfile_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_meanfile(), + GetArenaForAllocation()); + } + det_crop_mode_.UnsafeSetDefault(nullptr); + if (from._internal_has_det_crop_mode()) { + det_crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_det_crop_mode(), + GetArenaForAllocation()); + } + if (from._internal_has_weight_filler()) { + weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); + } else { + weight_filler_ = nullptr; + } + if (from._internal_has_bias_filler()) { + bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); + } else { + bias_filler_ = nullptr; + } + if (from._internal_has_hdf5_output_param()) { + hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_); + } else { + hdf5_output_param_ = nullptr; + } + ::memcpy(&num_output_, &from.num_output_, + static_cast(reinterpret_cast(&det_fg_fraction_) - + reinterpret_cast(&num_output_)) + sizeof(det_fg_fraction_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.V0LayerParameter) +} + +inline void V0LayerParameter::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +meanfile_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + meanfile_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +det_crop_mode_.UnsafeSetDefault(nullptr); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&new_height_) - + reinterpret_cast(&weight_filler_)) + sizeof(new_height_)); +concat_dim_ = 1u; +biasterm_ = true; +group_ = 1u; +stride_ = 1u; +dropout_ratio_ = 0.5f; +local_size_ = 5u; +alpha_ = 1; +beta_ = 0.75f; +scale_ = 1; +k_ = 1; +det_fg_threshold_ = 0.5f; +det_bg_threshold_ = 0.5f; +det_fg_fraction_ = 0.25f; +} + +V0LayerParameter::~V0LayerParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.V0LayerParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void V0LayerParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + meanfile_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + det_crop_mode_.DestroyNoArena(nullptr); + if (this != internal_default_instance()) delete weight_filler_; + if (this != internal_default_instance()) delete bias_filler_; + if (this != internal_default_instance()) delete hdf5_output_param_; +} + +void V0LayerParameter::ArenaDtor(void* object) { + V0LayerParameter* _this = reinterpret_cast< V0LayerParameter* >(object); + (void)_this; +} +void V0LayerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void V0LayerParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void V0LayerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.V0LayerParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + blobs_.Clear(); + blobs_lr_.Clear(); + weight_decay_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + type_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + source_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + meanfile_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + det_crop_mode_.ClearToDefault(::opencv_caffe::V0LayerParameter::_i_give_permission_to_break_this_code_default_det_crop_mode_, GetArenaForAllocation()); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(weight_filler_ != nullptr); + weight_filler_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(bias_filler_ != nullptr); + bias_filler_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(hdf5_output_param_ != nullptr); + hdf5_output_param_->Clear(); + } + } + if (cached_has_bits & 0x0000ff00u) { + ::memset(&num_output_, 0, static_cast( + reinterpret_cast(&mirror_) - + reinterpret_cast(&num_output_)) + sizeof(mirror_)); + } + if (cached_has_bits & 0x00ff0000u) { + ::memset(&shuffle_images_, 0, static_cast( + reinterpret_cast(&new_height_) - + reinterpret_cast(&shuffle_images_)) + sizeof(new_height_)); + concat_dim_ = 1u; + biasterm_ = true; + } + if (cached_has_bits & 0xff000000u) { + group_ = 1u; + stride_ = 1u; + dropout_ratio_ = 0.5f; + local_size_ = 5u; + alpha_ = 1; + beta_ = 0.75f; + scale_ = 1; + k_ = 1; + } + cached_has_bits = _has_bits_[1]; + if (cached_has_bits & 0x00000007u) { + det_fg_threshold_ = 0.5f; + det_bg_threshold_ = 0.5f; + det_fg_fraction_ = 0.25f; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* V0LayerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.name"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_type(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.type"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 num_output = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_num_output(&_has_bits_); + num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool biasterm = 4 [default = true]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_biasterm(&_has_bits_); + biasterm_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter weight_filler = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.FillerParameter bias_filler = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pad = 7 [default = 0]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_pad(&_has_bits_); + pad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 kernelsize = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_kernelsize(&_has_bits_); + kernelsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 group = 9 [default = 1]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_group(&_has_bits_); + group_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 stride = 10 [default = 1]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_stride(&_has_bits_); + stride_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::V0LayerParameter_PoolMethod_IsValid(val))) { + _internal_set_pool(static_cast<::opencv_caffe::V0LayerParameter_PoolMethod>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional float dropout_ratio = 12 [default = 0.5]; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 101)) { + _Internal::set_has_dropout_ratio(&_has_bits_); + dropout_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional uint32 local_size = 13 [default = 5]; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + _Internal::set_has_local_size(&_has_bits_); + local_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float alpha = 14 [default = 1]; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 117)) { + _Internal::set_has_alpha(&_has_bits_); + alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float beta = 15 [default = 0.75]; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 125)) { + _Internal::set_has_beta(&_has_bits_); + beta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional string source = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_source(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.source"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float scale = 17 [default = 1]; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 141)) { + _Internal::set_has_scale(&_has_bits_); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional string meanfile = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + auto str = _internal_mutable_meanfile(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.meanfile"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 batchsize = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { + _Internal::set_has_batchsize(&_has_bits_); + batchsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 cropsize = 20 [default = 0]; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + _Internal::set_has_cropsize(&_has_bits_); + cropsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool mirror = 21 [default = false]; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { + _Internal::set_has_mirror(&_has_bits_); + mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float k = 22 [default = 1]; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 181)) { + _Internal::set_has_k(&_has_bits_); + k_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // repeated .opencv_caffe.BlobProto blobs = 50; + case 50: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_blobs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<402>(ptr)); + } else + goto handle_unusual; + continue; + // repeated float blobs_lr = 51; + case 51: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 157)) { + ptr -= 2; + do { + ptr += 2; + _internal_add_blobs_lr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<413>(ptr)); + } else if (static_cast(tag) == 154) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_blobs_lr(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float weight_decay = 52; + case 52: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 165)) { + ptr -= 2; + do { + ptr += 2; + _internal_add_weight_decay(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<421>(ptr)); + } else if (static_cast(tag) == 162) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_weight_decay(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 rand_skip = 53 [default = 0]; + case 53: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { + _Internal::set_has_rand_skip(&_has_bits_); + rand_skip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float det_fg_threshold = 54 [default = 0.5]; + case 54: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 181)) { + _Internal::set_has_det_fg_threshold(&_has_bits_); + det_fg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float det_bg_threshold = 55 [default = 0.5]; + case 55: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 189)) { + _Internal::set_has_det_bg_threshold(&_has_bits_); + det_bg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float det_fg_fraction = 56 [default = 0.25]; + case 56: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 197)) { + _Internal::set_has_det_fg_fraction(&_has_bits_); + det_fg_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional uint32 det_context_pad = 58 [default = 0]; + case 58: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 208)) { + _Internal::set_has_det_context_pad(&_has_bits_); + det_context_pad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string det_crop_mode = 59 [default = "warp"]; + case 59: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + auto str = _internal_mutable_det_crop_mode(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.det_crop_mode"); + #endif // !NDEBUG + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 new_num = 60 [default = 0]; + case 60: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { + _Internal::set_has_new_num(&_has_bits_); + new_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 new_channels = 61 [default = 0]; + case 61: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { + _Internal::set_has_new_channels(&_has_bits_); + new_channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 new_height = 62 [default = 0]; + case 62: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { + _Internal::set_has_new_height(&_has_bits_); + new_height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 new_width = 63 [default = 0]; + case 63: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { + _Internal::set_has_new_width(&_has_bits_); + new_width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool shuffle_images = 64 [default = false]; + case 64: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 0)) { + _Internal::set_has_shuffle_images(&_has_bits_); + shuffle_images_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 concat_dim = 65 [default = 1]; + case 65: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_concat_dim(&_has_bits_); + concat_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001; + case 1001: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_hdf5_output_param(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* V0LayerParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.V0LayerParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V0LayerParameter.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional string type = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_type().data(), static_cast(this->_internal_type().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V0LayerParameter.type"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_type(), target); + } + + // optional uint32 num_output = 3; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_num_output(), target); + } + + // optional bool biasterm = 4 [default = true]; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_biasterm(), target); + } + + // optional .opencv_caffe.FillerParameter weight_filler = 5; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::weight_filler(this), target, stream); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 6; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::bias_filler(this), target, stream); + } + + // optional uint32 pad = 7 [default = 0]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_pad(), target); + } + + // optional uint32 kernelsize = 8; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_kernelsize(), target); + } + + // optional uint32 group = 9 [default = 1]; + if (cached_has_bits & 0x01000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_group(), target); + } + + // optional uint32 stride = 10 [default = 1]; + if (cached_has_bits & 0x02000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_stride(), target); + } + + // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 11, this->_internal_pool(), target); + } + + // optional float dropout_ratio = 12 [default = 0.5]; + if (cached_has_bits & 0x04000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(12, this->_internal_dropout_ratio(), target); + } + + // optional uint32 local_size = 13 [default = 5]; + if (cached_has_bits & 0x08000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(13, this->_internal_local_size(), target); + } + + // optional float alpha = 14 [default = 1]; + if (cached_has_bits & 0x10000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(14, this->_internal_alpha(), target); + } + + // optional float beta = 15 [default = 0.75]; + if (cached_has_bits & 0x20000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(15, this->_internal_beta(), target); + } + + // optional string source = 16; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_source().data(), static_cast(this->_internal_source().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V0LayerParameter.source"); + target = stream->WriteStringMaybeAliased( + 16, this->_internal_source(), target); + } + + // optional float scale = 17 [default = 1]; + if (cached_has_bits & 0x40000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(17, this->_internal_scale(), target); + } + + // optional string meanfile = 18; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_meanfile().data(), static_cast(this->_internal_meanfile().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V0LayerParameter.meanfile"); + target = stream->WriteStringMaybeAliased( + 18, this->_internal_meanfile(), target); + } + + // optional uint32 batchsize = 19; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(19, this->_internal_batchsize(), target); + } + + // optional uint32 cropsize = 20 [default = 0]; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(20, this->_internal_cropsize(), target); + } + + // optional bool mirror = 21 [default = false]; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(21, this->_internal_mirror(), target); + } + + // optional float k = 22 [default = 1]; + if (cached_has_bits & 0x80000000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(22, this->_internal_k(), target); + } + + // repeated .opencv_caffe.BlobProto blobs = 50; + for (unsigned int i = 0, + n = static_cast(this->_internal_blobs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(50, this->_internal_blobs(i), target, stream); + } + + // repeated float blobs_lr = 51; + for (int i = 0, n = this->_internal_blobs_lr_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(51, this->_internal_blobs_lr(i), target); + } + + // repeated float weight_decay = 52; + for (int i = 0, n = this->_internal_weight_decay_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(52, this->_internal_weight_decay(i), target); + } + + // optional uint32 rand_skip = 53 [default = 0]; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(53, this->_internal_rand_skip(), target); + } + + cached_has_bits = _has_bits_[1]; + // optional float det_fg_threshold = 54 [default = 0.5]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(54, this->_internal_det_fg_threshold(), target); + } + + // optional float det_bg_threshold = 55 [default = 0.5]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(55, this->_internal_det_bg_threshold(), target); + } + + // optional float det_fg_fraction = 56 [default = 0.25]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(56, this->_internal_det_fg_fraction(), target); + } + + cached_has_bits = _has_bits_[0]; + // optional uint32 det_context_pad = 58 [default = 0]; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(58, this->_internal_det_context_pad(), target); + } + + // optional string det_crop_mode = 59 [default = "warp"]; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_det_crop_mode().data(), static_cast(this->_internal_det_crop_mode().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "opencv_caffe.V0LayerParameter.det_crop_mode"); + target = stream->WriteStringMaybeAliased( + 59, this->_internal_det_crop_mode(), target); + } + + // optional int32 new_num = 60 [default = 0]; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(60, this->_internal_new_num(), target); + } + + // optional int32 new_channels = 61 [default = 0]; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(61, this->_internal_new_channels(), target); + } + + // optional int32 new_height = 62 [default = 0]; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(62, this->_internal_new_height(), target); + } + + // optional int32 new_width = 63 [default = 0]; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(63, this->_internal_new_width(), target); + } + + // optional bool shuffle_images = 64 [default = false]; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(64, this->_internal_shuffle_images(), target); + } + + // optional uint32 concat_dim = 65 [default = 1]; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(65, this->_internal_concat_dim(), target); + } + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1001, _Internal::hdf5_output_param(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.V0LayerParameter) + return target; +} + +size_t V0LayerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.V0LayerParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .opencv_caffe.BlobProto blobs = 50; + total_size += 2UL * this->_internal_blobs_size(); + for (const auto& msg : this->blobs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated float blobs_lr = 51; + { + unsigned int count = static_cast(this->_internal_blobs_lr_size()); + size_t data_size = 4UL * count; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_blobs_lr_size()); + total_size += data_size; + } + + // repeated float weight_decay = 52; + { + unsigned int count = static_cast(this->_internal_weight_decay_size()); + size_t data_size = 4UL * count; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_weight_decay_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string type = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_type()); + } + + // optional string source = 16; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_source()); + } + + // optional string meanfile = 18; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_meanfile()); + } + + // optional string det_crop_mode = 59 [default = "warp"]; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_det_crop_mode()); + } + + // optional .opencv_caffe.FillerParameter weight_filler = 5; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *weight_filler_); + } + + // optional .opencv_caffe.FillerParameter bias_filler = 6; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bias_filler_); + } + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hdf5_output_param_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional uint32 num_output = 3; + if (cached_has_bits & 0x00000100u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); + } + + // optional uint32 pad = 7 [default = 0]; + if (cached_has_bits & 0x00000200u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad()); + } + + // optional uint32 kernelsize = 8; + if (cached_has_bits & 0x00000400u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernelsize()); + } + + // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_pool()); + } + + // optional uint32 batchsize = 19; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_batchsize()); + } + + // optional uint32 cropsize = 20 [default = 0]; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_cropsize()); + } + + // optional int32 new_width = 63 [default = 0]; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_new_width()); + } + + // optional bool mirror = 21 [default = false]; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + 1; + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional bool shuffle_images = 64 [default = false]; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + 1; + } + + // optional uint32 rand_skip = 53 [default = 0]; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_rand_skip()); + } + + // optional uint32 det_context_pad = 58 [default = 0]; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_det_context_pad()); + } + + // optional int32 new_num = 60 [default = 0]; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_new_num()); + } + + // optional int32 new_channels = 61 [default = 0]; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_new_channels()); + } + + // optional int32 new_height = 62 [default = 0]; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_new_height()); + } + + // optional uint32 concat_dim = 65 [default = 1]; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_concat_dim()); + } + + // optional bool biasterm = 4 [default = true]; + if (cached_has_bits & 0x00800000u) { + total_size += 1 + 1; + } + + } + if (cached_has_bits & 0xff000000u) { + // optional uint32 group = 9 [default = 1]; + if (cached_has_bits & 0x01000000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_group()); + } + + // optional uint32 stride = 10 [default = 1]; + if (cached_has_bits & 0x02000000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride()); + } + + // optional float dropout_ratio = 12 [default = 0.5]; + if (cached_has_bits & 0x04000000u) { + total_size += 1 + 4; + } + + // optional uint32 local_size = 13 [default = 5]; + if (cached_has_bits & 0x08000000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_local_size()); + } + + // optional float alpha = 14 [default = 1]; + if (cached_has_bits & 0x10000000u) { + total_size += 1 + 4; + } + + // optional float beta = 15 [default = 0.75]; + if (cached_has_bits & 0x20000000u) { + total_size += 1 + 4; + } + + // optional float scale = 17 [default = 1]; + if (cached_has_bits & 0x40000000u) { + total_size += 2 + 4; + } + + // optional float k = 22 [default = 1]; + if (cached_has_bits & 0x80000000u) { + total_size += 2 + 4; + } + + } + cached_has_bits = _has_bits_[1]; + if (cached_has_bits & 0x00000007u) { + // optional float det_fg_threshold = 54 [default = 0.5]; + if (cached_has_bits & 0x00000001u) { + total_size += 2 + 4; + } + + // optional float det_bg_threshold = 55 [default = 0.5]; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + 4; + } + + // optional float det_fg_fraction = 56 [default = 0.25]; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData V0LayerParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + V0LayerParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*V0LayerParameter::GetClassData() const { return &_class_data_; } + +void V0LayerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void V0LayerParameter::MergeFrom(const V0LayerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.V0LayerParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + blobs_.MergeFrom(from.blobs_); + blobs_lr_.MergeFrom(from.blobs_lr_); + weight_decay_.MergeFrom(from.weight_decay_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_type(from._internal_type()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_source(from._internal_source()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_meanfile(from._internal_meanfile()); + } + if (cached_has_bits & 0x00000010u) { + _internal_set_det_crop_mode(from._internal_det_crop_mode()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); + } + if (cached_has_bits & 0x00000080u) { + _internal_mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from._internal_hdf5_output_param()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + num_output_ = from.num_output_; + } + if (cached_has_bits & 0x00000200u) { + pad_ = from.pad_; + } + if (cached_has_bits & 0x00000400u) { + kernelsize_ = from.kernelsize_; + } + if (cached_has_bits & 0x00000800u) { + pool_ = from.pool_; + } + if (cached_has_bits & 0x00001000u) { + batchsize_ = from.batchsize_; + } + if (cached_has_bits & 0x00002000u) { + cropsize_ = from.cropsize_; + } + if (cached_has_bits & 0x00004000u) { + new_width_ = from.new_width_; + } + if (cached_has_bits & 0x00008000u) { + mirror_ = from.mirror_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + shuffle_images_ = from.shuffle_images_; + } + if (cached_has_bits & 0x00020000u) { + rand_skip_ = from.rand_skip_; + } + if (cached_has_bits & 0x00040000u) { + det_context_pad_ = from.det_context_pad_; + } + if (cached_has_bits & 0x00080000u) { + new_num_ = from.new_num_; + } + if (cached_has_bits & 0x00100000u) { + new_channels_ = from.new_channels_; + } + if (cached_has_bits & 0x00200000u) { + new_height_ = from.new_height_; + } + if (cached_has_bits & 0x00400000u) { + concat_dim_ = from.concat_dim_; + } + if (cached_has_bits & 0x00800000u) { + biasterm_ = from.biasterm_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + group_ = from.group_; + } + if (cached_has_bits & 0x02000000u) { + stride_ = from.stride_; + } + if (cached_has_bits & 0x04000000u) { + dropout_ratio_ = from.dropout_ratio_; + } + if (cached_has_bits & 0x08000000u) { + local_size_ = from.local_size_; + } + if (cached_has_bits & 0x10000000u) { + alpha_ = from.alpha_; + } + if (cached_has_bits & 0x20000000u) { + beta_ = from.beta_; + } + if (cached_has_bits & 0x40000000u) { + scale_ = from.scale_; + } + if (cached_has_bits & 0x80000000u) { + k_ = from.k_; + } + _has_bits_[0] |= cached_has_bits; + } + cached_has_bits = from._has_bits_[1]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + det_fg_threshold_ = from.det_fg_threshold_; + } + if (cached_has_bits & 0x00000002u) { + det_bg_threshold_ = from.det_bg_threshold_; + } + if (cached_has_bits & 0x00000004u) { + det_fg_fraction_ = from.det_fg_fraction_; + } + _has_bits_[1] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void V0LayerParameter::CopyFrom(const V0LayerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.V0LayerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool V0LayerParameter::IsInitialized() const { + return true; +} + +void V0LayerParameter::InternalSwap(V0LayerParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(_has_bits_[1], other->_has_bits_[1]); + blobs_.InternalSwap(&other->blobs_); + blobs_lr_.InternalSwap(&other->blobs_lr_); + weight_decay_.InternalSwap(&other->weight_decay_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &type_, lhs_arena, + &other->type_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &source_, lhs_arena, + &other->source_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &meanfile_, lhs_arena, + &other->meanfile_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + nullptr, + &det_crop_mode_, lhs_arena, + &other->det_crop_mode_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(V0LayerParameter, new_height_) + + sizeof(V0LayerParameter::new_height_) + - PROTOBUF_FIELD_OFFSET(V0LayerParameter, weight_filler_)>( + reinterpret_cast(&weight_filler_), + reinterpret_cast(&other->weight_filler_)); + swap(concat_dim_, other->concat_dim_); + swap(biasterm_, other->biasterm_); + swap(group_, other->group_); + swap(stride_, other->stride_); + swap(dropout_ratio_, other->dropout_ratio_); + swap(local_size_, other->local_size_); + swap(alpha_, other->alpha_); + swap(beta_, other->beta_); + swap(scale_, other->scale_); + swap(k_, other->k_); + swap(det_fg_threshold_, other->det_fg_threshold_); + swap(det_bg_threshold_, other->det_bg_threshold_); + swap(det_fg_fraction_, other->det_fg_fraction_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata V0LayerParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[65]); +} + +// =================================================================== + +class PReLUParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::opencv_caffe::FillerParameter& filler(const PReLUParameter* msg); + static void set_has_filler(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_channel_shared(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::opencv_caffe::FillerParameter& +PReLUParameter::_Internal::filler(const PReLUParameter* msg) { + return *msg->filler_; +} +PReLUParameter::PReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.PReLUParameter) +} +PReLUParameter::PReLUParameter(const PReLUParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_filler()) { + filler_ = new ::opencv_caffe::FillerParameter(*from.filler_); + } else { + filler_ = nullptr; + } + channel_shared_ = from.channel_shared_; + // @@protoc_insertion_point(copy_constructor:opencv_caffe.PReLUParameter) +} + +inline void PReLUParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&filler_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&channel_shared_) - + reinterpret_cast(&filler_)) + sizeof(channel_shared_)); +} + +PReLUParameter::~PReLUParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.PReLUParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void PReLUParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete filler_; +} + +void PReLUParameter::ArenaDtor(void* object) { + PReLUParameter* _this = reinterpret_cast< PReLUParameter* >(object); + (void)_this; +} +void PReLUParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PReLUParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PReLUParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.PReLUParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(filler_ != nullptr); + filler_->Clear(); + } + channel_shared_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PReLUParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .opencv_caffe.FillerParameter filler = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_filler(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool channel_shared = 2 [default = false]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_channel_shared(&has_bits); + channel_shared_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PReLUParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PReLUParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_caffe.FillerParameter filler = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::filler(this), target, stream); + } + + // optional bool channel_shared = 2 [default = false]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_channel_shared(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PReLUParameter) + return target; +} + +size_t PReLUParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PReLUParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .opencv_caffe.FillerParameter filler = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *filler_); + } + + // optional bool channel_shared = 2 [default = false]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PReLUParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + PReLUParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PReLUParameter::GetClassData() const { return &_class_data_; } + +void PReLUParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void PReLUParameter::MergeFrom(const PReLUParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PReLUParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_filler()); + } + if (cached_has_bits & 0x00000002u) { + channel_shared_ = from.channel_shared_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PReLUParameter::CopyFrom(const PReLUParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PReLUParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PReLUParameter::IsInitialized() const { + return true; +} + +void PReLUParameter::InternalSwap(PReLUParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PReLUParameter, channel_shared_) + + sizeof(PReLUParameter::channel_shared_) + - PROTOBUF_FIELD_OFFSET(PReLUParameter, filler_)>( + reinterpret_cast(&filler_), + reinterpret_cast(&other->filler_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PReLUParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[66]); +} + +// =================================================================== + +class NormalizedBBox::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_xmin(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_ymin(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_xmax(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_ymax(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_label(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_difficult(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_score(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_size(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +NormalizedBBox::NormalizedBBox(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.NormalizedBBox) +} +NormalizedBBox::NormalizedBBox(const NormalizedBBox& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&xmin_, &from.xmin_, + static_cast(reinterpret_cast(&size_) - + reinterpret_cast(&xmin_)) + sizeof(size_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.NormalizedBBox) +} + +inline void NormalizedBBox::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&xmin_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&size_) - + reinterpret_cast(&xmin_)) + sizeof(size_)); +} + +NormalizedBBox::~NormalizedBBox() { + // @@protoc_insertion_point(destructor:opencv_caffe.NormalizedBBox) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void NormalizedBBox::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void NormalizedBBox::ArenaDtor(void* object) { + NormalizedBBox* _this = reinterpret_cast< NormalizedBBox* >(object); + (void)_this; +} +void NormalizedBBox::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void NormalizedBBox::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void NormalizedBBox::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.NormalizedBBox) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + ::memset(&xmin_, 0, static_cast( + reinterpret_cast(&size_) - + reinterpret_cast(&xmin_)) + sizeof(size_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NormalizedBBox::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional float xmin = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_xmin(&has_bits); + xmin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float ymin = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_ymin(&has_bits); + ymin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float xmax = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_xmax(&has_bits); + xmax_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float ymax = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { + _Internal::set_has_ymax(&has_bits); + ymax_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional int32 label = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_label(&has_bits); + label_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool difficult = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_difficult(&has_bits); + difficult_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float score = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { + _Internal::set_has_score(&has_bits); + score_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional float size = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { + _Internal::set_has_size(&has_bits); + size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NormalizedBBox::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NormalizedBBox) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float xmin = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_xmin(), target); + } + + // optional float ymin = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_ymin(), target); + } + + // optional float xmax = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_xmax(), target); + } + + // optional float ymax = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_ymax(), target); + } + + // optional int32 label = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_label(), target); + } + + // optional bool difficult = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_difficult(), target); + } + + // optional float score = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_score(), target); + } + + // optional float size = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_size(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NormalizedBBox) + return target; +} + +size_t NormalizedBBox::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NormalizedBBox) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional float xmin = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float ymin = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float xmax = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + // optional float ymax = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + // optional int32 label = 5; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_label()); + } + + // optional bool difficult = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional float score = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 4; + } + + // optional float size = 8; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NormalizedBBox::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + NormalizedBBox::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NormalizedBBox::GetClassData() const { return &_class_data_; } + +void NormalizedBBox::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void NormalizedBBox::MergeFrom(const NormalizedBBox& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NormalizedBBox) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + xmin_ = from.xmin_; + } + if (cached_has_bits & 0x00000002u) { + ymin_ = from.ymin_; + } + if (cached_has_bits & 0x00000004u) { + xmax_ = from.xmax_; + } + if (cached_has_bits & 0x00000008u) { + ymax_ = from.ymax_; + } + if (cached_has_bits & 0x00000010u) { + label_ = from.label_; + } + if (cached_has_bits & 0x00000020u) { + difficult_ = from.difficult_; + } + if (cached_has_bits & 0x00000040u) { + score_ = from.score_; + } + if (cached_has_bits & 0x00000080u) { + size_ = from.size_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NormalizedBBox::CopyFrom(const NormalizedBBox& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NormalizedBBox) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NormalizedBBox::IsInitialized() const { + return true; +} + +void NormalizedBBox::InternalSwap(NormalizedBBox* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(NormalizedBBox, size_) + + sizeof(NormalizedBBox::size_) + - PROTOBUF_FIELD_OFFSET(NormalizedBBox, xmin_)>( + reinterpret_cast(&xmin_), + reinterpret_cast(&other->xmin_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NormalizedBBox::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[67]); +} + +// =================================================================== + +class ROIPoolingParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_pooled_h(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_pooled_w(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_spatial_scale(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ROIPoolingParameter::ROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ROIPoolingParameter) +} +ROIPoolingParameter::ROIPoolingParameter(const ROIPoolingParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&pooled_h_, &from.pooled_h_, + static_cast(reinterpret_cast(&spatial_scale_) - + reinterpret_cast(&pooled_h_)) + sizeof(spatial_scale_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ROIPoolingParameter) +} + +inline void ROIPoolingParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&pooled_h_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&pooled_w_) - + reinterpret_cast(&pooled_h_)) + sizeof(pooled_w_)); +spatial_scale_ = 1; +} + +ROIPoolingParameter::~ROIPoolingParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ROIPoolingParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ROIPoolingParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ROIPoolingParameter::ArenaDtor(void* object) { + ROIPoolingParameter* _this = reinterpret_cast< ROIPoolingParameter* >(object); + (void)_this; +} +void ROIPoolingParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ROIPoolingParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ROIPoolingParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ROIPoolingParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&pooled_h_, 0, static_cast( + reinterpret_cast(&pooled_w_) - + reinterpret_cast(&pooled_h_)) + sizeof(pooled_w_)); + spatial_scale_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ROIPoolingParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 pooled_h = 1 [default = 0]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_pooled_h(&has_bits); + pooled_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pooled_w = 2 [default = 0]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_pooled_w(&has_bits); + pooled_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float spatial_scale = 3 [default = 1]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { + _Internal::set_has_spatial_scale(&has_bits); + spatial_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ROIPoolingParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ROIPoolingParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 pooled_h = 1 [default = 0]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pooled_h(), target); + } + + // optional uint32 pooled_w = 2 [default = 0]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_pooled_w(), target); + } + + // optional float spatial_scale = 3 [default = 1]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_spatial_scale(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ROIPoolingParameter) + return target; +} + +size_t ROIPoolingParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ROIPoolingParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional uint32 pooled_h = 1 [default = 0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pooled_h()); + } + + // optional uint32 pooled_w = 2 [default = 0]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pooled_w()); + } + + // optional float spatial_scale = 3 [default = 1]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ROIPoolingParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ROIPoolingParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ROIPoolingParameter::GetClassData() const { return &_class_data_; } + +void ROIPoolingParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ROIPoolingParameter::MergeFrom(const ROIPoolingParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ROIPoolingParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + pooled_h_ = from.pooled_h_; + } + if (cached_has_bits & 0x00000002u) { + pooled_w_ = from.pooled_w_; + } + if (cached_has_bits & 0x00000004u) { + spatial_scale_ = from.spatial_scale_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ROIPoolingParameter::CopyFrom(const ROIPoolingParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ROIPoolingParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ROIPoolingParameter::IsInitialized() const { + return true; +} + +void ROIPoolingParameter::InternalSwap(ROIPoolingParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ROIPoolingParameter, pooled_w_) + + sizeof(ROIPoolingParameter::pooled_w_) + - PROTOBUF_FIELD_OFFSET(ROIPoolingParameter, pooled_h_)>( + reinterpret_cast(&pooled_h_), + reinterpret_cast(&other->pooled_h_)); + swap(spatial_scale_, other->spatial_scale_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ROIPoolingParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[68]); +} + +// =================================================================== + +class ProposalParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_feat_stride(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_base_size(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_min_size(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_pre_nms_topn(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_post_nms_topn(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_nms_thresh(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +ProposalParameter::ProposalParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + ratio_(arena), + scale_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.ProposalParameter) +} +ProposalParameter::ProposalParameter(const ProposalParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + ratio_(from.ratio_), + scale_(from.scale_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&feat_stride_, &from.feat_stride_, + static_cast(reinterpret_cast(&nms_thresh_) - + reinterpret_cast(&feat_stride_)) + sizeof(nms_thresh_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.ProposalParameter) +} + +inline void ProposalParameter::SharedCtor() { +feat_stride_ = 16u; +base_size_ = 16u; +min_size_ = 16u; +pre_nms_topn_ = 6000u; +post_nms_topn_ = 300u; +nms_thresh_ = 0.7f; +} + +ProposalParameter::~ProposalParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.ProposalParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void ProposalParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ProposalParameter::ArenaDtor(void* object) { + ProposalParameter* _this = reinterpret_cast< ProposalParameter* >(object); + (void)_this; +} +void ProposalParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ProposalParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ProposalParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.ProposalParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ratio_.Clear(); + scale_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + feat_stride_ = 16u; + base_size_ = 16u; + min_size_ = 16u; + pre_nms_topn_ = 6000u; + post_nms_topn_ = 300u; + nms_thresh_ = 0.7f; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ProposalParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 feat_stride = 1 [default = 16]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_feat_stride(&has_bits); + feat_stride_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 base_size = 2 [default = 16]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_base_size(&has_bits); + base_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 min_size = 3 [default = 16]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_min_size(&has_bits); + min_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float ratio = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_ratio(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<37>(ptr)); + } else if (static_cast(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_ratio(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float scale = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_scale(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr)); + } else if (static_cast(tag) == 42) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_scale(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pre_nms_topn = 6 [default = 6000]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_pre_nms_topn(&has_bits); + pre_nms_topn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 post_nms_topn = 7 [default = 300]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_post_nms_topn(&has_bits); + post_nms_topn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float nms_thresh = 8 [default = 0.7]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { + _Internal::set_has_nms_thresh(&has_bits); + nms_thresh_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ProposalParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ProposalParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 feat_stride = 1 [default = 16]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_feat_stride(), target); + } + + // optional uint32 base_size = 2 [default = 16]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_base_size(), target); + } + + // optional uint32 min_size = 3 [default = 16]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_min_size(), target); + } + + // repeated float ratio = 4; + for (int i = 0, n = this->_internal_ratio_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_ratio(i), target); + } + + // repeated float scale = 5; + for (int i = 0, n = this->_internal_scale_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_scale(i), target); + } + + // optional uint32 pre_nms_topn = 6 [default = 6000]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_pre_nms_topn(), target); + } + + // optional uint32 post_nms_topn = 7 [default = 300]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_post_nms_topn(), target); + } + + // optional float nms_thresh = 8 [default = 0.7]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_nms_thresh(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ProposalParameter) + return target; +} + +size_t ProposalParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ProposalParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float ratio = 4; + { + unsigned int count = static_cast(this->_internal_ratio_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_ratio_size()); + total_size += data_size; + } + + // repeated float scale = 5; + { + unsigned int count = static_cast(this->_internal_scale_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_scale_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional uint32 feat_stride = 1 [default = 16]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_feat_stride()); + } + + // optional uint32 base_size = 2 [default = 16]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_base_size()); + } + + // optional uint32 min_size = 3 [default = 16]; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_min_size()); + } + + // optional uint32 pre_nms_topn = 6 [default = 6000]; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pre_nms_topn()); + } + + // optional uint32 post_nms_topn = 7 [default = 300]; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_post_nms_topn()); + } + + // optional float nms_thresh = 8 [default = 0.7]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ProposalParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ProposalParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ProposalParameter::GetClassData() const { return &_class_data_; } + +void ProposalParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void ProposalParameter::MergeFrom(const ProposalParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ProposalParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + ratio_.MergeFrom(from.ratio_); + scale_.MergeFrom(from.scale_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + feat_stride_ = from.feat_stride_; + } + if (cached_has_bits & 0x00000002u) { + base_size_ = from.base_size_; + } + if (cached_has_bits & 0x00000004u) { + min_size_ = from.min_size_; + } + if (cached_has_bits & 0x00000008u) { + pre_nms_topn_ = from.pre_nms_topn_; + } + if (cached_has_bits & 0x00000010u) { + post_nms_topn_ = from.post_nms_topn_; + } + if (cached_has_bits & 0x00000020u) { + nms_thresh_ = from.nms_thresh_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ProposalParameter::CopyFrom(const ProposalParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ProposalParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ProposalParameter::IsInitialized() const { + return true; +} + +void ProposalParameter::InternalSwap(ProposalParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ratio_.InternalSwap(&other->ratio_); + scale_.InternalSwap(&other->scale_); + swap(feat_stride_, other->feat_stride_); + swap(base_size_, other->base_size_); + swap(min_size_, other->min_size_); + swap(pre_nms_topn_, other->pre_nms_topn_); + swap(post_nms_topn_, other->post_nms_topn_); + swap(nms_thresh_, other->nms_thresh_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ProposalParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[69]); +} + +// =================================================================== + +class PSROIPoolingParameter::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_spatial_scale(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_output_dim(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_group_size(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0; + } +}; + +PSROIPoolingParameter::PSROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:opencv_caffe.PSROIPoolingParameter) +} +PSROIPoolingParameter::PSROIPoolingParameter(const PSROIPoolingParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&spatial_scale_, &from.spatial_scale_, + static_cast(reinterpret_cast(&group_size_) - + reinterpret_cast(&spatial_scale_)) + sizeof(group_size_)); + // @@protoc_insertion_point(copy_constructor:opencv_caffe.PSROIPoolingParameter) +} + +inline void PSROIPoolingParameter::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&spatial_scale_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&group_size_) - + reinterpret_cast(&spatial_scale_)) + sizeof(group_size_)); +} + +PSROIPoolingParameter::~PSROIPoolingParameter() { + // @@protoc_insertion_point(destructor:opencv_caffe.PSROIPoolingParameter) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void PSROIPoolingParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void PSROIPoolingParameter::ArenaDtor(void* object) { + PSROIPoolingParameter* _this = reinterpret_cast< PSROIPoolingParameter* >(object); + (void)_this; +} +void PSROIPoolingParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PSROIPoolingParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PSROIPoolingParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_caffe.PSROIPoolingParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&spatial_scale_, 0, static_cast( + reinterpret_cast(&group_size_) - + reinterpret_cast(&spatial_scale_)) + sizeof(group_size_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PSROIPoolingParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required float spatial_scale = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_spatial_scale(&has_bits); + spatial_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // required int32 output_dim = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_output_dim(&has_bits); + output_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // required int32 group_size = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_group_size(&has_bits); + group_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PSROIPoolingParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PSROIPoolingParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required float spatial_scale = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_spatial_scale(), target); + } + + // required int32 output_dim = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_output_dim(), target); + } + + // required int32 group_size = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_group_size(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PSROIPoolingParameter) + return target; +} + +size_t PSROIPoolingParameter::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:opencv_caffe.PSROIPoolingParameter) + size_t total_size = 0; + + if (_internal_has_spatial_scale()) { + // required float spatial_scale = 1; + total_size += 1 + 4; + } + + if (_internal_has_output_dim()) { + // required int32 output_dim = 2; + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_output_dim()); + } + + if (_internal_has_group_size()) { + // required int32 group_size = 3; + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_group_size()); + } + + return total_size; +} +size_t PSROIPoolingParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PSROIPoolingParameter) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) { // All required fields are present. + // required float spatial_scale = 1; + total_size += 1 + 4; + + // required int32 output_dim = 2; + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_output_dim()); + + // required int32 group_size = 3; + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_group_size()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PSROIPoolingParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + PSROIPoolingParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PSROIPoolingParameter::GetClassData() const { return &_class_data_; } + +void PSROIPoolingParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void PSROIPoolingParameter::MergeFrom(const PSROIPoolingParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PSROIPoolingParameter) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + spatial_scale_ = from.spatial_scale_; + } + if (cached_has_bits & 0x00000002u) { + output_dim_ = from.output_dim_; + } + if (cached_has_bits & 0x00000004u) { + group_size_ = from.group_size_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PSROIPoolingParameter::CopyFrom(const PSROIPoolingParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PSROIPoolingParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PSROIPoolingParameter::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void PSROIPoolingParameter::InternalSwap(PSROIPoolingParameter* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PSROIPoolingParameter, group_size_) + + sizeof(PSROIPoolingParameter::group_size_) + - PROTOBUF_FIELD_OFFSET(PSROIPoolingParameter, spatial_scale_)>( + reinterpret_cast(&spatial_scale_), + reinterpret_cast(&other->spatial_scale_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PSROIPoolingParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, + file_level_metadata_opencv_2dcaffe_2eproto[70]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace opencv_caffe +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::opencv_caffe::BlobShape* Arena::CreateMaybeMessage< ::opencv_caffe::BlobShape >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::BlobShape >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::BlobProto* Arena::CreateMaybeMessage< ::opencv_caffe::BlobProto >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::BlobProto >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::BlobProtoVector* Arena::CreateMaybeMessage< ::opencv_caffe::BlobProtoVector >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::BlobProtoVector >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::PermuteParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PermuteParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::PermuteParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::NormalizeBBoxParameter* Arena::CreateMaybeMessage< ::opencv_caffe::NormalizeBBoxParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::NormalizeBBoxParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::PriorBoxParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PriorBoxParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::PriorBoxParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::DetectionOutputParameter* Arena::CreateMaybeMessage< ::opencv_caffe::DetectionOutputParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::DetectionOutputParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::Datum* Arena::CreateMaybeMessage< ::opencv_caffe::Datum >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::Datum >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::FillerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::FillerParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::FillerParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::NetParameter* Arena::CreateMaybeMessage< ::opencv_caffe::NetParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::NetParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::SolverParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SolverParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::SolverParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::SolverState* Arena::CreateMaybeMessage< ::opencv_caffe::SolverState >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::SolverState >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::NetState* Arena::CreateMaybeMessage< ::opencv_caffe::NetState >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::NetState >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::NetStateRule* Arena::CreateMaybeMessage< ::opencv_caffe::NetStateRule >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::NetStateRule >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ParamSpec* Arena::CreateMaybeMessage< ::opencv_caffe::ParamSpec >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ParamSpec >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::LayerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::LayerParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::LayerParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::TransformationParameter* Arena::CreateMaybeMessage< ::opencv_caffe::TransformationParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::TransformationParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::LossParameter* Arena::CreateMaybeMessage< ::opencv_caffe::LossParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::LossParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::AccuracyParameter* Arena::CreateMaybeMessage< ::opencv_caffe::AccuracyParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::AccuracyParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ArgMaxParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ArgMaxParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ArgMaxParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ConcatParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ConcatParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ConcatParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::BatchNormParameter* Arena::CreateMaybeMessage< ::opencv_caffe::BatchNormParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::BatchNormParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::BiasParameter* Arena::CreateMaybeMessage< ::opencv_caffe::BiasParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::BiasParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ContrastiveLossParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ContrastiveLossParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ContrastiveLossParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ConvolutionParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ConvolutionParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ConvolutionParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::CropParameter* Arena::CreateMaybeMessage< ::opencv_caffe::CropParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::CropParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::DataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::DataParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::DataParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::NonMaximumSuppressionParameter* Arena::CreateMaybeMessage< ::opencv_caffe::NonMaximumSuppressionParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::NonMaximumSuppressionParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::SaveOutputParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SaveOutputParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::SaveOutputParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::DropoutParameter* Arena::CreateMaybeMessage< ::opencv_caffe::DropoutParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::DropoutParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::DummyDataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::DummyDataParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::DummyDataParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::EltwiseParameter* Arena::CreateMaybeMessage< ::opencv_caffe::EltwiseParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::EltwiseParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ELUParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ELUParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ELUParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::EmbedParameter* Arena::CreateMaybeMessage< ::opencv_caffe::EmbedParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::EmbedParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ExpParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ExpParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ExpParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::FlattenParameter* Arena::CreateMaybeMessage< ::opencv_caffe::FlattenParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::FlattenParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::HDF5DataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::HDF5DataParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::HDF5DataParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::HDF5OutputParameter* Arena::CreateMaybeMessage< ::opencv_caffe::HDF5OutputParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::HDF5OutputParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::HingeLossParameter* Arena::CreateMaybeMessage< ::opencv_caffe::HingeLossParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::HingeLossParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ImageDataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ImageDataParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ImageDataParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::InfogainLossParameter* Arena::CreateMaybeMessage< ::opencv_caffe::InfogainLossParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::InfogainLossParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::InnerProductParameter* Arena::CreateMaybeMessage< ::opencv_caffe::InnerProductParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::InnerProductParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::InputParameter* Arena::CreateMaybeMessage< ::opencv_caffe::InputParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::InputParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::LogParameter* Arena::CreateMaybeMessage< ::opencv_caffe::LogParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::LogParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::LRNParameter* Arena::CreateMaybeMessage< ::opencv_caffe::LRNParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::LRNParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::MemoryDataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::MemoryDataParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::MemoryDataParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::MVNParameter* Arena::CreateMaybeMessage< ::opencv_caffe::MVNParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::MVNParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ParameterParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ParameterParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ParameterParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::PoolingParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PoolingParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::PoolingParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::PowerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PowerParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::PowerParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::PythonParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PythonParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::PythonParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::RecurrentParameter* Arena::CreateMaybeMessage< ::opencv_caffe::RecurrentParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::RecurrentParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ReductionParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ReductionParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ReductionParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ReLUParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ReLUParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ReLUParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ReshapeParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ReshapeParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ReshapeParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ScaleParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ScaleParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ScaleParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::SigmoidParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SigmoidParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::SigmoidParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::SliceParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SliceParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::SliceParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::SoftmaxParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SoftmaxParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::SoftmaxParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::TanHParameter* Arena::CreateMaybeMessage< ::opencv_caffe::TanHParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::TanHParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::TileParameter* Arena::CreateMaybeMessage< ::opencv_caffe::TileParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::TileParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ThresholdParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ThresholdParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ThresholdParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::WindowDataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::WindowDataParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::WindowDataParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::SPPParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SPPParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::SPPParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::V1LayerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::V1LayerParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::V1LayerParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::V0LayerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::V0LayerParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::V0LayerParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::PReLUParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PReLUParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::PReLUParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::NormalizedBBox* Arena::CreateMaybeMessage< ::opencv_caffe::NormalizedBBox >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::NormalizedBBox >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ROIPoolingParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ROIPoolingParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ROIPoolingParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::ProposalParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ProposalParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::ProposalParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::opencv_caffe::PSROIPoolingParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PSROIPoolingParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::opencv_caffe::PSROIPoolingParameter >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/modules/dnnlegacy/misc/caffe/opencv-caffe.pb.h b/modules/dnnlegacy/misc/caffe/opencv-caffe.pb.h new file mode 100644 index 00000000000..74ec5ca6e47 --- /dev/null +++ b/modules/dnnlegacy/misc/caffe/opencv-caffe.pb.h @@ -0,0 +1,44945 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: opencv-caffe.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_opencv_2dcaffe_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_opencv_2dcaffe_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3019000 +#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 3019001 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_opencv_2dcaffe_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_opencv_2dcaffe_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[71] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_opencv_2dcaffe_2eproto; +namespace opencv_caffe { +class AccuracyParameter; +struct AccuracyParameterDefaultTypeInternal; +extern AccuracyParameterDefaultTypeInternal _AccuracyParameter_default_instance_; +class ArgMaxParameter; +struct ArgMaxParameterDefaultTypeInternal; +extern ArgMaxParameterDefaultTypeInternal _ArgMaxParameter_default_instance_; +class BatchNormParameter; +struct BatchNormParameterDefaultTypeInternal; +extern BatchNormParameterDefaultTypeInternal _BatchNormParameter_default_instance_; +class BiasParameter; +struct BiasParameterDefaultTypeInternal; +extern BiasParameterDefaultTypeInternal _BiasParameter_default_instance_; +class BlobProto; +struct BlobProtoDefaultTypeInternal; +extern BlobProtoDefaultTypeInternal _BlobProto_default_instance_; +class BlobProtoVector; +struct BlobProtoVectorDefaultTypeInternal; +extern BlobProtoVectorDefaultTypeInternal _BlobProtoVector_default_instance_; +class BlobShape; +struct BlobShapeDefaultTypeInternal; +extern BlobShapeDefaultTypeInternal _BlobShape_default_instance_; +class ConcatParameter; +struct ConcatParameterDefaultTypeInternal; +extern ConcatParameterDefaultTypeInternal _ConcatParameter_default_instance_; +class ContrastiveLossParameter; +struct ContrastiveLossParameterDefaultTypeInternal; +extern ContrastiveLossParameterDefaultTypeInternal _ContrastiveLossParameter_default_instance_; +class ConvolutionParameter; +struct ConvolutionParameterDefaultTypeInternal; +extern ConvolutionParameterDefaultTypeInternal _ConvolutionParameter_default_instance_; +class CropParameter; +struct CropParameterDefaultTypeInternal; +extern CropParameterDefaultTypeInternal _CropParameter_default_instance_; +class DataParameter; +struct DataParameterDefaultTypeInternal; +extern DataParameterDefaultTypeInternal _DataParameter_default_instance_; +class Datum; +struct DatumDefaultTypeInternal; +extern DatumDefaultTypeInternal _Datum_default_instance_; +class DetectionOutputParameter; +struct DetectionOutputParameterDefaultTypeInternal; +extern DetectionOutputParameterDefaultTypeInternal _DetectionOutputParameter_default_instance_; +class DropoutParameter; +struct DropoutParameterDefaultTypeInternal; +extern DropoutParameterDefaultTypeInternal _DropoutParameter_default_instance_; +class DummyDataParameter; +struct DummyDataParameterDefaultTypeInternal; +extern DummyDataParameterDefaultTypeInternal _DummyDataParameter_default_instance_; +class ELUParameter; +struct ELUParameterDefaultTypeInternal; +extern ELUParameterDefaultTypeInternal _ELUParameter_default_instance_; +class EltwiseParameter; +struct EltwiseParameterDefaultTypeInternal; +extern EltwiseParameterDefaultTypeInternal _EltwiseParameter_default_instance_; +class EmbedParameter; +struct EmbedParameterDefaultTypeInternal; +extern EmbedParameterDefaultTypeInternal _EmbedParameter_default_instance_; +class ExpParameter; +struct ExpParameterDefaultTypeInternal; +extern ExpParameterDefaultTypeInternal _ExpParameter_default_instance_; +class FillerParameter; +struct FillerParameterDefaultTypeInternal; +extern FillerParameterDefaultTypeInternal _FillerParameter_default_instance_; +class FlattenParameter; +struct FlattenParameterDefaultTypeInternal; +extern FlattenParameterDefaultTypeInternal _FlattenParameter_default_instance_; +class HDF5DataParameter; +struct HDF5DataParameterDefaultTypeInternal; +extern HDF5DataParameterDefaultTypeInternal _HDF5DataParameter_default_instance_; +class HDF5OutputParameter; +struct HDF5OutputParameterDefaultTypeInternal; +extern HDF5OutputParameterDefaultTypeInternal _HDF5OutputParameter_default_instance_; +class HingeLossParameter; +struct HingeLossParameterDefaultTypeInternal; +extern HingeLossParameterDefaultTypeInternal _HingeLossParameter_default_instance_; +class ImageDataParameter; +struct ImageDataParameterDefaultTypeInternal; +extern ImageDataParameterDefaultTypeInternal _ImageDataParameter_default_instance_; +class InfogainLossParameter; +struct InfogainLossParameterDefaultTypeInternal; +extern InfogainLossParameterDefaultTypeInternal _InfogainLossParameter_default_instance_; +class InnerProductParameter; +struct InnerProductParameterDefaultTypeInternal; +extern InnerProductParameterDefaultTypeInternal _InnerProductParameter_default_instance_; +class InputParameter; +struct InputParameterDefaultTypeInternal; +extern InputParameterDefaultTypeInternal _InputParameter_default_instance_; +class LRNParameter; +struct LRNParameterDefaultTypeInternal; +extern LRNParameterDefaultTypeInternal _LRNParameter_default_instance_; +class LayerParameter; +struct LayerParameterDefaultTypeInternal; +extern LayerParameterDefaultTypeInternal _LayerParameter_default_instance_; +class LogParameter; +struct LogParameterDefaultTypeInternal; +extern LogParameterDefaultTypeInternal _LogParameter_default_instance_; +class LossParameter; +struct LossParameterDefaultTypeInternal; +extern LossParameterDefaultTypeInternal _LossParameter_default_instance_; +class MVNParameter; +struct MVNParameterDefaultTypeInternal; +extern MVNParameterDefaultTypeInternal _MVNParameter_default_instance_; +class MemoryDataParameter; +struct MemoryDataParameterDefaultTypeInternal; +extern MemoryDataParameterDefaultTypeInternal _MemoryDataParameter_default_instance_; +class NetParameter; +struct NetParameterDefaultTypeInternal; +extern NetParameterDefaultTypeInternal _NetParameter_default_instance_; +class NetState; +struct NetStateDefaultTypeInternal; +extern NetStateDefaultTypeInternal _NetState_default_instance_; +class NetStateRule; +struct NetStateRuleDefaultTypeInternal; +extern NetStateRuleDefaultTypeInternal _NetStateRule_default_instance_; +class NonMaximumSuppressionParameter; +struct NonMaximumSuppressionParameterDefaultTypeInternal; +extern NonMaximumSuppressionParameterDefaultTypeInternal _NonMaximumSuppressionParameter_default_instance_; +class NormalizeBBoxParameter; +struct NormalizeBBoxParameterDefaultTypeInternal; +extern NormalizeBBoxParameterDefaultTypeInternal _NormalizeBBoxParameter_default_instance_; +class NormalizedBBox; +struct NormalizedBBoxDefaultTypeInternal; +extern NormalizedBBoxDefaultTypeInternal _NormalizedBBox_default_instance_; +class PReLUParameter; +struct PReLUParameterDefaultTypeInternal; +extern PReLUParameterDefaultTypeInternal _PReLUParameter_default_instance_; +class PSROIPoolingParameter; +struct PSROIPoolingParameterDefaultTypeInternal; +extern PSROIPoolingParameterDefaultTypeInternal _PSROIPoolingParameter_default_instance_; +class ParamSpec; +struct ParamSpecDefaultTypeInternal; +extern ParamSpecDefaultTypeInternal _ParamSpec_default_instance_; +class ParameterParameter; +struct ParameterParameterDefaultTypeInternal; +extern ParameterParameterDefaultTypeInternal _ParameterParameter_default_instance_; +class PermuteParameter; +struct PermuteParameterDefaultTypeInternal; +extern PermuteParameterDefaultTypeInternal _PermuteParameter_default_instance_; +class PoolingParameter; +struct PoolingParameterDefaultTypeInternal; +extern PoolingParameterDefaultTypeInternal _PoolingParameter_default_instance_; +class PowerParameter; +struct PowerParameterDefaultTypeInternal; +extern PowerParameterDefaultTypeInternal _PowerParameter_default_instance_; +class PriorBoxParameter; +struct PriorBoxParameterDefaultTypeInternal; +extern PriorBoxParameterDefaultTypeInternal _PriorBoxParameter_default_instance_; +class ProposalParameter; +struct ProposalParameterDefaultTypeInternal; +extern ProposalParameterDefaultTypeInternal _ProposalParameter_default_instance_; +class PythonParameter; +struct PythonParameterDefaultTypeInternal; +extern PythonParameterDefaultTypeInternal _PythonParameter_default_instance_; +class ROIPoolingParameter; +struct ROIPoolingParameterDefaultTypeInternal; +extern ROIPoolingParameterDefaultTypeInternal _ROIPoolingParameter_default_instance_; +class ReLUParameter; +struct ReLUParameterDefaultTypeInternal; +extern ReLUParameterDefaultTypeInternal _ReLUParameter_default_instance_; +class RecurrentParameter; +struct RecurrentParameterDefaultTypeInternal; +extern RecurrentParameterDefaultTypeInternal _RecurrentParameter_default_instance_; +class ReductionParameter; +struct ReductionParameterDefaultTypeInternal; +extern ReductionParameterDefaultTypeInternal _ReductionParameter_default_instance_; +class ReshapeParameter; +struct ReshapeParameterDefaultTypeInternal; +extern ReshapeParameterDefaultTypeInternal _ReshapeParameter_default_instance_; +class SPPParameter; +struct SPPParameterDefaultTypeInternal; +extern SPPParameterDefaultTypeInternal _SPPParameter_default_instance_; +class SaveOutputParameter; +struct SaveOutputParameterDefaultTypeInternal; +extern SaveOutputParameterDefaultTypeInternal _SaveOutputParameter_default_instance_; +class ScaleParameter; +struct ScaleParameterDefaultTypeInternal; +extern ScaleParameterDefaultTypeInternal _ScaleParameter_default_instance_; +class SigmoidParameter; +struct SigmoidParameterDefaultTypeInternal; +extern SigmoidParameterDefaultTypeInternal _SigmoidParameter_default_instance_; +class SliceParameter; +struct SliceParameterDefaultTypeInternal; +extern SliceParameterDefaultTypeInternal _SliceParameter_default_instance_; +class SoftmaxParameter; +struct SoftmaxParameterDefaultTypeInternal; +extern SoftmaxParameterDefaultTypeInternal _SoftmaxParameter_default_instance_; +class SolverParameter; +struct SolverParameterDefaultTypeInternal; +extern SolverParameterDefaultTypeInternal _SolverParameter_default_instance_; +class SolverState; +struct SolverStateDefaultTypeInternal; +extern SolverStateDefaultTypeInternal _SolverState_default_instance_; +class TanHParameter; +struct TanHParameterDefaultTypeInternal; +extern TanHParameterDefaultTypeInternal _TanHParameter_default_instance_; +class ThresholdParameter; +struct ThresholdParameterDefaultTypeInternal; +extern ThresholdParameterDefaultTypeInternal _ThresholdParameter_default_instance_; +class TileParameter; +struct TileParameterDefaultTypeInternal; +extern TileParameterDefaultTypeInternal _TileParameter_default_instance_; +class TransformationParameter; +struct TransformationParameterDefaultTypeInternal; +extern TransformationParameterDefaultTypeInternal _TransformationParameter_default_instance_; +class V0LayerParameter; +struct V0LayerParameterDefaultTypeInternal; +extern V0LayerParameterDefaultTypeInternal _V0LayerParameter_default_instance_; +class V1LayerParameter; +struct V1LayerParameterDefaultTypeInternal; +extern V1LayerParameterDefaultTypeInternal _V1LayerParameter_default_instance_; +class WindowDataParameter; +struct WindowDataParameterDefaultTypeInternal; +extern WindowDataParameterDefaultTypeInternal _WindowDataParameter_default_instance_; +} // namespace opencv_caffe +PROTOBUF_NAMESPACE_OPEN +template<> ::opencv_caffe::AccuracyParameter* Arena::CreateMaybeMessage<::opencv_caffe::AccuracyParameter>(Arena*); +template<> ::opencv_caffe::ArgMaxParameter* Arena::CreateMaybeMessage<::opencv_caffe::ArgMaxParameter>(Arena*); +template<> ::opencv_caffe::BatchNormParameter* Arena::CreateMaybeMessage<::opencv_caffe::BatchNormParameter>(Arena*); +template<> ::opencv_caffe::BiasParameter* Arena::CreateMaybeMessage<::opencv_caffe::BiasParameter>(Arena*); +template<> ::opencv_caffe::BlobProto* Arena::CreateMaybeMessage<::opencv_caffe::BlobProto>(Arena*); +template<> ::opencv_caffe::BlobProtoVector* Arena::CreateMaybeMessage<::opencv_caffe::BlobProtoVector>(Arena*); +template<> ::opencv_caffe::BlobShape* Arena::CreateMaybeMessage<::opencv_caffe::BlobShape>(Arena*); +template<> ::opencv_caffe::ConcatParameter* Arena::CreateMaybeMessage<::opencv_caffe::ConcatParameter>(Arena*); +template<> ::opencv_caffe::ContrastiveLossParameter* Arena::CreateMaybeMessage<::opencv_caffe::ContrastiveLossParameter>(Arena*); +template<> ::opencv_caffe::ConvolutionParameter* Arena::CreateMaybeMessage<::opencv_caffe::ConvolutionParameter>(Arena*); +template<> ::opencv_caffe::CropParameter* Arena::CreateMaybeMessage<::opencv_caffe::CropParameter>(Arena*); +template<> ::opencv_caffe::DataParameter* Arena::CreateMaybeMessage<::opencv_caffe::DataParameter>(Arena*); +template<> ::opencv_caffe::Datum* Arena::CreateMaybeMessage<::opencv_caffe::Datum>(Arena*); +template<> ::opencv_caffe::DetectionOutputParameter* Arena::CreateMaybeMessage<::opencv_caffe::DetectionOutputParameter>(Arena*); +template<> ::opencv_caffe::DropoutParameter* Arena::CreateMaybeMessage<::opencv_caffe::DropoutParameter>(Arena*); +template<> ::opencv_caffe::DummyDataParameter* Arena::CreateMaybeMessage<::opencv_caffe::DummyDataParameter>(Arena*); +template<> ::opencv_caffe::ELUParameter* Arena::CreateMaybeMessage<::opencv_caffe::ELUParameter>(Arena*); +template<> ::opencv_caffe::EltwiseParameter* Arena::CreateMaybeMessage<::opencv_caffe::EltwiseParameter>(Arena*); +template<> ::opencv_caffe::EmbedParameter* Arena::CreateMaybeMessage<::opencv_caffe::EmbedParameter>(Arena*); +template<> ::opencv_caffe::ExpParameter* Arena::CreateMaybeMessage<::opencv_caffe::ExpParameter>(Arena*); +template<> ::opencv_caffe::FillerParameter* Arena::CreateMaybeMessage<::opencv_caffe::FillerParameter>(Arena*); +template<> ::opencv_caffe::FlattenParameter* Arena::CreateMaybeMessage<::opencv_caffe::FlattenParameter>(Arena*); +template<> ::opencv_caffe::HDF5DataParameter* Arena::CreateMaybeMessage<::opencv_caffe::HDF5DataParameter>(Arena*); +template<> ::opencv_caffe::HDF5OutputParameter* Arena::CreateMaybeMessage<::opencv_caffe::HDF5OutputParameter>(Arena*); +template<> ::opencv_caffe::HingeLossParameter* Arena::CreateMaybeMessage<::opencv_caffe::HingeLossParameter>(Arena*); +template<> ::opencv_caffe::ImageDataParameter* Arena::CreateMaybeMessage<::opencv_caffe::ImageDataParameter>(Arena*); +template<> ::opencv_caffe::InfogainLossParameter* Arena::CreateMaybeMessage<::opencv_caffe::InfogainLossParameter>(Arena*); +template<> ::opencv_caffe::InnerProductParameter* Arena::CreateMaybeMessage<::opencv_caffe::InnerProductParameter>(Arena*); +template<> ::opencv_caffe::InputParameter* Arena::CreateMaybeMessage<::opencv_caffe::InputParameter>(Arena*); +template<> ::opencv_caffe::LRNParameter* Arena::CreateMaybeMessage<::opencv_caffe::LRNParameter>(Arena*); +template<> ::opencv_caffe::LayerParameter* Arena::CreateMaybeMessage<::opencv_caffe::LayerParameter>(Arena*); +template<> ::opencv_caffe::LogParameter* Arena::CreateMaybeMessage<::opencv_caffe::LogParameter>(Arena*); +template<> ::opencv_caffe::LossParameter* Arena::CreateMaybeMessage<::opencv_caffe::LossParameter>(Arena*); +template<> ::opencv_caffe::MVNParameter* Arena::CreateMaybeMessage<::opencv_caffe::MVNParameter>(Arena*); +template<> ::opencv_caffe::MemoryDataParameter* Arena::CreateMaybeMessage<::opencv_caffe::MemoryDataParameter>(Arena*); +template<> ::opencv_caffe::NetParameter* Arena::CreateMaybeMessage<::opencv_caffe::NetParameter>(Arena*); +template<> ::opencv_caffe::NetState* Arena::CreateMaybeMessage<::opencv_caffe::NetState>(Arena*); +template<> ::opencv_caffe::NetStateRule* Arena::CreateMaybeMessage<::opencv_caffe::NetStateRule>(Arena*); +template<> ::opencv_caffe::NonMaximumSuppressionParameter* Arena::CreateMaybeMessage<::opencv_caffe::NonMaximumSuppressionParameter>(Arena*); +template<> ::opencv_caffe::NormalizeBBoxParameter* Arena::CreateMaybeMessage<::opencv_caffe::NormalizeBBoxParameter>(Arena*); +template<> ::opencv_caffe::NormalizedBBox* Arena::CreateMaybeMessage<::opencv_caffe::NormalizedBBox>(Arena*); +template<> ::opencv_caffe::PReLUParameter* Arena::CreateMaybeMessage<::opencv_caffe::PReLUParameter>(Arena*); +template<> ::opencv_caffe::PSROIPoolingParameter* Arena::CreateMaybeMessage<::opencv_caffe::PSROIPoolingParameter>(Arena*); +template<> ::opencv_caffe::ParamSpec* Arena::CreateMaybeMessage<::opencv_caffe::ParamSpec>(Arena*); +template<> ::opencv_caffe::ParameterParameter* Arena::CreateMaybeMessage<::opencv_caffe::ParameterParameter>(Arena*); +template<> ::opencv_caffe::PermuteParameter* Arena::CreateMaybeMessage<::opencv_caffe::PermuteParameter>(Arena*); +template<> ::opencv_caffe::PoolingParameter* Arena::CreateMaybeMessage<::opencv_caffe::PoolingParameter>(Arena*); +template<> ::opencv_caffe::PowerParameter* Arena::CreateMaybeMessage<::opencv_caffe::PowerParameter>(Arena*); +template<> ::opencv_caffe::PriorBoxParameter* Arena::CreateMaybeMessage<::opencv_caffe::PriorBoxParameter>(Arena*); +template<> ::opencv_caffe::ProposalParameter* Arena::CreateMaybeMessage<::opencv_caffe::ProposalParameter>(Arena*); +template<> ::opencv_caffe::PythonParameter* Arena::CreateMaybeMessage<::opencv_caffe::PythonParameter>(Arena*); +template<> ::opencv_caffe::ROIPoolingParameter* Arena::CreateMaybeMessage<::opencv_caffe::ROIPoolingParameter>(Arena*); +template<> ::opencv_caffe::ReLUParameter* Arena::CreateMaybeMessage<::opencv_caffe::ReLUParameter>(Arena*); +template<> ::opencv_caffe::RecurrentParameter* Arena::CreateMaybeMessage<::opencv_caffe::RecurrentParameter>(Arena*); +template<> ::opencv_caffe::ReductionParameter* Arena::CreateMaybeMessage<::opencv_caffe::ReductionParameter>(Arena*); +template<> ::opencv_caffe::ReshapeParameter* Arena::CreateMaybeMessage<::opencv_caffe::ReshapeParameter>(Arena*); +template<> ::opencv_caffe::SPPParameter* Arena::CreateMaybeMessage<::opencv_caffe::SPPParameter>(Arena*); +template<> ::opencv_caffe::SaveOutputParameter* Arena::CreateMaybeMessage<::opencv_caffe::SaveOutputParameter>(Arena*); +template<> ::opencv_caffe::ScaleParameter* Arena::CreateMaybeMessage<::opencv_caffe::ScaleParameter>(Arena*); +template<> ::opencv_caffe::SigmoidParameter* Arena::CreateMaybeMessage<::opencv_caffe::SigmoidParameter>(Arena*); +template<> ::opencv_caffe::SliceParameter* Arena::CreateMaybeMessage<::opencv_caffe::SliceParameter>(Arena*); +template<> ::opencv_caffe::SoftmaxParameter* Arena::CreateMaybeMessage<::opencv_caffe::SoftmaxParameter>(Arena*); +template<> ::opencv_caffe::SolverParameter* Arena::CreateMaybeMessage<::opencv_caffe::SolverParameter>(Arena*); +template<> ::opencv_caffe::SolverState* Arena::CreateMaybeMessage<::opencv_caffe::SolverState>(Arena*); +template<> ::opencv_caffe::TanHParameter* Arena::CreateMaybeMessage<::opencv_caffe::TanHParameter>(Arena*); +template<> ::opencv_caffe::ThresholdParameter* Arena::CreateMaybeMessage<::opencv_caffe::ThresholdParameter>(Arena*); +template<> ::opencv_caffe::TileParameter* Arena::CreateMaybeMessage<::opencv_caffe::TileParameter>(Arena*); +template<> ::opencv_caffe::TransformationParameter* Arena::CreateMaybeMessage<::opencv_caffe::TransformationParameter>(Arena*); +template<> ::opencv_caffe::V0LayerParameter* Arena::CreateMaybeMessage<::opencv_caffe::V0LayerParameter>(Arena*); +template<> ::opencv_caffe::V1LayerParameter* Arena::CreateMaybeMessage<::opencv_caffe::V1LayerParameter>(Arena*); +template<> ::opencv_caffe::WindowDataParameter* Arena::CreateMaybeMessage<::opencv_caffe::WindowDataParameter>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace opencv_caffe { + +enum PriorBoxParameter_CodeType : int { + PriorBoxParameter_CodeType_CORNER = 1, + PriorBoxParameter_CodeType_CENTER_SIZE = 2 +}; +bool PriorBoxParameter_CodeType_IsValid(int value); +constexpr PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MIN = PriorBoxParameter_CodeType_CORNER; +constexpr PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MAX = PriorBoxParameter_CodeType_CENTER_SIZE; +constexpr int PriorBoxParameter_CodeType_CodeType_ARRAYSIZE = PriorBoxParameter_CodeType_CodeType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PriorBoxParameter_CodeType_descriptor(); +template +inline const std::string& PriorBoxParameter_CodeType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PriorBoxParameter_CodeType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PriorBoxParameter_CodeType_descriptor(), enum_t_value); +} +inline bool PriorBoxParameter_CodeType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PriorBoxParameter_CodeType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PriorBoxParameter_CodeType_descriptor(), name, value); +} +enum FillerParameter_VarianceNorm : int { + FillerParameter_VarianceNorm_FAN_IN = 0, + FillerParameter_VarianceNorm_FAN_OUT = 1, + FillerParameter_VarianceNorm_AVERAGE = 2 +}; +bool FillerParameter_VarianceNorm_IsValid(int value); +constexpr FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MIN = FillerParameter_VarianceNorm_FAN_IN; +constexpr FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MAX = FillerParameter_VarianceNorm_AVERAGE; +constexpr int FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE = FillerParameter_VarianceNorm_VarianceNorm_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FillerParameter_VarianceNorm_descriptor(); +template +inline const std::string& FillerParameter_VarianceNorm_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function FillerParameter_VarianceNorm_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + FillerParameter_VarianceNorm_descriptor(), enum_t_value); +} +inline bool FillerParameter_VarianceNorm_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FillerParameter_VarianceNorm* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + FillerParameter_VarianceNorm_descriptor(), name, value); +} +enum SolverParameter_SnapshotFormat : int { + SolverParameter_SnapshotFormat_HDF5 = 0, + SolverParameter_SnapshotFormat_BINARYPROTO = 1 +}; +bool SolverParameter_SnapshotFormat_IsValid(int value); +constexpr SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MIN = SolverParameter_SnapshotFormat_HDF5; +constexpr SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MAX = SolverParameter_SnapshotFormat_BINARYPROTO; +constexpr int SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE = SolverParameter_SnapshotFormat_SnapshotFormat_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor(); +template +inline const std::string& SolverParameter_SnapshotFormat_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SolverParameter_SnapshotFormat_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SolverParameter_SnapshotFormat_descriptor(), enum_t_value); +} +inline bool SolverParameter_SnapshotFormat_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SnapshotFormat* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SolverParameter_SnapshotFormat_descriptor(), name, value); +} +enum SolverParameter_SolverMode : int { + SolverParameter_SolverMode_CPU = 0, + SolverParameter_SolverMode_GPU = 1 +}; +bool SolverParameter_SolverMode_IsValid(int value); +constexpr SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MIN = SolverParameter_SolverMode_CPU; +constexpr SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MAX = SolverParameter_SolverMode_GPU; +constexpr int SolverParameter_SolverMode_SolverMode_ARRAYSIZE = SolverParameter_SolverMode_SolverMode_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverMode_descriptor(); +template +inline const std::string& SolverParameter_SolverMode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SolverParameter_SolverMode_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SolverParameter_SolverMode_descriptor(), enum_t_value); +} +inline bool SolverParameter_SolverMode_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SolverMode* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SolverParameter_SolverMode_descriptor(), name, value); +} +enum SolverParameter_SolverType : int { + 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); +constexpr SolverParameter_SolverType SolverParameter_SolverType_SolverType_MIN = SolverParameter_SolverType_SGD; +constexpr SolverParameter_SolverType SolverParameter_SolverType_SolverType_MAX = SolverParameter_SolverType_ADAM; +constexpr int SolverParameter_SolverType_SolverType_ARRAYSIZE = SolverParameter_SolverType_SolverType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverType_descriptor(); +template +inline const std::string& SolverParameter_SolverType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SolverParameter_SolverType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SolverParameter_SolverType_descriptor(), enum_t_value); +} +inline bool SolverParameter_SolverType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SolverType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SolverParameter_SolverType_descriptor(), name, value); +} +enum ParamSpec_DimCheckMode : int { + ParamSpec_DimCheckMode_STRICT = 0, + ParamSpec_DimCheckMode_PERMISSIVE = 1 +}; +bool ParamSpec_DimCheckMode_IsValid(int value); +constexpr ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MIN = ParamSpec_DimCheckMode_STRICT; +constexpr ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MAX = ParamSpec_DimCheckMode_PERMISSIVE; +constexpr int ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE = ParamSpec_DimCheckMode_DimCheckMode_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ParamSpec_DimCheckMode_descriptor(); +template +inline const std::string& ParamSpec_DimCheckMode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ParamSpec_DimCheckMode_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ParamSpec_DimCheckMode_descriptor(), enum_t_value); +} +inline bool ParamSpec_DimCheckMode_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ParamSpec_DimCheckMode* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ParamSpec_DimCheckMode_descriptor(), name, value); +} +enum LossParameter_NormalizationMode : int { + LossParameter_NormalizationMode_FULL = 0, + LossParameter_NormalizationMode_VALID = 1, + LossParameter_NormalizationMode_BATCH_SIZE = 2, + LossParameter_NormalizationMode_NONE = 3 +}; +bool LossParameter_NormalizationMode_IsValid(int value); +constexpr LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MIN = LossParameter_NormalizationMode_FULL; +constexpr LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MAX = LossParameter_NormalizationMode_NONE; +constexpr int LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE = LossParameter_NormalizationMode_NormalizationMode_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LossParameter_NormalizationMode_descriptor(); +template +inline const std::string& LossParameter_NormalizationMode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function LossParameter_NormalizationMode_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + LossParameter_NormalizationMode_descriptor(), enum_t_value); +} +inline bool LossParameter_NormalizationMode_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LossParameter_NormalizationMode* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + LossParameter_NormalizationMode_descriptor(), name, value); +} +enum ConvolutionParameter_Engine : int { + ConvolutionParameter_Engine_DEFAULT = 0, + ConvolutionParameter_Engine_CAFFE = 1, + ConvolutionParameter_Engine_CUDNN = 2 +}; +bool ConvolutionParameter_Engine_IsValid(int value); +constexpr ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MIN = ConvolutionParameter_Engine_DEFAULT; +constexpr ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MAX = ConvolutionParameter_Engine_CUDNN; +constexpr int ConvolutionParameter_Engine_Engine_ARRAYSIZE = ConvolutionParameter_Engine_Engine_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConvolutionParameter_Engine_descriptor(); +template +inline const std::string& ConvolutionParameter_Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ConvolutionParameter_Engine_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ConvolutionParameter_Engine_descriptor(), enum_t_value); +} +inline bool ConvolutionParameter_Engine_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConvolutionParameter_Engine* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ConvolutionParameter_Engine_descriptor(), name, value); +} +enum DataParameter_DB : int { + DataParameter_DB_LEVELDB = 0, + DataParameter_DB_LMDB = 1 +}; +bool DataParameter_DB_IsValid(int value); +constexpr DataParameter_DB DataParameter_DB_DB_MIN = DataParameter_DB_LEVELDB; +constexpr DataParameter_DB DataParameter_DB_DB_MAX = DataParameter_DB_LMDB; +constexpr int DataParameter_DB_DB_ARRAYSIZE = DataParameter_DB_DB_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataParameter_DB_descriptor(); +template +inline const std::string& DataParameter_DB_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DataParameter_DB_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DataParameter_DB_descriptor(), enum_t_value); +} +inline bool DataParameter_DB_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataParameter_DB* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DataParameter_DB_descriptor(), name, value); +} +enum EltwiseParameter_EltwiseOp : int { + EltwiseParameter_EltwiseOp_PROD = 0, + EltwiseParameter_EltwiseOp_SUM = 1, + EltwiseParameter_EltwiseOp_MAX = 2 +}; +bool EltwiseParameter_EltwiseOp_IsValid(int value); +constexpr EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MIN = EltwiseParameter_EltwiseOp_PROD; +constexpr EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MAX = EltwiseParameter_EltwiseOp_MAX; +constexpr int EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE = EltwiseParameter_EltwiseOp_EltwiseOp_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor(); +template +inline const std::string& EltwiseParameter_EltwiseOp_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function EltwiseParameter_EltwiseOp_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + EltwiseParameter_EltwiseOp_descriptor(), enum_t_value); +} +inline bool EltwiseParameter_EltwiseOp_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EltwiseParameter_EltwiseOp* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + EltwiseParameter_EltwiseOp_descriptor(), name, value); +} +enum HingeLossParameter_Norm : int { + HingeLossParameter_Norm_L1 = 1, + HingeLossParameter_Norm_L2 = 2 +}; +bool HingeLossParameter_Norm_IsValid(int value); +constexpr HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MIN = HingeLossParameter_Norm_L1; +constexpr HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MAX = HingeLossParameter_Norm_L2; +constexpr int HingeLossParameter_Norm_Norm_ARRAYSIZE = HingeLossParameter_Norm_Norm_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HingeLossParameter_Norm_descriptor(); +template +inline const std::string& HingeLossParameter_Norm_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function HingeLossParameter_Norm_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + HingeLossParameter_Norm_descriptor(), enum_t_value); +} +inline bool HingeLossParameter_Norm_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HingeLossParameter_Norm* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + HingeLossParameter_Norm_descriptor(), name, value); +} +enum LRNParameter_NormRegion : int { + LRNParameter_NormRegion_ACROSS_CHANNELS = 0, + LRNParameter_NormRegion_WITHIN_CHANNEL = 1 +}; +bool LRNParameter_NormRegion_IsValid(int value); +constexpr LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MIN = LRNParameter_NormRegion_ACROSS_CHANNELS; +constexpr LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MAX = LRNParameter_NormRegion_WITHIN_CHANNEL; +constexpr int LRNParameter_NormRegion_NormRegion_ARRAYSIZE = LRNParameter_NormRegion_NormRegion_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_NormRegion_descriptor(); +template +inline const std::string& LRNParameter_NormRegion_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function LRNParameter_NormRegion_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + LRNParameter_NormRegion_descriptor(), enum_t_value); +} +inline bool LRNParameter_NormRegion_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LRNParameter_NormRegion* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + LRNParameter_NormRegion_descriptor(), name, value); +} +enum LRNParameter_Engine : int { + LRNParameter_Engine_DEFAULT = 0, + LRNParameter_Engine_CAFFE = 1, + LRNParameter_Engine_CUDNN = 2 +}; +bool LRNParameter_Engine_IsValid(int value); +constexpr LRNParameter_Engine LRNParameter_Engine_Engine_MIN = LRNParameter_Engine_DEFAULT; +constexpr LRNParameter_Engine LRNParameter_Engine_Engine_MAX = LRNParameter_Engine_CUDNN; +constexpr int LRNParameter_Engine_Engine_ARRAYSIZE = LRNParameter_Engine_Engine_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_Engine_descriptor(); +template +inline const std::string& LRNParameter_Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function LRNParameter_Engine_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + LRNParameter_Engine_descriptor(), enum_t_value); +} +inline bool LRNParameter_Engine_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LRNParameter_Engine* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + LRNParameter_Engine_descriptor(), name, value); +} +enum PoolingParameter_PoolMethod : int { + PoolingParameter_PoolMethod_MAX = 0, + PoolingParameter_PoolMethod_AVE = 1, + PoolingParameter_PoolMethod_STOCHASTIC = 2 +}; +bool PoolingParameter_PoolMethod_IsValid(int value); +constexpr PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MIN = PoolingParameter_PoolMethod_MAX; +constexpr PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MAX = PoolingParameter_PoolMethod_STOCHASTIC; +constexpr int PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE = PoolingParameter_PoolMethod_PoolMethod_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_PoolMethod_descriptor(); +template +inline const std::string& PoolingParameter_PoolMethod_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PoolingParameter_PoolMethod_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PoolingParameter_PoolMethod_descriptor(), enum_t_value); +} +inline bool PoolingParameter_PoolMethod_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PoolingParameter_PoolMethod* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PoolingParameter_PoolMethod_descriptor(), name, value); +} +enum PoolingParameter_Engine : int { + PoolingParameter_Engine_DEFAULT = 0, + PoolingParameter_Engine_CAFFE = 1, + PoolingParameter_Engine_CUDNN = 2 +}; +bool PoolingParameter_Engine_IsValid(int value); +constexpr PoolingParameter_Engine PoolingParameter_Engine_Engine_MIN = PoolingParameter_Engine_DEFAULT; +constexpr PoolingParameter_Engine PoolingParameter_Engine_Engine_MAX = PoolingParameter_Engine_CUDNN; +constexpr int PoolingParameter_Engine_Engine_ARRAYSIZE = PoolingParameter_Engine_Engine_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_Engine_descriptor(); +template +inline const std::string& PoolingParameter_Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PoolingParameter_Engine_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PoolingParameter_Engine_descriptor(), enum_t_value); +} +inline bool PoolingParameter_Engine_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PoolingParameter_Engine* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PoolingParameter_Engine_descriptor(), name, value); +} +enum ReductionParameter_ReductionOp : int { + ReductionParameter_ReductionOp_SUM = 1, + ReductionParameter_ReductionOp_ASUM = 2, + ReductionParameter_ReductionOp_SUMSQ = 3, + ReductionParameter_ReductionOp_MEAN = 4 +}; +bool ReductionParameter_ReductionOp_IsValid(int value); +constexpr ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MIN = ReductionParameter_ReductionOp_SUM; +constexpr ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MAX = ReductionParameter_ReductionOp_MEAN; +constexpr int ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE = ReductionParameter_ReductionOp_ReductionOp_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReductionParameter_ReductionOp_descriptor(); +template +inline const std::string& ReductionParameter_ReductionOp_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ReductionParameter_ReductionOp_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ReductionParameter_ReductionOp_descriptor(), enum_t_value); +} +inline bool ReductionParameter_ReductionOp_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReductionParameter_ReductionOp* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ReductionParameter_ReductionOp_descriptor(), name, value); +} +enum ReLUParameter_Engine : int { + ReLUParameter_Engine_DEFAULT = 0, + ReLUParameter_Engine_CAFFE = 1, + ReLUParameter_Engine_CUDNN = 2 +}; +bool ReLUParameter_Engine_IsValid(int value); +constexpr ReLUParameter_Engine ReLUParameter_Engine_Engine_MIN = ReLUParameter_Engine_DEFAULT; +constexpr ReLUParameter_Engine ReLUParameter_Engine_Engine_MAX = ReLUParameter_Engine_CUDNN; +constexpr int ReLUParameter_Engine_Engine_ARRAYSIZE = ReLUParameter_Engine_Engine_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReLUParameter_Engine_descriptor(); +template +inline const std::string& ReLUParameter_Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ReLUParameter_Engine_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ReLUParameter_Engine_descriptor(), enum_t_value); +} +inline bool ReLUParameter_Engine_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReLUParameter_Engine* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ReLUParameter_Engine_descriptor(), name, value); +} +enum SigmoidParameter_Engine : int { + SigmoidParameter_Engine_DEFAULT = 0, + SigmoidParameter_Engine_CAFFE = 1, + SigmoidParameter_Engine_CUDNN = 2 +}; +bool SigmoidParameter_Engine_IsValid(int value); +constexpr SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MIN = SigmoidParameter_Engine_DEFAULT; +constexpr SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MAX = SigmoidParameter_Engine_CUDNN; +constexpr int SigmoidParameter_Engine_Engine_ARRAYSIZE = SigmoidParameter_Engine_Engine_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SigmoidParameter_Engine_descriptor(); +template +inline const std::string& SigmoidParameter_Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SigmoidParameter_Engine_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SigmoidParameter_Engine_descriptor(), enum_t_value); +} +inline bool SigmoidParameter_Engine_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SigmoidParameter_Engine* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SigmoidParameter_Engine_descriptor(), name, value); +} +enum SoftmaxParameter_Engine : int { + SoftmaxParameter_Engine_DEFAULT = 0, + SoftmaxParameter_Engine_CAFFE = 1, + SoftmaxParameter_Engine_CUDNN = 2 +}; +bool SoftmaxParameter_Engine_IsValid(int value); +constexpr SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MIN = SoftmaxParameter_Engine_DEFAULT; +constexpr SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MAX = SoftmaxParameter_Engine_CUDNN; +constexpr int SoftmaxParameter_Engine_Engine_ARRAYSIZE = SoftmaxParameter_Engine_Engine_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SoftmaxParameter_Engine_descriptor(); +template +inline const std::string& SoftmaxParameter_Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SoftmaxParameter_Engine_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SoftmaxParameter_Engine_descriptor(), enum_t_value); +} +inline bool SoftmaxParameter_Engine_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SoftmaxParameter_Engine* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SoftmaxParameter_Engine_descriptor(), name, value); +} +enum TanHParameter_Engine : int { + TanHParameter_Engine_DEFAULT = 0, + TanHParameter_Engine_CAFFE = 1, + TanHParameter_Engine_CUDNN = 2 +}; +bool TanHParameter_Engine_IsValid(int value); +constexpr TanHParameter_Engine TanHParameter_Engine_Engine_MIN = TanHParameter_Engine_DEFAULT; +constexpr TanHParameter_Engine TanHParameter_Engine_Engine_MAX = TanHParameter_Engine_CUDNN; +constexpr int TanHParameter_Engine_Engine_ARRAYSIZE = TanHParameter_Engine_Engine_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TanHParameter_Engine_descriptor(); +template +inline const std::string& TanHParameter_Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function TanHParameter_Engine_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + TanHParameter_Engine_descriptor(), enum_t_value); +} +inline bool TanHParameter_Engine_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TanHParameter_Engine* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + TanHParameter_Engine_descriptor(), name, value); +} +enum SPPParameter_PoolMethod : int { + SPPParameter_PoolMethod_MAX = 0, + SPPParameter_PoolMethod_AVE = 1, + SPPParameter_PoolMethod_STOCHASTIC = 2 +}; +bool SPPParameter_PoolMethod_IsValid(int value); +constexpr SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MIN = SPPParameter_PoolMethod_MAX; +constexpr SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MAX = SPPParameter_PoolMethod_STOCHASTIC; +constexpr int SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE = SPPParameter_PoolMethod_PoolMethod_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_PoolMethod_descriptor(); +template +inline const std::string& SPPParameter_PoolMethod_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SPPParameter_PoolMethod_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SPPParameter_PoolMethod_descriptor(), enum_t_value); +} +inline bool SPPParameter_PoolMethod_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SPPParameter_PoolMethod* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SPPParameter_PoolMethod_descriptor(), name, value); +} +enum SPPParameter_Engine : int { + SPPParameter_Engine_DEFAULT = 0, + SPPParameter_Engine_CAFFE = 1, + SPPParameter_Engine_CUDNN = 2 +}; +bool SPPParameter_Engine_IsValid(int value); +constexpr SPPParameter_Engine SPPParameter_Engine_Engine_MIN = SPPParameter_Engine_DEFAULT; +constexpr SPPParameter_Engine SPPParameter_Engine_Engine_MAX = SPPParameter_Engine_CUDNN; +constexpr int SPPParameter_Engine_Engine_ARRAYSIZE = SPPParameter_Engine_Engine_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_Engine_descriptor(); +template +inline const std::string& SPPParameter_Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SPPParameter_Engine_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SPPParameter_Engine_descriptor(), enum_t_value); +} +inline bool SPPParameter_Engine_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SPPParameter_Engine* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SPPParameter_Engine_descriptor(), name, value); +} +enum V1LayerParameter_LayerType : int { + 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); +constexpr V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MIN = V1LayerParameter_LayerType_NONE; +constexpr V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MAX = V1LayerParameter_LayerType_DECONVOLUTION; +constexpr int V1LayerParameter_LayerType_LayerType_ARRAYSIZE = V1LayerParameter_LayerType_LayerType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_LayerType_descriptor(); +template +inline const std::string& V1LayerParameter_LayerType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function V1LayerParameter_LayerType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + V1LayerParameter_LayerType_descriptor(), enum_t_value); +} +inline bool V1LayerParameter_LayerType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1LayerParameter_LayerType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + V1LayerParameter_LayerType_descriptor(), name, value); +} +enum V1LayerParameter_DimCheckMode : int { + V1LayerParameter_DimCheckMode_STRICT = 0, + V1LayerParameter_DimCheckMode_PERMISSIVE = 1 +}; +bool V1LayerParameter_DimCheckMode_IsValid(int value); +constexpr V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MIN = V1LayerParameter_DimCheckMode_STRICT; +constexpr V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MAX = V1LayerParameter_DimCheckMode_PERMISSIVE; +constexpr int V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE = V1LayerParameter_DimCheckMode_DimCheckMode_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor(); +template +inline const std::string& V1LayerParameter_DimCheckMode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function V1LayerParameter_DimCheckMode_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + V1LayerParameter_DimCheckMode_descriptor(), enum_t_value); +} +inline bool V1LayerParameter_DimCheckMode_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1LayerParameter_DimCheckMode* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + V1LayerParameter_DimCheckMode_descriptor(), name, value); +} +enum V0LayerParameter_PoolMethod : int { + V0LayerParameter_PoolMethod_MAX = 0, + V0LayerParameter_PoolMethod_AVE = 1, + V0LayerParameter_PoolMethod_STOCHASTIC = 2 +}; +bool V0LayerParameter_PoolMethod_IsValid(int value); +constexpr V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MIN = V0LayerParameter_PoolMethod_MAX; +constexpr V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MAX = V0LayerParameter_PoolMethod_STOCHASTIC; +constexpr int V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE = V0LayerParameter_PoolMethod_PoolMethod_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor(); +template +inline const std::string& V0LayerParameter_PoolMethod_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function V0LayerParameter_PoolMethod_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + V0LayerParameter_PoolMethod_descriptor(), enum_t_value); +} +inline bool V0LayerParameter_PoolMethod_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V0LayerParameter_PoolMethod* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + V0LayerParameter_PoolMethod_descriptor(), name, value); +} +enum Type : int { + DOUBLE = 0, + FLOAT = 1, + FLOAT16 = 2, + INT = 3, + UINT = 4 +}; +bool Type_IsValid(int value); +constexpr Type Type_MIN = DOUBLE; +constexpr Type Type_MAX = UINT; +constexpr int Type_ARRAYSIZE = Type_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_descriptor(); +template +inline const std::string& Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Type_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Type_descriptor(), enum_t_value); +} +inline bool Type_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Type_descriptor(), name, value); +} +enum Phase : int { + TRAIN = 0, + TEST = 1 +}; +bool Phase_IsValid(int value); +constexpr Phase Phase_MIN = TRAIN; +constexpr Phase Phase_MAX = TEST; +constexpr int Phase_ARRAYSIZE = Phase_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Phase_descriptor(); +template +inline const std::string& Phase_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Phase_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Phase_descriptor(), enum_t_value); +} +inline bool Phase_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Phase* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Phase_descriptor(), name, value); +} +// =================================================================== + +class BlobShape final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobShape) */ { + public: + inline BlobShape() : BlobShape(nullptr) {} + ~BlobShape() override; + explicit constexpr BlobShape(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BlobShape(const BlobShape& from); + BlobShape(BlobShape&& from) noexcept + : BlobShape() { + *this = ::std::move(from); + } + + inline BlobShape& operator=(const BlobShape& from) { + CopyFrom(from); + return *this; + } + inline BlobShape& operator=(BlobShape&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BlobShape& default_instance() { + return *internal_default_instance(); + } + static inline const BlobShape* internal_default_instance() { + return reinterpret_cast( + &_BlobShape_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(BlobShape& a, BlobShape& b) { + a.Swap(&b); + } + inline void Swap(BlobShape* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BlobShape* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BlobShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BlobShape& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const BlobShape& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BlobShape* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.BlobShape"; + } + protected: + explicit BlobShape(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDimFieldNumber = 1, + }; + // repeated int64 dim = 1 [packed = true]; + int dim_size() const; + private: + int _internal_dim_size() const; + public: + void clear_dim(); + private: + int64_t _internal_dim(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + _internal_dim() const; + void _internal_add_dim(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + _internal_mutable_dim(); + public: + int64_t dim(int index) const; + void set_dim(int index, int64_t value); + void add_dim(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + dim() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + mutable_dim(); + + // @@protoc_insertion_point(class_scope:opencv_caffe.BlobShape) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dim_; + mutable std::atomic _dim_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class BlobProto final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobProto) */ { + public: + inline BlobProto() : BlobProto(nullptr) {} + ~BlobProto() override; + explicit constexpr BlobProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BlobProto(const BlobProto& from); + BlobProto(BlobProto&& from) noexcept + : BlobProto() { + *this = ::std::move(from); + } + + inline BlobProto& operator=(const BlobProto& from) { + CopyFrom(from); + return *this; + } + inline BlobProto& operator=(BlobProto&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BlobProto& default_instance() { + return *internal_default_instance(); + } + static inline const BlobProto* internal_default_instance() { + return reinterpret_cast( + &_BlobProto_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(BlobProto& a, BlobProto& b) { + a.Swap(&b); + } + inline void Swap(BlobProto* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BlobProto* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BlobProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BlobProto& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const BlobProto& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BlobProto* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.BlobProto"; + } + protected: + explicit BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDataFieldNumber = 5, + kDiffFieldNumber = 6, + kDoubleDataFieldNumber = 8, + kDoubleDiffFieldNumber = 9, + kRawDataFieldNumber = 12, + kShapeFieldNumber = 7, + kNumFieldNumber = 1, + kChannelsFieldNumber = 2, + kHeightFieldNumber = 3, + kWidthFieldNumber = 4, + kRawDataTypeFieldNumber = 10, + }; + // repeated float data = 5 [packed = true]; + int data_size() const; + private: + int _internal_data_size() const; + public: + void clear_data(); + private: + float _internal_data(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_data() const; + void _internal_add_data(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_data(); + public: + float data(int index) const; + void set_data(int index, float value); + void add_data(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_data(); + + // repeated float diff = 6 [packed = true]; + int diff_size() const; + private: + int _internal_diff_size() const; + public: + void clear_diff(); + private: + float _internal_diff(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_diff() const; + void _internal_add_diff(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_diff(); + public: + float diff(int index) const; + void set_diff(int index, float value); + void add_diff(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + diff() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_diff(); + + // repeated double double_data = 8 [packed = true]; + int double_data_size() const; + private: + int _internal_double_data_size() const; + public: + void clear_double_data(); + private: + double _internal_double_data(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + _internal_double_data() const; + void _internal_add_double_data(double value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + _internal_mutable_double_data(); + public: + double double_data(int index) const; + void set_double_data(int index, double value); + void add_double_data(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + double_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + mutable_double_data(); + + // repeated double double_diff = 9 [packed = true]; + int double_diff_size() const; + private: + int _internal_double_diff_size() const; + public: + void clear_double_diff(); + private: + double _internal_double_diff(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + _internal_double_diff() const; + void _internal_add_double_diff(double value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + _internal_mutable_double_diff(); + public: + double double_diff(int index) const; + void set_double_diff(int index, double value); + void add_double_diff(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + double_diff() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + mutable_double_diff(); + + // optional bytes raw_data = 12 [packed = false]; + bool has_raw_data() const; + private: + bool _internal_has_raw_data() const; + public: + void clear_raw_data(); + const std::string& raw_data() const; + template + void set_raw_data(ArgT0&& arg0, ArgT... args); + std::string* mutable_raw_data(); + PROTOBUF_NODISCARD std::string* release_raw_data(); + void set_allocated_raw_data(std::string* raw_data); + private: + const std::string& _internal_raw_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const std::string& value); + std::string* _internal_mutable_raw_data(); + public: + + // optional .opencv_caffe.BlobShape shape = 7; + bool has_shape() const; + private: + bool _internal_has_shape() const; + public: + void clear_shape(); + const ::opencv_caffe::BlobShape& shape() const; + PROTOBUF_NODISCARD ::opencv_caffe::BlobShape* release_shape(); + ::opencv_caffe::BlobShape* mutable_shape(); + void set_allocated_shape(::opencv_caffe::BlobShape* shape); + private: + const ::opencv_caffe::BlobShape& _internal_shape() const; + ::opencv_caffe::BlobShape* _internal_mutable_shape(); + public: + void unsafe_arena_set_allocated_shape( + ::opencv_caffe::BlobShape* shape); + ::opencv_caffe::BlobShape* unsafe_arena_release_shape(); + + // optional int32 num = 1 [default = 0]; + bool has_num() const; + private: + bool _internal_has_num() const; + public: + void clear_num(); + int32_t num() const; + void set_num(int32_t value); + private: + int32_t _internal_num() const; + void _internal_set_num(int32_t value); + public: + + // optional int32 channels = 2 [default = 0]; + bool has_channels() const; + private: + bool _internal_has_channels() const; + public: + void clear_channels(); + int32_t channels() const; + void set_channels(int32_t value); + private: + int32_t _internal_channels() const; + void _internal_set_channels(int32_t value); + public: + + // optional int32 height = 3 [default = 0]; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + int32_t height() const; + void set_height(int32_t value); + private: + int32_t _internal_height() const; + void _internal_set_height(int32_t value); + public: + + // optional int32 width = 4 [default = 0]; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + int32_t width() const; + void set_width(int32_t value); + private: + int32_t _internal_width() const; + void _internal_set_width(int32_t value); + public: + + // optional .opencv_caffe.Type raw_data_type = 10; + bool has_raw_data_type() const; + private: + bool _internal_has_raw_data_type() const; + public: + void clear_raw_data_type(); + ::opencv_caffe::Type raw_data_type() const; + void set_raw_data_type(::opencv_caffe::Type value); + private: + ::opencv_caffe::Type _internal_raw_data_type() const; + void _internal_set_raw_data_type(::opencv_caffe::Type value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.BlobProto) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > diff_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_diff_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_; + ::opencv_caffe::BlobShape* shape_; + int32_t num_; + int32_t channels_; + int32_t height_; + int32_t width_; + int raw_data_type_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class BlobProtoVector final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobProtoVector) */ { + public: + inline BlobProtoVector() : BlobProtoVector(nullptr) {} + ~BlobProtoVector() override; + explicit constexpr BlobProtoVector(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BlobProtoVector(const BlobProtoVector& from); + BlobProtoVector(BlobProtoVector&& from) noexcept + : BlobProtoVector() { + *this = ::std::move(from); + } + + inline BlobProtoVector& operator=(const BlobProtoVector& from) { + CopyFrom(from); + return *this; + } + inline BlobProtoVector& operator=(BlobProtoVector&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BlobProtoVector& default_instance() { + return *internal_default_instance(); + } + static inline const BlobProtoVector* internal_default_instance() { + return reinterpret_cast( + &_BlobProtoVector_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(BlobProtoVector& a, BlobProtoVector& b) { + a.Swap(&b); + } + inline void Swap(BlobProtoVector* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BlobProtoVector* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BlobProtoVector* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BlobProtoVector& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const BlobProtoVector& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BlobProtoVector* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.BlobProtoVector"; + } + protected: + explicit BlobProtoVector(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBlobsFieldNumber = 1, + }; + // repeated .opencv_caffe.BlobProto blobs = 1; + int blobs_size() const; + private: + int _internal_blobs_size() const; + public: + void clear_blobs(); + ::opencv_caffe::BlobProto* mutable_blobs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* + mutable_blobs(); + private: + const ::opencv_caffe::BlobProto& _internal_blobs(int index) const; + ::opencv_caffe::BlobProto* _internal_add_blobs(); + public: + const ::opencv_caffe::BlobProto& blobs(int index) const; + ::opencv_caffe::BlobProto* add_blobs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >& + blobs() const; + + // @@protoc_insertion_point(class_scope:opencv_caffe.BlobProtoVector) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class PermuteParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PermuteParameter) */ { + public: + inline PermuteParameter() : PermuteParameter(nullptr) {} + ~PermuteParameter() override; + explicit constexpr PermuteParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PermuteParameter(const PermuteParameter& from); + PermuteParameter(PermuteParameter&& from) noexcept + : PermuteParameter() { + *this = ::std::move(from); + } + + inline PermuteParameter& operator=(const PermuteParameter& from) { + CopyFrom(from); + return *this; + } + inline PermuteParameter& operator=(PermuteParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PermuteParameter& default_instance() { + return *internal_default_instance(); + } + static inline const PermuteParameter* internal_default_instance() { + return reinterpret_cast( + &_PermuteParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(PermuteParameter& a, PermuteParameter& b) { + a.Swap(&b); + } + inline void Swap(PermuteParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PermuteParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PermuteParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PermuteParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const PermuteParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PermuteParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.PermuteParameter"; + } + protected: + explicit PermuteParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOrderFieldNumber = 1, + }; + // repeated uint32 order = 1; + int order_size() const; + private: + int _internal_order_size() const; + public: + void clear_order(); + private: + uint32_t _internal_order(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_order() const; + void _internal_add_order(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_order(); + public: + uint32_t order(int index) const; + void set_order(int index, uint32_t value); + void add_order(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + order() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_order(); + + // @@protoc_insertion_point(class_scope:opencv_caffe.PermuteParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > order_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class NormalizeBBoxParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NormalizeBBoxParameter) */ { + public: + inline NormalizeBBoxParameter() : NormalizeBBoxParameter(nullptr) {} + ~NormalizeBBoxParameter() override; + explicit constexpr NormalizeBBoxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NormalizeBBoxParameter(const NormalizeBBoxParameter& from); + NormalizeBBoxParameter(NormalizeBBoxParameter&& from) noexcept + : NormalizeBBoxParameter() { + *this = ::std::move(from); + } + + inline NormalizeBBoxParameter& operator=(const NormalizeBBoxParameter& from) { + CopyFrom(from); + return *this; + } + inline NormalizeBBoxParameter& operator=(NormalizeBBoxParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NormalizeBBoxParameter& default_instance() { + return *internal_default_instance(); + } + static inline const NormalizeBBoxParameter* internal_default_instance() { + return reinterpret_cast( + &_NormalizeBBoxParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(NormalizeBBoxParameter& a, NormalizeBBoxParameter& b) { + a.Swap(&b); + } + inline void Swap(NormalizeBBoxParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NormalizeBBoxParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NormalizeBBoxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NormalizeBBoxParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const NormalizeBBoxParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NormalizeBBoxParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.NormalizeBBoxParameter"; + } + protected: + explicit NormalizeBBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kScaleFillerFieldNumber = 2, + kAcrossSpatialFieldNumber = 1, + kChannelSharedFieldNumber = 3, + kEpsFieldNumber = 4, + }; + // optional .opencv_caffe.FillerParameter scale_filler = 2; + bool has_scale_filler() const; + private: + bool _internal_has_scale_filler() const; + public: + void clear_scale_filler(); + const ::opencv_caffe::FillerParameter& scale_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_scale_filler(); + ::opencv_caffe::FillerParameter* mutable_scale_filler(); + void set_allocated_scale_filler(::opencv_caffe::FillerParameter* scale_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_scale_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_scale_filler(); + public: + void unsafe_arena_set_allocated_scale_filler( + ::opencv_caffe::FillerParameter* scale_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_scale_filler(); + + // optional bool across_spatial = 1 [default = true]; + bool has_across_spatial() const; + private: + bool _internal_has_across_spatial() const; + public: + void clear_across_spatial(); + bool across_spatial() const; + void set_across_spatial(bool value); + private: + bool _internal_across_spatial() const; + void _internal_set_across_spatial(bool value); + public: + + // optional bool channel_shared = 3 [default = true]; + bool has_channel_shared() const; + private: + bool _internal_has_channel_shared() const; + public: + void clear_channel_shared(); + bool channel_shared() const; + void set_channel_shared(bool value); + private: + bool _internal_channel_shared() const; + void _internal_set_channel_shared(bool value); + public: + + // optional float eps = 4 [default = 1e-10]; + bool has_eps() const; + private: + bool _internal_has_eps() const; + public: + void clear_eps(); + float eps() const; + void set_eps(float value); + private: + float _internal_eps() const; + void _internal_set_eps(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.NormalizeBBoxParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::FillerParameter* scale_filler_; + bool across_spatial_; + bool channel_shared_; + float eps_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class PriorBoxParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PriorBoxParameter) */ { + public: + inline PriorBoxParameter() : PriorBoxParameter(nullptr) {} + ~PriorBoxParameter() override; + explicit constexpr PriorBoxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PriorBoxParameter(const PriorBoxParameter& from); + PriorBoxParameter(PriorBoxParameter&& from) noexcept + : PriorBoxParameter() { + *this = ::std::move(from); + } + + inline PriorBoxParameter& operator=(const PriorBoxParameter& from) { + CopyFrom(from); + return *this; + } + inline PriorBoxParameter& operator=(PriorBoxParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PriorBoxParameter& default_instance() { + return *internal_default_instance(); + } + static inline const PriorBoxParameter* internal_default_instance() { + return reinterpret_cast( + &_PriorBoxParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(PriorBoxParameter& a, PriorBoxParameter& b) { + a.Swap(&b); + } + inline void Swap(PriorBoxParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PriorBoxParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PriorBoxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PriorBoxParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const PriorBoxParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PriorBoxParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.PriorBoxParameter"; + } + protected: + explicit PriorBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef PriorBoxParameter_CodeType CodeType; + static constexpr CodeType CORNER = + PriorBoxParameter_CodeType_CORNER; + static constexpr CodeType CENTER_SIZE = + PriorBoxParameter_CodeType_CENTER_SIZE; + static inline bool CodeType_IsValid(int value) { + return PriorBoxParameter_CodeType_IsValid(value); + } + static constexpr CodeType CodeType_MIN = + PriorBoxParameter_CodeType_CodeType_MIN; + static constexpr CodeType CodeType_MAX = + PriorBoxParameter_CodeType_CodeType_MAX; + static constexpr int CodeType_ARRAYSIZE = + PriorBoxParameter_CodeType_CodeType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + CodeType_descriptor() { + return PriorBoxParameter_CodeType_descriptor(); + } + template + static inline const std::string& CodeType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CodeType_Name."); + return PriorBoxParameter_CodeType_Name(enum_t_value); + } + static inline bool CodeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + CodeType* value) { + return PriorBoxParameter_CodeType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kMinSizeFieldNumber = 1, + kMaxSizeFieldNumber = 2, + kAspectRatioFieldNumber = 3, + kVarianceFieldNumber = 6, + kOffsetHFieldNumber = 14, + kOffsetWFieldNumber = 15, + kWidthFieldNumber = 16, + kHeightFieldNumber = 17, + kImgSizeFieldNumber = 7, + kImgHFieldNumber = 8, + kImgWFieldNumber = 9, + kStepFieldNumber = 10, + kStepHFieldNumber = 11, + kStepWFieldNumber = 12, + kFlipFieldNumber = 4, + kClipFieldNumber = 5, + kOffsetFieldNumber = 13, + }; + // repeated float min_size = 1; + int min_size_size() const; + private: + int _internal_min_size_size() const; + public: + void clear_min_size(); + private: + float _internal_min_size(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_min_size() const; + void _internal_add_min_size(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_min_size(); + public: + float min_size(int index) const; + void set_min_size(int index, float value); + void add_min_size(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + min_size() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_min_size(); + + // repeated float max_size = 2; + int max_size_size() const; + private: + int _internal_max_size_size() const; + public: + void clear_max_size(); + private: + float _internal_max_size(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_max_size() const; + void _internal_add_max_size(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_max_size(); + public: + float max_size(int index) const; + void set_max_size(int index, float value); + void add_max_size(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + max_size() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_max_size(); + + // repeated float aspect_ratio = 3; + int aspect_ratio_size() const; + private: + int _internal_aspect_ratio_size() const; + public: + void clear_aspect_ratio(); + private: + float _internal_aspect_ratio(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_aspect_ratio() const; + void _internal_add_aspect_ratio(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_aspect_ratio(); + public: + float aspect_ratio(int index) const; + void set_aspect_ratio(int index, float value); + void add_aspect_ratio(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + aspect_ratio() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_aspect_ratio(); + + // repeated float variance = 6; + int variance_size() const; + private: + int _internal_variance_size() const; + public: + void clear_variance(); + private: + float _internal_variance(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_variance() const; + void _internal_add_variance(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_variance(); + public: + float variance(int index) const; + void set_variance(int index, float value); + void add_variance(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + variance() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_variance(); + + // repeated float offset_h = 14; + int offset_h_size() const; + private: + int _internal_offset_h_size() const; + public: + void clear_offset_h(); + private: + float _internal_offset_h(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_offset_h() const; + void _internal_add_offset_h(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_offset_h(); + public: + float offset_h(int index) const; + void set_offset_h(int index, float value); + void add_offset_h(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + offset_h() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_offset_h(); + + // repeated float offset_w = 15; + int offset_w_size() const; + private: + int _internal_offset_w_size() const; + public: + void clear_offset_w(); + private: + float _internal_offset_w(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_offset_w() const; + void _internal_add_offset_w(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_offset_w(); + public: + float offset_w(int index) const; + void set_offset_w(int index, float value); + void add_offset_w(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + offset_w() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_offset_w(); + + // repeated float width = 16; + int width_size() const; + private: + int _internal_width_size() const; + public: + void clear_width(); + private: + float _internal_width(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_width() const; + void _internal_add_width(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_width(); + public: + float width(int index) const; + void set_width(int index, float value); + void add_width(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + width() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_width(); + + // repeated float height = 17; + int height_size() const; + private: + int _internal_height_size() const; + public: + void clear_height(); + private: + float _internal_height(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_height() const; + void _internal_add_height(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_height(); + public: + float height(int index) const; + void set_height(int index, float value); + void add_height(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + height() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_height(); + + // optional uint32 img_size = 7; + bool has_img_size() const; + private: + bool _internal_has_img_size() const; + public: + void clear_img_size(); + uint32_t img_size() const; + void set_img_size(uint32_t value); + private: + uint32_t _internal_img_size() const; + void _internal_set_img_size(uint32_t value); + public: + + // optional uint32 img_h = 8; + bool has_img_h() const; + private: + bool _internal_has_img_h() const; + public: + void clear_img_h(); + uint32_t img_h() const; + void set_img_h(uint32_t value); + private: + uint32_t _internal_img_h() const; + void _internal_set_img_h(uint32_t value); + public: + + // optional uint32 img_w = 9; + bool has_img_w() const; + private: + bool _internal_has_img_w() const; + public: + void clear_img_w(); + uint32_t img_w() const; + void set_img_w(uint32_t value); + private: + uint32_t _internal_img_w() const; + void _internal_set_img_w(uint32_t value); + public: + + // optional float step = 10; + bool has_step() const; + private: + bool _internal_has_step() const; + public: + void clear_step(); + float step() const; + void set_step(float value); + private: + float _internal_step() const; + void _internal_set_step(float value); + public: + + // optional float step_h = 11; + bool has_step_h() const; + private: + bool _internal_has_step_h() const; + public: + void clear_step_h(); + float step_h() const; + void set_step_h(float value); + private: + float _internal_step_h() const; + void _internal_set_step_h(float value); + public: + + // optional float step_w = 12; + bool has_step_w() const; + private: + bool _internal_has_step_w() const; + public: + void clear_step_w(); + float step_w() const; + void set_step_w(float value); + private: + float _internal_step_w() const; + void _internal_set_step_w(float value); + public: + + // optional bool flip = 4 [default = true]; + bool has_flip() const; + private: + bool _internal_has_flip() const; + public: + void clear_flip(); + bool flip() const; + void set_flip(bool value); + private: + bool _internal_flip() const; + void _internal_set_flip(bool value); + public: + + // optional bool clip = 5 [default = true]; + bool has_clip() const; + private: + bool _internal_has_clip() const; + public: + void clear_clip(); + bool clip() const; + void set_clip(bool value); + private: + bool _internal_clip() const; + void _internal_set_clip(bool value); + public: + + // optional float offset = 13 [default = 0.5]; + bool has_offset() const; + private: + bool _internal_has_offset() const; + public: + void clear_offset(); + float offset() const; + void set_offset(float value); + private: + float _internal_offset() const; + void _internal_set_offset(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.PriorBoxParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > min_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > max_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > aspect_ratio_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > variance_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > offset_h_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > offset_w_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > width_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > height_; + uint32_t img_size_; + uint32_t img_h_; + uint32_t img_w_; + float step_; + float step_h_; + float step_w_; + bool flip_; + bool clip_; + float offset_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class DetectionOutputParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DetectionOutputParameter) */ { + public: + inline DetectionOutputParameter() : DetectionOutputParameter(nullptr) {} + ~DetectionOutputParameter() override; + explicit constexpr DetectionOutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DetectionOutputParameter(const DetectionOutputParameter& from); + DetectionOutputParameter(DetectionOutputParameter&& from) noexcept + : DetectionOutputParameter() { + *this = ::std::move(from); + } + + inline DetectionOutputParameter& operator=(const DetectionOutputParameter& from) { + CopyFrom(from); + return *this; + } + inline DetectionOutputParameter& operator=(DetectionOutputParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DetectionOutputParameter& default_instance() { + return *internal_default_instance(); + } + static inline const DetectionOutputParameter* internal_default_instance() { + return reinterpret_cast( + &_DetectionOutputParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(DetectionOutputParameter& a, DetectionOutputParameter& b) { + a.Swap(&b); + } + inline void Swap(DetectionOutputParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DetectionOutputParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DetectionOutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const DetectionOutputParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const DetectionOutputParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DetectionOutputParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.DetectionOutputParameter"; + } + protected: + explicit DetectionOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNmsParamFieldNumber = 4, + kSaveOutputParamFieldNumber = 5, + kNumClassesFieldNumber = 1, + kBackgroundLabelIdFieldNumber = 3, + kConfidenceThresholdFieldNumber = 9, + kVarianceEncodedInTargetFieldNumber = 8, + kClipFieldNumber = 1000, + kKeepTopKFieldNumber = 7, + kCodeTypeFieldNumber = 6, + kShareLocationFieldNumber = 2, + kNormalizedBboxFieldNumber = 10, + }; + // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4; + bool has_nms_param() const; + private: + bool _internal_has_nms_param() const; + public: + void clear_nms_param(); + const ::opencv_caffe::NonMaximumSuppressionParameter& nms_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::NonMaximumSuppressionParameter* release_nms_param(); + ::opencv_caffe::NonMaximumSuppressionParameter* mutable_nms_param(); + void set_allocated_nms_param(::opencv_caffe::NonMaximumSuppressionParameter* nms_param); + private: + const ::opencv_caffe::NonMaximumSuppressionParameter& _internal_nms_param() const; + ::opencv_caffe::NonMaximumSuppressionParameter* _internal_mutable_nms_param(); + public: + void unsafe_arena_set_allocated_nms_param( + ::opencv_caffe::NonMaximumSuppressionParameter* nms_param); + ::opencv_caffe::NonMaximumSuppressionParameter* unsafe_arena_release_nms_param(); + + // optional .opencv_caffe.SaveOutputParameter save_output_param = 5; + bool has_save_output_param() const; + private: + bool _internal_has_save_output_param() const; + public: + void clear_save_output_param(); + const ::opencv_caffe::SaveOutputParameter& save_output_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::SaveOutputParameter& _internal_save_output_param() const; + ::opencv_caffe::SaveOutputParameter* _internal_mutable_save_output_param(); + public: + void unsafe_arena_set_allocated_save_output_param( + ::opencv_caffe::SaveOutputParameter* save_output_param); + ::opencv_caffe::SaveOutputParameter* unsafe_arena_release_save_output_param(); + + // optional uint32 num_classes = 1; + bool has_num_classes() const; + private: + bool _internal_has_num_classes() const; + public: + void clear_num_classes(); + uint32_t num_classes() const; + void set_num_classes(uint32_t value); + private: + uint32_t _internal_num_classes() const; + void _internal_set_num_classes(uint32_t value); + public: + + // optional int32 background_label_id = 3 [default = 0]; + bool has_background_label_id() const; + private: + bool _internal_has_background_label_id() const; + public: + void clear_background_label_id(); + int32_t background_label_id() const; + void set_background_label_id(int32_t value); + private: + int32_t _internal_background_label_id() const; + void _internal_set_background_label_id(int32_t value); + public: + + // optional float confidence_threshold = 9; + bool has_confidence_threshold() const; + private: + bool _internal_has_confidence_threshold() const; + public: + void clear_confidence_threshold(); + float confidence_threshold() const; + void set_confidence_threshold(float value); + private: + float _internal_confidence_threshold() const; + void _internal_set_confidence_threshold(float value); + public: + + // optional bool variance_encoded_in_target = 8 [default = false]; + bool has_variance_encoded_in_target() const; + private: + bool _internal_has_variance_encoded_in_target() const; + public: + void clear_variance_encoded_in_target(); + bool variance_encoded_in_target() const; + void set_variance_encoded_in_target(bool value); + private: + bool _internal_variance_encoded_in_target() const; + void _internal_set_variance_encoded_in_target(bool value); + public: + + // optional bool clip = 1000 [default = false]; + bool has_clip() const; + private: + bool _internal_has_clip() const; + public: + void clear_clip(); + bool clip() const; + void set_clip(bool value); + private: + bool _internal_clip() const; + void _internal_set_clip(bool value); + public: + + // optional int32 keep_top_k = 7 [default = -1]; + bool has_keep_top_k() const; + private: + bool _internal_has_keep_top_k() const; + public: + void clear_keep_top_k(); + int32_t keep_top_k() const; + void set_keep_top_k(int32_t value); + private: + int32_t _internal_keep_top_k() const; + void _internal_set_keep_top_k(int32_t value); + public: + + // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + bool has_code_type() const; + private: + bool _internal_has_code_type() const; + public: + void clear_code_type(); + ::opencv_caffe::PriorBoxParameter_CodeType code_type() const; + void set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value); + private: + ::opencv_caffe::PriorBoxParameter_CodeType _internal_code_type() const; + void _internal_set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value); + public: + + // optional bool share_location = 2 [default = true]; + bool has_share_location() const; + private: + bool _internal_has_share_location() const; + public: + void clear_share_location(); + bool share_location() const; + void set_share_location(bool value); + private: + bool _internal_share_location() const; + void _internal_set_share_location(bool value); + public: + + // optional bool normalized_bbox = 10 [default = true]; + bool has_normalized_bbox() const; + private: + bool _internal_has_normalized_bbox() const; + public: + void clear_normalized_bbox(); + bool normalized_bbox() const; + void set_normalized_bbox(bool value); + private: + bool _internal_normalized_bbox() const; + void _internal_set_normalized_bbox(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.DetectionOutputParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::NonMaximumSuppressionParameter* nms_param_; + ::opencv_caffe::SaveOutputParameter* save_output_param_; + uint32_t num_classes_; + int32_t background_label_id_; + float confidence_threshold_; + bool variance_encoded_in_target_; + bool clip_; + int32_t keep_top_k_; + int code_type_; + bool share_location_; + bool normalized_bbox_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class Datum final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.Datum) */ { + public: + inline Datum() : Datum(nullptr) {} + ~Datum() override; + explicit constexpr Datum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Datum(const Datum& from); + Datum(Datum&& from) noexcept + : Datum() { + *this = ::std::move(from); + } + + inline Datum& operator=(const Datum& from) { + CopyFrom(from); + return *this; + } + inline Datum& operator=(Datum&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Datum& default_instance() { + return *internal_default_instance(); + } + static inline const Datum* internal_default_instance() { + return reinterpret_cast( + &_Datum_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(Datum& a, Datum& b) { + a.Swap(&b); + } + inline void Swap(Datum* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Datum* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Datum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Datum& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const Datum& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Datum* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.Datum"; + } + protected: + explicit Datum(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFloatDataFieldNumber = 6, + kDataFieldNumber = 4, + kChannelsFieldNumber = 1, + kHeightFieldNumber = 2, + kWidthFieldNumber = 3, + kLabelFieldNumber = 5, + kEncodedFieldNumber = 7, + }; + // repeated float float_data = 6; + int float_data_size() const; + private: + int _internal_float_data_size() const; + public: + void clear_float_data(); + private: + float _internal_float_data(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_float_data() const; + void _internal_add_float_data(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_float_data(); + public: + float float_data(int index) const; + void set_float_data(int index, float value); + void add_float_data(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + float_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_float_data(); + + // optional bytes data = 4; + bool has_data() const; + private: + bool _internal_has_data() const; + public: + void clear_data(); + const std::string& data() const; + template + void set_data(ArgT0&& arg0, ArgT... args); + std::string* mutable_data(); + PROTOBUF_NODISCARD std::string* release_data(); + void set_allocated_data(std::string* data); + private: + const std::string& _internal_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value); + std::string* _internal_mutable_data(); + public: + + // optional int32 channels = 1; + bool has_channels() const; + private: + bool _internal_has_channels() const; + public: + void clear_channels(); + int32_t channels() const; + void set_channels(int32_t value); + private: + int32_t _internal_channels() const; + void _internal_set_channels(int32_t value); + public: + + // optional int32 height = 2; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + int32_t height() const; + void set_height(int32_t value); + private: + int32_t _internal_height() const; + void _internal_set_height(int32_t value); + public: + + // optional int32 width = 3; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + int32_t width() const; + void set_width(int32_t value); + private: + int32_t _internal_width() const; + void _internal_set_width(int32_t value); + public: + + // optional int32 label = 5; + bool has_label() const; + private: + bool _internal_has_label() const; + public: + void clear_label(); + int32_t label() const; + void set_label(int32_t value); + private: + int32_t _internal_label() const; + void _internal_set_label(int32_t value); + public: + + // optional bool encoded = 7 [default = false]; + bool has_encoded() const; + private: + bool _internal_has_encoded() const; + public: + void clear_encoded(); + bool encoded() const; + void set_encoded(bool value); + private: + bool _internal_encoded() const; + void _internal_set_encoded(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.Datum) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_; + int32_t channels_; + int32_t height_; + int32_t width_; + int32_t label_; + bool encoded_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class FillerParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.FillerParameter) */ { + public: + inline FillerParameter() : FillerParameter(nullptr) {} + ~FillerParameter() override; + explicit constexpr FillerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FillerParameter(const FillerParameter& from); + FillerParameter(FillerParameter&& from) noexcept + : FillerParameter() { + *this = ::std::move(from); + } + + inline FillerParameter& operator=(const FillerParameter& from) { + CopyFrom(from); + return *this; + } + inline FillerParameter& operator=(FillerParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const FillerParameter& default_instance() { + return *internal_default_instance(); + } + static inline const FillerParameter* internal_default_instance() { + return reinterpret_cast( + &_FillerParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(FillerParameter& a, FillerParameter& b) { + a.Swap(&b); + } + inline void Swap(FillerParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FillerParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FillerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const FillerParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const FillerParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FillerParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.FillerParameter"; + } + protected: + explicit FillerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef FillerParameter_VarianceNorm VarianceNorm; + static constexpr VarianceNorm FAN_IN = + FillerParameter_VarianceNorm_FAN_IN; + static constexpr VarianceNorm FAN_OUT = + FillerParameter_VarianceNorm_FAN_OUT; + static constexpr VarianceNorm AVERAGE = + FillerParameter_VarianceNorm_AVERAGE; + static inline bool VarianceNorm_IsValid(int value) { + return FillerParameter_VarianceNorm_IsValid(value); + } + static constexpr VarianceNorm VarianceNorm_MIN = + FillerParameter_VarianceNorm_VarianceNorm_MIN; + static constexpr VarianceNorm VarianceNorm_MAX = + FillerParameter_VarianceNorm_VarianceNorm_MAX; + static constexpr int VarianceNorm_ARRAYSIZE = + FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + VarianceNorm_descriptor() { + return FillerParameter_VarianceNorm_descriptor(); + } + template + static inline const std::string& VarianceNorm_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function VarianceNorm_Name."); + return FillerParameter_VarianceNorm_Name(enum_t_value); + } + static inline bool VarianceNorm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + VarianceNorm* value) { + return FillerParameter_VarianceNorm_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTypeFieldNumber = 1, + kValueFieldNumber = 2, + kMinFieldNumber = 3, + kMeanFieldNumber = 5, + kVarianceNormFieldNumber = 8, + kSparseFieldNumber = 7, + kMaxFieldNumber = 4, + kStdFieldNumber = 6, + }; + // optional string type = 1 [default = "constant"]; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const std::string& type() const; + template + void set_type(ArgT0&& arg0, ArgT... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* type); + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value); + std::string* _internal_mutable_type(); + public: + + // optional float value = 2 [default = 0]; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + float value() const; + void set_value(float value); + private: + float _internal_value() const; + void _internal_set_value(float value); + public: + + // optional float min = 3 [default = 0]; + bool has_min() const; + private: + bool _internal_has_min() const; + public: + void clear_min(); + float min() const; + void set_min(float value); + private: + float _internal_min() const; + void _internal_set_min(float value); + public: + + // optional float mean = 5 [default = 0]; + bool has_mean() const; + private: + bool _internal_has_mean() const; + public: + void clear_mean(); + float mean() const; + void set_mean(float value); + private: + float _internal_mean() const; + void _internal_set_mean(float value); + public: + + // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + bool has_variance_norm() const; + private: + bool _internal_has_variance_norm() const; + public: + void clear_variance_norm(); + ::opencv_caffe::FillerParameter_VarianceNorm variance_norm() const; + void set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value); + private: + ::opencv_caffe::FillerParameter_VarianceNorm _internal_variance_norm() const; + void _internal_set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value); + public: + + // optional int32 sparse = 7 [default = -1]; + bool has_sparse() const; + private: + bool _internal_has_sparse() const; + public: + void clear_sparse(); + int32_t sparse() const; + void set_sparse(int32_t value); + private: + int32_t _internal_sparse() const; + void _internal_set_sparse(int32_t value); + public: + + // optional float max = 4 [default = 1]; + bool has_max() const; + private: + bool _internal_has_max() const; + public: + void clear_max(); + float max() const; + void set_max(float value); + private: + float _internal_max() const; + void _internal_set_max(float value); + public: + + // optional float std = 6 [default = 1]; + bool has_std() const; + private: + bool _internal_has_std() const; + public: + void clear_std(); + float std() const; + void set_std(float value); + private: + float _internal_std() const; + void _internal_set_std(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.FillerParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_type_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_; + float value_; + float min_; + float mean_; + int variance_norm_; + int32_t sparse_; + float max_; + float std_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class NetParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetParameter) */ { + public: + inline NetParameter() : NetParameter(nullptr) {} + ~NetParameter() override; + explicit constexpr NetParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NetParameter(const NetParameter& from); + NetParameter(NetParameter&& from) noexcept + : NetParameter() { + *this = ::std::move(from); + } + + inline NetParameter& operator=(const NetParameter& from) { + CopyFrom(from); + return *this; + } + inline NetParameter& operator=(NetParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NetParameter& default_instance() { + return *internal_default_instance(); + } + static inline const NetParameter* internal_default_instance() { + return reinterpret_cast( + &_NetParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(NetParameter& a, NetParameter& b) { + a.Swap(&b); + } + inline void Swap(NetParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NetParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NetParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NetParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const NetParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NetParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.NetParameter"; + } + protected: + explicit NetParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLayersFieldNumber = 2, + kInputFieldNumber = 3, + kInputDimFieldNumber = 4, + kInputShapeFieldNumber = 8, + kLayerFieldNumber = 100, + kNameFieldNumber = 1, + kStateFieldNumber = 6, + kForceBackwardFieldNumber = 5, + kDebugInfoFieldNumber = 7, + }; + // repeated .opencv_caffe.V1LayerParameter layers = 2; + int layers_size() const; + private: + int _internal_layers_size() const; + public: + void clear_layers(); + ::opencv_caffe::V1LayerParameter* mutable_layers(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >* + mutable_layers(); + private: + const ::opencv_caffe::V1LayerParameter& _internal_layers(int index) const; + ::opencv_caffe::V1LayerParameter* _internal_add_layers(); + public: + const ::opencv_caffe::V1LayerParameter& layers(int index) const; + ::opencv_caffe::V1LayerParameter* add_layers(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >& + layers() const; + + // repeated string input = 3; + int input_size() const; + private: + int _internal_input_size() const; + public: + void clear_input(); + const std::string& input(int index) const; + std::string* mutable_input(int index); + void set_input(int index, const std::string& value); + void set_input(int index, std::string&& value); + 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); + void add_input(std::string&& value); + void add_input(const char* value); + void add_input(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& input() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_input(); + private: + const std::string& _internal_input(int index) const; + std::string* _internal_add_input(); + public: + + // repeated int32 input_dim = 4; + int input_dim_size() const; + private: + int _internal_input_dim_size() const; + public: + void clear_input_dim(); + private: + int32_t _internal_input_dim(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_input_dim() const; + void _internal_add_input_dim(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_input_dim(); + public: + int32_t input_dim(int index) const; + void set_input_dim(int index, int32_t value); + void add_input_dim(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + input_dim() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_input_dim(); + + // repeated .opencv_caffe.BlobShape input_shape = 8; + int input_shape_size() const; + private: + int _internal_input_shape_size() const; + public: + void clear_input_shape(); + ::opencv_caffe::BlobShape* mutable_input_shape(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >* + mutable_input_shape(); + private: + const ::opencv_caffe::BlobShape& _internal_input_shape(int index) const; + ::opencv_caffe::BlobShape* _internal_add_input_shape(); + public: + const ::opencv_caffe::BlobShape& input_shape(int index) const; + ::opencv_caffe::BlobShape* add_input_shape(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >& + input_shape() const; + + // repeated .opencv_caffe.LayerParameter layer = 100; + int layer_size() const; + private: + int _internal_layer_size() const; + public: + void clear_layer(); + ::opencv_caffe::LayerParameter* mutable_layer(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::LayerParameter >* + mutable_layer(); + private: + const ::opencv_caffe::LayerParameter& _internal_layer(int index) const; + ::opencv_caffe::LayerParameter* _internal_add_layer(); + public: + const ::opencv_caffe::LayerParameter& layer(int index) const; + ::opencv_caffe::LayerParameter* add_layer(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::LayerParameter >& + layer() const; + + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional .opencv_caffe.NetState state = 6; + bool has_state() const; + private: + bool _internal_has_state() const; + public: + void clear_state(); + const ::opencv_caffe::NetState& state() const; + PROTOBUF_NODISCARD ::opencv_caffe::NetState* release_state(); + ::opencv_caffe::NetState* mutable_state(); + void set_allocated_state(::opencv_caffe::NetState* state); + private: + const ::opencv_caffe::NetState& _internal_state() const; + ::opencv_caffe::NetState* _internal_mutable_state(); + public: + void unsafe_arena_set_allocated_state( + ::opencv_caffe::NetState* state); + ::opencv_caffe::NetState* unsafe_arena_release_state(); + + // optional bool force_backward = 5 [default = false]; + bool has_force_backward() const; + private: + bool _internal_has_force_backward() const; + public: + void clear_force_backward(); + bool force_backward() const; + void set_force_backward(bool value); + private: + bool _internal_force_backward() const; + void _internal_set_force_backward(bool value); + public: + + // optional bool debug_info = 7 [default = false]; + bool has_debug_info() const; + private: + bool _internal_has_debug_info() const; + public: + void clear_debug_info(); + bool debug_info() const; + void set_debug_info(bool value); + private: + bool _internal_debug_info() const; + void _internal_set_debug_info(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.NetParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter > layers_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField input_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > input_dim_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape > input_shape_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::LayerParameter > layer_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::opencv_caffe::NetState* state_; + bool force_backward_; + bool debug_info_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class SolverParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SolverParameter) */ { + public: + inline SolverParameter() : SolverParameter(nullptr) {} + ~SolverParameter() override; + explicit constexpr SolverParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SolverParameter(const SolverParameter& from); + SolverParameter(SolverParameter&& from) noexcept + : SolverParameter() { + *this = ::std::move(from); + } + + inline SolverParameter& operator=(const SolverParameter& from) { + CopyFrom(from); + return *this; + } + inline SolverParameter& operator=(SolverParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SolverParameter& default_instance() { + return *internal_default_instance(); + } + static inline const SolverParameter* internal_default_instance() { + return reinterpret_cast( + &_SolverParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(SolverParameter& a, SolverParameter& b) { + a.Swap(&b); + } + inline void Swap(SolverParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SolverParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SolverParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SolverParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const SolverParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SolverParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.SolverParameter"; + } + protected: + explicit SolverParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SolverParameter_SnapshotFormat SnapshotFormat; + static constexpr SnapshotFormat HDF5 = + SolverParameter_SnapshotFormat_HDF5; + static constexpr SnapshotFormat BINARYPROTO = + SolverParameter_SnapshotFormat_BINARYPROTO; + static inline bool SnapshotFormat_IsValid(int value) { + return SolverParameter_SnapshotFormat_IsValid(value); + } + static constexpr SnapshotFormat SnapshotFormat_MIN = + SolverParameter_SnapshotFormat_SnapshotFormat_MIN; + static constexpr SnapshotFormat SnapshotFormat_MAX = + SolverParameter_SnapshotFormat_SnapshotFormat_MAX; + static constexpr int SnapshotFormat_ARRAYSIZE = + SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SnapshotFormat_descriptor() { + return SolverParameter_SnapshotFormat_descriptor(); + } + template + static inline const std::string& SnapshotFormat_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SnapshotFormat_Name."); + return SolverParameter_SnapshotFormat_Name(enum_t_value); + } + static inline bool SnapshotFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SnapshotFormat* value) { + return SolverParameter_SnapshotFormat_Parse(name, value); + } + + typedef SolverParameter_SolverMode SolverMode; + static constexpr SolverMode CPU = + SolverParameter_SolverMode_CPU; + static constexpr SolverMode GPU = + SolverParameter_SolverMode_GPU; + static inline bool SolverMode_IsValid(int value) { + return SolverParameter_SolverMode_IsValid(value); + } + static constexpr SolverMode SolverMode_MIN = + SolverParameter_SolverMode_SolverMode_MIN; + static constexpr SolverMode SolverMode_MAX = + SolverParameter_SolverMode_SolverMode_MAX; + static constexpr int SolverMode_ARRAYSIZE = + SolverParameter_SolverMode_SolverMode_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SolverMode_descriptor() { + return SolverParameter_SolverMode_descriptor(); + } + template + static inline const std::string& SolverMode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SolverMode_Name."); + return SolverParameter_SolverMode_Name(enum_t_value); + } + static inline bool SolverMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SolverMode* value) { + return SolverParameter_SolverMode_Parse(name, value); + } + + typedef SolverParameter_SolverType SolverType; + static constexpr SolverType SGD = + SolverParameter_SolverType_SGD; + static constexpr SolverType NESTEROV = + SolverParameter_SolverType_NESTEROV; + static constexpr SolverType ADAGRAD = + SolverParameter_SolverType_ADAGRAD; + static constexpr SolverType RMSPROP = + SolverParameter_SolverType_RMSPROP; + static constexpr SolverType ADADELTA = + SolverParameter_SolverType_ADADELTA; + static constexpr SolverType ADAM = + SolverParameter_SolverType_ADAM; + static inline bool SolverType_IsValid(int value) { + return SolverParameter_SolverType_IsValid(value); + } + static constexpr SolverType SolverType_MIN = + SolverParameter_SolverType_SolverType_MIN; + static constexpr SolverType SolverType_MAX = + SolverParameter_SolverType_SolverType_MAX; + static constexpr int SolverType_ARRAYSIZE = + SolverParameter_SolverType_SolverType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SolverType_descriptor() { + return SolverParameter_SolverType_descriptor(); + } + template + static inline const std::string& SolverType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SolverType_Name."); + return SolverParameter_SolverType_Name(enum_t_value); + } + static inline bool SolverType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SolverType* value) { + return SolverParameter_SolverType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTestNetFieldNumber = 2, + kTestIterFieldNumber = 3, + kTestNetParamFieldNumber = 22, + kTestStateFieldNumber = 27, + kStepvalueFieldNumber = 34, + kTrainNetFieldNumber = 1, + kLrPolicyFieldNumber = 8, + kSnapshotPrefixFieldNumber = 15, + kNetFieldNumber = 24, + kRegularizationTypeFieldNumber = 29, + kTypeFieldNumber = 40, + kTrainNetParamFieldNumber = 21, + kNetParamFieldNumber = 25, + kTrainStateFieldNumber = 26, + kTestIntervalFieldNumber = 4, + kBaseLrFieldNumber = 5, + kDisplayFieldNumber = 6, + kMaxIterFieldNumber = 7, + kGammaFieldNumber = 9, + kPowerFieldNumber = 10, + kMomentumFieldNumber = 11, + kWeightDecayFieldNumber = 12, + kStepsizeFieldNumber = 13, + kSnapshotFieldNumber = 14, + kDeviceIdFieldNumber = 18, + kTestComputeLossFieldNumber = 19, + kSnapshotDiffFieldNumber = 16, + kDebugInfoFieldNumber = 23, + kSolverTypeFieldNumber = 30, + kMomentum2FieldNumber = 39, + kRandomSeedFieldNumber = 20, + kSolverModeFieldNumber = 17, + kTestInitializationFieldNumber = 32, + kSnapshotAfterTrainFieldNumber = 28, + kDeltaFieldNumber = 31, + kAverageLossFieldNumber = 33, + kClipGradientsFieldNumber = 35, + kIterSizeFieldNumber = 36, + kSnapshotFormatFieldNumber = 37, + kRmsDecayFieldNumber = 38, + }; + // repeated string test_net = 2; + int test_net_size() const; + private: + int _internal_test_net_size() const; + public: + void clear_test_net(); + 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); + void set_test_net(int index, std::string&& value); + 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); + void add_test_net(std::string&& value); + void add_test_net(const char* value); + void add_test_net(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& test_net() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_test_net(); + private: + const std::string& _internal_test_net(int index) const; + std::string* _internal_add_test_net(); + public: + + // repeated int32 test_iter = 3; + int test_iter_size() const; + private: + int _internal_test_iter_size() const; + public: + void clear_test_iter(); + private: + int32_t _internal_test_iter(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_test_iter() const; + void _internal_add_test_iter(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_test_iter(); + public: + int32_t test_iter(int index) const; + void set_test_iter(int index, int32_t value); + void add_test_iter(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + test_iter() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_test_iter(); + + // repeated .opencv_caffe.NetParameter test_net_param = 22; + int test_net_param_size() const; + private: + int _internal_test_net_param_size() const; + public: + void clear_test_net_param(); + ::opencv_caffe::NetParameter* mutable_test_net_param(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetParameter >* + mutable_test_net_param(); + private: + const ::opencv_caffe::NetParameter& _internal_test_net_param(int index) const; + ::opencv_caffe::NetParameter* _internal_add_test_net_param(); + public: + const ::opencv_caffe::NetParameter& test_net_param(int index) const; + ::opencv_caffe::NetParameter* add_test_net_param(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetParameter >& + test_net_param() const; + + // repeated .opencv_caffe.NetState test_state = 27; + int test_state_size() const; + private: + int _internal_test_state_size() const; + public: + void clear_test_state(); + ::opencv_caffe::NetState* mutable_test_state(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState >* + mutable_test_state(); + private: + const ::opencv_caffe::NetState& _internal_test_state(int index) const; + ::opencv_caffe::NetState* _internal_add_test_state(); + public: + const ::opencv_caffe::NetState& test_state(int index) const; + ::opencv_caffe::NetState* add_test_state(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState >& + test_state() const; + + // repeated int32 stepvalue = 34; + int stepvalue_size() const; + private: + int _internal_stepvalue_size() const; + public: + void clear_stepvalue(); + private: + int32_t _internal_stepvalue(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_stepvalue() const; + void _internal_add_stepvalue(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_stepvalue(); + public: + int32_t stepvalue(int index) const; + void set_stepvalue(int index, int32_t value); + void add_stepvalue(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + stepvalue() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_stepvalue(); + + // optional string train_net = 1; + bool has_train_net() const; + private: + bool _internal_has_train_net() const; + public: + void clear_train_net(); + const std::string& train_net() const; + template + void set_train_net(ArgT0&& arg0, ArgT... args); + std::string* mutable_train_net(); + PROTOBUF_NODISCARD std::string* release_train_net(); + void set_allocated_train_net(std::string* train_net); + private: + const std::string& _internal_train_net() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_train_net(const std::string& value); + std::string* _internal_mutable_train_net(); + public: + + // optional string lr_policy = 8; + bool has_lr_policy() const; + private: + bool _internal_has_lr_policy() const; + public: + void clear_lr_policy(); + const std::string& lr_policy() const; + template + void set_lr_policy(ArgT0&& arg0, ArgT... args); + std::string* mutable_lr_policy(); + PROTOBUF_NODISCARD std::string* release_lr_policy(); + void set_allocated_lr_policy(std::string* lr_policy); + private: + const std::string& _internal_lr_policy() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_lr_policy(const std::string& value); + std::string* _internal_mutable_lr_policy(); + public: + + // optional string snapshot_prefix = 15; + bool has_snapshot_prefix() const; + private: + bool _internal_has_snapshot_prefix() const; + public: + void clear_snapshot_prefix(); + const std::string& snapshot_prefix() const; + template + void set_snapshot_prefix(ArgT0&& arg0, ArgT... args); + std::string* mutable_snapshot_prefix(); + PROTOBUF_NODISCARD std::string* release_snapshot_prefix(); + void set_allocated_snapshot_prefix(std::string* snapshot_prefix); + private: + const std::string& _internal_snapshot_prefix() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshot_prefix(const std::string& value); + std::string* _internal_mutable_snapshot_prefix(); + public: + + // optional string net = 24; + bool has_net() const; + private: + bool _internal_has_net() const; + public: + void clear_net(); + const std::string& net() const; + template + void set_net(ArgT0&& arg0, ArgT... args); + std::string* mutable_net(); + PROTOBUF_NODISCARD std::string* release_net(); + void set_allocated_net(std::string* net); + private: + const std::string& _internal_net() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_net(const std::string& value); + std::string* _internal_mutable_net(); + public: + + // optional string regularization_type = 29 [default = "L2"]; + bool has_regularization_type() const; + private: + bool _internal_has_regularization_type() const; + public: + void clear_regularization_type(); + const std::string& regularization_type() const; + template + void set_regularization_type(ArgT0&& arg0, ArgT... args); + std::string* mutable_regularization_type(); + PROTOBUF_NODISCARD std::string* release_regularization_type(); + void set_allocated_regularization_type(std::string* regularization_type); + private: + const std::string& _internal_regularization_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_regularization_type(const std::string& value); + std::string* _internal_mutable_regularization_type(); + public: + + // optional string type = 40 [default = "SGD"]; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const std::string& type() const; + template + void set_type(ArgT0&& arg0, ArgT... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* type); + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value); + std::string* _internal_mutable_type(); + public: + + // optional .opencv_caffe.NetParameter train_net_param = 21; + bool has_train_net_param() const; + private: + bool _internal_has_train_net_param() const; + public: + void clear_train_net_param(); + const ::opencv_caffe::NetParameter& train_net_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::NetParameter& _internal_train_net_param() const; + ::opencv_caffe::NetParameter* _internal_mutable_train_net_param(); + public: + void unsafe_arena_set_allocated_train_net_param( + ::opencv_caffe::NetParameter* train_net_param); + ::opencv_caffe::NetParameter* unsafe_arena_release_train_net_param(); + + // optional .opencv_caffe.NetParameter net_param = 25; + bool has_net_param() const; + private: + bool _internal_has_net_param() const; + public: + void clear_net_param(); + const ::opencv_caffe::NetParameter& net_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::NetParameter* release_net_param(); + ::opencv_caffe::NetParameter* mutable_net_param(); + void set_allocated_net_param(::opencv_caffe::NetParameter* net_param); + private: + const ::opencv_caffe::NetParameter& _internal_net_param() const; + ::opencv_caffe::NetParameter* _internal_mutable_net_param(); + public: + void unsafe_arena_set_allocated_net_param( + ::opencv_caffe::NetParameter* net_param); + ::opencv_caffe::NetParameter* unsafe_arena_release_net_param(); + + // optional .opencv_caffe.NetState train_state = 26; + bool has_train_state() const; + private: + bool _internal_has_train_state() const; + public: + void clear_train_state(); + const ::opencv_caffe::NetState& train_state() const; + PROTOBUF_NODISCARD ::opencv_caffe::NetState* release_train_state(); + ::opencv_caffe::NetState* mutable_train_state(); + void set_allocated_train_state(::opencv_caffe::NetState* train_state); + private: + const ::opencv_caffe::NetState& _internal_train_state() const; + ::opencv_caffe::NetState* _internal_mutable_train_state(); + public: + void unsafe_arena_set_allocated_train_state( + ::opencv_caffe::NetState* train_state); + ::opencv_caffe::NetState* unsafe_arena_release_train_state(); + + // optional int32 test_interval = 4 [default = 0]; + bool has_test_interval() const; + private: + bool _internal_has_test_interval() const; + public: + void clear_test_interval(); + int32_t test_interval() const; + void set_test_interval(int32_t value); + private: + int32_t _internal_test_interval() const; + void _internal_set_test_interval(int32_t value); + public: + + // optional float base_lr = 5; + bool has_base_lr() const; + private: + bool _internal_has_base_lr() const; + public: + void clear_base_lr(); + float base_lr() const; + void set_base_lr(float value); + private: + float _internal_base_lr() const; + void _internal_set_base_lr(float value); + public: + + // optional int32 display = 6; + bool has_display() const; + private: + bool _internal_has_display() const; + public: + void clear_display(); + int32_t display() const; + void set_display(int32_t value); + private: + int32_t _internal_display() const; + void _internal_set_display(int32_t value); + public: + + // optional int32 max_iter = 7; + bool has_max_iter() const; + private: + bool _internal_has_max_iter() const; + public: + void clear_max_iter(); + int32_t max_iter() const; + void set_max_iter(int32_t value); + private: + int32_t _internal_max_iter() const; + void _internal_set_max_iter(int32_t value); + public: + + // optional float gamma = 9; + bool has_gamma() const; + private: + bool _internal_has_gamma() const; + public: + void clear_gamma(); + float gamma() const; + void set_gamma(float value); + private: + float _internal_gamma() const; + void _internal_set_gamma(float value); + public: + + // optional float power = 10; + bool has_power() const; + private: + bool _internal_has_power() const; + public: + void clear_power(); + float power() const; + void set_power(float value); + private: + float _internal_power() const; + void _internal_set_power(float value); + public: + + // optional float momentum = 11; + bool has_momentum() const; + private: + bool _internal_has_momentum() const; + public: + void clear_momentum(); + float momentum() const; + void set_momentum(float value); + private: + float _internal_momentum() const; + void _internal_set_momentum(float value); + public: + + // optional float weight_decay = 12; + bool has_weight_decay() const; + private: + bool _internal_has_weight_decay() const; + public: + void clear_weight_decay(); + float weight_decay() const; + void set_weight_decay(float value); + private: + float _internal_weight_decay() const; + void _internal_set_weight_decay(float value); + public: + + // optional int32 stepsize = 13; + bool has_stepsize() const; + private: + bool _internal_has_stepsize() const; + public: + void clear_stepsize(); + int32_t stepsize() const; + void set_stepsize(int32_t value); + private: + int32_t _internal_stepsize() const; + void _internal_set_stepsize(int32_t value); + public: + + // optional int32 snapshot = 14 [default = 0]; + bool has_snapshot() const; + private: + bool _internal_has_snapshot() const; + public: + void clear_snapshot(); + int32_t snapshot() const; + void set_snapshot(int32_t value); + private: + int32_t _internal_snapshot() const; + void _internal_set_snapshot(int32_t value); + public: + + // optional int32 device_id = 18 [default = 0]; + bool has_device_id() const; + private: + bool _internal_has_device_id() const; + public: + void clear_device_id(); + int32_t device_id() const; + void set_device_id(int32_t value); + private: + int32_t _internal_device_id() const; + void _internal_set_device_id(int32_t value); + public: + + // optional bool test_compute_loss = 19 [default = false]; + bool has_test_compute_loss() const; + private: + bool _internal_has_test_compute_loss() const; + public: + void clear_test_compute_loss(); + bool test_compute_loss() const; + void set_test_compute_loss(bool value); + private: + bool _internal_test_compute_loss() const; + void _internal_set_test_compute_loss(bool value); + public: + + // optional bool snapshot_diff = 16 [default = false]; + bool has_snapshot_diff() const; + private: + bool _internal_has_snapshot_diff() const; + public: + void clear_snapshot_diff(); + bool snapshot_diff() const; + void set_snapshot_diff(bool value); + private: + bool _internal_snapshot_diff() const; + void _internal_set_snapshot_diff(bool value); + public: + + // optional bool debug_info = 23 [default = false]; + bool has_debug_info() const; + private: + bool _internal_has_debug_info() const; + public: + void clear_debug_info(); + bool debug_info() const; + void set_debug_info(bool value); + private: + bool _internal_debug_info() const; + void _internal_set_debug_info(bool value); + public: + + // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + bool has_solver_type() const; + private: + bool _internal_has_solver_type() const; + public: + void clear_solver_type(); + ::opencv_caffe::SolverParameter_SolverType solver_type() const; + void set_solver_type(::opencv_caffe::SolverParameter_SolverType value); + private: + ::opencv_caffe::SolverParameter_SolverType _internal_solver_type() const; + void _internal_set_solver_type(::opencv_caffe::SolverParameter_SolverType value); + public: + + // optional float momentum2 = 39 [default = 0.999]; + bool has_momentum2() const; + private: + bool _internal_has_momentum2() const; + public: + void clear_momentum2(); + float momentum2() const; + void set_momentum2(float value); + private: + float _internal_momentum2() const; + void _internal_set_momentum2(float value); + public: + + // optional int64 random_seed = 20 [default = -1]; + bool has_random_seed() const; + private: + bool _internal_has_random_seed() const; + public: + void clear_random_seed(); + int64_t random_seed() const; + void set_random_seed(int64_t value); + private: + int64_t _internal_random_seed() const; + void _internal_set_random_seed(int64_t value); + public: + + // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + bool has_solver_mode() const; + private: + bool _internal_has_solver_mode() const; + public: + void clear_solver_mode(); + ::opencv_caffe::SolverParameter_SolverMode solver_mode() const; + void set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value); + private: + ::opencv_caffe::SolverParameter_SolverMode _internal_solver_mode() const; + void _internal_set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value); + public: + + // optional bool test_initialization = 32 [default = true]; + bool has_test_initialization() const; + private: + bool _internal_has_test_initialization() const; + public: + void clear_test_initialization(); + bool test_initialization() const; + void set_test_initialization(bool value); + private: + bool _internal_test_initialization() const; + void _internal_set_test_initialization(bool value); + public: + + // optional bool snapshot_after_train = 28 [default = true]; + bool has_snapshot_after_train() const; + private: + bool _internal_has_snapshot_after_train() const; + public: + void clear_snapshot_after_train(); + bool snapshot_after_train() const; + void set_snapshot_after_train(bool value); + private: + bool _internal_snapshot_after_train() const; + void _internal_set_snapshot_after_train(bool value); + public: + + // optional float delta = 31 [default = 1e-08]; + bool has_delta() const; + private: + bool _internal_has_delta() const; + public: + void clear_delta(); + float delta() const; + void set_delta(float value); + private: + float _internal_delta() const; + void _internal_set_delta(float value); + public: + + // optional int32 average_loss = 33 [default = 1]; + bool has_average_loss() const; + private: + bool _internal_has_average_loss() const; + public: + void clear_average_loss(); + int32_t average_loss() const; + void set_average_loss(int32_t value); + private: + int32_t _internal_average_loss() const; + void _internal_set_average_loss(int32_t value); + public: + + // optional float clip_gradients = 35 [default = -1]; + bool has_clip_gradients() const; + private: + bool _internal_has_clip_gradients() const; + public: + void clear_clip_gradients(); + float clip_gradients() const; + void set_clip_gradients(float value); + private: + float _internal_clip_gradients() const; + void _internal_set_clip_gradients(float value); + public: + + // optional int32 iter_size = 36 [default = 1]; + bool has_iter_size() const; + private: + bool _internal_has_iter_size() const; + public: + void clear_iter_size(); + int32_t iter_size() const; + void set_iter_size(int32_t value); + private: + int32_t _internal_iter_size() const; + void _internal_set_iter_size(int32_t value); + public: + + // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + bool has_snapshot_format() const; + private: + bool _internal_has_snapshot_format() const; + public: + void clear_snapshot_format(); + ::opencv_caffe::SolverParameter_SnapshotFormat snapshot_format() const; + void set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value); + private: + ::opencv_caffe::SolverParameter_SnapshotFormat _internal_snapshot_format() const; + void _internal_set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value); + public: + + // optional float rms_decay = 38 [default = 0.99]; + bool has_rms_decay() const; + private: + bool _internal_has_rms_decay() const; + public: + void clear_rms_decay(); + float rms_decay() const; + void set_rms_decay(float value); + private: + float _internal_rms_decay() const; + void _internal_set_rms_decay(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.SolverParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField test_net_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > test_iter_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetParameter > test_net_param_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState > test_state_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > stepvalue_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr train_net_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lr_policy_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshot_prefix_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr net_; + static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_regularization_type_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr regularization_type_; + static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_type_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_; + ::opencv_caffe::NetParameter* train_net_param_; + ::opencv_caffe::NetParameter* net_param_; + ::opencv_caffe::NetState* train_state_; + int32_t test_interval_; + float base_lr_; + int32_t display_; + int32_t max_iter_; + float gamma_; + float power_; + float momentum_; + float weight_decay_; + int32_t stepsize_; + int32_t snapshot_; + int32_t device_id_; + bool test_compute_loss_; + bool snapshot_diff_; + bool debug_info_; + int solver_type_; + float momentum2_; + int64_t random_seed_; + int solver_mode_; + bool test_initialization_; + bool snapshot_after_train_; + float delta_; + int32_t average_loss_; + float clip_gradients_; + int32_t iter_size_; + int snapshot_format_; + float rms_decay_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class SolverState final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SolverState) */ { + public: + inline SolverState() : SolverState(nullptr) {} + ~SolverState() override; + explicit constexpr SolverState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SolverState(const SolverState& from); + SolverState(SolverState&& from) noexcept + : SolverState() { + *this = ::std::move(from); + } + + inline SolverState& operator=(const SolverState& from) { + CopyFrom(from); + return *this; + } + inline SolverState& operator=(SolverState&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SolverState& default_instance() { + return *internal_default_instance(); + } + static inline const SolverState* internal_default_instance() { + return reinterpret_cast( + &_SolverState_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(SolverState& a, SolverState& b) { + a.Swap(&b); + } + inline void Swap(SolverState* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SolverState* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SolverState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SolverState& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const SolverState& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SolverState* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.SolverState"; + } + protected: + explicit SolverState(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kHistoryFieldNumber = 3, + kLearnedNetFieldNumber = 2, + kIterFieldNumber = 1, + kCurrentStepFieldNumber = 4, + }; + // repeated .opencv_caffe.BlobProto history = 3; + int history_size() const; + private: + int _internal_history_size() const; + public: + void clear_history(); + ::opencv_caffe::BlobProto* mutable_history(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* + mutable_history(); + private: + const ::opencv_caffe::BlobProto& _internal_history(int index) const; + ::opencv_caffe::BlobProto* _internal_add_history(); + public: + const ::opencv_caffe::BlobProto& history(int index) const; + ::opencv_caffe::BlobProto* add_history(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >& + history() const; + + // optional string learned_net = 2; + bool has_learned_net() const; + private: + bool _internal_has_learned_net() const; + public: + void clear_learned_net(); + const std::string& learned_net() const; + template + void set_learned_net(ArgT0&& arg0, ArgT... args); + std::string* mutable_learned_net(); + PROTOBUF_NODISCARD std::string* release_learned_net(); + void set_allocated_learned_net(std::string* learned_net); + private: + const std::string& _internal_learned_net() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_learned_net(const std::string& value); + std::string* _internal_mutable_learned_net(); + public: + + // optional int32 iter = 1; + bool has_iter() const; + private: + bool _internal_has_iter() const; + public: + void clear_iter(); + int32_t iter() const; + void set_iter(int32_t value); + private: + int32_t _internal_iter() const; + void _internal_set_iter(int32_t value); + public: + + // optional int32 current_step = 4 [default = 0]; + bool has_current_step() const; + private: + bool _internal_has_current_step() const; + public: + void clear_current_step(); + int32_t current_step() const; + void set_current_step(int32_t value); + private: + int32_t _internal_current_step() const; + void _internal_set_current_step(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.SolverState) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > history_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr learned_net_; + int32_t iter_; + int32_t current_step_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class NetState final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetState) */ { + public: + inline NetState() : NetState(nullptr) {} + ~NetState() override; + explicit constexpr NetState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NetState(const NetState& from); + NetState(NetState&& from) noexcept + : NetState() { + *this = ::std::move(from); + } + + inline NetState& operator=(const NetState& from) { + CopyFrom(from); + return *this; + } + inline NetState& operator=(NetState&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NetState& default_instance() { + return *internal_default_instance(); + } + static inline const NetState* internal_default_instance() { + return reinterpret_cast( + &_NetState_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(NetState& a, NetState& b) { + a.Swap(&b); + } + inline void Swap(NetState* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NetState* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NetState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NetState& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const NetState& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NetState* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.NetState"; + } + protected: + explicit NetState(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStageFieldNumber = 3, + kLevelFieldNumber = 2, + kPhaseFieldNumber = 1, + }; + // repeated string stage = 3; + int stage_size() const; + private: + int _internal_stage_size() const; + public: + void clear_stage(); + const std::string& stage(int index) const; + std::string* mutable_stage(int index); + void set_stage(int index, const std::string& value); + void set_stage(int index, std::string&& value); + 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); + void add_stage(std::string&& value); + void add_stage(const char* value); + void add_stage(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& stage() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_stage(); + private: + const std::string& _internal_stage(int index) const; + std::string* _internal_add_stage(); + public: + + // optional int32 level = 2 [default = 0]; + bool has_level() const; + private: + bool _internal_has_level() const; + public: + void clear_level(); + int32_t level() const; + void set_level(int32_t value); + private: + int32_t _internal_level() const; + void _internal_set_level(int32_t value); + public: + + // optional .opencv_caffe.Phase phase = 1 [default = TEST]; + bool has_phase() const; + private: + bool _internal_has_phase() const; + public: + void clear_phase(); + ::opencv_caffe::Phase phase() const; + void set_phase(::opencv_caffe::Phase value); + private: + ::opencv_caffe::Phase _internal_phase() const; + void _internal_set_phase(::opencv_caffe::Phase value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.NetState) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField stage_; + int32_t level_; + int phase_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class NetStateRule final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetStateRule) */ { + public: + inline NetStateRule() : NetStateRule(nullptr) {} + ~NetStateRule() override; + explicit constexpr NetStateRule(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NetStateRule(const NetStateRule& from); + NetStateRule(NetStateRule&& from) noexcept + : NetStateRule() { + *this = ::std::move(from); + } + + inline NetStateRule& operator=(const NetStateRule& from) { + CopyFrom(from); + return *this; + } + inline NetStateRule& operator=(NetStateRule&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NetStateRule& default_instance() { + return *internal_default_instance(); + } + static inline const NetStateRule* internal_default_instance() { + return reinterpret_cast( + &_NetStateRule_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(NetStateRule& a, NetStateRule& b) { + a.Swap(&b); + } + inline void Swap(NetStateRule* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NetStateRule* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NetStateRule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NetStateRule& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const NetStateRule& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NetStateRule* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.NetStateRule"; + } + protected: + explicit NetStateRule(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStageFieldNumber = 4, + kNotStageFieldNumber = 5, + kPhaseFieldNumber = 1, + kMinLevelFieldNumber = 2, + kMaxLevelFieldNumber = 3, + }; + // repeated string stage = 4; + int stage_size() const; + private: + int _internal_stage_size() const; + public: + void clear_stage(); + const std::string& stage(int index) const; + std::string* mutable_stage(int index); + void set_stage(int index, const std::string& value); + void set_stage(int index, std::string&& value); + 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); + void add_stage(std::string&& value); + void add_stage(const char* value); + void add_stage(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& stage() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_stage(); + private: + const std::string& _internal_stage(int index) const; + std::string* _internal_add_stage(); + public: + + // repeated string not_stage = 5; + int not_stage_size() const; + private: + int _internal_not_stage_size() const; + public: + void clear_not_stage(); + 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); + void set_not_stage(int index, std::string&& value); + 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); + void add_not_stage(std::string&& value); + void add_not_stage(const char* value); + void add_not_stage(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& not_stage() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_not_stage(); + private: + const std::string& _internal_not_stage(int index) const; + std::string* _internal_add_not_stage(); + public: + + // optional .opencv_caffe.Phase phase = 1; + bool has_phase() const; + private: + bool _internal_has_phase() const; + public: + void clear_phase(); + ::opencv_caffe::Phase phase() const; + void set_phase(::opencv_caffe::Phase value); + private: + ::opencv_caffe::Phase _internal_phase() const; + void _internal_set_phase(::opencv_caffe::Phase value); + public: + + // optional int32 min_level = 2; + bool has_min_level() const; + private: + bool _internal_has_min_level() const; + public: + void clear_min_level(); + int32_t min_level() const; + void set_min_level(int32_t value); + private: + int32_t _internal_min_level() const; + void _internal_set_min_level(int32_t value); + public: + + // optional int32 max_level = 3; + bool has_max_level() const; + private: + bool _internal_has_max_level() const; + public: + void clear_max_level(); + int32_t max_level() const; + void set_max_level(int32_t value); + private: + int32_t _internal_max_level() const; + void _internal_set_max_level(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.NetStateRule) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField stage_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField not_stage_; + int phase_; + int32_t min_level_; + int32_t max_level_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ParamSpec final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ParamSpec) */ { + public: + inline ParamSpec() : ParamSpec(nullptr) {} + ~ParamSpec() override; + explicit constexpr ParamSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParamSpec(const ParamSpec& from); + ParamSpec(ParamSpec&& from) noexcept + : ParamSpec() { + *this = ::std::move(from); + } + + inline ParamSpec& operator=(const ParamSpec& from) { + CopyFrom(from); + return *this; + } + inline ParamSpec& operator=(ParamSpec&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ParamSpec& default_instance() { + return *internal_default_instance(); + } + static inline const ParamSpec* internal_default_instance() { + return reinterpret_cast( + &_ParamSpec_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(ParamSpec& a, ParamSpec& b) { + a.Swap(&b); + } + inline void Swap(ParamSpec* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParamSpec* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ParamSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ParamSpec& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ParamSpec& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParamSpec* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ParamSpec"; + } + protected: + explicit ParamSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ParamSpec_DimCheckMode DimCheckMode; + static constexpr DimCheckMode STRICT = + ParamSpec_DimCheckMode_STRICT; + static constexpr DimCheckMode PERMISSIVE = + ParamSpec_DimCheckMode_PERMISSIVE; + static inline bool DimCheckMode_IsValid(int value) { + return ParamSpec_DimCheckMode_IsValid(value); + } + static constexpr DimCheckMode DimCheckMode_MIN = + ParamSpec_DimCheckMode_DimCheckMode_MIN; + static constexpr DimCheckMode DimCheckMode_MAX = + ParamSpec_DimCheckMode_DimCheckMode_MAX; + static constexpr int DimCheckMode_ARRAYSIZE = + ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + DimCheckMode_descriptor() { + return ParamSpec_DimCheckMode_descriptor(); + } + template + static inline const std::string& DimCheckMode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DimCheckMode_Name."); + return ParamSpec_DimCheckMode_Name(enum_t_value); + } + static inline bool DimCheckMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + DimCheckMode* value) { + return ParamSpec_DimCheckMode_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kShareModeFieldNumber = 2, + kLrMultFieldNumber = 3, + kDecayMultFieldNumber = 4, + }; + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2; + bool has_share_mode() const; + private: + bool _internal_has_share_mode() const; + public: + void clear_share_mode(); + ::opencv_caffe::ParamSpec_DimCheckMode share_mode() const; + void set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value); + private: + ::opencv_caffe::ParamSpec_DimCheckMode _internal_share_mode() const; + void _internal_set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value); + public: + + // optional float lr_mult = 3 [default = 1]; + bool has_lr_mult() const; + private: + bool _internal_has_lr_mult() const; + public: + void clear_lr_mult(); + float lr_mult() const; + void set_lr_mult(float value); + private: + float _internal_lr_mult() const; + void _internal_set_lr_mult(float value); + public: + + // optional float decay_mult = 4 [default = 1]; + bool has_decay_mult() const; + private: + bool _internal_has_decay_mult() const; + public: + void clear_decay_mult(); + float decay_mult() const; + void set_decay_mult(float value); + private: + float _internal_decay_mult() const; + void _internal_set_decay_mult(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ParamSpec) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + int share_mode_; + float lr_mult_; + float decay_mult_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class LayerParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LayerParameter) */ { + public: + inline LayerParameter() : LayerParameter(nullptr) {} + ~LayerParameter() override; + explicit constexpr LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LayerParameter(const LayerParameter& from); + LayerParameter(LayerParameter&& from) noexcept + : LayerParameter() { + *this = ::std::move(from); + } + + inline LayerParameter& operator=(const LayerParameter& from) { + CopyFrom(from); + return *this; + } + inline LayerParameter& operator=(LayerParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LayerParameter& default_instance() { + return *internal_default_instance(); + } + static inline const LayerParameter* internal_default_instance() { + return reinterpret_cast( + &_LayerParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(LayerParameter& a, LayerParameter& b) { + a.Swap(&b); + } + inline void Swap(LayerParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LayerParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LayerParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const LayerParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LayerParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.LayerParameter"; + } + protected: + explicit LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBottomFieldNumber = 3, + kTopFieldNumber = 4, + kLossWeightFieldNumber = 5, + kParamFieldNumber = 6, + kBlobsFieldNumber = 7, + kIncludeFieldNumber = 8, + kExcludeFieldNumber = 9, + kPropagateDownFieldNumber = 11, + kNameFieldNumber = 1, + kTypeFieldNumber = 2, + kTransformParamFieldNumber = 100, + kLossParamFieldNumber = 101, + kAccuracyParamFieldNumber = 102, + kArgmaxParamFieldNumber = 103, + kConcatParamFieldNumber = 104, + kContrastiveLossParamFieldNumber = 105, + kConvolutionParamFieldNumber = 106, + kDataParamFieldNumber = 107, + kDropoutParamFieldNumber = 108, + kDummyDataParamFieldNumber = 109, + kEltwiseParamFieldNumber = 110, + kExpParamFieldNumber = 111, + kHdf5DataParamFieldNumber = 112, + kHdf5OutputParamFieldNumber = 113, + kHingeLossParamFieldNumber = 114, + kImageDataParamFieldNumber = 115, + kInfogainLossParamFieldNumber = 116, + kInnerProductParamFieldNumber = 117, + kLrnParamFieldNumber = 118, + kMemoryDataParamFieldNumber = 119, + kMvnParamFieldNumber = 120, + kPoolingParamFieldNumber = 121, + kPowerParamFieldNumber = 122, + kReluParamFieldNumber = 123, + kSigmoidParamFieldNumber = 124, + kSoftmaxParamFieldNumber = 125, + kSliceParamFieldNumber = 126, + kTanhParamFieldNumber = 127, + kThresholdParamFieldNumber = 128, + kWindowDataParamFieldNumber = 129, + kPythonParamFieldNumber = 130, + kPreluParamFieldNumber = 131, + kSppParamFieldNumber = 132, + kReshapeParamFieldNumber = 133, + kLogParamFieldNumber = 134, + kFlattenParamFieldNumber = 135, + kReductionParamFieldNumber = 136, + kEmbedParamFieldNumber = 137, + kTileParamFieldNumber = 138, + kBatchNormParamFieldNumber = 139, + kEluParamFieldNumber = 140, + kBiasParamFieldNumber = 141, + kScaleParamFieldNumber = 142, + kInputParamFieldNumber = 143, + kCropParamFieldNumber = 144, + kParameterParamFieldNumber = 145, + kRecurrentParamFieldNumber = 146, + kDetectionOutputParamFieldNumber = 147, + kPermuteParamFieldNumber = 148, + kNormParamFieldNumber = 149, + kPriorBoxParamFieldNumber = 150, + kProposalParamFieldNumber = 201, + kPsroiPoolingParamFieldNumber = 10002, + kRoiPoolingParamFieldNumber = 8266711, + kPhaseFieldNumber = 10, + }; + // repeated string bottom = 3; + int bottom_size() const; + private: + int _internal_bottom_size() const; + public: + void clear_bottom(); + const std::string& bottom(int index) const; + std::string* mutable_bottom(int index); + void set_bottom(int index, const std::string& value); + void set_bottom(int index, std::string&& value); + 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); + void add_bottom(std::string&& value); + void add_bottom(const char* value); + void add_bottom(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& bottom() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_bottom(); + private: + const std::string& _internal_bottom(int index) const; + std::string* _internal_add_bottom(); + public: + + // repeated string top = 4; + int top_size() const; + private: + int _internal_top_size() const; + public: + void clear_top(); + const std::string& top(int index) const; + std::string* mutable_top(int index); + void set_top(int index, const std::string& value); + void set_top(int index, std::string&& value); + 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); + void add_top(std::string&& value); + void add_top(const char* value); + void add_top(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& top() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_top(); + private: + const std::string& _internal_top(int index) const; + std::string* _internal_add_top(); + public: + + // repeated float loss_weight = 5; + int loss_weight_size() const; + private: + int _internal_loss_weight_size() const; + public: + void clear_loss_weight(); + private: + float _internal_loss_weight(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_loss_weight() const; + void _internal_add_loss_weight(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_loss_weight(); + public: + float loss_weight(int index) const; + void set_loss_weight(int index, float value); + void add_loss_weight(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + loss_weight() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_loss_weight(); + + // repeated .opencv_caffe.ParamSpec param = 6; + int param_size() const; + private: + int _internal_param_size() const; + public: + void clear_param(); + ::opencv_caffe::ParamSpec* mutable_param(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec >* + mutable_param(); + private: + const ::opencv_caffe::ParamSpec& _internal_param(int index) const; + ::opencv_caffe::ParamSpec* _internal_add_param(); + public: + const ::opencv_caffe::ParamSpec& param(int index) const; + ::opencv_caffe::ParamSpec* add_param(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec >& + param() const; + + // repeated .opencv_caffe.BlobProto blobs = 7; + int blobs_size() const; + private: + int _internal_blobs_size() const; + public: + void clear_blobs(); + ::opencv_caffe::BlobProto* mutable_blobs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* + mutable_blobs(); + private: + const ::opencv_caffe::BlobProto& _internal_blobs(int index) const; + ::opencv_caffe::BlobProto* _internal_add_blobs(); + public: + const ::opencv_caffe::BlobProto& blobs(int index) const; + ::opencv_caffe::BlobProto* add_blobs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >& + blobs() const; + + // repeated .opencv_caffe.NetStateRule include = 8; + int include_size() const; + private: + int _internal_include_size() const; + public: + void clear_include(); + ::opencv_caffe::NetStateRule* mutable_include(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >* + mutable_include(); + private: + const ::opencv_caffe::NetStateRule& _internal_include(int index) const; + ::opencv_caffe::NetStateRule* _internal_add_include(); + public: + const ::opencv_caffe::NetStateRule& include(int index) const; + ::opencv_caffe::NetStateRule* add_include(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >& + include() const; + + // repeated .opencv_caffe.NetStateRule exclude = 9; + int exclude_size() const; + private: + int _internal_exclude_size() const; + public: + void clear_exclude(); + ::opencv_caffe::NetStateRule* mutable_exclude(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >* + mutable_exclude(); + private: + const ::opencv_caffe::NetStateRule& _internal_exclude(int index) const; + ::opencv_caffe::NetStateRule* _internal_add_exclude(); + public: + const ::opencv_caffe::NetStateRule& exclude(int index) const; + ::opencv_caffe::NetStateRule* add_exclude(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >& + exclude() const; + + // repeated bool propagate_down = 11; + int propagate_down_size() const; + private: + int _internal_propagate_down_size() const; + public: + void clear_propagate_down(); + private: + bool _internal_propagate_down(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& + _internal_propagate_down() const; + void _internal_add_propagate_down(bool value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* + _internal_mutable_propagate_down(); + public: + bool propagate_down(int index) const; + void set_propagate_down(int index, bool value); + void add_propagate_down(bool value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& + propagate_down() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* + mutable_propagate_down(); + + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string type = 2; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const std::string& type() const; + template + void set_type(ArgT0&& arg0, ArgT... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* type); + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value); + std::string* _internal_mutable_type(); + public: + + // optional .opencv_caffe.TransformationParameter transform_param = 100; + bool has_transform_param() const; + private: + bool _internal_has_transform_param() const; + public: + void clear_transform_param(); + const ::opencv_caffe::TransformationParameter& transform_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::TransformationParameter* release_transform_param(); + ::opencv_caffe::TransformationParameter* mutable_transform_param(); + void set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param); + private: + const ::opencv_caffe::TransformationParameter& _internal_transform_param() const; + ::opencv_caffe::TransformationParameter* _internal_mutable_transform_param(); + public: + void unsafe_arena_set_allocated_transform_param( + ::opencv_caffe::TransformationParameter* transform_param); + ::opencv_caffe::TransformationParameter* unsafe_arena_release_transform_param(); + + // optional .opencv_caffe.LossParameter loss_param = 101; + bool has_loss_param() const; + private: + bool _internal_has_loss_param() const; + public: + void clear_loss_param(); + const ::opencv_caffe::LossParameter& loss_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::LossParameter* release_loss_param(); + ::opencv_caffe::LossParameter* mutable_loss_param(); + void set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param); + private: + const ::opencv_caffe::LossParameter& _internal_loss_param() const; + ::opencv_caffe::LossParameter* _internal_mutable_loss_param(); + public: + void unsafe_arena_set_allocated_loss_param( + ::opencv_caffe::LossParameter* loss_param); + ::opencv_caffe::LossParameter* unsafe_arena_release_loss_param(); + + // optional .opencv_caffe.AccuracyParameter accuracy_param = 102; + bool has_accuracy_param() const; + private: + bool _internal_has_accuracy_param() const; + public: + void clear_accuracy_param(); + const ::opencv_caffe::AccuracyParameter& accuracy_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::AccuracyParameter* release_accuracy_param(); + ::opencv_caffe::AccuracyParameter* mutable_accuracy_param(); + void set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param); + private: + const ::opencv_caffe::AccuracyParameter& _internal_accuracy_param() const; + ::opencv_caffe::AccuracyParameter* _internal_mutable_accuracy_param(); + public: + void unsafe_arena_set_allocated_accuracy_param( + ::opencv_caffe::AccuracyParameter* accuracy_param); + ::opencv_caffe::AccuracyParameter* unsafe_arena_release_accuracy_param(); + + // optional .opencv_caffe.ArgMaxParameter argmax_param = 103; + bool has_argmax_param() const; + private: + bool _internal_has_argmax_param() const; + public: + void clear_argmax_param(); + const ::opencv_caffe::ArgMaxParameter& argmax_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ArgMaxParameter* release_argmax_param(); + ::opencv_caffe::ArgMaxParameter* mutable_argmax_param(); + void set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param); + private: + const ::opencv_caffe::ArgMaxParameter& _internal_argmax_param() const; + ::opencv_caffe::ArgMaxParameter* _internal_mutable_argmax_param(); + public: + void unsafe_arena_set_allocated_argmax_param( + ::opencv_caffe::ArgMaxParameter* argmax_param); + ::opencv_caffe::ArgMaxParameter* unsafe_arena_release_argmax_param(); + + // optional .opencv_caffe.ConcatParameter concat_param = 104; + bool has_concat_param() const; + private: + bool _internal_has_concat_param() const; + public: + void clear_concat_param(); + const ::opencv_caffe::ConcatParameter& concat_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ConcatParameter* release_concat_param(); + ::opencv_caffe::ConcatParameter* mutable_concat_param(); + void set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param); + private: + const ::opencv_caffe::ConcatParameter& _internal_concat_param() const; + ::opencv_caffe::ConcatParameter* _internal_mutable_concat_param(); + public: + void unsafe_arena_set_allocated_concat_param( + ::opencv_caffe::ConcatParameter* concat_param); + ::opencv_caffe::ConcatParameter* unsafe_arena_release_concat_param(); + + // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105; + bool has_contrastive_loss_param() const; + private: + bool _internal_has_contrastive_loss_param() const; + public: + void clear_contrastive_loss_param(); + const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::ContrastiveLossParameter& _internal_contrastive_loss_param() const; + ::opencv_caffe::ContrastiveLossParameter* _internal_mutable_contrastive_loss_param(); + public: + void unsafe_arena_set_allocated_contrastive_loss_param( + ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param); + ::opencv_caffe::ContrastiveLossParameter* unsafe_arena_release_contrastive_loss_param(); + + // optional .opencv_caffe.ConvolutionParameter convolution_param = 106; + bool has_convolution_param() const; + private: + bool _internal_has_convolution_param() const; + public: + void clear_convolution_param(); + const ::opencv_caffe::ConvolutionParameter& convolution_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ConvolutionParameter* release_convolution_param(); + ::opencv_caffe::ConvolutionParameter* mutable_convolution_param(); + void set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param); + private: + const ::opencv_caffe::ConvolutionParameter& _internal_convolution_param() const; + ::opencv_caffe::ConvolutionParameter* _internal_mutable_convolution_param(); + public: + void unsafe_arena_set_allocated_convolution_param( + ::opencv_caffe::ConvolutionParameter* convolution_param); + ::opencv_caffe::ConvolutionParameter* unsafe_arena_release_convolution_param(); + + // optional .opencv_caffe.DataParameter data_param = 107; + bool has_data_param() const; + private: + bool _internal_has_data_param() const; + public: + void clear_data_param(); + const ::opencv_caffe::DataParameter& data_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::DataParameter* release_data_param(); + ::opencv_caffe::DataParameter* mutable_data_param(); + void set_allocated_data_param(::opencv_caffe::DataParameter* data_param); + private: + const ::opencv_caffe::DataParameter& _internal_data_param() const; + ::opencv_caffe::DataParameter* _internal_mutable_data_param(); + public: + void unsafe_arena_set_allocated_data_param( + ::opencv_caffe::DataParameter* data_param); + ::opencv_caffe::DataParameter* unsafe_arena_release_data_param(); + + // optional .opencv_caffe.DropoutParameter dropout_param = 108; + bool has_dropout_param() const; + private: + bool _internal_has_dropout_param() const; + public: + void clear_dropout_param(); + const ::opencv_caffe::DropoutParameter& dropout_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::DropoutParameter* release_dropout_param(); + ::opencv_caffe::DropoutParameter* mutable_dropout_param(); + void set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param); + private: + const ::opencv_caffe::DropoutParameter& _internal_dropout_param() const; + ::opencv_caffe::DropoutParameter* _internal_mutable_dropout_param(); + public: + void unsafe_arena_set_allocated_dropout_param( + ::opencv_caffe::DropoutParameter* dropout_param); + ::opencv_caffe::DropoutParameter* unsafe_arena_release_dropout_param(); + + // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109; + bool has_dummy_data_param() const; + private: + bool _internal_has_dummy_data_param() const; + public: + void clear_dummy_data_param(); + const ::opencv_caffe::DummyDataParameter& dummy_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::DummyDataParameter& _internal_dummy_data_param() const; + ::opencv_caffe::DummyDataParameter* _internal_mutable_dummy_data_param(); + public: + void unsafe_arena_set_allocated_dummy_data_param( + ::opencv_caffe::DummyDataParameter* dummy_data_param); + ::opencv_caffe::DummyDataParameter* unsafe_arena_release_dummy_data_param(); + + // optional .opencv_caffe.EltwiseParameter eltwise_param = 110; + bool has_eltwise_param() const; + private: + bool _internal_has_eltwise_param() const; + public: + void clear_eltwise_param(); + const ::opencv_caffe::EltwiseParameter& eltwise_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::EltwiseParameter* release_eltwise_param(); + ::opencv_caffe::EltwiseParameter* mutable_eltwise_param(); + void set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param); + private: + const ::opencv_caffe::EltwiseParameter& _internal_eltwise_param() const; + ::opencv_caffe::EltwiseParameter* _internal_mutable_eltwise_param(); + public: + void unsafe_arena_set_allocated_eltwise_param( + ::opencv_caffe::EltwiseParameter* eltwise_param); + ::opencv_caffe::EltwiseParameter* unsafe_arena_release_eltwise_param(); + + // optional .opencv_caffe.ExpParameter exp_param = 111; + bool has_exp_param() const; + private: + bool _internal_has_exp_param() const; + public: + void clear_exp_param(); + const ::opencv_caffe::ExpParameter& exp_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ExpParameter* release_exp_param(); + ::opencv_caffe::ExpParameter* mutable_exp_param(); + void set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param); + private: + const ::opencv_caffe::ExpParameter& _internal_exp_param() const; + ::opencv_caffe::ExpParameter* _internal_mutable_exp_param(); + public: + void unsafe_arena_set_allocated_exp_param( + ::opencv_caffe::ExpParameter* exp_param); + ::opencv_caffe::ExpParameter* unsafe_arena_release_exp_param(); + + // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112; + bool has_hdf5_data_param() const; + private: + bool _internal_has_hdf5_data_param() const; + public: + void clear_hdf5_data_param(); + const ::opencv_caffe::HDF5DataParameter& hdf5_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::HDF5DataParameter& _internal_hdf5_data_param() const; + ::opencv_caffe::HDF5DataParameter* _internal_mutable_hdf5_data_param(); + public: + void unsafe_arena_set_allocated_hdf5_data_param( + ::opencv_caffe::HDF5DataParameter* hdf5_data_param); + ::opencv_caffe::HDF5DataParameter* unsafe_arena_release_hdf5_data_param(); + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113; + bool has_hdf5_output_param() const; + private: + bool _internal_has_hdf5_output_param() const; + public: + void clear_hdf5_output_param(); + const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::HDF5OutputParameter& _internal_hdf5_output_param() const; + ::opencv_caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param(); + public: + void unsafe_arena_set_allocated_hdf5_output_param( + ::opencv_caffe::HDF5OutputParameter* hdf5_output_param); + ::opencv_caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param(); + + // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114; + bool has_hinge_loss_param() const; + private: + bool _internal_has_hinge_loss_param() const; + public: + void clear_hinge_loss_param(); + const ::opencv_caffe::HingeLossParameter& hinge_loss_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::HingeLossParameter& _internal_hinge_loss_param() const; + ::opencv_caffe::HingeLossParameter* _internal_mutable_hinge_loss_param(); + public: + void unsafe_arena_set_allocated_hinge_loss_param( + ::opencv_caffe::HingeLossParameter* hinge_loss_param); + ::opencv_caffe::HingeLossParameter* unsafe_arena_release_hinge_loss_param(); + + // optional .opencv_caffe.ImageDataParameter image_data_param = 115; + bool has_image_data_param() const; + private: + bool _internal_has_image_data_param() const; + public: + void clear_image_data_param(); + const ::opencv_caffe::ImageDataParameter& image_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::ImageDataParameter& _internal_image_data_param() const; + ::opencv_caffe::ImageDataParameter* _internal_mutable_image_data_param(); + public: + void unsafe_arena_set_allocated_image_data_param( + ::opencv_caffe::ImageDataParameter* image_data_param); + ::opencv_caffe::ImageDataParameter* unsafe_arena_release_image_data_param(); + + // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116; + bool has_infogain_loss_param() const; + private: + bool _internal_has_infogain_loss_param() const; + public: + void clear_infogain_loss_param(); + const ::opencv_caffe::InfogainLossParameter& infogain_loss_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::InfogainLossParameter& _internal_infogain_loss_param() const; + ::opencv_caffe::InfogainLossParameter* _internal_mutable_infogain_loss_param(); + public: + void unsafe_arena_set_allocated_infogain_loss_param( + ::opencv_caffe::InfogainLossParameter* infogain_loss_param); + ::opencv_caffe::InfogainLossParameter* unsafe_arena_release_infogain_loss_param(); + + // optional .opencv_caffe.InnerProductParameter inner_product_param = 117; + bool has_inner_product_param() const; + private: + bool _internal_has_inner_product_param() const; + public: + void clear_inner_product_param(); + const ::opencv_caffe::InnerProductParameter& inner_product_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::InnerProductParameter& _internal_inner_product_param() const; + ::opencv_caffe::InnerProductParameter* _internal_mutable_inner_product_param(); + public: + void unsafe_arena_set_allocated_inner_product_param( + ::opencv_caffe::InnerProductParameter* inner_product_param); + ::opencv_caffe::InnerProductParameter* unsafe_arena_release_inner_product_param(); + + // optional .opencv_caffe.LRNParameter lrn_param = 118; + bool has_lrn_param() const; + private: + bool _internal_has_lrn_param() const; + public: + void clear_lrn_param(); + const ::opencv_caffe::LRNParameter& lrn_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::LRNParameter* release_lrn_param(); + ::opencv_caffe::LRNParameter* mutable_lrn_param(); + void set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param); + private: + const ::opencv_caffe::LRNParameter& _internal_lrn_param() const; + ::opencv_caffe::LRNParameter* _internal_mutable_lrn_param(); + public: + void unsafe_arena_set_allocated_lrn_param( + ::opencv_caffe::LRNParameter* lrn_param); + ::opencv_caffe::LRNParameter* unsafe_arena_release_lrn_param(); + + // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119; + bool has_memory_data_param() const; + private: + bool _internal_has_memory_data_param() const; + public: + void clear_memory_data_param(); + const ::opencv_caffe::MemoryDataParameter& memory_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::MemoryDataParameter& _internal_memory_data_param() const; + ::opencv_caffe::MemoryDataParameter* _internal_mutable_memory_data_param(); + public: + void unsafe_arena_set_allocated_memory_data_param( + ::opencv_caffe::MemoryDataParameter* memory_data_param); + ::opencv_caffe::MemoryDataParameter* unsafe_arena_release_memory_data_param(); + + // optional .opencv_caffe.MVNParameter mvn_param = 120; + bool has_mvn_param() const; + private: + bool _internal_has_mvn_param() const; + public: + void clear_mvn_param(); + const ::opencv_caffe::MVNParameter& mvn_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::MVNParameter* release_mvn_param(); + ::opencv_caffe::MVNParameter* mutable_mvn_param(); + void set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param); + private: + const ::opencv_caffe::MVNParameter& _internal_mvn_param() const; + ::opencv_caffe::MVNParameter* _internal_mutable_mvn_param(); + public: + void unsafe_arena_set_allocated_mvn_param( + ::opencv_caffe::MVNParameter* mvn_param); + ::opencv_caffe::MVNParameter* unsafe_arena_release_mvn_param(); + + // optional .opencv_caffe.PoolingParameter pooling_param = 121; + bool has_pooling_param() const; + private: + bool _internal_has_pooling_param() const; + public: + void clear_pooling_param(); + const ::opencv_caffe::PoolingParameter& pooling_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::PoolingParameter* release_pooling_param(); + ::opencv_caffe::PoolingParameter* mutable_pooling_param(); + void set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param); + private: + const ::opencv_caffe::PoolingParameter& _internal_pooling_param() const; + ::opencv_caffe::PoolingParameter* _internal_mutable_pooling_param(); + public: + void unsafe_arena_set_allocated_pooling_param( + ::opencv_caffe::PoolingParameter* pooling_param); + ::opencv_caffe::PoolingParameter* unsafe_arena_release_pooling_param(); + + // optional .opencv_caffe.PowerParameter power_param = 122; + bool has_power_param() const; + private: + bool _internal_has_power_param() const; + public: + void clear_power_param(); + const ::opencv_caffe::PowerParameter& power_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::PowerParameter* release_power_param(); + ::opencv_caffe::PowerParameter* mutable_power_param(); + void set_allocated_power_param(::opencv_caffe::PowerParameter* power_param); + private: + const ::opencv_caffe::PowerParameter& _internal_power_param() const; + ::opencv_caffe::PowerParameter* _internal_mutable_power_param(); + public: + void unsafe_arena_set_allocated_power_param( + ::opencv_caffe::PowerParameter* power_param); + ::opencv_caffe::PowerParameter* unsafe_arena_release_power_param(); + + // optional .opencv_caffe.ReLUParameter relu_param = 123; + bool has_relu_param() const; + private: + bool _internal_has_relu_param() const; + public: + void clear_relu_param(); + const ::opencv_caffe::ReLUParameter& relu_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ReLUParameter* release_relu_param(); + ::opencv_caffe::ReLUParameter* mutable_relu_param(); + void set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param); + private: + const ::opencv_caffe::ReLUParameter& _internal_relu_param() const; + ::opencv_caffe::ReLUParameter* _internal_mutable_relu_param(); + public: + void unsafe_arena_set_allocated_relu_param( + ::opencv_caffe::ReLUParameter* relu_param); + ::opencv_caffe::ReLUParameter* unsafe_arena_release_relu_param(); + + // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124; + bool has_sigmoid_param() const; + private: + bool _internal_has_sigmoid_param() const; + public: + void clear_sigmoid_param(); + const ::opencv_caffe::SigmoidParameter& sigmoid_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::SigmoidParameter* release_sigmoid_param(); + ::opencv_caffe::SigmoidParameter* mutable_sigmoid_param(); + void set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param); + private: + const ::opencv_caffe::SigmoidParameter& _internal_sigmoid_param() const; + ::opencv_caffe::SigmoidParameter* _internal_mutable_sigmoid_param(); + public: + void unsafe_arena_set_allocated_sigmoid_param( + ::opencv_caffe::SigmoidParameter* sigmoid_param); + ::opencv_caffe::SigmoidParameter* unsafe_arena_release_sigmoid_param(); + + // optional .opencv_caffe.SoftmaxParameter softmax_param = 125; + bool has_softmax_param() const; + private: + bool _internal_has_softmax_param() const; + public: + void clear_softmax_param(); + const ::opencv_caffe::SoftmaxParameter& softmax_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::SoftmaxParameter* release_softmax_param(); + ::opencv_caffe::SoftmaxParameter* mutable_softmax_param(); + void set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param); + private: + const ::opencv_caffe::SoftmaxParameter& _internal_softmax_param() const; + ::opencv_caffe::SoftmaxParameter* _internal_mutable_softmax_param(); + public: + void unsafe_arena_set_allocated_softmax_param( + ::opencv_caffe::SoftmaxParameter* softmax_param); + ::opencv_caffe::SoftmaxParameter* unsafe_arena_release_softmax_param(); + + // optional .opencv_caffe.SliceParameter slice_param = 126; + bool has_slice_param() const; + private: + bool _internal_has_slice_param() const; + public: + void clear_slice_param(); + const ::opencv_caffe::SliceParameter& slice_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::SliceParameter* release_slice_param(); + ::opencv_caffe::SliceParameter* mutable_slice_param(); + void set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param); + private: + const ::opencv_caffe::SliceParameter& _internal_slice_param() const; + ::opencv_caffe::SliceParameter* _internal_mutable_slice_param(); + public: + void unsafe_arena_set_allocated_slice_param( + ::opencv_caffe::SliceParameter* slice_param); + ::opencv_caffe::SliceParameter* unsafe_arena_release_slice_param(); + + // optional .opencv_caffe.TanHParameter tanh_param = 127; + bool has_tanh_param() const; + private: + bool _internal_has_tanh_param() const; + public: + void clear_tanh_param(); + const ::opencv_caffe::TanHParameter& tanh_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::TanHParameter* release_tanh_param(); + ::opencv_caffe::TanHParameter* mutable_tanh_param(); + void set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param); + private: + const ::opencv_caffe::TanHParameter& _internal_tanh_param() const; + ::opencv_caffe::TanHParameter* _internal_mutable_tanh_param(); + public: + void unsafe_arena_set_allocated_tanh_param( + ::opencv_caffe::TanHParameter* tanh_param); + ::opencv_caffe::TanHParameter* unsafe_arena_release_tanh_param(); + + // optional .opencv_caffe.ThresholdParameter threshold_param = 128; + bool has_threshold_param() const; + private: + bool _internal_has_threshold_param() const; + public: + void clear_threshold_param(); + const ::opencv_caffe::ThresholdParameter& threshold_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ThresholdParameter* release_threshold_param(); + ::opencv_caffe::ThresholdParameter* mutable_threshold_param(); + void set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param); + private: + const ::opencv_caffe::ThresholdParameter& _internal_threshold_param() const; + ::opencv_caffe::ThresholdParameter* _internal_mutable_threshold_param(); + public: + void unsafe_arena_set_allocated_threshold_param( + ::opencv_caffe::ThresholdParameter* threshold_param); + ::opencv_caffe::ThresholdParameter* unsafe_arena_release_threshold_param(); + + // optional .opencv_caffe.WindowDataParameter window_data_param = 129; + bool has_window_data_param() const; + private: + bool _internal_has_window_data_param() const; + public: + void clear_window_data_param(); + const ::opencv_caffe::WindowDataParameter& window_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::WindowDataParameter& _internal_window_data_param() const; + ::opencv_caffe::WindowDataParameter* _internal_mutable_window_data_param(); + public: + void unsafe_arena_set_allocated_window_data_param( + ::opencv_caffe::WindowDataParameter* window_data_param); + ::opencv_caffe::WindowDataParameter* unsafe_arena_release_window_data_param(); + + // optional .opencv_caffe.PythonParameter python_param = 130; + bool has_python_param() const; + private: + bool _internal_has_python_param() const; + public: + void clear_python_param(); + const ::opencv_caffe::PythonParameter& python_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::PythonParameter* release_python_param(); + ::opencv_caffe::PythonParameter* mutable_python_param(); + void set_allocated_python_param(::opencv_caffe::PythonParameter* python_param); + private: + const ::opencv_caffe::PythonParameter& _internal_python_param() const; + ::opencv_caffe::PythonParameter* _internal_mutable_python_param(); + public: + void unsafe_arena_set_allocated_python_param( + ::opencv_caffe::PythonParameter* python_param); + ::opencv_caffe::PythonParameter* unsafe_arena_release_python_param(); + + // optional .opencv_caffe.PReLUParameter prelu_param = 131; + bool has_prelu_param() const; + private: + bool _internal_has_prelu_param() const; + public: + void clear_prelu_param(); + const ::opencv_caffe::PReLUParameter& prelu_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::PReLUParameter* release_prelu_param(); + ::opencv_caffe::PReLUParameter* mutable_prelu_param(); + void set_allocated_prelu_param(::opencv_caffe::PReLUParameter* prelu_param); + private: + const ::opencv_caffe::PReLUParameter& _internal_prelu_param() const; + ::opencv_caffe::PReLUParameter* _internal_mutable_prelu_param(); + public: + void unsafe_arena_set_allocated_prelu_param( + ::opencv_caffe::PReLUParameter* prelu_param); + ::opencv_caffe::PReLUParameter* unsafe_arena_release_prelu_param(); + + // optional .opencv_caffe.SPPParameter spp_param = 132; + bool has_spp_param() const; + private: + bool _internal_has_spp_param() const; + public: + void clear_spp_param(); + const ::opencv_caffe::SPPParameter& spp_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::SPPParameter* release_spp_param(); + ::opencv_caffe::SPPParameter* mutable_spp_param(); + void set_allocated_spp_param(::opencv_caffe::SPPParameter* spp_param); + private: + const ::opencv_caffe::SPPParameter& _internal_spp_param() const; + ::opencv_caffe::SPPParameter* _internal_mutable_spp_param(); + public: + void unsafe_arena_set_allocated_spp_param( + ::opencv_caffe::SPPParameter* spp_param); + ::opencv_caffe::SPPParameter* unsafe_arena_release_spp_param(); + + // optional .opencv_caffe.ReshapeParameter reshape_param = 133; + bool has_reshape_param() const; + private: + bool _internal_has_reshape_param() const; + public: + void clear_reshape_param(); + const ::opencv_caffe::ReshapeParameter& reshape_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ReshapeParameter* release_reshape_param(); + ::opencv_caffe::ReshapeParameter* mutable_reshape_param(); + void set_allocated_reshape_param(::opencv_caffe::ReshapeParameter* reshape_param); + private: + const ::opencv_caffe::ReshapeParameter& _internal_reshape_param() const; + ::opencv_caffe::ReshapeParameter* _internal_mutable_reshape_param(); + public: + void unsafe_arena_set_allocated_reshape_param( + ::opencv_caffe::ReshapeParameter* reshape_param); + ::opencv_caffe::ReshapeParameter* unsafe_arena_release_reshape_param(); + + // optional .opencv_caffe.LogParameter log_param = 134; + bool has_log_param() const; + private: + bool _internal_has_log_param() const; + public: + void clear_log_param(); + const ::opencv_caffe::LogParameter& log_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::LogParameter* release_log_param(); + ::opencv_caffe::LogParameter* mutable_log_param(); + void set_allocated_log_param(::opencv_caffe::LogParameter* log_param); + private: + const ::opencv_caffe::LogParameter& _internal_log_param() const; + ::opencv_caffe::LogParameter* _internal_mutable_log_param(); + public: + void unsafe_arena_set_allocated_log_param( + ::opencv_caffe::LogParameter* log_param); + ::opencv_caffe::LogParameter* unsafe_arena_release_log_param(); + + // optional .opencv_caffe.FlattenParameter flatten_param = 135; + bool has_flatten_param() const; + private: + bool _internal_has_flatten_param() const; + public: + void clear_flatten_param(); + const ::opencv_caffe::FlattenParameter& flatten_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::FlattenParameter* release_flatten_param(); + ::opencv_caffe::FlattenParameter* mutable_flatten_param(); + void set_allocated_flatten_param(::opencv_caffe::FlattenParameter* flatten_param); + private: + const ::opencv_caffe::FlattenParameter& _internal_flatten_param() const; + ::opencv_caffe::FlattenParameter* _internal_mutable_flatten_param(); + public: + void unsafe_arena_set_allocated_flatten_param( + ::opencv_caffe::FlattenParameter* flatten_param); + ::opencv_caffe::FlattenParameter* unsafe_arena_release_flatten_param(); + + // optional .opencv_caffe.ReductionParameter reduction_param = 136; + bool has_reduction_param() const; + private: + bool _internal_has_reduction_param() const; + public: + void clear_reduction_param(); + const ::opencv_caffe::ReductionParameter& reduction_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ReductionParameter* release_reduction_param(); + ::opencv_caffe::ReductionParameter* mutable_reduction_param(); + void set_allocated_reduction_param(::opencv_caffe::ReductionParameter* reduction_param); + private: + const ::opencv_caffe::ReductionParameter& _internal_reduction_param() const; + ::opencv_caffe::ReductionParameter* _internal_mutable_reduction_param(); + public: + void unsafe_arena_set_allocated_reduction_param( + ::opencv_caffe::ReductionParameter* reduction_param); + ::opencv_caffe::ReductionParameter* unsafe_arena_release_reduction_param(); + + // optional .opencv_caffe.EmbedParameter embed_param = 137; + bool has_embed_param() const; + private: + bool _internal_has_embed_param() const; + public: + void clear_embed_param(); + const ::opencv_caffe::EmbedParameter& embed_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::EmbedParameter* release_embed_param(); + ::opencv_caffe::EmbedParameter* mutable_embed_param(); + void set_allocated_embed_param(::opencv_caffe::EmbedParameter* embed_param); + private: + const ::opencv_caffe::EmbedParameter& _internal_embed_param() const; + ::opencv_caffe::EmbedParameter* _internal_mutable_embed_param(); + public: + void unsafe_arena_set_allocated_embed_param( + ::opencv_caffe::EmbedParameter* embed_param); + ::opencv_caffe::EmbedParameter* unsafe_arena_release_embed_param(); + + // optional .opencv_caffe.TileParameter tile_param = 138; + bool has_tile_param() const; + private: + bool _internal_has_tile_param() const; + public: + void clear_tile_param(); + const ::opencv_caffe::TileParameter& tile_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::TileParameter* release_tile_param(); + ::opencv_caffe::TileParameter* mutable_tile_param(); + void set_allocated_tile_param(::opencv_caffe::TileParameter* tile_param); + private: + const ::opencv_caffe::TileParameter& _internal_tile_param() const; + ::opencv_caffe::TileParameter* _internal_mutable_tile_param(); + public: + void unsafe_arena_set_allocated_tile_param( + ::opencv_caffe::TileParameter* tile_param); + ::opencv_caffe::TileParameter* unsafe_arena_release_tile_param(); + + // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139; + bool has_batch_norm_param() const; + private: + bool _internal_has_batch_norm_param() const; + public: + void clear_batch_norm_param(); + const ::opencv_caffe::BatchNormParameter& batch_norm_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::BatchNormParameter& _internal_batch_norm_param() const; + ::opencv_caffe::BatchNormParameter* _internal_mutable_batch_norm_param(); + public: + void unsafe_arena_set_allocated_batch_norm_param( + ::opencv_caffe::BatchNormParameter* batch_norm_param); + ::opencv_caffe::BatchNormParameter* unsafe_arena_release_batch_norm_param(); + + // optional .opencv_caffe.ELUParameter elu_param = 140; + bool has_elu_param() const; + private: + bool _internal_has_elu_param() const; + public: + void clear_elu_param(); + const ::opencv_caffe::ELUParameter& elu_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ELUParameter* release_elu_param(); + ::opencv_caffe::ELUParameter* mutable_elu_param(); + void set_allocated_elu_param(::opencv_caffe::ELUParameter* elu_param); + private: + const ::opencv_caffe::ELUParameter& _internal_elu_param() const; + ::opencv_caffe::ELUParameter* _internal_mutable_elu_param(); + public: + void unsafe_arena_set_allocated_elu_param( + ::opencv_caffe::ELUParameter* elu_param); + ::opencv_caffe::ELUParameter* unsafe_arena_release_elu_param(); + + // optional .opencv_caffe.BiasParameter bias_param = 141; + bool has_bias_param() const; + private: + bool _internal_has_bias_param() const; + public: + void clear_bias_param(); + const ::opencv_caffe::BiasParameter& bias_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::BiasParameter* release_bias_param(); + ::opencv_caffe::BiasParameter* mutable_bias_param(); + void set_allocated_bias_param(::opencv_caffe::BiasParameter* bias_param); + private: + const ::opencv_caffe::BiasParameter& _internal_bias_param() const; + ::opencv_caffe::BiasParameter* _internal_mutable_bias_param(); + public: + void unsafe_arena_set_allocated_bias_param( + ::opencv_caffe::BiasParameter* bias_param); + ::opencv_caffe::BiasParameter* unsafe_arena_release_bias_param(); + + // optional .opencv_caffe.ScaleParameter scale_param = 142; + bool has_scale_param() const; + private: + bool _internal_has_scale_param() const; + public: + void clear_scale_param(); + const ::opencv_caffe::ScaleParameter& scale_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ScaleParameter* release_scale_param(); + ::opencv_caffe::ScaleParameter* mutable_scale_param(); + void set_allocated_scale_param(::opencv_caffe::ScaleParameter* scale_param); + private: + const ::opencv_caffe::ScaleParameter& _internal_scale_param() const; + ::opencv_caffe::ScaleParameter* _internal_mutable_scale_param(); + public: + void unsafe_arena_set_allocated_scale_param( + ::opencv_caffe::ScaleParameter* scale_param); + ::opencv_caffe::ScaleParameter* unsafe_arena_release_scale_param(); + + // optional .opencv_caffe.InputParameter input_param = 143; + bool has_input_param() const; + private: + bool _internal_has_input_param() const; + public: + void clear_input_param(); + const ::opencv_caffe::InputParameter& input_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::InputParameter* release_input_param(); + ::opencv_caffe::InputParameter* mutable_input_param(); + void set_allocated_input_param(::opencv_caffe::InputParameter* input_param); + private: + const ::opencv_caffe::InputParameter& _internal_input_param() const; + ::opencv_caffe::InputParameter* _internal_mutable_input_param(); + public: + void unsafe_arena_set_allocated_input_param( + ::opencv_caffe::InputParameter* input_param); + ::opencv_caffe::InputParameter* unsafe_arena_release_input_param(); + + // optional .opencv_caffe.CropParameter crop_param = 144; + bool has_crop_param() const; + private: + bool _internal_has_crop_param() const; + public: + void clear_crop_param(); + const ::opencv_caffe::CropParameter& crop_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::CropParameter* release_crop_param(); + ::opencv_caffe::CropParameter* mutable_crop_param(); + void set_allocated_crop_param(::opencv_caffe::CropParameter* crop_param); + private: + const ::opencv_caffe::CropParameter& _internal_crop_param() const; + ::opencv_caffe::CropParameter* _internal_mutable_crop_param(); + public: + void unsafe_arena_set_allocated_crop_param( + ::opencv_caffe::CropParameter* crop_param); + ::opencv_caffe::CropParameter* unsafe_arena_release_crop_param(); + + // optional .opencv_caffe.ParameterParameter parameter_param = 145; + bool has_parameter_param() const; + private: + bool _internal_has_parameter_param() const; + public: + void clear_parameter_param(); + const ::opencv_caffe::ParameterParameter& parameter_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ParameterParameter* release_parameter_param(); + ::opencv_caffe::ParameterParameter* mutable_parameter_param(); + void set_allocated_parameter_param(::opencv_caffe::ParameterParameter* parameter_param); + private: + const ::opencv_caffe::ParameterParameter& _internal_parameter_param() const; + ::opencv_caffe::ParameterParameter* _internal_mutable_parameter_param(); + public: + void unsafe_arena_set_allocated_parameter_param( + ::opencv_caffe::ParameterParameter* parameter_param); + ::opencv_caffe::ParameterParameter* unsafe_arena_release_parameter_param(); + + // optional .opencv_caffe.RecurrentParameter recurrent_param = 146; + bool has_recurrent_param() const; + private: + bool _internal_has_recurrent_param() const; + public: + void clear_recurrent_param(); + const ::opencv_caffe::RecurrentParameter& recurrent_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::RecurrentParameter* release_recurrent_param(); + ::opencv_caffe::RecurrentParameter* mutable_recurrent_param(); + void set_allocated_recurrent_param(::opencv_caffe::RecurrentParameter* recurrent_param); + private: + const ::opencv_caffe::RecurrentParameter& _internal_recurrent_param() const; + ::opencv_caffe::RecurrentParameter* _internal_mutable_recurrent_param(); + public: + void unsafe_arena_set_allocated_recurrent_param( + ::opencv_caffe::RecurrentParameter* recurrent_param); + ::opencv_caffe::RecurrentParameter* unsafe_arena_release_recurrent_param(); + + // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147; + bool has_detection_output_param() const; + private: + bool _internal_has_detection_output_param() const; + public: + void clear_detection_output_param(); + const ::opencv_caffe::DetectionOutputParameter& detection_output_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::DetectionOutputParameter& _internal_detection_output_param() const; + ::opencv_caffe::DetectionOutputParameter* _internal_mutable_detection_output_param(); + public: + void unsafe_arena_set_allocated_detection_output_param( + ::opencv_caffe::DetectionOutputParameter* detection_output_param); + ::opencv_caffe::DetectionOutputParameter* unsafe_arena_release_detection_output_param(); + + // optional .opencv_caffe.PermuteParameter permute_param = 148; + bool has_permute_param() const; + private: + bool _internal_has_permute_param() const; + public: + void clear_permute_param(); + const ::opencv_caffe::PermuteParameter& permute_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::PermuteParameter* release_permute_param(); + ::opencv_caffe::PermuteParameter* mutable_permute_param(); + void set_allocated_permute_param(::opencv_caffe::PermuteParameter* permute_param); + private: + const ::opencv_caffe::PermuteParameter& _internal_permute_param() const; + ::opencv_caffe::PermuteParameter* _internal_mutable_permute_param(); + public: + void unsafe_arena_set_allocated_permute_param( + ::opencv_caffe::PermuteParameter* permute_param); + ::opencv_caffe::PermuteParameter* unsafe_arena_release_permute_param(); + + // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149; + bool has_norm_param() const; + private: + bool _internal_has_norm_param() const; + public: + void clear_norm_param(); + const ::opencv_caffe::NormalizeBBoxParameter& norm_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::NormalizeBBoxParameter* release_norm_param(); + ::opencv_caffe::NormalizeBBoxParameter* mutable_norm_param(); + void set_allocated_norm_param(::opencv_caffe::NormalizeBBoxParameter* norm_param); + private: + const ::opencv_caffe::NormalizeBBoxParameter& _internal_norm_param() const; + ::opencv_caffe::NormalizeBBoxParameter* _internal_mutable_norm_param(); + public: + void unsafe_arena_set_allocated_norm_param( + ::opencv_caffe::NormalizeBBoxParameter* norm_param); + ::opencv_caffe::NormalizeBBoxParameter* unsafe_arena_release_norm_param(); + + // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150; + bool has_prior_box_param() const; + private: + bool _internal_has_prior_box_param() const; + public: + void clear_prior_box_param(); + const ::opencv_caffe::PriorBoxParameter& prior_box_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::PriorBoxParameter& _internal_prior_box_param() const; + ::opencv_caffe::PriorBoxParameter* _internal_mutable_prior_box_param(); + public: + void unsafe_arena_set_allocated_prior_box_param( + ::opencv_caffe::PriorBoxParameter* prior_box_param); + ::opencv_caffe::PriorBoxParameter* unsafe_arena_release_prior_box_param(); + + // optional .opencv_caffe.ProposalParameter proposal_param = 201; + bool has_proposal_param() const; + private: + bool _internal_has_proposal_param() const; + public: + void clear_proposal_param(); + const ::opencv_caffe::ProposalParameter& proposal_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ProposalParameter* release_proposal_param(); + ::opencv_caffe::ProposalParameter* mutable_proposal_param(); + void set_allocated_proposal_param(::opencv_caffe::ProposalParameter* proposal_param); + private: + const ::opencv_caffe::ProposalParameter& _internal_proposal_param() const; + ::opencv_caffe::ProposalParameter* _internal_mutable_proposal_param(); + public: + void unsafe_arena_set_allocated_proposal_param( + ::opencv_caffe::ProposalParameter* proposal_param); + ::opencv_caffe::ProposalParameter* unsafe_arena_release_proposal_param(); + + // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002; + bool has_psroi_pooling_param() const; + private: + bool _internal_has_psroi_pooling_param() const; + public: + void clear_psroi_pooling_param(); + const ::opencv_caffe::PSROIPoolingParameter& psroi_pooling_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::PSROIPoolingParameter& _internal_psroi_pooling_param() const; + ::opencv_caffe::PSROIPoolingParameter* _internal_mutable_psroi_pooling_param(); + public: + void unsafe_arena_set_allocated_psroi_pooling_param( + ::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param); + ::opencv_caffe::PSROIPoolingParameter* unsafe_arena_release_psroi_pooling_param(); + + // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711; + bool has_roi_pooling_param() const; + private: + bool _internal_has_roi_pooling_param() const; + public: + void clear_roi_pooling_param(); + const ::opencv_caffe::ROIPoolingParameter& roi_pooling_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::ROIPoolingParameter& _internal_roi_pooling_param() const; + ::opencv_caffe::ROIPoolingParameter* _internal_mutable_roi_pooling_param(); + public: + void unsafe_arena_set_allocated_roi_pooling_param( + ::opencv_caffe::ROIPoolingParameter* roi_pooling_param); + ::opencv_caffe::ROIPoolingParameter* unsafe_arena_release_roi_pooling_param(); + + // optional .opencv_caffe.Phase phase = 10; + bool has_phase() const; + private: + bool _internal_has_phase() const; + public: + void clear_phase(); + ::opencv_caffe::Phase phase() const; + void set_phase(::opencv_caffe::Phase value); + private: + ::opencv_caffe::Phase _internal_phase() const; + void _internal_set_phase(::opencv_caffe::Phase value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.LayerParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField bottom_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField top_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > loss_weight_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec > param_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule > include_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule > exclude_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > propagate_down_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::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_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class TransformationParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TransformationParameter) */ { + public: + inline TransformationParameter() : TransformationParameter(nullptr) {} + ~TransformationParameter() override; + explicit constexpr TransformationParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TransformationParameter(const TransformationParameter& from); + TransformationParameter(TransformationParameter&& from) noexcept + : TransformationParameter() { + *this = ::std::move(from); + } + + inline TransformationParameter& operator=(const TransformationParameter& from) { + CopyFrom(from); + return *this; + } + inline TransformationParameter& operator=(TransformationParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const TransformationParameter& default_instance() { + return *internal_default_instance(); + } + static inline const TransformationParameter* internal_default_instance() { + return reinterpret_cast( + &_TransformationParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(TransformationParameter& a, TransformationParameter& b) { + a.Swap(&b); + } + inline void Swap(TransformationParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TransformationParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TransformationParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const TransformationParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const TransformationParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TransformationParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.TransformationParameter"; + } + protected: + explicit TransformationParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMeanValueFieldNumber = 5, + kMeanFileFieldNumber = 4, + kCropSizeFieldNumber = 3, + kMirrorFieldNumber = 2, + kForceColorFieldNumber = 6, + kForceGrayFieldNumber = 7, + kScaleFieldNumber = 1, + }; + // repeated float mean_value = 5; + int mean_value_size() const; + private: + int _internal_mean_value_size() const; + public: + void clear_mean_value(); + private: + float _internal_mean_value(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_mean_value() const; + void _internal_add_mean_value(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_mean_value(); + public: + float mean_value(int index) const; + void set_mean_value(int index, float value); + void add_mean_value(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + mean_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_mean_value(); + + // optional string mean_file = 4; + bool has_mean_file() const; + private: + bool _internal_has_mean_file() const; + public: + void clear_mean_file(); + const std::string& mean_file() const; + template + void set_mean_file(ArgT0&& arg0, ArgT... args); + std::string* mutable_mean_file(); + PROTOBUF_NODISCARD std::string* release_mean_file(); + void set_allocated_mean_file(std::string* mean_file); + private: + const std::string& _internal_mean_file() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value); + std::string* _internal_mutable_mean_file(); + public: + + // optional uint32 crop_size = 3 [default = 0]; + bool has_crop_size() const; + private: + bool _internal_has_crop_size() const; + public: + void clear_crop_size(); + uint32_t crop_size() const; + void set_crop_size(uint32_t value); + private: + uint32_t _internal_crop_size() const; + void _internal_set_crop_size(uint32_t value); + public: + + // optional bool mirror = 2 [default = false]; + bool has_mirror() const; + private: + bool _internal_has_mirror() const; + public: + void clear_mirror(); + bool mirror() const; + void set_mirror(bool value); + private: + bool _internal_mirror() const; + void _internal_set_mirror(bool value); + public: + + // optional bool force_color = 6 [default = false]; + bool has_force_color() const; + private: + bool _internal_has_force_color() const; + public: + void clear_force_color(); + bool force_color() const; + void set_force_color(bool value); + private: + bool _internal_force_color() const; + void _internal_set_force_color(bool value); + public: + + // optional bool force_gray = 7 [default = false]; + bool has_force_gray() const; + private: + bool _internal_has_force_gray() const; + public: + void clear_force_gray(); + bool force_gray() const; + void set_force_gray(bool value); + private: + bool _internal_force_gray() const; + void _internal_set_force_gray(bool value); + public: + + // optional float scale = 1 [default = 1]; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.TransformationParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > mean_value_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_; + uint32_t crop_size_; + bool mirror_; + bool force_color_; + bool force_gray_; + float scale_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class LossParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LossParameter) */ { + public: + inline LossParameter() : LossParameter(nullptr) {} + ~LossParameter() override; + explicit constexpr LossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LossParameter(const LossParameter& from); + LossParameter(LossParameter&& from) noexcept + : LossParameter() { + *this = ::std::move(from); + } + + inline LossParameter& operator=(const LossParameter& from) { + CopyFrom(from); + return *this; + } + inline LossParameter& operator=(LossParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LossParameter& default_instance() { + return *internal_default_instance(); + } + static inline const LossParameter* internal_default_instance() { + return reinterpret_cast( + &_LossParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(LossParameter& a, LossParameter& b) { + a.Swap(&b); + } + inline void Swap(LossParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LossParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LossParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const LossParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LossParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.LossParameter"; + } + protected: + explicit LossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef LossParameter_NormalizationMode NormalizationMode; + static constexpr NormalizationMode FULL = + LossParameter_NormalizationMode_FULL; + static constexpr NormalizationMode VALID = + LossParameter_NormalizationMode_VALID; + static constexpr NormalizationMode BATCH_SIZE = + LossParameter_NormalizationMode_BATCH_SIZE; + static constexpr NormalizationMode NONE = + LossParameter_NormalizationMode_NONE; + static inline bool NormalizationMode_IsValid(int value) { + return LossParameter_NormalizationMode_IsValid(value); + } + static constexpr NormalizationMode NormalizationMode_MIN = + LossParameter_NormalizationMode_NormalizationMode_MIN; + static constexpr NormalizationMode NormalizationMode_MAX = + LossParameter_NormalizationMode_NormalizationMode_MAX; + static constexpr int NormalizationMode_ARRAYSIZE = + LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + NormalizationMode_descriptor() { + return LossParameter_NormalizationMode_descriptor(); + } + template + static inline const std::string& NormalizationMode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function NormalizationMode_Name."); + return LossParameter_NormalizationMode_Name(enum_t_value); + } + static inline bool NormalizationMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + NormalizationMode* value) { + return LossParameter_NormalizationMode_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kIgnoreLabelFieldNumber = 1, + kNormalizeFieldNumber = 2, + kNormalizationFieldNumber = 3, + }; + // optional int32 ignore_label = 1; + bool has_ignore_label() const; + private: + bool _internal_has_ignore_label() const; + public: + void clear_ignore_label(); + int32_t ignore_label() const; + void set_ignore_label(int32_t value); + private: + int32_t _internal_ignore_label() const; + void _internal_set_ignore_label(int32_t value); + public: + + // optional bool normalize = 2; + bool has_normalize() const; + private: + bool _internal_has_normalize() const; + public: + void clear_normalize(); + bool normalize() const; + void set_normalize(bool value); + private: + bool _internal_normalize() const; + void _internal_set_normalize(bool value); + public: + + // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + bool has_normalization() const; + private: + bool _internal_has_normalization() const; + public: + void clear_normalization(); + ::opencv_caffe::LossParameter_NormalizationMode normalization() const; + void set_normalization(::opencv_caffe::LossParameter_NormalizationMode value); + private: + ::opencv_caffe::LossParameter_NormalizationMode _internal_normalization() const; + void _internal_set_normalization(::opencv_caffe::LossParameter_NormalizationMode value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.LossParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int32_t ignore_label_; + bool normalize_; + int normalization_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class AccuracyParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.AccuracyParameter) */ { + public: + inline AccuracyParameter() : AccuracyParameter(nullptr) {} + ~AccuracyParameter() override; + explicit constexpr AccuracyParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AccuracyParameter(const AccuracyParameter& from); + AccuracyParameter(AccuracyParameter&& from) noexcept + : AccuracyParameter() { + *this = ::std::move(from); + } + + inline AccuracyParameter& operator=(const AccuracyParameter& from) { + CopyFrom(from); + return *this; + } + inline AccuracyParameter& operator=(AccuracyParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const AccuracyParameter& default_instance() { + return *internal_default_instance(); + } + static inline const AccuracyParameter* internal_default_instance() { + return reinterpret_cast( + &_AccuracyParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(AccuracyParameter& a, AccuracyParameter& b) { + a.Swap(&b); + } + inline void Swap(AccuracyParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AccuracyParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AccuracyParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const AccuracyParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const AccuracyParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(AccuracyParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.AccuracyParameter"; + } + protected: + explicit AccuracyParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIgnoreLabelFieldNumber = 3, + kTopKFieldNumber = 1, + kAxisFieldNumber = 2, + }; + // optional int32 ignore_label = 3; + bool has_ignore_label() const; + private: + bool _internal_has_ignore_label() const; + public: + void clear_ignore_label(); + int32_t ignore_label() const; + void set_ignore_label(int32_t value); + private: + int32_t _internal_ignore_label() const; + void _internal_set_ignore_label(int32_t value); + public: + + // optional uint32 top_k = 1 [default = 1]; + bool has_top_k() const; + private: + bool _internal_has_top_k() const; + public: + void clear_top_k(); + uint32_t top_k() const; + void set_top_k(uint32_t value); + private: + uint32_t _internal_top_k() const; + void _internal_set_top_k(uint32_t value); + public: + + // optional int32 axis = 2 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.AccuracyParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int32_t ignore_label_; + uint32_t top_k_; + int32_t axis_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ArgMaxParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ArgMaxParameter) */ { + public: + inline ArgMaxParameter() : ArgMaxParameter(nullptr) {} + ~ArgMaxParameter() override; + explicit constexpr ArgMaxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ArgMaxParameter(const ArgMaxParameter& from); + ArgMaxParameter(ArgMaxParameter&& from) noexcept + : ArgMaxParameter() { + *this = ::std::move(from); + } + + inline ArgMaxParameter& operator=(const ArgMaxParameter& from) { + CopyFrom(from); + return *this; + } + inline ArgMaxParameter& operator=(ArgMaxParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ArgMaxParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ArgMaxParameter* internal_default_instance() { + return reinterpret_cast( + &_ArgMaxParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(ArgMaxParameter& a, ArgMaxParameter& b) { + a.Swap(&b); + } + inline void Swap(ArgMaxParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ArgMaxParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ArgMaxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ArgMaxParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ArgMaxParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ArgMaxParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ArgMaxParameter"; + } + protected: + explicit ArgMaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOutMaxValFieldNumber = 1, + kAxisFieldNumber = 3, + kTopKFieldNumber = 2, + }; + // optional bool out_max_val = 1 [default = false]; + bool has_out_max_val() const; + private: + bool _internal_has_out_max_val() const; + public: + void clear_out_max_val(); + bool out_max_val() const; + void set_out_max_val(bool value); + private: + bool _internal_out_max_val() const; + void _internal_set_out_max_val(bool value); + public: + + // optional int32 axis = 3; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // optional uint32 top_k = 2 [default = 1]; + bool has_top_k() const; + private: + bool _internal_has_top_k() const; + public: + void clear_top_k(); + uint32_t top_k() const; + void set_top_k(uint32_t value); + private: + uint32_t _internal_top_k() const; + void _internal_set_top_k(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ArgMaxParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool out_max_val_; + int32_t axis_; + uint32_t top_k_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ConcatParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ConcatParameter) */ { + public: + inline ConcatParameter() : ConcatParameter(nullptr) {} + ~ConcatParameter() override; + explicit constexpr ConcatParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ConcatParameter(const ConcatParameter& from); + ConcatParameter(ConcatParameter&& from) noexcept + : ConcatParameter() { + *this = ::std::move(from); + } + + inline ConcatParameter& operator=(const ConcatParameter& from) { + CopyFrom(from); + return *this; + } + inline ConcatParameter& operator=(ConcatParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ConcatParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ConcatParameter* internal_default_instance() { + return reinterpret_cast( + &_ConcatParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(ConcatParameter& a, ConcatParameter& b) { + a.Swap(&b); + } + inline void Swap(ConcatParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ConcatParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConcatParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ConcatParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ConcatParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ConcatParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ConcatParameter"; + } + protected: + explicit ConcatParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kConcatDimFieldNumber = 1, + kAxisFieldNumber = 2, + }; + // optional uint32 concat_dim = 1 [default = 1]; + bool has_concat_dim() const; + private: + bool _internal_has_concat_dim() const; + public: + void clear_concat_dim(); + uint32_t concat_dim() const; + void set_concat_dim(uint32_t value); + private: + uint32_t _internal_concat_dim() const; + void _internal_set_concat_dim(uint32_t value); + public: + + // optional int32 axis = 2 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ConcatParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t concat_dim_; + int32_t axis_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class BatchNormParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BatchNormParameter) */ { + public: + inline BatchNormParameter() : BatchNormParameter(nullptr) {} + ~BatchNormParameter() override; + explicit constexpr BatchNormParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BatchNormParameter(const BatchNormParameter& from); + BatchNormParameter(BatchNormParameter&& from) noexcept + : BatchNormParameter() { + *this = ::std::move(from); + } + + inline BatchNormParameter& operator=(const BatchNormParameter& from) { + CopyFrom(from); + return *this; + } + inline BatchNormParameter& operator=(BatchNormParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BatchNormParameter& default_instance() { + return *internal_default_instance(); + } + static inline const BatchNormParameter* internal_default_instance() { + return reinterpret_cast( + &_BatchNormParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(BatchNormParameter& a, BatchNormParameter& b) { + a.Swap(&b); + } + inline void Swap(BatchNormParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BatchNormParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BatchNormParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BatchNormParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const BatchNormParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BatchNormParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.BatchNormParameter"; + } + protected: + explicit BatchNormParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUseGlobalStatsFieldNumber = 1, + kScaleBiasFieldNumber = 7, + kMovingAverageFractionFieldNumber = 2, + kEpsFieldNumber = 3, + }; + // optional bool use_global_stats = 1; + bool has_use_global_stats() const; + private: + bool _internal_has_use_global_stats() const; + public: + void clear_use_global_stats(); + bool use_global_stats() const; + void set_use_global_stats(bool value); + private: + bool _internal_use_global_stats() const; + void _internal_set_use_global_stats(bool value); + public: + + // optional bool scale_bias = 7 [default = false]; + bool has_scale_bias() const; + private: + bool _internal_has_scale_bias() const; + public: + void clear_scale_bias(); + bool scale_bias() const; + void set_scale_bias(bool value); + private: + bool _internal_scale_bias() const; + void _internal_set_scale_bias(bool value); + public: + + // optional float moving_average_fraction = 2 [default = 0.999]; + bool has_moving_average_fraction() const; + private: + bool _internal_has_moving_average_fraction() const; + public: + void clear_moving_average_fraction(); + float moving_average_fraction() const; + void set_moving_average_fraction(float value); + private: + float _internal_moving_average_fraction() const; + void _internal_set_moving_average_fraction(float value); + public: + + // optional float eps = 3 [default = 1e-05]; + bool has_eps() const; + private: + bool _internal_has_eps() const; + public: + void clear_eps(); + float eps() const; + void set_eps(float value); + private: + float _internal_eps() const; + void _internal_set_eps(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.BatchNormParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool use_global_stats_; + bool scale_bias_; + float moving_average_fraction_; + float eps_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class BiasParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BiasParameter) */ { + public: + inline BiasParameter() : BiasParameter(nullptr) {} + ~BiasParameter() override; + explicit constexpr BiasParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BiasParameter(const BiasParameter& from); + BiasParameter(BiasParameter&& from) noexcept + : BiasParameter() { + *this = ::std::move(from); + } + + inline BiasParameter& operator=(const BiasParameter& from) { + CopyFrom(from); + return *this; + } + inline BiasParameter& operator=(BiasParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BiasParameter& default_instance() { + return *internal_default_instance(); + } + static inline const BiasParameter* internal_default_instance() { + return reinterpret_cast( + &_BiasParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(BiasParameter& a, BiasParameter& b) { + a.Swap(&b); + } + inline void Swap(BiasParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BiasParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BiasParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BiasParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const BiasParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BiasParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.BiasParameter"; + } + protected: + explicit BiasParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFillerFieldNumber = 3, + kAxisFieldNumber = 1, + kNumAxesFieldNumber = 2, + }; + // optional .opencv_caffe.FillerParameter filler = 3; + bool has_filler() const; + private: + bool _internal_has_filler() const; + public: + void clear_filler(); + const ::opencv_caffe::FillerParameter& filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_filler(); + ::opencv_caffe::FillerParameter* mutable_filler(); + void set_allocated_filler(::opencv_caffe::FillerParameter* filler); + private: + const ::opencv_caffe::FillerParameter& _internal_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_filler(); + public: + void unsafe_arena_set_allocated_filler( + ::opencv_caffe::FillerParameter* filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_filler(); + + // optional int32 axis = 1 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // optional int32 num_axes = 2 [default = 1]; + bool has_num_axes() const; + private: + bool _internal_has_num_axes() const; + public: + void clear_num_axes(); + int32_t num_axes() const; + void set_num_axes(int32_t value); + private: + int32_t _internal_num_axes() const; + void _internal_set_num_axes(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.BiasParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::FillerParameter* filler_; + int32_t axis_; + int32_t num_axes_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ContrastiveLossParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ContrastiveLossParameter) */ { + public: + inline ContrastiveLossParameter() : ContrastiveLossParameter(nullptr) {} + ~ContrastiveLossParameter() override; + explicit constexpr ContrastiveLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ContrastiveLossParameter(const ContrastiveLossParameter& from); + ContrastiveLossParameter(ContrastiveLossParameter&& from) noexcept + : ContrastiveLossParameter() { + *this = ::std::move(from); + } + + inline ContrastiveLossParameter& operator=(const ContrastiveLossParameter& from) { + CopyFrom(from); + return *this; + } + inline ContrastiveLossParameter& operator=(ContrastiveLossParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ContrastiveLossParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ContrastiveLossParameter* internal_default_instance() { + return reinterpret_cast( + &_ContrastiveLossParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(ContrastiveLossParameter& a, ContrastiveLossParameter& b) { + a.Swap(&b); + } + inline void Swap(ContrastiveLossParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ContrastiveLossParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ContrastiveLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ContrastiveLossParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ContrastiveLossParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ContrastiveLossParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ContrastiveLossParameter"; + } + protected: + explicit ContrastiveLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLegacyVersionFieldNumber = 2, + kMarginFieldNumber = 1, + }; + // optional bool legacy_version = 2 [default = false]; + bool has_legacy_version() const; + private: + bool _internal_has_legacy_version() const; + public: + void clear_legacy_version(); + bool legacy_version() const; + void set_legacy_version(bool value); + private: + bool _internal_legacy_version() const; + void _internal_set_legacy_version(bool value); + public: + + // optional float margin = 1 [default = 1]; + bool has_margin() const; + private: + bool _internal_has_margin() const; + public: + void clear_margin(); + float margin() const; + void set_margin(float value); + private: + float _internal_margin() const; + void _internal_set_margin(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ContrastiveLossParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool legacy_version_; + float margin_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ConvolutionParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ConvolutionParameter) */ { + public: + inline ConvolutionParameter() : ConvolutionParameter(nullptr) {} + ~ConvolutionParameter() override; + explicit constexpr ConvolutionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ConvolutionParameter(const ConvolutionParameter& from); + ConvolutionParameter(ConvolutionParameter&& from) noexcept + : ConvolutionParameter() { + *this = ::std::move(from); + } + + inline ConvolutionParameter& operator=(const ConvolutionParameter& from) { + CopyFrom(from); + return *this; + } + inline ConvolutionParameter& operator=(ConvolutionParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ConvolutionParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ConvolutionParameter* internal_default_instance() { + return reinterpret_cast( + &_ConvolutionParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(ConvolutionParameter& a, ConvolutionParameter& b) { + a.Swap(&b); + } + inline void Swap(ConvolutionParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ConvolutionParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConvolutionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ConvolutionParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ConvolutionParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ConvolutionParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ConvolutionParameter"; + } + protected: + explicit ConvolutionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ConvolutionParameter_Engine Engine; + static constexpr Engine DEFAULT = + ConvolutionParameter_Engine_DEFAULT; + static constexpr Engine CAFFE = + ConvolutionParameter_Engine_CAFFE; + static constexpr Engine CUDNN = + ConvolutionParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return ConvolutionParameter_Engine_IsValid(value); + } + static constexpr Engine Engine_MIN = + ConvolutionParameter_Engine_Engine_MIN; + static constexpr Engine Engine_MAX = + ConvolutionParameter_Engine_Engine_MAX; + static constexpr int Engine_ARRAYSIZE = + ConvolutionParameter_Engine_Engine_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Engine_descriptor() { + return ConvolutionParameter_Engine_descriptor(); + } + template + static inline const std::string& Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Engine_Name."); + return ConvolutionParameter_Engine_Name(enum_t_value); + } + static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Engine* value) { + return ConvolutionParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kPadFieldNumber = 3, + kKernelSizeFieldNumber = 4, + kStrideFieldNumber = 6, + kDilationFieldNumber = 18, + kWeightFillerFieldNumber = 7, + kBiasFillerFieldNumber = 8, + kNumOutputFieldNumber = 1, + kPadHFieldNumber = 9, + kPadWFieldNumber = 10, + kKernelHFieldNumber = 11, + kKernelWFieldNumber = 12, + kStrideHFieldNumber = 13, + kStrideWFieldNumber = 14, + kEngineFieldNumber = 15, + kForceNdIm2ColFieldNumber = 17, + kAxisFieldNumber = 16, + kBiasTermFieldNumber = 2, + kGroupFieldNumber = 5, + }; + // repeated uint32 pad = 3; + int pad_size() const; + private: + int _internal_pad_size() const; + public: + void clear_pad(); + private: + uint32_t _internal_pad(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_pad() const; + void _internal_add_pad(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_pad(); + public: + uint32_t pad(int index) const; + void set_pad(int index, uint32_t value); + void add_pad(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + pad() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_pad(); + + // repeated uint32 kernel_size = 4; + int kernel_size_size() const; + private: + int _internal_kernel_size_size() const; + public: + void clear_kernel_size(); + private: + uint32_t _internal_kernel_size(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_kernel_size() const; + void _internal_add_kernel_size(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_kernel_size(); + public: + uint32_t kernel_size(int index) const; + void set_kernel_size(int index, uint32_t value); + void add_kernel_size(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + kernel_size() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_kernel_size(); + + // repeated uint32 stride = 6; + int stride_size() const; + private: + int _internal_stride_size() const; + public: + void clear_stride(); + private: + uint32_t _internal_stride(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_stride() const; + void _internal_add_stride(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_stride(); + public: + uint32_t stride(int index) const; + void set_stride(int index, uint32_t value); + void add_stride(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + stride() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_stride(); + + // repeated uint32 dilation = 18; + int dilation_size() const; + private: + int _internal_dilation_size() const; + public: + void clear_dilation(); + private: + uint32_t _internal_dilation(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_dilation() const; + void _internal_add_dilation(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_dilation(); + public: + uint32_t dilation(int index) const; + void set_dilation(int index, uint32_t value); + void add_dilation(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + dilation() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_dilation(); + + // optional .opencv_caffe.FillerParameter weight_filler = 7; + bool has_weight_filler() const; + private: + bool _internal_has_weight_filler() const; + public: + void clear_weight_filler(); + const ::opencv_caffe::FillerParameter& weight_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler(); + ::opencv_caffe::FillerParameter* mutable_weight_filler(); + void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_weight_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler(); + public: + void unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler(); + + // optional .opencv_caffe.FillerParameter bias_filler = 8; + bool has_bias_filler() const; + private: + bool _internal_has_bias_filler() const; + public: + void clear_bias_filler(); + const ::opencv_caffe::FillerParameter& bias_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler(); + ::opencv_caffe::FillerParameter* mutable_bias_filler(); + void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_bias_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler(); + public: + void unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler(); + + // optional uint32 num_output = 1; + bool has_num_output() const; + private: + bool _internal_has_num_output() const; + public: + void clear_num_output(); + uint32_t num_output() const; + void set_num_output(uint32_t value); + private: + uint32_t _internal_num_output() const; + void _internal_set_num_output(uint32_t value); + public: + + // optional uint32 pad_h = 9 [default = 0]; + bool has_pad_h() const; + private: + bool _internal_has_pad_h() const; + public: + void clear_pad_h(); + uint32_t pad_h() const; + void set_pad_h(uint32_t value); + private: + uint32_t _internal_pad_h() const; + void _internal_set_pad_h(uint32_t value); + public: + + // optional uint32 pad_w = 10 [default = 0]; + bool has_pad_w() const; + private: + bool _internal_has_pad_w() const; + public: + void clear_pad_w(); + uint32_t pad_w() const; + void set_pad_w(uint32_t value); + private: + uint32_t _internal_pad_w() const; + void _internal_set_pad_w(uint32_t value); + public: + + // optional uint32 kernel_h = 11; + bool has_kernel_h() const; + private: + bool _internal_has_kernel_h() const; + public: + void clear_kernel_h(); + uint32_t kernel_h() const; + void set_kernel_h(uint32_t value); + private: + uint32_t _internal_kernel_h() const; + void _internal_set_kernel_h(uint32_t value); + public: + + // optional uint32 kernel_w = 12; + bool has_kernel_w() const; + private: + bool _internal_has_kernel_w() const; + public: + void clear_kernel_w(); + uint32_t kernel_w() const; + void set_kernel_w(uint32_t value); + private: + uint32_t _internal_kernel_w() const; + void _internal_set_kernel_w(uint32_t value); + public: + + // optional uint32 stride_h = 13; + bool has_stride_h() const; + private: + bool _internal_has_stride_h() const; + public: + void clear_stride_h(); + uint32_t stride_h() const; + void set_stride_h(uint32_t value); + private: + uint32_t _internal_stride_h() const; + void _internal_set_stride_h(uint32_t value); + public: + + // optional uint32 stride_w = 14; + bool has_stride_w() const; + private: + bool _internal_has_stride_w() const; + public: + void clear_stride_w(); + uint32_t stride_w() const; + void set_stride_w(uint32_t value); + private: + uint32_t _internal_stride_w() const; + void _internal_set_stride_w(uint32_t value); + public: + + // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + bool has_engine() const; + private: + bool _internal_has_engine() const; + public: + void clear_engine(); + ::opencv_caffe::ConvolutionParameter_Engine engine() const; + void set_engine(::opencv_caffe::ConvolutionParameter_Engine value); + private: + ::opencv_caffe::ConvolutionParameter_Engine _internal_engine() const; + void _internal_set_engine(::opencv_caffe::ConvolutionParameter_Engine value); + public: + + // optional bool force_nd_im2col = 17 [default = false]; + bool has_force_nd_im2col() const; + private: + bool _internal_has_force_nd_im2col() const; + public: + void clear_force_nd_im2col(); + bool force_nd_im2col() const; + void set_force_nd_im2col(bool value); + private: + bool _internal_force_nd_im2col() const; + void _internal_set_force_nd_im2col(bool value); + public: + + // optional int32 axis = 16 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // optional bool bias_term = 2 [default = true]; + bool has_bias_term() const; + private: + bool _internal_has_bias_term() const; + public: + void clear_bias_term(); + bool bias_term() const; + void set_bias_term(bool value); + private: + bool _internal_bias_term() const; + void _internal_set_bias_term(bool value); + public: + + // optional uint32 group = 5 [default = 1]; + bool has_group() const; + private: + bool _internal_has_group() const; + public: + void clear_group(); + uint32_t group() const; + void set_group(uint32_t value); + private: + uint32_t _internal_group() const; + void _internal_set_group(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ConvolutionParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > pad_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > kernel_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > stride_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > dilation_; + ::opencv_caffe::FillerParameter* weight_filler_; + ::opencv_caffe::FillerParameter* bias_filler_; + uint32_t num_output_; + uint32_t pad_h_; + uint32_t pad_w_; + uint32_t kernel_h_; + uint32_t kernel_w_; + uint32_t stride_h_; + uint32_t stride_w_; + int engine_; + bool force_nd_im2col_; + int32_t axis_; + bool bias_term_; + uint32_t group_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class CropParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.CropParameter) */ { + public: + inline CropParameter() : CropParameter(nullptr) {} + ~CropParameter() override; + explicit constexpr CropParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CropParameter(const CropParameter& from); + CropParameter(CropParameter&& from) noexcept + : CropParameter() { + *this = ::std::move(from); + } + + inline CropParameter& operator=(const CropParameter& from) { + CopyFrom(from); + return *this; + } + inline CropParameter& operator=(CropParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const CropParameter& default_instance() { + return *internal_default_instance(); + } + static inline const CropParameter* internal_default_instance() { + return reinterpret_cast( + &_CropParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(CropParameter& a, CropParameter& b) { + a.Swap(&b); + } + inline void Swap(CropParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CropParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CropParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CropParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const CropParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CropParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.CropParameter"; + } + protected: + explicit CropParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOffsetFieldNumber = 2, + kAxisFieldNumber = 1, + }; + // repeated uint32 offset = 2; + int offset_size() const; + private: + int _internal_offset_size() const; + public: + void clear_offset(); + private: + uint32_t _internal_offset(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_offset() const; + void _internal_add_offset(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_offset(); + public: + uint32_t offset(int index) const; + void set_offset(int index, uint32_t value); + void add_offset(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + offset() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_offset(); + + // optional int32 axis = 1 [default = 2]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.CropParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > offset_; + int32_t axis_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class DataParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DataParameter) */ { + public: + inline DataParameter() : DataParameter(nullptr) {} + ~DataParameter() override; + explicit constexpr DataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DataParameter(const DataParameter& from); + DataParameter(DataParameter&& from) noexcept + : DataParameter() { + *this = ::std::move(from); + } + + inline DataParameter& operator=(const DataParameter& from) { + CopyFrom(from); + return *this; + } + inline DataParameter& operator=(DataParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DataParameter& default_instance() { + return *internal_default_instance(); + } + static inline const DataParameter* internal_default_instance() { + return reinterpret_cast( + &_DataParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(DataParameter& a, DataParameter& b) { + a.Swap(&b); + } + inline void Swap(DataParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DataParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const DataParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const DataParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DataParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.DataParameter"; + } + protected: + explicit DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef DataParameter_DB DB; + static constexpr DB LEVELDB = + DataParameter_DB_LEVELDB; + static constexpr DB LMDB = + DataParameter_DB_LMDB; + static inline bool DB_IsValid(int value) { + return DataParameter_DB_IsValid(value); + } + static constexpr DB DB_MIN = + DataParameter_DB_DB_MIN; + static constexpr DB DB_MAX = + DataParameter_DB_DB_MAX; + static constexpr int DB_ARRAYSIZE = + DataParameter_DB_DB_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + DB_descriptor() { + return DataParameter_DB_descriptor(); + } + template + static inline const std::string& DB_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DB_Name."); + return DataParameter_DB_Name(enum_t_value); + } + static inline bool DB_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + DB* value) { + return DataParameter_DB_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kSourceFieldNumber = 1, + kMeanFileFieldNumber = 3, + kBatchSizeFieldNumber = 4, + kCropSizeFieldNumber = 5, + kRandSkipFieldNumber = 7, + kMirrorFieldNumber = 6, + kForceEncodedColorFieldNumber = 9, + kBackendFieldNumber = 8, + kScaleFieldNumber = 2, + kPrefetchFieldNumber = 10, + }; + // optional string source = 1; + bool has_source() const; + private: + bool _internal_has_source() const; + public: + void clear_source(); + const std::string& source() const; + template + void set_source(ArgT0&& arg0, ArgT... args); + std::string* mutable_source(); + PROTOBUF_NODISCARD std::string* release_source(); + void set_allocated_source(std::string* source); + private: + const std::string& _internal_source() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value); + std::string* _internal_mutable_source(); + public: + + // optional string mean_file = 3; + bool has_mean_file() const; + private: + bool _internal_has_mean_file() const; + public: + void clear_mean_file(); + const std::string& mean_file() const; + template + void set_mean_file(ArgT0&& arg0, ArgT... args); + std::string* mutable_mean_file(); + PROTOBUF_NODISCARD std::string* release_mean_file(); + void set_allocated_mean_file(std::string* mean_file); + private: + const std::string& _internal_mean_file() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value); + std::string* _internal_mutable_mean_file(); + public: + + // optional uint32 batch_size = 4; + bool has_batch_size() const; + private: + bool _internal_has_batch_size() const; + public: + void clear_batch_size(); + uint32_t batch_size() const; + void set_batch_size(uint32_t value); + private: + uint32_t _internal_batch_size() const; + void _internal_set_batch_size(uint32_t value); + public: + + // optional uint32 crop_size = 5 [default = 0]; + bool has_crop_size() const; + private: + bool _internal_has_crop_size() const; + public: + void clear_crop_size(); + uint32_t crop_size() const; + void set_crop_size(uint32_t value); + private: + uint32_t _internal_crop_size() const; + void _internal_set_crop_size(uint32_t value); + public: + + // optional uint32 rand_skip = 7 [default = 0]; + bool has_rand_skip() const; + private: + bool _internal_has_rand_skip() const; + public: + void clear_rand_skip(); + uint32_t rand_skip() const; + void set_rand_skip(uint32_t value); + private: + uint32_t _internal_rand_skip() const; + void _internal_set_rand_skip(uint32_t value); + public: + + // optional bool mirror = 6 [default = false]; + bool has_mirror() const; + private: + bool _internal_has_mirror() const; + public: + void clear_mirror(); + bool mirror() const; + void set_mirror(bool value); + private: + bool _internal_mirror() const; + void _internal_set_mirror(bool value); + public: + + // optional bool force_encoded_color = 9 [default = false]; + bool has_force_encoded_color() const; + private: + bool _internal_has_force_encoded_color() const; + public: + void clear_force_encoded_color(); + bool force_encoded_color() const; + void set_force_encoded_color(bool value); + private: + bool _internal_force_encoded_color() const; + void _internal_set_force_encoded_color(bool value); + public: + + // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + bool has_backend() const; + private: + bool _internal_has_backend() const; + public: + void clear_backend(); + ::opencv_caffe::DataParameter_DB backend() const; + void set_backend(::opencv_caffe::DataParameter_DB value); + private: + ::opencv_caffe::DataParameter_DB _internal_backend() const; + void _internal_set_backend(::opencv_caffe::DataParameter_DB value); + public: + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // optional uint32 prefetch = 10 [default = 4]; + bool has_prefetch() const; + private: + bool _internal_has_prefetch() const; + public: + void clear_prefetch(); + uint32_t prefetch() const; + void set_prefetch(uint32_t value); + private: + uint32_t _internal_prefetch() const; + void _internal_set_prefetch(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.DataParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_; + uint32_t batch_size_; + uint32_t crop_size_; + uint32_t rand_skip_; + bool mirror_; + bool force_encoded_color_; + int backend_; + float scale_; + uint32_t prefetch_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class NonMaximumSuppressionParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NonMaximumSuppressionParameter) */ { + public: + inline NonMaximumSuppressionParameter() : NonMaximumSuppressionParameter(nullptr) {} + ~NonMaximumSuppressionParameter() override; + explicit constexpr NonMaximumSuppressionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NonMaximumSuppressionParameter(const NonMaximumSuppressionParameter& from); + NonMaximumSuppressionParameter(NonMaximumSuppressionParameter&& from) noexcept + : NonMaximumSuppressionParameter() { + *this = ::std::move(from); + } + + inline NonMaximumSuppressionParameter& operator=(const NonMaximumSuppressionParameter& from) { + CopyFrom(from); + return *this; + } + inline NonMaximumSuppressionParameter& operator=(NonMaximumSuppressionParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NonMaximumSuppressionParameter& default_instance() { + return *internal_default_instance(); + } + static inline const NonMaximumSuppressionParameter* internal_default_instance() { + return reinterpret_cast( + &_NonMaximumSuppressionParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(NonMaximumSuppressionParameter& a, NonMaximumSuppressionParameter& b) { + a.Swap(&b); + } + inline void Swap(NonMaximumSuppressionParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NonMaximumSuppressionParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NonMaximumSuppressionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NonMaximumSuppressionParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const NonMaximumSuppressionParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NonMaximumSuppressionParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.NonMaximumSuppressionParameter"; + } + protected: + explicit NonMaximumSuppressionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTopKFieldNumber = 2, + kNmsThresholdFieldNumber = 1, + kEtaFieldNumber = 3, + }; + // optional int32 top_k = 2; + bool has_top_k() const; + private: + bool _internal_has_top_k() const; + public: + void clear_top_k(); + int32_t top_k() const; + void set_top_k(int32_t value); + private: + int32_t _internal_top_k() const; + void _internal_set_top_k(int32_t value); + public: + + // optional float nms_threshold = 1 [default = 0.3]; + bool has_nms_threshold() const; + private: + bool _internal_has_nms_threshold() const; + public: + void clear_nms_threshold(); + float nms_threshold() const; + void set_nms_threshold(float value); + private: + float _internal_nms_threshold() const; + void _internal_set_nms_threshold(float value); + public: + + // optional float eta = 3 [default = 1]; + bool has_eta() const; + private: + bool _internal_has_eta() const; + public: + void clear_eta(); + float eta() const; + void set_eta(float value); + private: + float _internal_eta() const; + void _internal_set_eta(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.NonMaximumSuppressionParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int32_t top_k_; + float nms_threshold_; + float eta_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class SaveOutputParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SaveOutputParameter) */ { + public: + inline SaveOutputParameter() : SaveOutputParameter(nullptr) {} + ~SaveOutputParameter() override; + explicit constexpr SaveOutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SaveOutputParameter(const SaveOutputParameter& from); + SaveOutputParameter(SaveOutputParameter&& from) noexcept + : SaveOutputParameter() { + *this = ::std::move(from); + } + + inline SaveOutputParameter& operator=(const SaveOutputParameter& from) { + CopyFrom(from); + return *this; + } + inline SaveOutputParameter& operator=(SaveOutputParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SaveOutputParameter& default_instance() { + return *internal_default_instance(); + } + static inline const SaveOutputParameter* internal_default_instance() { + return reinterpret_cast( + &_SaveOutputParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(SaveOutputParameter& a, SaveOutputParameter& b) { + a.Swap(&b); + } + inline void Swap(SaveOutputParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SaveOutputParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SaveOutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SaveOutputParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const SaveOutputParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SaveOutputParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.SaveOutputParameter"; + } + protected: + explicit SaveOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOutputDirectoryFieldNumber = 1, + kOutputNamePrefixFieldNumber = 2, + kOutputFormatFieldNumber = 3, + kLabelMapFileFieldNumber = 4, + kNameSizeFileFieldNumber = 5, + kNumTestImageFieldNumber = 6, + }; + // optional string output_directory = 1; + bool has_output_directory() const; + private: + bool _internal_has_output_directory() const; + public: + void clear_output_directory(); + const std::string& output_directory() const; + template + void set_output_directory(ArgT0&& arg0, ArgT... args); + std::string* mutable_output_directory(); + PROTOBUF_NODISCARD std::string* release_output_directory(); + void set_allocated_output_directory(std::string* output_directory); + private: + const std::string& _internal_output_directory() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_directory(const std::string& value); + std::string* _internal_mutable_output_directory(); + public: + + // optional string output_name_prefix = 2; + bool has_output_name_prefix() const; + private: + bool _internal_has_output_name_prefix() const; + public: + void clear_output_name_prefix(); + const std::string& output_name_prefix() const; + template + void set_output_name_prefix(ArgT0&& arg0, ArgT... args); + std::string* mutable_output_name_prefix(); + PROTOBUF_NODISCARD std::string* release_output_name_prefix(); + void set_allocated_output_name_prefix(std::string* output_name_prefix); + private: + const std::string& _internal_output_name_prefix() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_name_prefix(const std::string& value); + std::string* _internal_mutable_output_name_prefix(); + public: + + // optional string output_format = 3; + bool has_output_format() const; + private: + bool _internal_has_output_format() const; + public: + void clear_output_format(); + const std::string& output_format() const; + template + void set_output_format(ArgT0&& arg0, ArgT... args); + std::string* mutable_output_format(); + PROTOBUF_NODISCARD std::string* release_output_format(); + void set_allocated_output_format(std::string* output_format); + private: + const std::string& _internal_output_format() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_format(const std::string& value); + std::string* _internal_mutable_output_format(); + public: + + // optional string label_map_file = 4; + bool has_label_map_file() const; + private: + bool _internal_has_label_map_file() const; + public: + void clear_label_map_file(); + const std::string& label_map_file() const; + template + void set_label_map_file(ArgT0&& arg0, ArgT... args); + std::string* mutable_label_map_file(); + PROTOBUF_NODISCARD std::string* release_label_map_file(); + void set_allocated_label_map_file(std::string* label_map_file); + private: + const std::string& _internal_label_map_file() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_label_map_file(const std::string& value); + std::string* _internal_mutable_label_map_file(); + public: + + // optional string name_size_file = 5; + bool has_name_size_file() const; + private: + bool _internal_has_name_size_file() const; + public: + void clear_name_size_file(); + const std::string& name_size_file() const; + template + void set_name_size_file(ArgT0&& arg0, ArgT... args); + std::string* mutable_name_size_file(); + PROTOBUF_NODISCARD std::string* release_name_size_file(); + void set_allocated_name_size_file(std::string* name_size_file); + private: + const std::string& _internal_name_size_file() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name_size_file(const std::string& value); + std::string* _internal_mutable_name_size_file(); + public: + + // optional uint32 num_test_image = 6; + bool has_num_test_image() const; + private: + bool _internal_has_num_test_image() const; + public: + void clear_num_test_image(); + uint32_t num_test_image() const; + void set_num_test_image(uint32_t value); + private: + uint32_t _internal_num_test_image() const; + void _internal_set_num_test_image(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.SaveOutputParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_directory_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_name_prefix_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_format_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr label_map_file_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_size_file_; + uint32_t num_test_image_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class DropoutParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DropoutParameter) */ { + public: + inline DropoutParameter() : DropoutParameter(nullptr) {} + ~DropoutParameter() override; + explicit constexpr DropoutParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DropoutParameter(const DropoutParameter& from); + DropoutParameter(DropoutParameter&& from) noexcept + : DropoutParameter() { + *this = ::std::move(from); + } + + inline DropoutParameter& operator=(const DropoutParameter& from) { + CopyFrom(from); + return *this; + } + inline DropoutParameter& operator=(DropoutParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DropoutParameter& default_instance() { + return *internal_default_instance(); + } + static inline const DropoutParameter* internal_default_instance() { + return reinterpret_cast( + &_DropoutParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(DropoutParameter& a, DropoutParameter& b) { + a.Swap(&b); + } + inline void Swap(DropoutParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DropoutParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DropoutParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const DropoutParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const DropoutParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DropoutParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.DropoutParameter"; + } + protected: + explicit DropoutParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDropoutRatioFieldNumber = 1, + kScaleTrainFieldNumber = 2, + }; + // optional float dropout_ratio = 1 [default = 0.5]; + bool has_dropout_ratio() const; + private: + bool _internal_has_dropout_ratio() const; + public: + void clear_dropout_ratio(); + float dropout_ratio() const; + void set_dropout_ratio(float value); + private: + float _internal_dropout_ratio() const; + void _internal_set_dropout_ratio(float value); + public: + + // optional bool scale_train = 2 [default = true]; + bool has_scale_train() const; + private: + bool _internal_has_scale_train() const; + public: + void clear_scale_train(); + bool scale_train() const; + void set_scale_train(bool value); + private: + bool _internal_scale_train() const; + void _internal_set_scale_train(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.DropoutParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float dropout_ratio_; + bool scale_train_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class DummyDataParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DummyDataParameter) */ { + public: + inline DummyDataParameter() : DummyDataParameter(nullptr) {} + ~DummyDataParameter() override; + explicit constexpr DummyDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DummyDataParameter(const DummyDataParameter& from); + DummyDataParameter(DummyDataParameter&& from) noexcept + : DummyDataParameter() { + *this = ::std::move(from); + } + + inline DummyDataParameter& operator=(const DummyDataParameter& from) { + CopyFrom(from); + return *this; + } + inline DummyDataParameter& operator=(DummyDataParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DummyDataParameter& default_instance() { + return *internal_default_instance(); + } + static inline const DummyDataParameter* internal_default_instance() { + return reinterpret_cast( + &_DummyDataParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 30; + + friend void swap(DummyDataParameter& a, DummyDataParameter& b) { + a.Swap(&b); + } + inline void Swap(DummyDataParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DummyDataParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DummyDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const DummyDataParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const DummyDataParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DummyDataParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.DummyDataParameter"; + } + protected: + explicit DummyDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDataFillerFieldNumber = 1, + kNumFieldNumber = 2, + kChannelsFieldNumber = 3, + kHeightFieldNumber = 4, + kWidthFieldNumber = 5, + kShapeFieldNumber = 6, + }; + // repeated .opencv_caffe.FillerParameter data_filler = 1; + int data_filler_size() const; + private: + int _internal_data_filler_size() const; + public: + void clear_data_filler(); + ::opencv_caffe::FillerParameter* mutable_data_filler(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter >* + mutable_data_filler(); + private: + const ::opencv_caffe::FillerParameter& _internal_data_filler(int index) const; + ::opencv_caffe::FillerParameter* _internal_add_data_filler(); + public: + const ::opencv_caffe::FillerParameter& data_filler(int index) const; + ::opencv_caffe::FillerParameter* add_data_filler(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter >& + data_filler() const; + + // repeated uint32 num = 2; + int num_size() const; + private: + int _internal_num_size() const; + public: + void clear_num(); + private: + uint32_t _internal_num(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_num() const; + void _internal_add_num(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_num(); + public: + uint32_t num(int index) const; + void set_num(int index, uint32_t value); + void add_num(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + num() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_num(); + + // repeated uint32 channels = 3; + int channels_size() const; + private: + int _internal_channels_size() const; + public: + void clear_channels(); + private: + uint32_t _internal_channels(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_channels() const; + void _internal_add_channels(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_channels(); + public: + uint32_t channels(int index) const; + void set_channels(int index, uint32_t value); + void add_channels(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + channels() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_channels(); + + // repeated uint32 height = 4; + int height_size() const; + private: + int _internal_height_size() const; + public: + void clear_height(); + private: + uint32_t _internal_height(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_height() const; + void _internal_add_height(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_height(); + public: + uint32_t height(int index) const; + void set_height(int index, uint32_t value); + void add_height(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + height() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_height(); + + // repeated uint32 width = 5; + int width_size() const; + private: + int _internal_width_size() const; + public: + void clear_width(); + private: + uint32_t _internal_width(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_width() const; + void _internal_add_width(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_width(); + public: + uint32_t width(int index) const; + void set_width(int index, uint32_t value); + void add_width(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + width() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_width(); + + // repeated .opencv_caffe.BlobShape shape = 6; + int shape_size() const; + private: + int _internal_shape_size() const; + public: + void clear_shape(); + ::opencv_caffe::BlobShape* mutable_shape(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >* + mutable_shape(); + private: + const ::opencv_caffe::BlobShape& _internal_shape(int index) const; + ::opencv_caffe::BlobShape* _internal_add_shape(); + public: + const ::opencv_caffe::BlobShape& shape(int index) const; + ::opencv_caffe::BlobShape* add_shape(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >& + shape() const; + + // @@protoc_insertion_point(class_scope:opencv_caffe.DummyDataParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter > data_filler_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > num_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > channels_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > height_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > width_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape > shape_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class EltwiseParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.EltwiseParameter) */ { + public: + inline EltwiseParameter() : EltwiseParameter(nullptr) {} + ~EltwiseParameter() override; + explicit constexpr EltwiseParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + EltwiseParameter(const EltwiseParameter& from); + EltwiseParameter(EltwiseParameter&& from) noexcept + : EltwiseParameter() { + *this = ::std::move(from); + } + + inline EltwiseParameter& operator=(const EltwiseParameter& from) { + CopyFrom(from); + return *this; + } + inline EltwiseParameter& operator=(EltwiseParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EltwiseParameter& default_instance() { + return *internal_default_instance(); + } + static inline const EltwiseParameter* internal_default_instance() { + return reinterpret_cast( + &_EltwiseParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 31; + + friend void swap(EltwiseParameter& a, EltwiseParameter& b) { + a.Swap(&b); + } + inline void Swap(EltwiseParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EltwiseParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EltwiseParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const EltwiseParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const EltwiseParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(EltwiseParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.EltwiseParameter"; + } + protected: + explicit EltwiseParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef EltwiseParameter_EltwiseOp EltwiseOp; + static constexpr EltwiseOp PROD = + EltwiseParameter_EltwiseOp_PROD; + static constexpr EltwiseOp SUM = + EltwiseParameter_EltwiseOp_SUM; + static constexpr EltwiseOp MAX = + EltwiseParameter_EltwiseOp_MAX; + static inline bool EltwiseOp_IsValid(int value) { + return EltwiseParameter_EltwiseOp_IsValid(value); + } + static constexpr EltwiseOp EltwiseOp_MIN = + EltwiseParameter_EltwiseOp_EltwiseOp_MIN; + static constexpr EltwiseOp EltwiseOp_MAX = + EltwiseParameter_EltwiseOp_EltwiseOp_MAX; + static constexpr int EltwiseOp_ARRAYSIZE = + EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + EltwiseOp_descriptor() { + return EltwiseParameter_EltwiseOp_descriptor(); + } + template + static inline const std::string& EltwiseOp_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function EltwiseOp_Name."); + return EltwiseParameter_EltwiseOp_Name(enum_t_value); + } + static inline bool EltwiseOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + EltwiseOp* value) { + return EltwiseParameter_EltwiseOp_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kCoeffFieldNumber = 2, + kOperationFieldNumber = 1, + kStableProdGradFieldNumber = 3, + }; + // repeated float coeff = 2; + int coeff_size() const; + private: + int _internal_coeff_size() const; + public: + void clear_coeff(); + private: + float _internal_coeff(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_coeff() const; + void _internal_add_coeff(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_coeff(); + public: + float coeff(int index) const; + void set_coeff(int index, float value); + void add_coeff(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + coeff() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_coeff(); + + // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + bool has_operation() const; + private: + bool _internal_has_operation() const; + public: + void clear_operation(); + ::opencv_caffe::EltwiseParameter_EltwiseOp operation() const; + void set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value); + private: + ::opencv_caffe::EltwiseParameter_EltwiseOp _internal_operation() const; + void _internal_set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value); + public: + + // optional bool stable_prod_grad = 3 [default = true]; + bool has_stable_prod_grad() const; + private: + bool _internal_has_stable_prod_grad() const; + public: + void clear_stable_prod_grad(); + bool stable_prod_grad() const; + void set_stable_prod_grad(bool value); + private: + bool _internal_stable_prod_grad() const; + void _internal_set_stable_prod_grad(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.EltwiseParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > coeff_; + int operation_; + bool stable_prod_grad_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ELUParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ELUParameter) */ { + public: + inline ELUParameter() : ELUParameter(nullptr) {} + ~ELUParameter() override; + explicit constexpr ELUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ELUParameter(const ELUParameter& from); + ELUParameter(ELUParameter&& from) noexcept + : ELUParameter() { + *this = ::std::move(from); + } + + inline ELUParameter& operator=(const ELUParameter& from) { + CopyFrom(from); + return *this; + } + inline ELUParameter& operator=(ELUParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ELUParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ELUParameter* internal_default_instance() { + return reinterpret_cast( + &_ELUParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 32; + + friend void swap(ELUParameter& a, ELUParameter& b) { + a.Swap(&b); + } + inline void Swap(ELUParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ELUParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ELUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ELUParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ELUParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ELUParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ELUParameter"; + } + protected: + explicit ELUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAlphaFieldNumber = 1, + }; + // optional float alpha = 1 [default = 1]; + bool has_alpha() const; + private: + bool _internal_has_alpha() const; + public: + void clear_alpha(); + float alpha() const; + void set_alpha(float value); + private: + float _internal_alpha() const; + void _internal_set_alpha(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ELUParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float alpha_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class EmbedParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.EmbedParameter) */ { + public: + inline EmbedParameter() : EmbedParameter(nullptr) {} + ~EmbedParameter() override; + explicit constexpr EmbedParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + EmbedParameter(const EmbedParameter& from); + EmbedParameter(EmbedParameter&& from) noexcept + : EmbedParameter() { + *this = ::std::move(from); + } + + inline EmbedParameter& operator=(const EmbedParameter& from) { + CopyFrom(from); + return *this; + } + inline EmbedParameter& operator=(EmbedParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EmbedParameter& default_instance() { + return *internal_default_instance(); + } + static inline const EmbedParameter* internal_default_instance() { + return reinterpret_cast( + &_EmbedParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 33; + + friend void swap(EmbedParameter& a, EmbedParameter& b) { + a.Swap(&b); + } + inline void Swap(EmbedParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EmbedParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EmbedParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const EmbedParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const EmbedParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(EmbedParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.EmbedParameter"; + } + protected: + explicit EmbedParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kWeightFillerFieldNumber = 4, + kBiasFillerFieldNumber = 5, + kNumOutputFieldNumber = 1, + kInputDimFieldNumber = 2, + kBiasTermFieldNumber = 3, + }; + // optional .opencv_caffe.FillerParameter weight_filler = 4; + bool has_weight_filler() const; + private: + bool _internal_has_weight_filler() const; + public: + void clear_weight_filler(); + const ::opencv_caffe::FillerParameter& weight_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler(); + ::opencv_caffe::FillerParameter* mutable_weight_filler(); + void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_weight_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler(); + public: + void unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler(); + + // optional .opencv_caffe.FillerParameter bias_filler = 5; + bool has_bias_filler() const; + private: + bool _internal_has_bias_filler() const; + public: + void clear_bias_filler(); + const ::opencv_caffe::FillerParameter& bias_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler(); + ::opencv_caffe::FillerParameter* mutable_bias_filler(); + void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_bias_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler(); + public: + void unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler(); + + // optional uint32 num_output = 1; + bool has_num_output() const; + private: + bool _internal_has_num_output() const; + public: + void clear_num_output(); + uint32_t num_output() const; + void set_num_output(uint32_t value); + private: + uint32_t _internal_num_output() const; + void _internal_set_num_output(uint32_t value); + public: + + // optional uint32 input_dim = 2; + bool has_input_dim() const; + private: + bool _internal_has_input_dim() const; + public: + void clear_input_dim(); + uint32_t input_dim() const; + void set_input_dim(uint32_t value); + private: + uint32_t _internal_input_dim() const; + void _internal_set_input_dim(uint32_t value); + public: + + // optional bool bias_term = 3 [default = true]; + bool has_bias_term() const; + private: + bool _internal_has_bias_term() const; + public: + void clear_bias_term(); + bool bias_term() const; + void set_bias_term(bool value); + private: + bool _internal_bias_term() const; + void _internal_set_bias_term(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.EmbedParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::FillerParameter* weight_filler_; + ::opencv_caffe::FillerParameter* bias_filler_; + uint32_t num_output_; + uint32_t input_dim_; + bool bias_term_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ExpParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ExpParameter) */ { + public: + inline ExpParameter() : ExpParameter(nullptr) {} + ~ExpParameter() override; + explicit constexpr ExpParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ExpParameter(const ExpParameter& from); + ExpParameter(ExpParameter&& from) noexcept + : ExpParameter() { + *this = ::std::move(from); + } + + inline ExpParameter& operator=(const ExpParameter& from) { + CopyFrom(from); + return *this; + } + inline ExpParameter& operator=(ExpParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ExpParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ExpParameter* internal_default_instance() { + return reinterpret_cast( + &_ExpParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 34; + + friend void swap(ExpParameter& a, ExpParameter& b) { + a.Swap(&b); + } + inline void Swap(ExpParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ExpParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ExpParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ExpParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ExpParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ExpParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ExpParameter"; + } + protected: + explicit ExpParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShiftFieldNumber = 3, + kBaseFieldNumber = 1, + kScaleFieldNumber = 2, + }; + // optional float shift = 3 [default = 0]; + bool has_shift() const; + private: + bool _internal_has_shift() const; + public: + void clear_shift(); + float shift() const; + void set_shift(float value); + private: + float _internal_shift() const; + void _internal_set_shift(float value); + public: + + // optional float base = 1 [default = -1]; + bool has_base() const; + private: + bool _internal_has_base() const; + public: + void clear_base(); + float base() const; + void set_base(float value); + private: + float _internal_base() const; + void _internal_set_base(float value); + public: + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ExpParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float shift_; + float base_; + float scale_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class FlattenParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.FlattenParameter) */ { + public: + inline FlattenParameter() : FlattenParameter(nullptr) {} + ~FlattenParameter() override; + explicit constexpr FlattenParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FlattenParameter(const FlattenParameter& from); + FlattenParameter(FlattenParameter&& from) noexcept + : FlattenParameter() { + *this = ::std::move(from); + } + + inline FlattenParameter& operator=(const FlattenParameter& from) { + CopyFrom(from); + return *this; + } + inline FlattenParameter& operator=(FlattenParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const FlattenParameter& default_instance() { + return *internal_default_instance(); + } + static inline const FlattenParameter* internal_default_instance() { + return reinterpret_cast( + &_FlattenParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 35; + + friend void swap(FlattenParameter& a, FlattenParameter& b) { + a.Swap(&b); + } + inline void Swap(FlattenParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FlattenParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FlattenParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const FlattenParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const FlattenParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FlattenParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.FlattenParameter"; + } + protected: + explicit FlattenParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAxisFieldNumber = 1, + kEndAxisFieldNumber = 2, + }; + // optional int32 axis = 1 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // optional int32 end_axis = 2 [default = -1]; + bool has_end_axis() const; + private: + bool _internal_has_end_axis() const; + public: + void clear_end_axis(); + int32_t end_axis() const; + void set_end_axis(int32_t value); + private: + int32_t _internal_end_axis() const; + void _internal_set_end_axis(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.FlattenParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int32_t axis_; + int32_t end_axis_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class HDF5DataParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HDF5DataParameter) */ { + public: + inline HDF5DataParameter() : HDF5DataParameter(nullptr) {} + ~HDF5DataParameter() override; + explicit constexpr HDF5DataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HDF5DataParameter(const HDF5DataParameter& from); + HDF5DataParameter(HDF5DataParameter&& from) noexcept + : HDF5DataParameter() { + *this = ::std::move(from); + } + + inline HDF5DataParameter& operator=(const HDF5DataParameter& from) { + CopyFrom(from); + return *this; + } + inline HDF5DataParameter& operator=(HDF5DataParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HDF5DataParameter& default_instance() { + return *internal_default_instance(); + } + static inline const HDF5DataParameter* internal_default_instance() { + return reinterpret_cast( + &_HDF5DataParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 36; + + friend void swap(HDF5DataParameter& a, HDF5DataParameter& b) { + a.Swap(&b); + } + inline void Swap(HDF5DataParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HDF5DataParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HDF5DataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HDF5DataParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const HDF5DataParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HDF5DataParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.HDF5DataParameter"; + } + protected: + explicit HDF5DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSourceFieldNumber = 1, + kBatchSizeFieldNumber = 2, + kShuffleFieldNumber = 3, + }; + // optional string source = 1; + bool has_source() const; + private: + bool _internal_has_source() const; + public: + void clear_source(); + const std::string& source() const; + template + void set_source(ArgT0&& arg0, ArgT... args); + std::string* mutable_source(); + PROTOBUF_NODISCARD std::string* release_source(); + void set_allocated_source(std::string* source); + private: + const std::string& _internal_source() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value); + std::string* _internal_mutable_source(); + public: + + // optional uint32 batch_size = 2; + bool has_batch_size() const; + private: + bool _internal_has_batch_size() const; + public: + void clear_batch_size(); + uint32_t batch_size() const; + void set_batch_size(uint32_t value); + private: + uint32_t _internal_batch_size() const; + void _internal_set_batch_size(uint32_t value); + public: + + // optional bool shuffle = 3 [default = false]; + bool has_shuffle() const; + private: + bool _internal_has_shuffle() const; + public: + void clear_shuffle(); + bool shuffle() const; + void set_shuffle(bool value); + private: + bool _internal_shuffle() const; + void _internal_set_shuffle(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.HDF5DataParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; + uint32_t batch_size_; + bool shuffle_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class HDF5OutputParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HDF5OutputParameter) */ { + public: + inline HDF5OutputParameter() : HDF5OutputParameter(nullptr) {} + ~HDF5OutputParameter() override; + explicit constexpr HDF5OutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HDF5OutputParameter(const HDF5OutputParameter& from); + HDF5OutputParameter(HDF5OutputParameter&& from) noexcept + : HDF5OutputParameter() { + *this = ::std::move(from); + } + + inline HDF5OutputParameter& operator=(const HDF5OutputParameter& from) { + CopyFrom(from); + return *this; + } + inline HDF5OutputParameter& operator=(HDF5OutputParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HDF5OutputParameter& default_instance() { + return *internal_default_instance(); + } + static inline const HDF5OutputParameter* internal_default_instance() { + return reinterpret_cast( + &_HDF5OutputParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 37; + + friend void swap(HDF5OutputParameter& a, HDF5OutputParameter& b) { + a.Swap(&b); + } + inline void Swap(HDF5OutputParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HDF5OutputParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HDF5OutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HDF5OutputParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const HDF5OutputParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HDF5OutputParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.HDF5OutputParameter"; + } + protected: + explicit HDF5OutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFileNameFieldNumber = 1, + }; + // optional string file_name = 1; + bool has_file_name() const; + private: + bool _internal_has_file_name() const; + public: + void clear_file_name(); + const std::string& file_name() const; + template + void set_file_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_file_name(); + PROTOBUF_NODISCARD std::string* release_file_name(); + void set_allocated_file_name(std::string* file_name); + private: + const std::string& _internal_file_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value); + std::string* _internal_mutable_file_name(); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.HDF5OutputParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class HingeLossParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HingeLossParameter) */ { + public: + inline HingeLossParameter() : HingeLossParameter(nullptr) {} + ~HingeLossParameter() override; + explicit constexpr HingeLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HingeLossParameter(const HingeLossParameter& from); + HingeLossParameter(HingeLossParameter&& from) noexcept + : HingeLossParameter() { + *this = ::std::move(from); + } + + inline HingeLossParameter& operator=(const HingeLossParameter& from) { + CopyFrom(from); + return *this; + } + inline HingeLossParameter& operator=(HingeLossParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HingeLossParameter& default_instance() { + return *internal_default_instance(); + } + static inline const HingeLossParameter* internal_default_instance() { + return reinterpret_cast( + &_HingeLossParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 38; + + friend void swap(HingeLossParameter& a, HingeLossParameter& b) { + a.Swap(&b); + } + inline void Swap(HingeLossParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HingeLossParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HingeLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HingeLossParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const HingeLossParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HingeLossParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.HingeLossParameter"; + } + protected: + explicit HingeLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef HingeLossParameter_Norm Norm; + static constexpr Norm L1 = + HingeLossParameter_Norm_L1; + static constexpr Norm L2 = + HingeLossParameter_Norm_L2; + static inline bool Norm_IsValid(int value) { + return HingeLossParameter_Norm_IsValid(value); + } + static constexpr Norm Norm_MIN = + HingeLossParameter_Norm_Norm_MIN; + static constexpr Norm Norm_MAX = + HingeLossParameter_Norm_Norm_MAX; + static constexpr int Norm_ARRAYSIZE = + HingeLossParameter_Norm_Norm_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Norm_descriptor() { + return HingeLossParameter_Norm_descriptor(); + } + template + static inline const std::string& Norm_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Norm_Name."); + return HingeLossParameter_Norm_Name(enum_t_value); + } + static inline bool Norm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Norm* value) { + return HingeLossParameter_Norm_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kNormFieldNumber = 1, + }; + // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + bool has_norm() const; + private: + bool _internal_has_norm() const; + public: + void clear_norm(); + ::opencv_caffe::HingeLossParameter_Norm norm() const; + void set_norm(::opencv_caffe::HingeLossParameter_Norm value); + private: + ::opencv_caffe::HingeLossParameter_Norm _internal_norm() const; + void _internal_set_norm(::opencv_caffe::HingeLossParameter_Norm value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.HingeLossParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int norm_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ImageDataParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ImageDataParameter) */ { + public: + inline ImageDataParameter() : ImageDataParameter(nullptr) {} + ~ImageDataParameter() override; + explicit constexpr ImageDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ImageDataParameter(const ImageDataParameter& from); + ImageDataParameter(ImageDataParameter&& from) noexcept + : ImageDataParameter() { + *this = ::std::move(from); + } + + inline ImageDataParameter& operator=(const ImageDataParameter& from) { + CopyFrom(from); + return *this; + } + inline ImageDataParameter& operator=(ImageDataParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ImageDataParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ImageDataParameter* internal_default_instance() { + return reinterpret_cast( + &_ImageDataParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 39; + + friend void swap(ImageDataParameter& a, ImageDataParameter& b) { + a.Swap(&b); + } + inline void Swap(ImageDataParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ImageDataParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ImageDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ImageDataParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ImageDataParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ImageDataParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ImageDataParameter"; + } + protected: + explicit ImageDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSourceFieldNumber = 1, + kMeanFileFieldNumber = 3, + kRootFolderFieldNumber = 12, + kCropSizeFieldNumber = 5, + kRandSkipFieldNumber = 7, + kShuffleFieldNumber = 8, + kMirrorFieldNumber = 6, + kNewHeightFieldNumber = 9, + kNewWidthFieldNumber = 10, + kIsColorFieldNumber = 11, + kScaleFieldNumber = 2, + kBatchSizeFieldNumber = 4, + }; + // optional string source = 1; + bool has_source() const; + private: + bool _internal_has_source() const; + public: + void clear_source(); + const std::string& source() const; + template + void set_source(ArgT0&& arg0, ArgT... args); + std::string* mutable_source(); + PROTOBUF_NODISCARD std::string* release_source(); + void set_allocated_source(std::string* source); + private: + const std::string& _internal_source() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value); + std::string* _internal_mutable_source(); + public: + + // optional string mean_file = 3; + bool has_mean_file() const; + private: + bool _internal_has_mean_file() const; + public: + void clear_mean_file(); + const std::string& mean_file() const; + template + void set_mean_file(ArgT0&& arg0, ArgT... args); + std::string* mutable_mean_file(); + PROTOBUF_NODISCARD std::string* release_mean_file(); + void set_allocated_mean_file(std::string* mean_file); + private: + const std::string& _internal_mean_file() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value); + std::string* _internal_mutable_mean_file(); + public: + + // optional string root_folder = 12 [default = ""]; + bool has_root_folder() const; + private: + bool _internal_has_root_folder() const; + public: + void clear_root_folder(); + const std::string& root_folder() const; + template + void set_root_folder(ArgT0&& arg0, ArgT... args); + std::string* mutable_root_folder(); + PROTOBUF_NODISCARD std::string* release_root_folder(); + void set_allocated_root_folder(std::string* root_folder); + private: + const std::string& _internal_root_folder() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_root_folder(const std::string& value); + std::string* _internal_mutable_root_folder(); + public: + + // optional uint32 crop_size = 5 [default = 0]; + bool has_crop_size() const; + private: + bool _internal_has_crop_size() const; + public: + void clear_crop_size(); + uint32_t crop_size() const; + void set_crop_size(uint32_t value); + private: + uint32_t _internal_crop_size() const; + void _internal_set_crop_size(uint32_t value); + public: + + // optional uint32 rand_skip = 7 [default = 0]; + bool has_rand_skip() const; + private: + bool _internal_has_rand_skip() const; + public: + void clear_rand_skip(); + uint32_t rand_skip() const; + void set_rand_skip(uint32_t value); + private: + uint32_t _internal_rand_skip() const; + void _internal_set_rand_skip(uint32_t value); + public: + + // optional bool shuffle = 8 [default = false]; + bool has_shuffle() const; + private: + bool _internal_has_shuffle() const; + public: + void clear_shuffle(); + bool shuffle() const; + void set_shuffle(bool value); + private: + bool _internal_shuffle() const; + void _internal_set_shuffle(bool value); + public: + + // optional bool mirror = 6 [default = false]; + bool has_mirror() const; + private: + bool _internal_has_mirror() const; + public: + void clear_mirror(); + bool mirror() const; + void set_mirror(bool value); + private: + bool _internal_mirror() const; + void _internal_set_mirror(bool value); + public: + + // optional uint32 new_height = 9 [default = 0]; + bool has_new_height() const; + private: + bool _internal_has_new_height() const; + public: + void clear_new_height(); + uint32_t new_height() const; + void set_new_height(uint32_t value); + private: + uint32_t _internal_new_height() const; + void _internal_set_new_height(uint32_t value); + public: + + // optional uint32 new_width = 10 [default = 0]; + bool has_new_width() const; + private: + bool _internal_has_new_width() const; + public: + void clear_new_width(); + uint32_t new_width() const; + void set_new_width(uint32_t value); + private: + uint32_t _internal_new_width() const; + void _internal_set_new_width(uint32_t value); + public: + + // optional bool is_color = 11 [default = true]; + bool has_is_color() const; + private: + bool _internal_has_is_color() const; + public: + void clear_is_color(); + bool is_color() const; + void set_is_color(bool value); + private: + bool _internal_is_color() const; + void _internal_set_is_color(bool value); + public: + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // optional uint32 batch_size = 4 [default = 1]; + bool has_batch_size() const; + private: + bool _internal_has_batch_size() const; + public: + void clear_batch_size(); + uint32_t batch_size() const; + void set_batch_size(uint32_t value); + private: + uint32_t _internal_batch_size() const; + void _internal_set_batch_size(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ImageDataParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_folder_; + uint32_t crop_size_; + uint32_t rand_skip_; + bool shuffle_; + bool mirror_; + uint32_t new_height_; + uint32_t new_width_; + bool is_color_; + float scale_; + uint32_t batch_size_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class InfogainLossParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InfogainLossParameter) */ { + public: + inline InfogainLossParameter() : InfogainLossParameter(nullptr) {} + ~InfogainLossParameter() override; + explicit constexpr InfogainLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + InfogainLossParameter(const InfogainLossParameter& from); + InfogainLossParameter(InfogainLossParameter&& from) noexcept + : InfogainLossParameter() { + *this = ::std::move(from); + } + + inline InfogainLossParameter& operator=(const InfogainLossParameter& from) { + CopyFrom(from); + return *this; + } + inline InfogainLossParameter& operator=(InfogainLossParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const InfogainLossParameter& default_instance() { + return *internal_default_instance(); + } + static inline const InfogainLossParameter* internal_default_instance() { + return reinterpret_cast( + &_InfogainLossParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 40; + + friend void swap(InfogainLossParameter& a, InfogainLossParameter& b) { + a.Swap(&b); + } + inline void Swap(InfogainLossParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(InfogainLossParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + InfogainLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const InfogainLossParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const InfogainLossParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(InfogainLossParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.InfogainLossParameter"; + } + protected: + explicit InfogainLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSourceFieldNumber = 1, + }; + // optional string source = 1; + bool has_source() const; + private: + bool _internal_has_source() const; + public: + void clear_source(); + const std::string& source() const; + template + void set_source(ArgT0&& arg0, ArgT... args); + std::string* mutable_source(); + PROTOBUF_NODISCARD std::string* release_source(); + void set_allocated_source(std::string* source); + private: + const std::string& _internal_source() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value); + std::string* _internal_mutable_source(); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.InfogainLossParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class InnerProductParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InnerProductParameter) */ { + public: + inline InnerProductParameter() : InnerProductParameter(nullptr) {} + ~InnerProductParameter() override; + explicit constexpr InnerProductParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + InnerProductParameter(const InnerProductParameter& from); + InnerProductParameter(InnerProductParameter&& from) noexcept + : InnerProductParameter() { + *this = ::std::move(from); + } + + inline InnerProductParameter& operator=(const InnerProductParameter& from) { + CopyFrom(from); + return *this; + } + inline InnerProductParameter& operator=(InnerProductParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const InnerProductParameter& default_instance() { + return *internal_default_instance(); + } + static inline const InnerProductParameter* internal_default_instance() { + return reinterpret_cast( + &_InnerProductParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 41; + + friend void swap(InnerProductParameter& a, InnerProductParameter& b) { + a.Swap(&b); + } + inline void Swap(InnerProductParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(InnerProductParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + InnerProductParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const InnerProductParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const InnerProductParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(InnerProductParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.InnerProductParameter"; + } + protected: + explicit InnerProductParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kWeightFillerFieldNumber = 3, + kBiasFillerFieldNumber = 4, + kNumOutputFieldNumber = 1, + kTransposeFieldNumber = 6, + kBiasTermFieldNumber = 2, + kAxisFieldNumber = 5, + }; + // optional .opencv_caffe.FillerParameter weight_filler = 3; + bool has_weight_filler() const; + private: + bool _internal_has_weight_filler() const; + public: + void clear_weight_filler(); + const ::opencv_caffe::FillerParameter& weight_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler(); + ::opencv_caffe::FillerParameter* mutable_weight_filler(); + void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_weight_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler(); + public: + void unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler(); + + // optional .opencv_caffe.FillerParameter bias_filler = 4; + bool has_bias_filler() const; + private: + bool _internal_has_bias_filler() const; + public: + void clear_bias_filler(); + const ::opencv_caffe::FillerParameter& bias_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler(); + ::opencv_caffe::FillerParameter* mutable_bias_filler(); + void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_bias_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler(); + public: + void unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler(); + + // optional uint32 num_output = 1; + bool has_num_output() const; + private: + bool _internal_has_num_output() const; + public: + void clear_num_output(); + uint32_t num_output() const; + void set_num_output(uint32_t value); + private: + uint32_t _internal_num_output() const; + void _internal_set_num_output(uint32_t value); + public: + + // optional bool transpose = 6 [default = false]; + bool has_transpose() const; + private: + bool _internal_has_transpose() const; + public: + void clear_transpose(); + bool transpose() const; + void set_transpose(bool value); + private: + bool _internal_transpose() const; + void _internal_set_transpose(bool value); + public: + + // optional bool bias_term = 2 [default = true]; + bool has_bias_term() const; + private: + bool _internal_has_bias_term() const; + public: + void clear_bias_term(); + bool bias_term() const; + void set_bias_term(bool value); + private: + bool _internal_bias_term() const; + void _internal_set_bias_term(bool value); + public: + + // optional int32 axis = 5 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.InnerProductParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::FillerParameter* weight_filler_; + ::opencv_caffe::FillerParameter* bias_filler_; + uint32_t num_output_; + bool transpose_; + bool bias_term_; + int32_t axis_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class InputParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InputParameter) */ { + public: + inline InputParameter() : InputParameter(nullptr) {} + ~InputParameter() override; + explicit constexpr InputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + InputParameter(const InputParameter& from); + InputParameter(InputParameter&& from) noexcept + : InputParameter() { + *this = ::std::move(from); + } + + inline InputParameter& operator=(const InputParameter& from) { + CopyFrom(from); + return *this; + } + inline InputParameter& operator=(InputParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const InputParameter& default_instance() { + return *internal_default_instance(); + } + static inline const InputParameter* internal_default_instance() { + return reinterpret_cast( + &_InputParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 42; + + friend void swap(InputParameter& a, InputParameter& b) { + a.Swap(&b); + } + inline void Swap(InputParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(InputParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + InputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const InputParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const InputParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(InputParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.InputParameter"; + } + protected: + explicit InputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShapeFieldNumber = 1, + }; + // repeated .opencv_caffe.BlobShape shape = 1; + int shape_size() const; + private: + int _internal_shape_size() const; + public: + void clear_shape(); + ::opencv_caffe::BlobShape* mutable_shape(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >* + mutable_shape(); + private: + const ::opencv_caffe::BlobShape& _internal_shape(int index) const; + ::opencv_caffe::BlobShape* _internal_add_shape(); + public: + const ::opencv_caffe::BlobShape& shape(int index) const; + ::opencv_caffe::BlobShape* add_shape(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >& + shape() const; + + // @@protoc_insertion_point(class_scope:opencv_caffe.InputParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape > shape_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class LogParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LogParameter) */ { + public: + inline LogParameter() : LogParameter(nullptr) {} + ~LogParameter() override; + explicit constexpr LogParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LogParameter(const LogParameter& from); + LogParameter(LogParameter&& from) noexcept + : LogParameter() { + *this = ::std::move(from); + } + + inline LogParameter& operator=(const LogParameter& from) { + CopyFrom(from); + return *this; + } + inline LogParameter& operator=(LogParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LogParameter& default_instance() { + return *internal_default_instance(); + } + static inline const LogParameter* internal_default_instance() { + return reinterpret_cast( + &_LogParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 43; + + friend void swap(LogParameter& a, LogParameter& b) { + a.Swap(&b); + } + inline void Swap(LogParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LogParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LogParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LogParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const LogParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LogParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.LogParameter"; + } + protected: + explicit LogParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShiftFieldNumber = 3, + kBaseFieldNumber = 1, + kScaleFieldNumber = 2, + }; + // optional float shift = 3 [default = 0]; + bool has_shift() const; + private: + bool _internal_has_shift() const; + public: + void clear_shift(); + float shift() const; + void set_shift(float value); + private: + float _internal_shift() const; + void _internal_set_shift(float value); + public: + + // optional float base = 1 [default = -1]; + bool has_base() const; + private: + bool _internal_has_base() const; + public: + void clear_base(); + float base() const; + void set_base(float value); + private: + float _internal_base() const; + void _internal_set_base(float value); + public: + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.LogParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float shift_; + float base_; + float scale_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class LRNParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LRNParameter) */ { + public: + inline LRNParameter() : LRNParameter(nullptr) {} + ~LRNParameter() override; + explicit constexpr LRNParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LRNParameter(const LRNParameter& from); + LRNParameter(LRNParameter&& from) noexcept + : LRNParameter() { + *this = ::std::move(from); + } + + inline LRNParameter& operator=(const LRNParameter& from) { + CopyFrom(from); + return *this; + } + inline LRNParameter& operator=(LRNParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LRNParameter& default_instance() { + return *internal_default_instance(); + } + static inline const LRNParameter* internal_default_instance() { + return reinterpret_cast( + &_LRNParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 44; + + friend void swap(LRNParameter& a, LRNParameter& b) { + a.Swap(&b); + } + inline void Swap(LRNParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LRNParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LRNParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LRNParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const LRNParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LRNParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.LRNParameter"; + } + protected: + explicit LRNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef LRNParameter_NormRegion NormRegion; + static constexpr NormRegion ACROSS_CHANNELS = + LRNParameter_NormRegion_ACROSS_CHANNELS; + static constexpr NormRegion WITHIN_CHANNEL = + LRNParameter_NormRegion_WITHIN_CHANNEL; + static inline bool NormRegion_IsValid(int value) { + return LRNParameter_NormRegion_IsValid(value); + } + static constexpr NormRegion NormRegion_MIN = + LRNParameter_NormRegion_NormRegion_MIN; + static constexpr NormRegion NormRegion_MAX = + LRNParameter_NormRegion_NormRegion_MAX; + static constexpr int NormRegion_ARRAYSIZE = + LRNParameter_NormRegion_NormRegion_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + NormRegion_descriptor() { + return LRNParameter_NormRegion_descriptor(); + } + template + static inline const std::string& NormRegion_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function NormRegion_Name."); + return LRNParameter_NormRegion_Name(enum_t_value); + } + static inline bool NormRegion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + NormRegion* value) { + return LRNParameter_NormRegion_Parse(name, value); + } + + typedef LRNParameter_Engine Engine; + static constexpr Engine DEFAULT = + LRNParameter_Engine_DEFAULT; + static constexpr Engine CAFFE = + LRNParameter_Engine_CAFFE; + static constexpr Engine CUDNN = + LRNParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return LRNParameter_Engine_IsValid(value); + } + static constexpr Engine Engine_MIN = + LRNParameter_Engine_Engine_MIN; + static constexpr Engine Engine_MAX = + LRNParameter_Engine_Engine_MAX; + static constexpr int Engine_ARRAYSIZE = + LRNParameter_Engine_Engine_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Engine_descriptor() { + return LRNParameter_Engine_descriptor(); + } + template + static inline const std::string& Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Engine_Name."); + return LRNParameter_Engine_Name(enum_t_value); + } + static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Engine* value) { + return LRNParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kNormRegionFieldNumber = 4, + kEngineFieldNumber = 6, + kLocalSizeFieldNumber = 1, + kAlphaFieldNumber = 2, + kBetaFieldNumber = 3, + kKFieldNumber = 5, + }; + // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + bool has_norm_region() const; + private: + bool _internal_has_norm_region() const; + public: + void clear_norm_region(); + ::opencv_caffe::LRNParameter_NormRegion norm_region() const; + void set_norm_region(::opencv_caffe::LRNParameter_NormRegion value); + private: + ::opencv_caffe::LRNParameter_NormRegion _internal_norm_region() const; + void _internal_set_norm_region(::opencv_caffe::LRNParameter_NormRegion value); + public: + + // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + bool has_engine() const; + private: + bool _internal_has_engine() const; + public: + void clear_engine(); + ::opencv_caffe::LRNParameter_Engine engine() const; + void set_engine(::opencv_caffe::LRNParameter_Engine value); + private: + ::opencv_caffe::LRNParameter_Engine _internal_engine() const; + void _internal_set_engine(::opencv_caffe::LRNParameter_Engine value); + public: + + // optional uint32 local_size = 1 [default = 5]; + bool has_local_size() const; + private: + bool _internal_has_local_size() const; + public: + void clear_local_size(); + uint32_t local_size() const; + void set_local_size(uint32_t value); + private: + uint32_t _internal_local_size() const; + void _internal_set_local_size(uint32_t value); + public: + + // optional float alpha = 2 [default = 1]; + bool has_alpha() const; + private: + bool _internal_has_alpha() const; + public: + void clear_alpha(); + float alpha() const; + void set_alpha(float value); + private: + float _internal_alpha() const; + void _internal_set_alpha(float value); + public: + + // optional float beta = 3 [default = 0.75]; + bool has_beta() const; + private: + bool _internal_has_beta() const; + public: + void clear_beta(); + float beta() const; + void set_beta(float value); + private: + float _internal_beta() const; + void _internal_set_beta(float value); + public: + + // optional float k = 5 [default = 1]; + bool has_k() const; + private: + bool _internal_has_k() const; + public: + void clear_k(); + float k() const; + void set_k(float value); + private: + float _internal_k() const; + void _internal_set_k(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.LRNParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int norm_region_; + int engine_; + uint32_t local_size_; + float alpha_; + float beta_; + float k_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class MemoryDataParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.MemoryDataParameter) */ { + public: + inline MemoryDataParameter() : MemoryDataParameter(nullptr) {} + ~MemoryDataParameter() override; + explicit constexpr MemoryDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MemoryDataParameter(const MemoryDataParameter& from); + MemoryDataParameter(MemoryDataParameter&& from) noexcept + : MemoryDataParameter() { + *this = ::std::move(from); + } + + inline MemoryDataParameter& operator=(const MemoryDataParameter& from) { + CopyFrom(from); + return *this; + } + inline MemoryDataParameter& operator=(MemoryDataParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MemoryDataParameter& default_instance() { + return *internal_default_instance(); + } + static inline const MemoryDataParameter* internal_default_instance() { + return reinterpret_cast( + &_MemoryDataParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 45; + + friend void swap(MemoryDataParameter& a, MemoryDataParameter& b) { + a.Swap(&b); + } + inline void Swap(MemoryDataParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MemoryDataParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MemoryDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MemoryDataParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const MemoryDataParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MemoryDataParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.MemoryDataParameter"; + } + protected: + explicit MemoryDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBatchSizeFieldNumber = 1, + kChannelsFieldNumber = 2, + kHeightFieldNumber = 3, + kWidthFieldNumber = 4, + }; + // optional uint32 batch_size = 1; + bool has_batch_size() const; + private: + bool _internal_has_batch_size() const; + public: + void clear_batch_size(); + uint32_t batch_size() const; + void set_batch_size(uint32_t value); + private: + uint32_t _internal_batch_size() const; + void _internal_set_batch_size(uint32_t value); + public: + + // optional uint32 channels = 2; + bool has_channels() const; + private: + bool _internal_has_channels() const; + public: + void clear_channels(); + uint32_t channels() const; + void set_channels(uint32_t value); + private: + uint32_t _internal_channels() const; + void _internal_set_channels(uint32_t value); + public: + + // optional uint32 height = 3; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + uint32_t height() const; + void set_height(uint32_t value); + private: + uint32_t _internal_height() const; + void _internal_set_height(uint32_t value); + public: + + // optional uint32 width = 4; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + uint32_t width() const; + void set_width(uint32_t value); + private: + uint32_t _internal_width() const; + void _internal_set_width(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.MemoryDataParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t batch_size_; + uint32_t channels_; + uint32_t height_; + uint32_t width_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class MVNParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.MVNParameter) */ { + public: + inline MVNParameter() : MVNParameter(nullptr) {} + ~MVNParameter() override; + explicit constexpr MVNParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MVNParameter(const MVNParameter& from); + MVNParameter(MVNParameter&& from) noexcept + : MVNParameter() { + *this = ::std::move(from); + } + + inline MVNParameter& operator=(const MVNParameter& from) { + CopyFrom(from); + return *this; + } + inline MVNParameter& operator=(MVNParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MVNParameter& default_instance() { + return *internal_default_instance(); + } + static inline const MVNParameter* internal_default_instance() { + return reinterpret_cast( + &_MVNParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 46; + + friend void swap(MVNParameter& a, MVNParameter& b) { + a.Swap(&b); + } + inline void Swap(MVNParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MVNParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MVNParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MVNParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const MVNParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MVNParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.MVNParameter"; + } + protected: + explicit MVNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAcrossChannelsFieldNumber = 2, + kNormalizeVarianceFieldNumber = 1, + kEpsFieldNumber = 3, + }; + // optional bool across_channels = 2 [default = false]; + bool has_across_channels() const; + private: + bool _internal_has_across_channels() const; + public: + void clear_across_channels(); + bool across_channels() const; + void set_across_channels(bool value); + private: + bool _internal_across_channels() const; + void _internal_set_across_channels(bool value); + public: + + // optional bool normalize_variance = 1 [default = true]; + bool has_normalize_variance() const; + private: + bool _internal_has_normalize_variance() const; + public: + void clear_normalize_variance(); + bool normalize_variance() const; + void set_normalize_variance(bool value); + private: + bool _internal_normalize_variance() const; + void _internal_set_normalize_variance(bool value); + public: + + // optional float eps = 3 [default = 1e-09]; + bool has_eps() const; + private: + bool _internal_has_eps() const; + public: + void clear_eps(); + float eps() const; + void set_eps(float value); + private: + float _internal_eps() const; + void _internal_set_eps(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.MVNParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool across_channels_; + bool normalize_variance_; + float eps_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ParameterParameter) */ { + public: + inline ParameterParameter() : ParameterParameter(nullptr) {} + ~ParameterParameter() override; + explicit constexpr ParameterParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterParameter(const ParameterParameter& from); + ParameterParameter(ParameterParameter&& from) noexcept + : ParameterParameter() { + *this = ::std::move(from); + } + + inline ParameterParameter& operator=(const ParameterParameter& from) { + CopyFrom(from); + return *this; + } + inline ParameterParameter& operator=(ParameterParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ParameterParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterParameter* internal_default_instance() { + return reinterpret_cast( + &_ParameterParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 47; + + friend void swap(ParameterParameter& a, ParameterParameter& b) { + a.Swap(&b); + } + inline void Swap(ParameterParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ParameterParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ParameterParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ParameterParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ParameterParameter"; + } + protected: + explicit ParameterParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShapeFieldNumber = 1, + }; + // optional .opencv_caffe.BlobShape shape = 1; + bool has_shape() const; + private: + bool _internal_has_shape() const; + public: + void clear_shape(); + const ::opencv_caffe::BlobShape& shape() const; + PROTOBUF_NODISCARD ::opencv_caffe::BlobShape* release_shape(); + ::opencv_caffe::BlobShape* mutable_shape(); + void set_allocated_shape(::opencv_caffe::BlobShape* shape); + private: + const ::opencv_caffe::BlobShape& _internal_shape() const; + ::opencv_caffe::BlobShape* _internal_mutable_shape(); + public: + void unsafe_arena_set_allocated_shape( + ::opencv_caffe::BlobShape* shape); + ::opencv_caffe::BlobShape* unsafe_arena_release_shape(); + + // @@protoc_insertion_point(class_scope:opencv_caffe.ParameterParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::BlobShape* shape_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class PoolingParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PoolingParameter) */ { + public: + inline PoolingParameter() : PoolingParameter(nullptr) {} + ~PoolingParameter() override; + explicit constexpr PoolingParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PoolingParameter(const PoolingParameter& from); + PoolingParameter(PoolingParameter&& from) noexcept + : PoolingParameter() { + *this = ::std::move(from); + } + + inline PoolingParameter& operator=(const PoolingParameter& from) { + CopyFrom(from); + return *this; + } + inline PoolingParameter& operator=(PoolingParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PoolingParameter& default_instance() { + return *internal_default_instance(); + } + static inline const PoolingParameter* internal_default_instance() { + return reinterpret_cast( + &_PoolingParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 48; + + friend void swap(PoolingParameter& a, PoolingParameter& b) { + a.Swap(&b); + } + inline void Swap(PoolingParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PoolingParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PoolingParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PoolingParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const PoolingParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PoolingParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.PoolingParameter"; + } + protected: + explicit PoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef PoolingParameter_PoolMethod PoolMethod; + static constexpr PoolMethod MAX = + PoolingParameter_PoolMethod_MAX; + static constexpr PoolMethod AVE = + PoolingParameter_PoolMethod_AVE; + static constexpr PoolMethod STOCHASTIC = + PoolingParameter_PoolMethod_STOCHASTIC; + static inline bool PoolMethod_IsValid(int value) { + return PoolingParameter_PoolMethod_IsValid(value); + } + static constexpr PoolMethod PoolMethod_MIN = + PoolingParameter_PoolMethod_PoolMethod_MIN; + static constexpr PoolMethod PoolMethod_MAX = + PoolingParameter_PoolMethod_PoolMethod_MAX; + static constexpr int PoolMethod_ARRAYSIZE = + PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + PoolMethod_descriptor() { + return PoolingParameter_PoolMethod_descriptor(); + } + template + static inline const std::string& PoolMethod_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PoolMethod_Name."); + return PoolingParameter_PoolMethod_Name(enum_t_value); + } + static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + PoolMethod* value) { + return PoolingParameter_PoolMethod_Parse(name, value); + } + + typedef PoolingParameter_Engine Engine; + static constexpr Engine DEFAULT = + PoolingParameter_Engine_DEFAULT; + static constexpr Engine CAFFE = + PoolingParameter_Engine_CAFFE; + static constexpr Engine CUDNN = + PoolingParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return PoolingParameter_Engine_IsValid(value); + } + static constexpr Engine Engine_MIN = + PoolingParameter_Engine_Engine_MIN; + static constexpr Engine Engine_MAX = + PoolingParameter_Engine_Engine_MAX; + static constexpr int Engine_ARRAYSIZE = + PoolingParameter_Engine_Engine_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Engine_descriptor() { + return PoolingParameter_Engine_descriptor(); + } + template + static inline const std::string& Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Engine_Name."); + return PoolingParameter_Engine_Name(enum_t_value); + } + static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Engine* value) { + return PoolingParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kPoolFieldNumber = 1, + kKernelSizeFieldNumber = 2, + kPadFieldNumber = 4, + kKernelHFieldNumber = 5, + kKernelWFieldNumber = 6, + kStrideHFieldNumber = 7, + kStrideWFieldNumber = 8, + kPadHFieldNumber = 9, + kPadWFieldNumber = 10, + kEngineFieldNumber = 11, + kGlobalPoolingFieldNumber = 12, + kStrideFieldNumber = 3, + kCeilModeFieldNumber = 13, + }; + // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + bool has_pool() const; + private: + bool _internal_has_pool() const; + public: + void clear_pool(); + ::opencv_caffe::PoolingParameter_PoolMethod pool() const; + void set_pool(::opencv_caffe::PoolingParameter_PoolMethod value); + private: + ::opencv_caffe::PoolingParameter_PoolMethod _internal_pool() const; + void _internal_set_pool(::opencv_caffe::PoolingParameter_PoolMethod value); + public: + + // optional uint32 kernel_size = 2; + bool has_kernel_size() const; + private: + bool _internal_has_kernel_size() const; + public: + void clear_kernel_size(); + uint32_t kernel_size() const; + void set_kernel_size(uint32_t value); + private: + uint32_t _internal_kernel_size() const; + void _internal_set_kernel_size(uint32_t value); + public: + + // optional uint32 pad = 4 [default = 0]; + bool has_pad() const; + private: + bool _internal_has_pad() const; + public: + void clear_pad(); + uint32_t pad() const; + void set_pad(uint32_t value); + private: + uint32_t _internal_pad() const; + void _internal_set_pad(uint32_t value); + public: + + // optional uint32 kernel_h = 5; + bool has_kernel_h() const; + private: + bool _internal_has_kernel_h() const; + public: + void clear_kernel_h(); + uint32_t kernel_h() const; + void set_kernel_h(uint32_t value); + private: + uint32_t _internal_kernel_h() const; + void _internal_set_kernel_h(uint32_t value); + public: + + // optional uint32 kernel_w = 6; + bool has_kernel_w() const; + private: + bool _internal_has_kernel_w() const; + public: + void clear_kernel_w(); + uint32_t kernel_w() const; + void set_kernel_w(uint32_t value); + private: + uint32_t _internal_kernel_w() const; + void _internal_set_kernel_w(uint32_t value); + public: + + // optional uint32 stride_h = 7; + bool has_stride_h() const; + private: + bool _internal_has_stride_h() const; + public: + void clear_stride_h(); + uint32_t stride_h() const; + void set_stride_h(uint32_t value); + private: + uint32_t _internal_stride_h() const; + void _internal_set_stride_h(uint32_t value); + public: + + // optional uint32 stride_w = 8; + bool has_stride_w() const; + private: + bool _internal_has_stride_w() const; + public: + void clear_stride_w(); + uint32_t stride_w() const; + void set_stride_w(uint32_t value); + private: + uint32_t _internal_stride_w() const; + void _internal_set_stride_w(uint32_t value); + public: + + // optional uint32 pad_h = 9 [default = 0]; + bool has_pad_h() const; + private: + bool _internal_has_pad_h() const; + public: + void clear_pad_h(); + uint32_t pad_h() const; + void set_pad_h(uint32_t value); + private: + uint32_t _internal_pad_h() const; + void _internal_set_pad_h(uint32_t value); + public: + + // optional uint32 pad_w = 10 [default = 0]; + bool has_pad_w() const; + private: + bool _internal_has_pad_w() const; + public: + void clear_pad_w(); + uint32_t pad_w() const; + void set_pad_w(uint32_t value); + private: + uint32_t _internal_pad_w() const; + void _internal_set_pad_w(uint32_t value); + public: + + // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + bool has_engine() const; + private: + bool _internal_has_engine() const; + public: + void clear_engine(); + ::opencv_caffe::PoolingParameter_Engine engine() const; + void set_engine(::opencv_caffe::PoolingParameter_Engine value); + private: + ::opencv_caffe::PoolingParameter_Engine _internal_engine() const; + void _internal_set_engine(::opencv_caffe::PoolingParameter_Engine value); + public: + + // optional bool global_pooling = 12 [default = false]; + bool has_global_pooling() const; + private: + bool _internal_has_global_pooling() const; + public: + void clear_global_pooling(); + bool global_pooling() const; + void set_global_pooling(bool value); + private: + bool _internal_global_pooling() const; + void _internal_set_global_pooling(bool value); + public: + + // optional uint32 stride = 3 [default = 1]; + bool has_stride() const; + private: + bool _internal_has_stride() const; + public: + void clear_stride(); + uint32_t stride() const; + void set_stride(uint32_t value); + private: + uint32_t _internal_stride() const; + void _internal_set_stride(uint32_t value); + public: + + // optional bool ceil_mode = 13 [default = true]; + bool has_ceil_mode() const; + private: + bool _internal_has_ceil_mode() const; + public: + void clear_ceil_mode(); + bool ceil_mode() const; + void set_ceil_mode(bool value); + private: + bool _internal_ceil_mode() const; + void _internal_set_ceil_mode(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.PoolingParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int pool_; + uint32_t kernel_size_; + uint32_t pad_; + uint32_t kernel_h_; + uint32_t kernel_w_; + uint32_t stride_h_; + uint32_t stride_w_; + uint32_t pad_h_; + uint32_t pad_w_; + int engine_; + bool global_pooling_; + uint32_t stride_; + bool ceil_mode_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class PowerParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PowerParameter) */ { + public: + inline PowerParameter() : PowerParameter(nullptr) {} + ~PowerParameter() override; + explicit constexpr PowerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PowerParameter(const PowerParameter& from); + PowerParameter(PowerParameter&& from) noexcept + : PowerParameter() { + *this = ::std::move(from); + } + + inline PowerParameter& operator=(const PowerParameter& from) { + CopyFrom(from); + return *this; + } + inline PowerParameter& operator=(PowerParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PowerParameter& default_instance() { + return *internal_default_instance(); + } + static inline const PowerParameter* internal_default_instance() { + return reinterpret_cast( + &_PowerParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 49; + + friend void swap(PowerParameter& a, PowerParameter& b) { + a.Swap(&b); + } + inline void Swap(PowerParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PowerParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PowerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PowerParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const PowerParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PowerParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.PowerParameter"; + } + protected: + explicit PowerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShiftFieldNumber = 3, + kPowerFieldNumber = 1, + kScaleFieldNumber = 2, + }; + // optional float shift = 3 [default = 0]; + bool has_shift() const; + private: + bool _internal_has_shift() const; + public: + void clear_shift(); + float shift() const; + void set_shift(float value); + private: + float _internal_shift() const; + void _internal_set_shift(float value); + public: + + // optional float power = 1 [default = 1]; + bool has_power() const; + private: + bool _internal_has_power() const; + public: + void clear_power(); + float power() const; + void set_power(float value); + private: + float _internal_power() const; + void _internal_set_power(float value); + public: + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.PowerParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float shift_; + float power_; + float scale_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class PythonParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PythonParameter) */ { + public: + inline PythonParameter() : PythonParameter(nullptr) {} + ~PythonParameter() override; + explicit constexpr PythonParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PythonParameter(const PythonParameter& from); + PythonParameter(PythonParameter&& from) noexcept + : PythonParameter() { + *this = ::std::move(from); + } + + inline PythonParameter& operator=(const PythonParameter& from) { + CopyFrom(from); + return *this; + } + inline PythonParameter& operator=(PythonParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PythonParameter& default_instance() { + return *internal_default_instance(); + } + static inline const PythonParameter* internal_default_instance() { + return reinterpret_cast( + &_PythonParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 50; + + friend void swap(PythonParameter& a, PythonParameter& b) { + a.Swap(&b); + } + inline void Swap(PythonParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PythonParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PythonParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PythonParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const PythonParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PythonParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.PythonParameter"; + } + protected: + explicit PythonParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kModuleFieldNumber = 1, + kLayerFieldNumber = 2, + kParamStrFieldNumber = 3, + kShareInParallelFieldNumber = 4, + }; + // optional string module = 1; + bool has_module() const; + private: + bool _internal_has_module() const; + public: + void clear_module(); + const std::string& module() const; + template + void set_module(ArgT0&& arg0, ArgT... args); + std::string* mutable_module(); + PROTOBUF_NODISCARD std::string* release_module(); + void set_allocated_module(std::string* module); + private: + const std::string& _internal_module() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_module(const std::string& value); + std::string* _internal_mutable_module(); + public: + + // optional string layer = 2; + bool has_layer() const; + private: + bool _internal_has_layer() const; + public: + void clear_layer(); + const std::string& layer() const; + template + void set_layer(ArgT0&& arg0, ArgT... args); + std::string* mutable_layer(); + PROTOBUF_NODISCARD std::string* release_layer(); + void set_allocated_layer(std::string* layer); + private: + const std::string& _internal_layer() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_layer(const std::string& value); + std::string* _internal_mutable_layer(); + public: + + // optional string param_str = 3 [default = ""]; + bool has_param_str() const; + private: + bool _internal_has_param_str() const; + public: + void clear_param_str(); + const std::string& param_str() const; + template + void set_param_str(ArgT0&& arg0, ArgT... args); + std::string* mutable_param_str(); + PROTOBUF_NODISCARD std::string* release_param_str(); + void set_allocated_param_str(std::string* param_str); + private: + const std::string& _internal_param_str() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_param_str(const std::string& value); + std::string* _internal_mutable_param_str(); + public: + + // optional bool share_in_parallel = 4 [default = false]; + bool has_share_in_parallel() const; + private: + bool _internal_has_share_in_parallel() const; + public: + void clear_share_in_parallel(); + bool share_in_parallel() const; + void set_share_in_parallel(bool value); + private: + bool _internal_share_in_parallel() const; + void _internal_set_share_in_parallel(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.PythonParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr module_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr layer_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param_str_; + bool share_in_parallel_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class RecurrentParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.RecurrentParameter) */ { + public: + inline RecurrentParameter() : RecurrentParameter(nullptr) {} + ~RecurrentParameter() override; + explicit constexpr RecurrentParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RecurrentParameter(const RecurrentParameter& from); + RecurrentParameter(RecurrentParameter&& from) noexcept + : RecurrentParameter() { + *this = ::std::move(from); + } + + inline RecurrentParameter& operator=(const RecurrentParameter& from) { + CopyFrom(from); + return *this; + } + inline RecurrentParameter& operator=(RecurrentParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RecurrentParameter& default_instance() { + return *internal_default_instance(); + } + static inline const RecurrentParameter* internal_default_instance() { + return reinterpret_cast( + &_RecurrentParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 51; + + friend void swap(RecurrentParameter& a, RecurrentParameter& b) { + a.Swap(&b); + } + inline void Swap(RecurrentParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RecurrentParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RecurrentParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const RecurrentParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const RecurrentParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RecurrentParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.RecurrentParameter"; + } + protected: + explicit RecurrentParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kWeightFillerFieldNumber = 2, + kBiasFillerFieldNumber = 3, + kNumOutputFieldNumber = 1, + kDebugInfoFieldNumber = 4, + kExposeHiddenFieldNumber = 5, + }; + // optional .opencv_caffe.FillerParameter weight_filler = 2; + bool has_weight_filler() const; + private: + bool _internal_has_weight_filler() const; + public: + void clear_weight_filler(); + const ::opencv_caffe::FillerParameter& weight_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler(); + ::opencv_caffe::FillerParameter* mutable_weight_filler(); + void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_weight_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler(); + public: + void unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler(); + + // optional .opencv_caffe.FillerParameter bias_filler = 3; + bool has_bias_filler() const; + private: + bool _internal_has_bias_filler() const; + public: + void clear_bias_filler(); + const ::opencv_caffe::FillerParameter& bias_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler(); + ::opencv_caffe::FillerParameter* mutable_bias_filler(); + void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_bias_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler(); + public: + void unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler(); + + // optional uint32 num_output = 1 [default = 0]; + bool has_num_output() const; + private: + bool _internal_has_num_output() const; + public: + void clear_num_output(); + uint32_t num_output() const; + void set_num_output(uint32_t value); + private: + uint32_t _internal_num_output() const; + void _internal_set_num_output(uint32_t value); + public: + + // optional bool debug_info = 4 [default = false]; + bool has_debug_info() const; + private: + bool _internal_has_debug_info() const; + public: + void clear_debug_info(); + bool debug_info() const; + void set_debug_info(bool value); + private: + bool _internal_debug_info() const; + void _internal_set_debug_info(bool value); + public: + + // optional bool expose_hidden = 5 [default = false]; + bool has_expose_hidden() const; + private: + bool _internal_has_expose_hidden() const; + public: + void clear_expose_hidden(); + bool expose_hidden() const; + void set_expose_hidden(bool value); + private: + bool _internal_expose_hidden() const; + void _internal_set_expose_hidden(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.RecurrentParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::FillerParameter* weight_filler_; + ::opencv_caffe::FillerParameter* bias_filler_; + uint32_t num_output_; + bool debug_info_; + bool expose_hidden_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ReductionParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReductionParameter) */ { + public: + inline ReductionParameter() : ReductionParameter(nullptr) {} + ~ReductionParameter() override; + explicit constexpr ReductionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReductionParameter(const ReductionParameter& from); + ReductionParameter(ReductionParameter&& from) noexcept + : ReductionParameter() { + *this = ::std::move(from); + } + + inline ReductionParameter& operator=(const ReductionParameter& from) { + CopyFrom(from); + return *this; + } + inline ReductionParameter& operator=(ReductionParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ReductionParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ReductionParameter* internal_default_instance() { + return reinterpret_cast( + &_ReductionParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 52; + + friend void swap(ReductionParameter& a, ReductionParameter& b) { + a.Swap(&b); + } + inline void Swap(ReductionParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReductionParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ReductionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ReductionParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ReductionParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReductionParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ReductionParameter"; + } + protected: + explicit ReductionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ReductionParameter_ReductionOp ReductionOp; + static constexpr ReductionOp SUM = + ReductionParameter_ReductionOp_SUM; + static constexpr ReductionOp ASUM = + ReductionParameter_ReductionOp_ASUM; + static constexpr ReductionOp SUMSQ = + ReductionParameter_ReductionOp_SUMSQ; + static constexpr ReductionOp MEAN = + ReductionParameter_ReductionOp_MEAN; + static inline bool ReductionOp_IsValid(int value) { + return ReductionParameter_ReductionOp_IsValid(value); + } + static constexpr ReductionOp ReductionOp_MIN = + ReductionParameter_ReductionOp_ReductionOp_MIN; + static constexpr ReductionOp ReductionOp_MAX = + ReductionParameter_ReductionOp_ReductionOp_MAX; + static constexpr int ReductionOp_ARRAYSIZE = + ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ReductionOp_descriptor() { + return ReductionParameter_ReductionOp_descriptor(); + } + template + static inline const std::string& ReductionOp_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ReductionOp_Name."); + return ReductionParameter_ReductionOp_Name(enum_t_value); + } + static inline bool ReductionOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ReductionOp* value) { + return ReductionParameter_ReductionOp_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kAxisFieldNumber = 2, + kOperationFieldNumber = 1, + kCoeffFieldNumber = 3, + }; + // optional int32 axis = 2 [default = 0]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + bool has_operation() const; + private: + bool _internal_has_operation() const; + public: + void clear_operation(); + ::opencv_caffe::ReductionParameter_ReductionOp operation() const; + void set_operation(::opencv_caffe::ReductionParameter_ReductionOp value); + private: + ::opencv_caffe::ReductionParameter_ReductionOp _internal_operation() const; + void _internal_set_operation(::opencv_caffe::ReductionParameter_ReductionOp value); + public: + + // optional float coeff = 3 [default = 1]; + bool has_coeff() const; + private: + bool _internal_has_coeff() const; + public: + void clear_coeff(); + float coeff() const; + void set_coeff(float value); + private: + float _internal_coeff() const; + void _internal_set_coeff(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ReductionParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int32_t axis_; + int operation_; + float coeff_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ReLUParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReLUParameter) */ { + public: + inline ReLUParameter() : ReLUParameter(nullptr) {} + ~ReLUParameter() override; + explicit constexpr ReLUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReLUParameter(const ReLUParameter& from); + ReLUParameter(ReLUParameter&& from) noexcept + : ReLUParameter() { + *this = ::std::move(from); + } + + inline ReLUParameter& operator=(const ReLUParameter& from) { + CopyFrom(from); + return *this; + } + inline ReLUParameter& operator=(ReLUParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ReLUParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ReLUParameter* internal_default_instance() { + return reinterpret_cast( + &_ReLUParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 53; + + friend void swap(ReLUParameter& a, ReLUParameter& b) { + a.Swap(&b); + } + inline void Swap(ReLUParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReLUParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ReLUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ReLUParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ReLUParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReLUParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ReLUParameter"; + } + protected: + explicit ReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ReLUParameter_Engine Engine; + static constexpr Engine DEFAULT = + ReLUParameter_Engine_DEFAULT; + static constexpr Engine CAFFE = + ReLUParameter_Engine_CAFFE; + static constexpr Engine CUDNN = + ReLUParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return ReLUParameter_Engine_IsValid(value); + } + static constexpr Engine Engine_MIN = + ReLUParameter_Engine_Engine_MIN; + static constexpr Engine Engine_MAX = + ReLUParameter_Engine_Engine_MAX; + static constexpr int Engine_ARRAYSIZE = + ReLUParameter_Engine_Engine_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Engine_descriptor() { + return ReLUParameter_Engine_descriptor(); + } + template + static inline const std::string& Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Engine_Name."); + return ReLUParameter_Engine_Name(enum_t_value); + } + static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Engine* value) { + return ReLUParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kNegativeSlopeFieldNumber = 1, + kEngineFieldNumber = 2, + }; + // optional float negative_slope = 1 [default = 0]; + bool has_negative_slope() const; + private: + bool _internal_has_negative_slope() const; + public: + void clear_negative_slope(); + float negative_slope() const; + void set_negative_slope(float value); + private: + float _internal_negative_slope() const; + void _internal_set_negative_slope(float value); + public: + + // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + bool has_engine() const; + private: + bool _internal_has_engine() const; + public: + void clear_engine(); + ::opencv_caffe::ReLUParameter_Engine engine() const; + void set_engine(::opencv_caffe::ReLUParameter_Engine value); + private: + ::opencv_caffe::ReLUParameter_Engine _internal_engine() const; + void _internal_set_engine(::opencv_caffe::ReLUParameter_Engine value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ReLUParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float negative_slope_; + int engine_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ReshapeParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReshapeParameter) */ { + public: + inline ReshapeParameter() : ReshapeParameter(nullptr) {} + ~ReshapeParameter() override; + explicit constexpr ReshapeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReshapeParameter(const ReshapeParameter& from); + ReshapeParameter(ReshapeParameter&& from) noexcept + : ReshapeParameter() { + *this = ::std::move(from); + } + + inline ReshapeParameter& operator=(const ReshapeParameter& from) { + CopyFrom(from); + return *this; + } + inline ReshapeParameter& operator=(ReshapeParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ReshapeParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ReshapeParameter* internal_default_instance() { + return reinterpret_cast( + &_ReshapeParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 54; + + friend void swap(ReshapeParameter& a, ReshapeParameter& b) { + a.Swap(&b); + } + inline void Swap(ReshapeParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReshapeParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ReshapeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ReshapeParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ReshapeParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReshapeParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ReshapeParameter"; + } + protected: + explicit ReshapeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShapeFieldNumber = 1, + kAxisFieldNumber = 2, + kNumAxesFieldNumber = 3, + }; + // optional .opencv_caffe.BlobShape shape = 1; + bool has_shape() const; + private: + bool _internal_has_shape() const; + public: + void clear_shape(); + const ::opencv_caffe::BlobShape& shape() const; + PROTOBUF_NODISCARD ::opencv_caffe::BlobShape* release_shape(); + ::opencv_caffe::BlobShape* mutable_shape(); + void set_allocated_shape(::opencv_caffe::BlobShape* shape); + private: + const ::opencv_caffe::BlobShape& _internal_shape() const; + ::opencv_caffe::BlobShape* _internal_mutable_shape(); + public: + void unsafe_arena_set_allocated_shape( + ::opencv_caffe::BlobShape* shape); + ::opencv_caffe::BlobShape* unsafe_arena_release_shape(); + + // optional int32 axis = 2 [default = 0]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // optional int32 num_axes = 3 [default = -1]; + bool has_num_axes() const; + private: + bool _internal_has_num_axes() const; + public: + void clear_num_axes(); + int32_t num_axes() const; + void set_num_axes(int32_t value); + private: + int32_t _internal_num_axes() const; + void _internal_set_num_axes(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ReshapeParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::BlobShape* shape_; + int32_t axis_; + int32_t num_axes_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ScaleParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ScaleParameter) */ { + public: + inline ScaleParameter() : ScaleParameter(nullptr) {} + ~ScaleParameter() override; + explicit constexpr ScaleParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ScaleParameter(const ScaleParameter& from); + ScaleParameter(ScaleParameter&& from) noexcept + : ScaleParameter() { + *this = ::std::move(from); + } + + inline ScaleParameter& operator=(const ScaleParameter& from) { + CopyFrom(from); + return *this; + } + inline ScaleParameter& operator=(ScaleParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ScaleParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ScaleParameter* internal_default_instance() { + return reinterpret_cast( + &_ScaleParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 55; + + friend void swap(ScaleParameter& a, ScaleParameter& b) { + a.Swap(&b); + } + inline void Swap(ScaleParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ScaleParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScaleParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ScaleParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ScaleParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ScaleParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ScaleParameter"; + } + protected: + explicit ScaleParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFillerFieldNumber = 3, + kBiasFillerFieldNumber = 5, + kBiasTermFieldNumber = 4, + kAxisFieldNumber = 1, + kNumAxesFieldNumber = 2, + }; + // optional .opencv_caffe.FillerParameter filler = 3; + bool has_filler() const; + private: + bool _internal_has_filler() const; + public: + void clear_filler(); + const ::opencv_caffe::FillerParameter& filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_filler(); + ::opencv_caffe::FillerParameter* mutable_filler(); + void set_allocated_filler(::opencv_caffe::FillerParameter* filler); + private: + const ::opencv_caffe::FillerParameter& _internal_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_filler(); + public: + void unsafe_arena_set_allocated_filler( + ::opencv_caffe::FillerParameter* filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_filler(); + + // optional .opencv_caffe.FillerParameter bias_filler = 5; + bool has_bias_filler() const; + private: + bool _internal_has_bias_filler() const; + public: + void clear_bias_filler(); + const ::opencv_caffe::FillerParameter& bias_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler(); + ::opencv_caffe::FillerParameter* mutable_bias_filler(); + void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_bias_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler(); + public: + void unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler(); + + // optional bool bias_term = 4 [default = false]; + bool has_bias_term() const; + private: + bool _internal_has_bias_term() const; + public: + void clear_bias_term(); + bool bias_term() const; + void set_bias_term(bool value); + private: + bool _internal_bias_term() const; + void _internal_set_bias_term(bool value); + public: + + // optional int32 axis = 1 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // optional int32 num_axes = 2 [default = 1]; + bool has_num_axes() const; + private: + bool _internal_has_num_axes() const; + public: + void clear_num_axes(); + int32_t num_axes() const; + void set_num_axes(int32_t value); + private: + int32_t _internal_num_axes() const; + void _internal_set_num_axes(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ScaleParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::FillerParameter* filler_; + ::opencv_caffe::FillerParameter* bias_filler_; + bool bias_term_; + int32_t axis_; + int32_t num_axes_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class SigmoidParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SigmoidParameter) */ { + public: + inline SigmoidParameter() : SigmoidParameter(nullptr) {} + ~SigmoidParameter() override; + explicit constexpr SigmoidParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SigmoidParameter(const SigmoidParameter& from); + SigmoidParameter(SigmoidParameter&& from) noexcept + : SigmoidParameter() { + *this = ::std::move(from); + } + + inline SigmoidParameter& operator=(const SigmoidParameter& from) { + CopyFrom(from); + return *this; + } + inline SigmoidParameter& operator=(SigmoidParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SigmoidParameter& default_instance() { + return *internal_default_instance(); + } + static inline const SigmoidParameter* internal_default_instance() { + return reinterpret_cast( + &_SigmoidParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 56; + + friend void swap(SigmoidParameter& a, SigmoidParameter& b) { + a.Swap(&b); + } + inline void Swap(SigmoidParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SigmoidParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SigmoidParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SigmoidParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const SigmoidParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SigmoidParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.SigmoidParameter"; + } + protected: + explicit SigmoidParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SigmoidParameter_Engine Engine; + static constexpr Engine DEFAULT = + SigmoidParameter_Engine_DEFAULT; + static constexpr Engine CAFFE = + SigmoidParameter_Engine_CAFFE; + static constexpr Engine CUDNN = + SigmoidParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return SigmoidParameter_Engine_IsValid(value); + } + static constexpr Engine Engine_MIN = + SigmoidParameter_Engine_Engine_MIN; + static constexpr Engine Engine_MAX = + SigmoidParameter_Engine_Engine_MAX; + static constexpr int Engine_ARRAYSIZE = + SigmoidParameter_Engine_Engine_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Engine_descriptor() { + return SigmoidParameter_Engine_descriptor(); + } + template + static inline const std::string& Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Engine_Name."); + return SigmoidParameter_Engine_Name(enum_t_value); + } + static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Engine* value) { + return SigmoidParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kEngineFieldNumber = 1, + }; + // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + bool has_engine() const; + private: + bool _internal_has_engine() const; + public: + void clear_engine(); + ::opencv_caffe::SigmoidParameter_Engine engine() const; + void set_engine(::opencv_caffe::SigmoidParameter_Engine value); + private: + ::opencv_caffe::SigmoidParameter_Engine _internal_engine() const; + void _internal_set_engine(::opencv_caffe::SigmoidParameter_Engine value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.SigmoidParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int engine_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class SliceParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SliceParameter) */ { + public: + inline SliceParameter() : SliceParameter(nullptr) {} + ~SliceParameter() override; + explicit constexpr SliceParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SliceParameter(const SliceParameter& from); + SliceParameter(SliceParameter&& from) noexcept + : SliceParameter() { + *this = ::std::move(from); + } + + inline SliceParameter& operator=(const SliceParameter& from) { + CopyFrom(from); + return *this; + } + inline SliceParameter& operator=(SliceParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SliceParameter& default_instance() { + return *internal_default_instance(); + } + static inline const SliceParameter* internal_default_instance() { + return reinterpret_cast( + &_SliceParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 57; + + friend void swap(SliceParameter& a, SliceParameter& b) { + a.Swap(&b); + } + inline void Swap(SliceParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SliceParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SliceParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SliceParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const SliceParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SliceParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.SliceParameter"; + } + protected: + explicit SliceParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSlicePointFieldNumber = 2, + kSliceDimFieldNumber = 1, + kAxisFieldNumber = 3, + }; + // repeated uint32 slice_point = 2; + int slice_point_size() const; + private: + int _internal_slice_point_size() const; + public: + void clear_slice_point(); + private: + uint32_t _internal_slice_point(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_slice_point() const; + void _internal_add_slice_point(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_slice_point(); + public: + uint32_t slice_point(int index) const; + void set_slice_point(int index, uint32_t value); + void add_slice_point(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + slice_point() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_slice_point(); + + // optional uint32 slice_dim = 1 [default = 1]; + bool has_slice_dim() const; + private: + bool _internal_has_slice_dim() const; + public: + void clear_slice_dim(); + uint32_t slice_dim() const; + void set_slice_dim(uint32_t value); + private: + uint32_t _internal_slice_dim() const; + void _internal_set_slice_dim(uint32_t value); + public: + + // optional int32 axis = 3 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.SliceParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > slice_point_; + uint32_t slice_dim_; + int32_t axis_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class SoftmaxParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SoftmaxParameter) */ { + public: + inline SoftmaxParameter() : SoftmaxParameter(nullptr) {} + ~SoftmaxParameter() override; + explicit constexpr SoftmaxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SoftmaxParameter(const SoftmaxParameter& from); + SoftmaxParameter(SoftmaxParameter&& from) noexcept + : SoftmaxParameter() { + *this = ::std::move(from); + } + + inline SoftmaxParameter& operator=(const SoftmaxParameter& from) { + CopyFrom(from); + return *this; + } + inline SoftmaxParameter& operator=(SoftmaxParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SoftmaxParameter& default_instance() { + return *internal_default_instance(); + } + static inline const SoftmaxParameter* internal_default_instance() { + return reinterpret_cast( + &_SoftmaxParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 58; + + friend void swap(SoftmaxParameter& a, SoftmaxParameter& b) { + a.Swap(&b); + } + inline void Swap(SoftmaxParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SoftmaxParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SoftmaxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SoftmaxParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const SoftmaxParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SoftmaxParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.SoftmaxParameter"; + } + protected: + explicit SoftmaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SoftmaxParameter_Engine Engine; + static constexpr Engine DEFAULT = + SoftmaxParameter_Engine_DEFAULT; + static constexpr Engine CAFFE = + SoftmaxParameter_Engine_CAFFE; + static constexpr Engine CUDNN = + SoftmaxParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return SoftmaxParameter_Engine_IsValid(value); + } + static constexpr Engine Engine_MIN = + SoftmaxParameter_Engine_Engine_MIN; + static constexpr Engine Engine_MAX = + SoftmaxParameter_Engine_Engine_MAX; + static constexpr int Engine_ARRAYSIZE = + SoftmaxParameter_Engine_Engine_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Engine_descriptor() { + return SoftmaxParameter_Engine_descriptor(); + } + template + static inline const std::string& Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Engine_Name."); + return SoftmaxParameter_Engine_Name(enum_t_value); + } + static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Engine* value) { + return SoftmaxParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kEngineFieldNumber = 1, + kAxisFieldNumber = 2, + }; + // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + bool has_engine() const; + private: + bool _internal_has_engine() const; + public: + void clear_engine(); + ::opencv_caffe::SoftmaxParameter_Engine engine() const; + void set_engine(::opencv_caffe::SoftmaxParameter_Engine value); + private: + ::opencv_caffe::SoftmaxParameter_Engine _internal_engine() const; + void _internal_set_engine(::opencv_caffe::SoftmaxParameter_Engine value); + public: + + // optional int32 axis = 2 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.SoftmaxParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int engine_; + int32_t axis_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class TanHParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TanHParameter) */ { + public: + inline TanHParameter() : TanHParameter(nullptr) {} + ~TanHParameter() override; + explicit constexpr TanHParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TanHParameter(const TanHParameter& from); + TanHParameter(TanHParameter&& from) noexcept + : TanHParameter() { + *this = ::std::move(from); + } + + inline TanHParameter& operator=(const TanHParameter& from) { + CopyFrom(from); + return *this; + } + inline TanHParameter& operator=(TanHParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const TanHParameter& default_instance() { + return *internal_default_instance(); + } + static inline const TanHParameter* internal_default_instance() { + return reinterpret_cast( + &_TanHParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 59; + + friend void swap(TanHParameter& a, TanHParameter& b) { + a.Swap(&b); + } + inline void Swap(TanHParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TanHParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TanHParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const TanHParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const TanHParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TanHParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.TanHParameter"; + } + protected: + explicit TanHParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef TanHParameter_Engine Engine; + static constexpr Engine DEFAULT = + TanHParameter_Engine_DEFAULT; + static constexpr Engine CAFFE = + TanHParameter_Engine_CAFFE; + static constexpr Engine CUDNN = + TanHParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return TanHParameter_Engine_IsValid(value); + } + static constexpr Engine Engine_MIN = + TanHParameter_Engine_Engine_MIN; + static constexpr Engine Engine_MAX = + TanHParameter_Engine_Engine_MAX; + static constexpr int Engine_ARRAYSIZE = + TanHParameter_Engine_Engine_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Engine_descriptor() { + return TanHParameter_Engine_descriptor(); + } + template + static inline const std::string& Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Engine_Name."); + return TanHParameter_Engine_Name(enum_t_value); + } + static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Engine* value) { + return TanHParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kEngineFieldNumber = 1, + }; + // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + bool has_engine() const; + private: + bool _internal_has_engine() const; + public: + void clear_engine(); + ::opencv_caffe::TanHParameter_Engine engine() const; + void set_engine(::opencv_caffe::TanHParameter_Engine value); + private: + ::opencv_caffe::TanHParameter_Engine _internal_engine() const; + void _internal_set_engine(::opencv_caffe::TanHParameter_Engine value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.TanHParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int engine_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class TileParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TileParameter) */ { + public: + inline TileParameter() : TileParameter(nullptr) {} + ~TileParameter() override; + explicit constexpr TileParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TileParameter(const TileParameter& from); + TileParameter(TileParameter&& from) noexcept + : TileParameter() { + *this = ::std::move(from); + } + + inline TileParameter& operator=(const TileParameter& from) { + CopyFrom(from); + return *this; + } + inline TileParameter& operator=(TileParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const TileParameter& default_instance() { + return *internal_default_instance(); + } + static inline const TileParameter* internal_default_instance() { + return reinterpret_cast( + &_TileParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 60; + + friend void swap(TileParameter& a, TileParameter& b) { + a.Swap(&b); + } + inline void Swap(TileParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TileParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TileParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const TileParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const TileParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TileParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.TileParameter"; + } + protected: + explicit TileParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTilesFieldNumber = 2, + kAxisFieldNumber = 1, + }; + // optional int32 tiles = 2; + bool has_tiles() const; + private: + bool _internal_has_tiles() const; + public: + void clear_tiles(); + int32_t tiles() const; + void set_tiles(int32_t value); + private: + int32_t _internal_tiles() const; + void _internal_set_tiles(int32_t value); + public: + + // optional int32 axis = 1 [default = 1]; + bool has_axis() const; + private: + bool _internal_has_axis() const; + public: + void clear_axis(); + int32_t axis() const; + void set_axis(int32_t value); + private: + int32_t _internal_axis() const; + void _internal_set_axis(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.TileParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int32_t tiles_; + int32_t axis_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ThresholdParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ThresholdParameter) */ { + public: + inline ThresholdParameter() : ThresholdParameter(nullptr) {} + ~ThresholdParameter() override; + explicit constexpr ThresholdParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThresholdParameter(const ThresholdParameter& from); + ThresholdParameter(ThresholdParameter&& from) noexcept + : ThresholdParameter() { + *this = ::std::move(from); + } + + inline ThresholdParameter& operator=(const ThresholdParameter& from) { + CopyFrom(from); + return *this; + } + inline ThresholdParameter& operator=(ThresholdParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ThresholdParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ThresholdParameter* internal_default_instance() { + return reinterpret_cast( + &_ThresholdParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 61; + + friend void swap(ThresholdParameter& a, ThresholdParameter& b) { + a.Swap(&b); + } + inline void Swap(ThresholdParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThresholdParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThresholdParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ThresholdParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ThresholdParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ThresholdParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ThresholdParameter"; + } + protected: + explicit ThresholdParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kThresholdFieldNumber = 1, + }; + // optional float threshold = 1 [default = 0]; + bool has_threshold() const; + private: + bool _internal_has_threshold() const; + public: + void clear_threshold(); + float threshold() const; + void set_threshold(float value); + private: + float _internal_threshold() const; + void _internal_set_threshold(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ThresholdParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float threshold_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class WindowDataParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.WindowDataParameter) */ { + public: + inline WindowDataParameter() : WindowDataParameter(nullptr) {} + ~WindowDataParameter() override; + explicit constexpr WindowDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WindowDataParameter(const WindowDataParameter& from); + WindowDataParameter(WindowDataParameter&& from) noexcept + : WindowDataParameter() { + *this = ::std::move(from); + } + + inline WindowDataParameter& operator=(const WindowDataParameter& from) { + CopyFrom(from); + return *this; + } + inline WindowDataParameter& operator=(WindowDataParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WindowDataParameter& default_instance() { + return *internal_default_instance(); + } + static inline const WindowDataParameter* internal_default_instance() { + return reinterpret_cast( + &_WindowDataParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 62; + + friend void swap(WindowDataParameter& a, WindowDataParameter& b) { + a.Swap(&b); + } + inline void Swap(WindowDataParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WindowDataParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WindowDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const WindowDataParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const WindowDataParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(WindowDataParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.WindowDataParameter"; + } + protected: + explicit WindowDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSourceFieldNumber = 1, + kMeanFileFieldNumber = 3, + kCropModeFieldNumber = 11, + kRootFolderFieldNumber = 13, + kBatchSizeFieldNumber = 4, + kCropSizeFieldNumber = 5, + kMirrorFieldNumber = 6, + kCacheImagesFieldNumber = 12, + kContextPadFieldNumber = 10, + kScaleFieldNumber = 2, + kFgThresholdFieldNumber = 7, + kBgThresholdFieldNumber = 8, + kFgFractionFieldNumber = 9, + }; + // optional string source = 1; + bool has_source() const; + private: + bool _internal_has_source() const; + public: + void clear_source(); + const std::string& source() const; + template + void set_source(ArgT0&& arg0, ArgT... args); + std::string* mutable_source(); + PROTOBUF_NODISCARD std::string* release_source(); + void set_allocated_source(std::string* source); + private: + const std::string& _internal_source() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value); + std::string* _internal_mutable_source(); + public: + + // optional string mean_file = 3; + bool has_mean_file() const; + private: + bool _internal_has_mean_file() const; + public: + void clear_mean_file(); + const std::string& mean_file() const; + template + void set_mean_file(ArgT0&& arg0, ArgT... args); + std::string* mutable_mean_file(); + PROTOBUF_NODISCARD std::string* release_mean_file(); + void set_allocated_mean_file(std::string* mean_file); + private: + const std::string& _internal_mean_file() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value); + std::string* _internal_mutable_mean_file(); + public: + + // optional string crop_mode = 11 [default = "warp"]; + bool has_crop_mode() const; + private: + bool _internal_has_crop_mode() const; + public: + void clear_crop_mode(); + const std::string& crop_mode() const; + template + void set_crop_mode(ArgT0&& arg0, ArgT... args); + std::string* mutable_crop_mode(); + PROTOBUF_NODISCARD std::string* release_crop_mode(); + void set_allocated_crop_mode(std::string* crop_mode); + private: + const std::string& _internal_crop_mode() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_crop_mode(const std::string& value); + std::string* _internal_mutable_crop_mode(); + public: + + // optional string root_folder = 13 [default = ""]; + bool has_root_folder() const; + private: + bool _internal_has_root_folder() const; + public: + void clear_root_folder(); + const std::string& root_folder() const; + template + void set_root_folder(ArgT0&& arg0, ArgT... args); + std::string* mutable_root_folder(); + PROTOBUF_NODISCARD std::string* release_root_folder(); + void set_allocated_root_folder(std::string* root_folder); + private: + const std::string& _internal_root_folder() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_root_folder(const std::string& value); + std::string* _internal_mutable_root_folder(); + public: + + // optional uint32 batch_size = 4; + bool has_batch_size() const; + private: + bool _internal_has_batch_size() const; + public: + void clear_batch_size(); + uint32_t batch_size() const; + void set_batch_size(uint32_t value); + private: + uint32_t _internal_batch_size() const; + void _internal_set_batch_size(uint32_t value); + public: + + // optional uint32 crop_size = 5 [default = 0]; + bool has_crop_size() const; + private: + bool _internal_has_crop_size() const; + public: + void clear_crop_size(); + uint32_t crop_size() const; + void set_crop_size(uint32_t value); + private: + uint32_t _internal_crop_size() const; + void _internal_set_crop_size(uint32_t value); + public: + + // optional bool mirror = 6 [default = false]; + bool has_mirror() const; + private: + bool _internal_has_mirror() const; + public: + void clear_mirror(); + bool mirror() const; + void set_mirror(bool value); + private: + bool _internal_mirror() const; + void _internal_set_mirror(bool value); + public: + + // optional bool cache_images = 12 [default = false]; + bool has_cache_images() const; + private: + bool _internal_has_cache_images() const; + public: + void clear_cache_images(); + bool cache_images() const; + void set_cache_images(bool value); + private: + bool _internal_cache_images() const; + void _internal_set_cache_images(bool value); + public: + + // optional uint32 context_pad = 10 [default = 0]; + bool has_context_pad() const; + private: + bool _internal_has_context_pad() const; + public: + void clear_context_pad(); + uint32_t context_pad() const; + void set_context_pad(uint32_t value); + private: + uint32_t _internal_context_pad() const; + void _internal_set_context_pad(uint32_t value); + public: + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // optional float fg_threshold = 7 [default = 0.5]; + bool has_fg_threshold() const; + private: + bool _internal_has_fg_threshold() const; + public: + void clear_fg_threshold(); + float fg_threshold() const; + void set_fg_threshold(float value); + private: + float _internal_fg_threshold() const; + void _internal_set_fg_threshold(float value); + public: + + // optional float bg_threshold = 8 [default = 0.5]; + bool has_bg_threshold() const; + private: + bool _internal_has_bg_threshold() const; + public: + void clear_bg_threshold(); + float bg_threshold() const; + void set_bg_threshold(float value); + private: + float _internal_bg_threshold() const; + void _internal_set_bg_threshold(float value); + public: + + // optional float fg_fraction = 9 [default = 0.25]; + bool has_fg_fraction() const; + private: + bool _internal_has_fg_fraction() const; + public: + void clear_fg_fraction(); + float fg_fraction() const; + void set_fg_fraction(float value); + private: + float _internal_fg_fraction() const; + void _internal_set_fg_fraction(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.WindowDataParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_; + static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_crop_mode_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr crop_mode_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_folder_; + uint32_t batch_size_; + uint32_t crop_size_; + bool mirror_; + bool cache_images_; + uint32_t context_pad_; + float scale_; + float fg_threshold_; + float bg_threshold_; + float fg_fraction_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class SPPParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SPPParameter) */ { + public: + inline SPPParameter() : SPPParameter(nullptr) {} + ~SPPParameter() override; + explicit constexpr SPPParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SPPParameter(const SPPParameter& from); + SPPParameter(SPPParameter&& from) noexcept + : SPPParameter() { + *this = ::std::move(from); + } + + inline SPPParameter& operator=(const SPPParameter& from) { + CopyFrom(from); + return *this; + } + inline SPPParameter& operator=(SPPParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SPPParameter& default_instance() { + return *internal_default_instance(); + } + static inline const SPPParameter* internal_default_instance() { + return reinterpret_cast( + &_SPPParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 63; + + friend void swap(SPPParameter& a, SPPParameter& b) { + a.Swap(&b); + } + inline void Swap(SPPParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SPPParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SPPParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SPPParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const SPPParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SPPParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.SPPParameter"; + } + protected: + explicit SPPParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SPPParameter_PoolMethod PoolMethod; + static constexpr PoolMethod MAX = + SPPParameter_PoolMethod_MAX; + static constexpr PoolMethod AVE = + SPPParameter_PoolMethod_AVE; + static constexpr PoolMethod STOCHASTIC = + SPPParameter_PoolMethod_STOCHASTIC; + static inline bool PoolMethod_IsValid(int value) { + return SPPParameter_PoolMethod_IsValid(value); + } + static constexpr PoolMethod PoolMethod_MIN = + SPPParameter_PoolMethod_PoolMethod_MIN; + static constexpr PoolMethod PoolMethod_MAX = + SPPParameter_PoolMethod_PoolMethod_MAX; + static constexpr int PoolMethod_ARRAYSIZE = + SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + PoolMethod_descriptor() { + return SPPParameter_PoolMethod_descriptor(); + } + template + static inline const std::string& PoolMethod_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PoolMethod_Name."); + return SPPParameter_PoolMethod_Name(enum_t_value); + } + static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + PoolMethod* value) { + return SPPParameter_PoolMethod_Parse(name, value); + } + + typedef SPPParameter_Engine Engine; + static constexpr Engine DEFAULT = + SPPParameter_Engine_DEFAULT; + static constexpr Engine CAFFE = + SPPParameter_Engine_CAFFE; + static constexpr Engine CUDNN = + SPPParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return SPPParameter_Engine_IsValid(value); + } + static constexpr Engine Engine_MIN = + SPPParameter_Engine_Engine_MIN; + static constexpr Engine Engine_MAX = + SPPParameter_Engine_Engine_MAX; + static constexpr int Engine_ARRAYSIZE = + SPPParameter_Engine_Engine_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Engine_descriptor() { + return SPPParameter_Engine_descriptor(); + } + template + static inline const std::string& Engine_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Engine_Name."); + return SPPParameter_Engine_Name(enum_t_value); + } + static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Engine* value) { + return SPPParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kPyramidHeightFieldNumber = 1, + kPoolFieldNumber = 2, + kEngineFieldNumber = 6, + }; + // optional uint32 pyramid_height = 1; + bool has_pyramid_height() const; + private: + bool _internal_has_pyramid_height() const; + public: + void clear_pyramid_height(); + uint32_t pyramid_height() const; + void set_pyramid_height(uint32_t value); + private: + uint32_t _internal_pyramid_height() const; + void _internal_set_pyramid_height(uint32_t value); + public: + + // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + bool has_pool() const; + private: + bool _internal_has_pool() const; + public: + void clear_pool(); + ::opencv_caffe::SPPParameter_PoolMethod pool() const; + void set_pool(::opencv_caffe::SPPParameter_PoolMethod value); + private: + ::opencv_caffe::SPPParameter_PoolMethod _internal_pool() const; + void _internal_set_pool(::opencv_caffe::SPPParameter_PoolMethod value); + public: + + // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + bool has_engine() const; + private: + bool _internal_has_engine() const; + public: + void clear_engine(); + ::opencv_caffe::SPPParameter_Engine engine() const; + void set_engine(::opencv_caffe::SPPParameter_Engine value); + private: + ::opencv_caffe::SPPParameter_Engine _internal_engine() const; + void _internal_set_engine(::opencv_caffe::SPPParameter_Engine value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.SPPParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t pyramid_height_; + int pool_; + int engine_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class V1LayerParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.V1LayerParameter) */ { + public: + inline V1LayerParameter() : V1LayerParameter(nullptr) {} + ~V1LayerParameter() override; + explicit constexpr V1LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + V1LayerParameter(const V1LayerParameter& from); + V1LayerParameter(V1LayerParameter&& from) noexcept + : V1LayerParameter() { + *this = ::std::move(from); + } + + inline V1LayerParameter& operator=(const V1LayerParameter& from) { + CopyFrom(from); + return *this; + } + inline V1LayerParameter& operator=(V1LayerParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const V1LayerParameter& default_instance() { + return *internal_default_instance(); + } + static inline const V1LayerParameter* internal_default_instance() { + return reinterpret_cast( + &_V1LayerParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 64; + + friend void swap(V1LayerParameter& a, V1LayerParameter& b) { + a.Swap(&b); + } + inline void Swap(V1LayerParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(V1LayerParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + V1LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const V1LayerParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const V1LayerParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(V1LayerParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.V1LayerParameter"; + } + protected: + explicit V1LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef V1LayerParameter_LayerType LayerType; + static constexpr LayerType NONE = + V1LayerParameter_LayerType_NONE; + static constexpr LayerType ABSVAL = + V1LayerParameter_LayerType_ABSVAL; + static constexpr LayerType ACCURACY = + V1LayerParameter_LayerType_ACCURACY; + static constexpr LayerType ARGMAX = + V1LayerParameter_LayerType_ARGMAX; + static constexpr LayerType BNLL = + V1LayerParameter_LayerType_BNLL; + static constexpr LayerType CONCAT = + V1LayerParameter_LayerType_CONCAT; + static constexpr LayerType CONTRASTIVE_LOSS = + V1LayerParameter_LayerType_CONTRASTIVE_LOSS; + static constexpr LayerType CONVOLUTION = + V1LayerParameter_LayerType_CONVOLUTION; + static constexpr LayerType DATA = + V1LayerParameter_LayerType_DATA; + static constexpr LayerType DECONVOLUTION = + V1LayerParameter_LayerType_DECONVOLUTION; + static constexpr LayerType DROPOUT = + V1LayerParameter_LayerType_DROPOUT; + static constexpr LayerType DUMMY_DATA = + V1LayerParameter_LayerType_DUMMY_DATA; + static constexpr LayerType EUCLIDEAN_LOSS = + V1LayerParameter_LayerType_EUCLIDEAN_LOSS; + static constexpr LayerType ELTWISE = + V1LayerParameter_LayerType_ELTWISE; + static constexpr LayerType EXP = + V1LayerParameter_LayerType_EXP; + static constexpr LayerType FLATTEN = + V1LayerParameter_LayerType_FLATTEN; + static constexpr LayerType HDF5_DATA = + V1LayerParameter_LayerType_HDF5_DATA; + static constexpr LayerType HDF5_OUTPUT = + V1LayerParameter_LayerType_HDF5_OUTPUT; + static constexpr LayerType HINGE_LOSS = + V1LayerParameter_LayerType_HINGE_LOSS; + static constexpr LayerType IM2COL = + V1LayerParameter_LayerType_IM2COL; + static constexpr LayerType IMAGE_DATA = + V1LayerParameter_LayerType_IMAGE_DATA; + static constexpr LayerType INFOGAIN_LOSS = + V1LayerParameter_LayerType_INFOGAIN_LOSS; + static constexpr LayerType INNER_PRODUCT = + V1LayerParameter_LayerType_INNER_PRODUCT; + static constexpr LayerType LRN = + V1LayerParameter_LayerType_LRN; + static constexpr LayerType MEMORY_DATA = + V1LayerParameter_LayerType_MEMORY_DATA; + static constexpr LayerType MULTINOMIAL_LOGISTIC_LOSS = + V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS; + static constexpr LayerType MVN = + V1LayerParameter_LayerType_MVN; + static constexpr LayerType POOLING = + V1LayerParameter_LayerType_POOLING; + static constexpr LayerType POWER = + V1LayerParameter_LayerType_POWER; + static constexpr LayerType RELU = + V1LayerParameter_LayerType_RELU; + static constexpr LayerType SIGMOID = + V1LayerParameter_LayerType_SIGMOID; + static constexpr LayerType SIGMOID_CROSS_ENTROPY_LOSS = + V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS; + static constexpr LayerType SILENCE = + V1LayerParameter_LayerType_SILENCE; + static constexpr LayerType SOFTMAX = + V1LayerParameter_LayerType_SOFTMAX; + static constexpr LayerType SOFTMAX_LOSS = + V1LayerParameter_LayerType_SOFTMAX_LOSS; + static constexpr LayerType SPLIT = + V1LayerParameter_LayerType_SPLIT; + static constexpr LayerType SLICE = + V1LayerParameter_LayerType_SLICE; + static constexpr LayerType TANH = + V1LayerParameter_LayerType_TANH; + static constexpr LayerType WINDOW_DATA = + V1LayerParameter_LayerType_WINDOW_DATA; + static constexpr LayerType THRESHOLD = + V1LayerParameter_LayerType_THRESHOLD; + static inline bool LayerType_IsValid(int value) { + return V1LayerParameter_LayerType_IsValid(value); + } + static constexpr LayerType LayerType_MIN = + V1LayerParameter_LayerType_LayerType_MIN; + static constexpr LayerType LayerType_MAX = + V1LayerParameter_LayerType_LayerType_MAX; + static constexpr int LayerType_ARRAYSIZE = + V1LayerParameter_LayerType_LayerType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + LayerType_descriptor() { + return V1LayerParameter_LayerType_descriptor(); + } + template + static inline const std::string& LayerType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function LayerType_Name."); + return V1LayerParameter_LayerType_Name(enum_t_value); + } + static inline bool LayerType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + LayerType* value) { + return V1LayerParameter_LayerType_Parse(name, value); + } + + typedef V1LayerParameter_DimCheckMode DimCheckMode; + static constexpr DimCheckMode STRICT = + V1LayerParameter_DimCheckMode_STRICT; + static constexpr DimCheckMode PERMISSIVE = + V1LayerParameter_DimCheckMode_PERMISSIVE; + static inline bool DimCheckMode_IsValid(int value) { + return V1LayerParameter_DimCheckMode_IsValid(value); + } + static constexpr DimCheckMode DimCheckMode_MIN = + V1LayerParameter_DimCheckMode_DimCheckMode_MIN; + static constexpr DimCheckMode DimCheckMode_MAX = + V1LayerParameter_DimCheckMode_DimCheckMode_MAX; + static constexpr int DimCheckMode_ARRAYSIZE = + V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + DimCheckMode_descriptor() { + return V1LayerParameter_DimCheckMode_descriptor(); + } + template + static inline const std::string& DimCheckMode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DimCheckMode_Name."); + return V1LayerParameter_DimCheckMode_Name(enum_t_value); + } + static inline bool DimCheckMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + DimCheckMode* value) { + return V1LayerParameter_DimCheckMode_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kBottomFieldNumber = 2, + kTopFieldNumber = 3, + kBlobsFieldNumber = 6, + kBlobsLrFieldNumber = 7, + kWeightDecayFieldNumber = 8, + kIncludeFieldNumber = 32, + kExcludeFieldNumber = 33, + kLossWeightFieldNumber = 35, + kParamFieldNumber = 1001, + kBlobShareModeFieldNumber = 1002, + kNameFieldNumber = 4, + kLayerFieldNumber = 1, + kConcatParamFieldNumber = 9, + kConvolutionParamFieldNumber = 10, + kDataParamFieldNumber = 11, + kDropoutParamFieldNumber = 12, + kHdf5DataParamFieldNumber = 13, + kHdf5OutputParamFieldNumber = 14, + kImageDataParamFieldNumber = 15, + kInfogainLossParamFieldNumber = 16, + kInnerProductParamFieldNumber = 17, + kLrnParamFieldNumber = 18, + kPoolingParamFieldNumber = 19, + kWindowDataParamFieldNumber = 20, + kPowerParamFieldNumber = 21, + kMemoryDataParamFieldNumber = 22, + kArgmaxParamFieldNumber = 23, + kEltwiseParamFieldNumber = 24, + kThresholdParamFieldNumber = 25, + kDummyDataParamFieldNumber = 26, + kAccuracyParamFieldNumber = 27, + kHingeLossParamFieldNumber = 29, + kReluParamFieldNumber = 30, + kSliceParamFieldNumber = 31, + kMvnParamFieldNumber = 34, + kTransformParamFieldNumber = 36, + kTanhParamFieldNumber = 37, + kSigmoidParamFieldNumber = 38, + kSoftmaxParamFieldNumber = 39, + kContrastiveLossParamFieldNumber = 40, + kExpParamFieldNumber = 41, + kLossParamFieldNumber = 42, + kTypeFieldNumber = 5, + }; + // repeated string bottom = 2; + int bottom_size() const; + private: + int _internal_bottom_size() const; + public: + void clear_bottom(); + const std::string& bottom(int index) const; + std::string* mutable_bottom(int index); + void set_bottom(int index, const std::string& value); + void set_bottom(int index, std::string&& value); + 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); + void add_bottom(std::string&& value); + void add_bottom(const char* value); + void add_bottom(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& bottom() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_bottom(); + private: + const std::string& _internal_bottom(int index) const; + std::string* _internal_add_bottom(); + public: + + // repeated string top = 3; + int top_size() const; + private: + int _internal_top_size() const; + public: + void clear_top(); + const std::string& top(int index) const; + std::string* mutable_top(int index); + void set_top(int index, const std::string& value); + void set_top(int index, std::string&& value); + 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); + void add_top(std::string&& value); + void add_top(const char* value); + void add_top(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& top() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_top(); + private: + const std::string& _internal_top(int index) const; + std::string* _internal_add_top(); + public: + + // repeated .opencv_caffe.BlobProto blobs = 6; + int blobs_size() const; + private: + int _internal_blobs_size() const; + public: + void clear_blobs(); + ::opencv_caffe::BlobProto* mutable_blobs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* + mutable_blobs(); + private: + const ::opencv_caffe::BlobProto& _internal_blobs(int index) const; + ::opencv_caffe::BlobProto* _internal_add_blobs(); + public: + const ::opencv_caffe::BlobProto& blobs(int index) const; + ::opencv_caffe::BlobProto* add_blobs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >& + blobs() const; + + // repeated float blobs_lr = 7; + int blobs_lr_size() const; + private: + int _internal_blobs_lr_size() const; + public: + void clear_blobs_lr(); + private: + float _internal_blobs_lr(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_blobs_lr() const; + void _internal_add_blobs_lr(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_blobs_lr(); + public: + float blobs_lr(int index) const; + void set_blobs_lr(int index, float value); + void add_blobs_lr(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + blobs_lr() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_blobs_lr(); + + // repeated float weight_decay = 8; + int weight_decay_size() const; + private: + int _internal_weight_decay_size() const; + public: + void clear_weight_decay(); + private: + float _internal_weight_decay(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_weight_decay() const; + void _internal_add_weight_decay(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_weight_decay(); + public: + float weight_decay(int index) const; + void set_weight_decay(int index, float value); + void add_weight_decay(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + weight_decay() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_weight_decay(); + + // repeated .opencv_caffe.NetStateRule include = 32; + int include_size() const; + private: + int _internal_include_size() const; + public: + void clear_include(); + ::opencv_caffe::NetStateRule* mutable_include(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >* + mutable_include(); + private: + const ::opencv_caffe::NetStateRule& _internal_include(int index) const; + ::opencv_caffe::NetStateRule* _internal_add_include(); + public: + const ::opencv_caffe::NetStateRule& include(int index) const; + ::opencv_caffe::NetStateRule* add_include(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >& + include() const; + + // repeated .opencv_caffe.NetStateRule exclude = 33; + int exclude_size() const; + private: + int _internal_exclude_size() const; + public: + void clear_exclude(); + ::opencv_caffe::NetStateRule* mutable_exclude(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >* + mutable_exclude(); + private: + const ::opencv_caffe::NetStateRule& _internal_exclude(int index) const; + ::opencv_caffe::NetStateRule* _internal_add_exclude(); + public: + const ::opencv_caffe::NetStateRule& exclude(int index) const; + ::opencv_caffe::NetStateRule* add_exclude(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >& + exclude() const; + + // repeated float loss_weight = 35; + int loss_weight_size() const; + private: + int _internal_loss_weight_size() const; + public: + void clear_loss_weight(); + private: + float _internal_loss_weight(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_loss_weight() const; + void _internal_add_loss_weight(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_loss_weight(); + public: + float loss_weight(int index) const; + void set_loss_weight(int index, float value); + void add_loss_weight(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + loss_weight() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_loss_weight(); + + // repeated string param = 1001; + int param_size() const; + private: + int _internal_param_size() const; + public: + void clear_param(); + const std::string& param(int index) const; + std::string* mutable_param(int index); + void set_param(int index, const std::string& value); + void set_param(int index, std::string&& value); + 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); + void add_param(std::string&& value); + void add_param(const char* value); + void add_param(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& param() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_param(); + private: + const std::string& _internal_param(int index) const; + std::string* _internal_add_param(); + public: + + // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + int blob_share_mode_size() const; + private: + int _internal_blob_share_mode_size() const; + public: + void clear_blob_share_mode(); + private: + ::opencv_caffe::V1LayerParameter_DimCheckMode _internal_blob_share_mode(int index) const; + void _internal_add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_blob_share_mode(); + public: + ::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 ::PROTOBUF_NAMESPACE_ID::RepeatedField& blob_share_mode() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_blob_share_mode(); + + // optional string name = 4; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional .opencv_caffe.V0LayerParameter layer = 1; + bool has_layer() const; + private: + bool _internal_has_layer() const; + public: + void clear_layer(); + const ::opencv_caffe::V0LayerParameter& layer() const; + PROTOBUF_NODISCARD ::opencv_caffe::V0LayerParameter* release_layer(); + ::opencv_caffe::V0LayerParameter* mutable_layer(); + void set_allocated_layer(::opencv_caffe::V0LayerParameter* layer); + private: + const ::opencv_caffe::V0LayerParameter& _internal_layer() const; + ::opencv_caffe::V0LayerParameter* _internal_mutable_layer(); + public: + void unsafe_arena_set_allocated_layer( + ::opencv_caffe::V0LayerParameter* layer); + ::opencv_caffe::V0LayerParameter* unsafe_arena_release_layer(); + + // optional .opencv_caffe.ConcatParameter concat_param = 9; + bool has_concat_param() const; + private: + bool _internal_has_concat_param() const; + public: + void clear_concat_param(); + const ::opencv_caffe::ConcatParameter& concat_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ConcatParameter* release_concat_param(); + ::opencv_caffe::ConcatParameter* mutable_concat_param(); + void set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param); + private: + const ::opencv_caffe::ConcatParameter& _internal_concat_param() const; + ::opencv_caffe::ConcatParameter* _internal_mutable_concat_param(); + public: + void unsafe_arena_set_allocated_concat_param( + ::opencv_caffe::ConcatParameter* concat_param); + ::opencv_caffe::ConcatParameter* unsafe_arena_release_concat_param(); + + // optional .opencv_caffe.ConvolutionParameter convolution_param = 10; + bool has_convolution_param() const; + private: + bool _internal_has_convolution_param() const; + public: + void clear_convolution_param(); + const ::opencv_caffe::ConvolutionParameter& convolution_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ConvolutionParameter* release_convolution_param(); + ::opencv_caffe::ConvolutionParameter* mutable_convolution_param(); + void set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param); + private: + const ::opencv_caffe::ConvolutionParameter& _internal_convolution_param() const; + ::opencv_caffe::ConvolutionParameter* _internal_mutable_convolution_param(); + public: + void unsafe_arena_set_allocated_convolution_param( + ::opencv_caffe::ConvolutionParameter* convolution_param); + ::opencv_caffe::ConvolutionParameter* unsafe_arena_release_convolution_param(); + + // optional .opencv_caffe.DataParameter data_param = 11; + bool has_data_param() const; + private: + bool _internal_has_data_param() const; + public: + void clear_data_param(); + const ::opencv_caffe::DataParameter& data_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::DataParameter* release_data_param(); + ::opencv_caffe::DataParameter* mutable_data_param(); + void set_allocated_data_param(::opencv_caffe::DataParameter* data_param); + private: + const ::opencv_caffe::DataParameter& _internal_data_param() const; + ::opencv_caffe::DataParameter* _internal_mutable_data_param(); + public: + void unsafe_arena_set_allocated_data_param( + ::opencv_caffe::DataParameter* data_param); + ::opencv_caffe::DataParameter* unsafe_arena_release_data_param(); + + // optional .opencv_caffe.DropoutParameter dropout_param = 12; + bool has_dropout_param() const; + private: + bool _internal_has_dropout_param() const; + public: + void clear_dropout_param(); + const ::opencv_caffe::DropoutParameter& dropout_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::DropoutParameter* release_dropout_param(); + ::opencv_caffe::DropoutParameter* mutable_dropout_param(); + void set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param); + private: + const ::opencv_caffe::DropoutParameter& _internal_dropout_param() const; + ::opencv_caffe::DropoutParameter* _internal_mutable_dropout_param(); + public: + void unsafe_arena_set_allocated_dropout_param( + ::opencv_caffe::DropoutParameter* dropout_param); + ::opencv_caffe::DropoutParameter* unsafe_arena_release_dropout_param(); + + // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13; + bool has_hdf5_data_param() const; + private: + bool _internal_has_hdf5_data_param() const; + public: + void clear_hdf5_data_param(); + const ::opencv_caffe::HDF5DataParameter& hdf5_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::HDF5DataParameter& _internal_hdf5_data_param() const; + ::opencv_caffe::HDF5DataParameter* _internal_mutable_hdf5_data_param(); + public: + void unsafe_arena_set_allocated_hdf5_data_param( + ::opencv_caffe::HDF5DataParameter* hdf5_data_param); + ::opencv_caffe::HDF5DataParameter* unsafe_arena_release_hdf5_data_param(); + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14; + bool has_hdf5_output_param() const; + private: + bool _internal_has_hdf5_output_param() const; + public: + void clear_hdf5_output_param(); + const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::HDF5OutputParameter& _internal_hdf5_output_param() const; + ::opencv_caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param(); + public: + void unsafe_arena_set_allocated_hdf5_output_param( + ::opencv_caffe::HDF5OutputParameter* hdf5_output_param); + ::opencv_caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param(); + + // optional .opencv_caffe.ImageDataParameter image_data_param = 15; + bool has_image_data_param() const; + private: + bool _internal_has_image_data_param() const; + public: + void clear_image_data_param(); + const ::opencv_caffe::ImageDataParameter& image_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::ImageDataParameter& _internal_image_data_param() const; + ::opencv_caffe::ImageDataParameter* _internal_mutable_image_data_param(); + public: + void unsafe_arena_set_allocated_image_data_param( + ::opencv_caffe::ImageDataParameter* image_data_param); + ::opencv_caffe::ImageDataParameter* unsafe_arena_release_image_data_param(); + + // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16; + bool has_infogain_loss_param() const; + private: + bool _internal_has_infogain_loss_param() const; + public: + void clear_infogain_loss_param(); + const ::opencv_caffe::InfogainLossParameter& infogain_loss_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::InfogainLossParameter& _internal_infogain_loss_param() const; + ::opencv_caffe::InfogainLossParameter* _internal_mutable_infogain_loss_param(); + public: + void unsafe_arena_set_allocated_infogain_loss_param( + ::opencv_caffe::InfogainLossParameter* infogain_loss_param); + ::opencv_caffe::InfogainLossParameter* unsafe_arena_release_infogain_loss_param(); + + // optional .opencv_caffe.InnerProductParameter inner_product_param = 17; + bool has_inner_product_param() const; + private: + bool _internal_has_inner_product_param() const; + public: + void clear_inner_product_param(); + const ::opencv_caffe::InnerProductParameter& inner_product_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::InnerProductParameter& _internal_inner_product_param() const; + ::opencv_caffe::InnerProductParameter* _internal_mutable_inner_product_param(); + public: + void unsafe_arena_set_allocated_inner_product_param( + ::opencv_caffe::InnerProductParameter* inner_product_param); + ::opencv_caffe::InnerProductParameter* unsafe_arena_release_inner_product_param(); + + // optional .opencv_caffe.LRNParameter lrn_param = 18; + bool has_lrn_param() const; + private: + bool _internal_has_lrn_param() const; + public: + void clear_lrn_param(); + const ::opencv_caffe::LRNParameter& lrn_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::LRNParameter* release_lrn_param(); + ::opencv_caffe::LRNParameter* mutable_lrn_param(); + void set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param); + private: + const ::opencv_caffe::LRNParameter& _internal_lrn_param() const; + ::opencv_caffe::LRNParameter* _internal_mutable_lrn_param(); + public: + void unsafe_arena_set_allocated_lrn_param( + ::opencv_caffe::LRNParameter* lrn_param); + ::opencv_caffe::LRNParameter* unsafe_arena_release_lrn_param(); + + // optional .opencv_caffe.PoolingParameter pooling_param = 19; + bool has_pooling_param() const; + private: + bool _internal_has_pooling_param() const; + public: + void clear_pooling_param(); + const ::opencv_caffe::PoolingParameter& pooling_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::PoolingParameter* release_pooling_param(); + ::opencv_caffe::PoolingParameter* mutable_pooling_param(); + void set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param); + private: + const ::opencv_caffe::PoolingParameter& _internal_pooling_param() const; + ::opencv_caffe::PoolingParameter* _internal_mutable_pooling_param(); + public: + void unsafe_arena_set_allocated_pooling_param( + ::opencv_caffe::PoolingParameter* pooling_param); + ::opencv_caffe::PoolingParameter* unsafe_arena_release_pooling_param(); + + // optional .opencv_caffe.WindowDataParameter window_data_param = 20; + bool has_window_data_param() const; + private: + bool _internal_has_window_data_param() const; + public: + void clear_window_data_param(); + const ::opencv_caffe::WindowDataParameter& window_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::WindowDataParameter& _internal_window_data_param() const; + ::opencv_caffe::WindowDataParameter* _internal_mutable_window_data_param(); + public: + void unsafe_arena_set_allocated_window_data_param( + ::opencv_caffe::WindowDataParameter* window_data_param); + ::opencv_caffe::WindowDataParameter* unsafe_arena_release_window_data_param(); + + // optional .opencv_caffe.PowerParameter power_param = 21; + bool has_power_param() const; + private: + bool _internal_has_power_param() const; + public: + void clear_power_param(); + const ::opencv_caffe::PowerParameter& power_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::PowerParameter* release_power_param(); + ::opencv_caffe::PowerParameter* mutable_power_param(); + void set_allocated_power_param(::opencv_caffe::PowerParameter* power_param); + private: + const ::opencv_caffe::PowerParameter& _internal_power_param() const; + ::opencv_caffe::PowerParameter* _internal_mutable_power_param(); + public: + void unsafe_arena_set_allocated_power_param( + ::opencv_caffe::PowerParameter* power_param); + ::opencv_caffe::PowerParameter* unsafe_arena_release_power_param(); + + // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22; + bool has_memory_data_param() const; + private: + bool _internal_has_memory_data_param() const; + public: + void clear_memory_data_param(); + const ::opencv_caffe::MemoryDataParameter& memory_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::MemoryDataParameter& _internal_memory_data_param() const; + ::opencv_caffe::MemoryDataParameter* _internal_mutable_memory_data_param(); + public: + void unsafe_arena_set_allocated_memory_data_param( + ::opencv_caffe::MemoryDataParameter* memory_data_param); + ::opencv_caffe::MemoryDataParameter* unsafe_arena_release_memory_data_param(); + + // optional .opencv_caffe.ArgMaxParameter argmax_param = 23; + bool has_argmax_param() const; + private: + bool _internal_has_argmax_param() const; + public: + void clear_argmax_param(); + const ::opencv_caffe::ArgMaxParameter& argmax_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ArgMaxParameter* release_argmax_param(); + ::opencv_caffe::ArgMaxParameter* mutable_argmax_param(); + void set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param); + private: + const ::opencv_caffe::ArgMaxParameter& _internal_argmax_param() const; + ::opencv_caffe::ArgMaxParameter* _internal_mutable_argmax_param(); + public: + void unsafe_arena_set_allocated_argmax_param( + ::opencv_caffe::ArgMaxParameter* argmax_param); + ::opencv_caffe::ArgMaxParameter* unsafe_arena_release_argmax_param(); + + // optional .opencv_caffe.EltwiseParameter eltwise_param = 24; + bool has_eltwise_param() const; + private: + bool _internal_has_eltwise_param() const; + public: + void clear_eltwise_param(); + const ::opencv_caffe::EltwiseParameter& eltwise_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::EltwiseParameter* release_eltwise_param(); + ::opencv_caffe::EltwiseParameter* mutable_eltwise_param(); + void set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param); + private: + const ::opencv_caffe::EltwiseParameter& _internal_eltwise_param() const; + ::opencv_caffe::EltwiseParameter* _internal_mutable_eltwise_param(); + public: + void unsafe_arena_set_allocated_eltwise_param( + ::opencv_caffe::EltwiseParameter* eltwise_param); + ::opencv_caffe::EltwiseParameter* unsafe_arena_release_eltwise_param(); + + // optional .opencv_caffe.ThresholdParameter threshold_param = 25; + bool has_threshold_param() const; + private: + bool _internal_has_threshold_param() const; + public: + void clear_threshold_param(); + const ::opencv_caffe::ThresholdParameter& threshold_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ThresholdParameter* release_threshold_param(); + ::opencv_caffe::ThresholdParameter* mutable_threshold_param(); + void set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param); + private: + const ::opencv_caffe::ThresholdParameter& _internal_threshold_param() const; + ::opencv_caffe::ThresholdParameter* _internal_mutable_threshold_param(); + public: + void unsafe_arena_set_allocated_threshold_param( + ::opencv_caffe::ThresholdParameter* threshold_param); + ::opencv_caffe::ThresholdParameter* unsafe_arena_release_threshold_param(); + + // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26; + bool has_dummy_data_param() const; + private: + bool _internal_has_dummy_data_param() const; + public: + void clear_dummy_data_param(); + const ::opencv_caffe::DummyDataParameter& dummy_data_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::DummyDataParameter& _internal_dummy_data_param() const; + ::opencv_caffe::DummyDataParameter* _internal_mutable_dummy_data_param(); + public: + void unsafe_arena_set_allocated_dummy_data_param( + ::opencv_caffe::DummyDataParameter* dummy_data_param); + ::opencv_caffe::DummyDataParameter* unsafe_arena_release_dummy_data_param(); + + // optional .opencv_caffe.AccuracyParameter accuracy_param = 27; + bool has_accuracy_param() const; + private: + bool _internal_has_accuracy_param() const; + public: + void clear_accuracy_param(); + const ::opencv_caffe::AccuracyParameter& accuracy_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::AccuracyParameter* release_accuracy_param(); + ::opencv_caffe::AccuracyParameter* mutable_accuracy_param(); + void set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param); + private: + const ::opencv_caffe::AccuracyParameter& _internal_accuracy_param() const; + ::opencv_caffe::AccuracyParameter* _internal_mutable_accuracy_param(); + public: + void unsafe_arena_set_allocated_accuracy_param( + ::opencv_caffe::AccuracyParameter* accuracy_param); + ::opencv_caffe::AccuracyParameter* unsafe_arena_release_accuracy_param(); + + // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29; + bool has_hinge_loss_param() const; + private: + bool _internal_has_hinge_loss_param() const; + public: + void clear_hinge_loss_param(); + const ::opencv_caffe::HingeLossParameter& hinge_loss_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::HingeLossParameter& _internal_hinge_loss_param() const; + ::opencv_caffe::HingeLossParameter* _internal_mutable_hinge_loss_param(); + public: + void unsafe_arena_set_allocated_hinge_loss_param( + ::opencv_caffe::HingeLossParameter* hinge_loss_param); + ::opencv_caffe::HingeLossParameter* unsafe_arena_release_hinge_loss_param(); + + // optional .opencv_caffe.ReLUParameter relu_param = 30; + bool has_relu_param() const; + private: + bool _internal_has_relu_param() const; + public: + void clear_relu_param(); + const ::opencv_caffe::ReLUParameter& relu_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ReLUParameter* release_relu_param(); + ::opencv_caffe::ReLUParameter* mutable_relu_param(); + void set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param); + private: + const ::opencv_caffe::ReLUParameter& _internal_relu_param() const; + ::opencv_caffe::ReLUParameter* _internal_mutable_relu_param(); + public: + void unsafe_arena_set_allocated_relu_param( + ::opencv_caffe::ReLUParameter* relu_param); + ::opencv_caffe::ReLUParameter* unsafe_arena_release_relu_param(); + + // optional .opencv_caffe.SliceParameter slice_param = 31; + bool has_slice_param() const; + private: + bool _internal_has_slice_param() const; + public: + void clear_slice_param(); + const ::opencv_caffe::SliceParameter& slice_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::SliceParameter* release_slice_param(); + ::opencv_caffe::SliceParameter* mutable_slice_param(); + void set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param); + private: + const ::opencv_caffe::SliceParameter& _internal_slice_param() const; + ::opencv_caffe::SliceParameter* _internal_mutable_slice_param(); + public: + void unsafe_arena_set_allocated_slice_param( + ::opencv_caffe::SliceParameter* slice_param); + ::opencv_caffe::SliceParameter* unsafe_arena_release_slice_param(); + + // optional .opencv_caffe.MVNParameter mvn_param = 34; + bool has_mvn_param() const; + private: + bool _internal_has_mvn_param() const; + public: + void clear_mvn_param(); + const ::opencv_caffe::MVNParameter& mvn_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::MVNParameter* release_mvn_param(); + ::opencv_caffe::MVNParameter* mutable_mvn_param(); + void set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param); + private: + const ::opencv_caffe::MVNParameter& _internal_mvn_param() const; + ::opencv_caffe::MVNParameter* _internal_mutable_mvn_param(); + public: + void unsafe_arena_set_allocated_mvn_param( + ::opencv_caffe::MVNParameter* mvn_param); + ::opencv_caffe::MVNParameter* unsafe_arena_release_mvn_param(); + + // optional .opencv_caffe.TransformationParameter transform_param = 36; + bool has_transform_param() const; + private: + bool _internal_has_transform_param() const; + public: + void clear_transform_param(); + const ::opencv_caffe::TransformationParameter& transform_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::TransformationParameter* release_transform_param(); + ::opencv_caffe::TransformationParameter* mutable_transform_param(); + void set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param); + private: + const ::opencv_caffe::TransformationParameter& _internal_transform_param() const; + ::opencv_caffe::TransformationParameter* _internal_mutable_transform_param(); + public: + void unsafe_arena_set_allocated_transform_param( + ::opencv_caffe::TransformationParameter* transform_param); + ::opencv_caffe::TransformationParameter* unsafe_arena_release_transform_param(); + + // optional .opencv_caffe.TanHParameter tanh_param = 37; + bool has_tanh_param() const; + private: + bool _internal_has_tanh_param() const; + public: + void clear_tanh_param(); + const ::opencv_caffe::TanHParameter& tanh_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::TanHParameter* release_tanh_param(); + ::opencv_caffe::TanHParameter* mutable_tanh_param(); + void set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param); + private: + const ::opencv_caffe::TanHParameter& _internal_tanh_param() const; + ::opencv_caffe::TanHParameter* _internal_mutable_tanh_param(); + public: + void unsafe_arena_set_allocated_tanh_param( + ::opencv_caffe::TanHParameter* tanh_param); + ::opencv_caffe::TanHParameter* unsafe_arena_release_tanh_param(); + + // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38; + bool has_sigmoid_param() const; + private: + bool _internal_has_sigmoid_param() const; + public: + void clear_sigmoid_param(); + const ::opencv_caffe::SigmoidParameter& sigmoid_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::SigmoidParameter* release_sigmoid_param(); + ::opencv_caffe::SigmoidParameter* mutable_sigmoid_param(); + void set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param); + private: + const ::opencv_caffe::SigmoidParameter& _internal_sigmoid_param() const; + ::opencv_caffe::SigmoidParameter* _internal_mutable_sigmoid_param(); + public: + void unsafe_arena_set_allocated_sigmoid_param( + ::opencv_caffe::SigmoidParameter* sigmoid_param); + ::opencv_caffe::SigmoidParameter* unsafe_arena_release_sigmoid_param(); + + // optional .opencv_caffe.SoftmaxParameter softmax_param = 39; + bool has_softmax_param() const; + private: + bool _internal_has_softmax_param() const; + public: + void clear_softmax_param(); + const ::opencv_caffe::SoftmaxParameter& softmax_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::SoftmaxParameter* release_softmax_param(); + ::opencv_caffe::SoftmaxParameter* mutable_softmax_param(); + void set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param); + private: + const ::opencv_caffe::SoftmaxParameter& _internal_softmax_param() const; + ::opencv_caffe::SoftmaxParameter* _internal_mutable_softmax_param(); + public: + void unsafe_arena_set_allocated_softmax_param( + ::opencv_caffe::SoftmaxParameter* softmax_param); + ::opencv_caffe::SoftmaxParameter* unsafe_arena_release_softmax_param(); + + // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40; + bool has_contrastive_loss_param() const; + private: + bool _internal_has_contrastive_loss_param() const; + public: + void clear_contrastive_loss_param(); + const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::ContrastiveLossParameter& _internal_contrastive_loss_param() const; + ::opencv_caffe::ContrastiveLossParameter* _internal_mutable_contrastive_loss_param(); + public: + void unsafe_arena_set_allocated_contrastive_loss_param( + ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param); + ::opencv_caffe::ContrastiveLossParameter* unsafe_arena_release_contrastive_loss_param(); + + // optional .opencv_caffe.ExpParameter exp_param = 41; + bool has_exp_param() const; + private: + bool _internal_has_exp_param() const; + public: + void clear_exp_param(); + const ::opencv_caffe::ExpParameter& exp_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::ExpParameter* release_exp_param(); + ::opencv_caffe::ExpParameter* mutable_exp_param(); + void set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param); + private: + const ::opencv_caffe::ExpParameter& _internal_exp_param() const; + ::opencv_caffe::ExpParameter* _internal_mutable_exp_param(); + public: + void unsafe_arena_set_allocated_exp_param( + ::opencv_caffe::ExpParameter* exp_param); + ::opencv_caffe::ExpParameter* unsafe_arena_release_exp_param(); + + // optional .opencv_caffe.LossParameter loss_param = 42; + bool has_loss_param() const; + private: + bool _internal_has_loss_param() const; + public: + void clear_loss_param(); + const ::opencv_caffe::LossParameter& loss_param() const; + PROTOBUF_NODISCARD ::opencv_caffe::LossParameter* release_loss_param(); + ::opencv_caffe::LossParameter* mutable_loss_param(); + void set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param); + private: + const ::opencv_caffe::LossParameter& _internal_loss_param() const; + ::opencv_caffe::LossParameter* _internal_mutable_loss_param(); + public: + void unsafe_arena_set_allocated_loss_param( + ::opencv_caffe::LossParameter* loss_param); + ::opencv_caffe::LossParameter* unsafe_arena_release_loss_param(); + + // optional .opencv_caffe.V1LayerParameter.LayerType type = 5; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::opencv_caffe::V1LayerParameter_LayerType type() const; + void set_type(::opencv_caffe::V1LayerParameter_LayerType value); + private: + ::opencv_caffe::V1LayerParameter_LayerType _internal_type() const; + void _internal_set_type(::opencv_caffe::V1LayerParameter_LayerType value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.V1LayerParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField bottom_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField top_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > blobs_lr_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > weight_decay_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule > include_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule > exclude_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > loss_weight_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField param_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField blob_share_mode_; + ::PROTOBUF_NAMESPACE_ID::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_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class V0LayerParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.V0LayerParameter) */ { + public: + inline V0LayerParameter() : V0LayerParameter(nullptr) {} + ~V0LayerParameter() override; + explicit constexpr V0LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + V0LayerParameter(const V0LayerParameter& from); + V0LayerParameter(V0LayerParameter&& from) noexcept + : V0LayerParameter() { + *this = ::std::move(from); + } + + inline V0LayerParameter& operator=(const V0LayerParameter& from) { + CopyFrom(from); + return *this; + } + inline V0LayerParameter& operator=(V0LayerParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const V0LayerParameter& default_instance() { + return *internal_default_instance(); + } + static inline const V0LayerParameter* internal_default_instance() { + return reinterpret_cast( + &_V0LayerParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 65; + + friend void swap(V0LayerParameter& a, V0LayerParameter& b) { + a.Swap(&b); + } + inline void Swap(V0LayerParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(V0LayerParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + V0LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const V0LayerParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const V0LayerParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(V0LayerParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.V0LayerParameter"; + } + protected: + explicit V0LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef V0LayerParameter_PoolMethod PoolMethod; + static constexpr PoolMethod MAX = + V0LayerParameter_PoolMethod_MAX; + static constexpr PoolMethod AVE = + V0LayerParameter_PoolMethod_AVE; + static constexpr PoolMethod STOCHASTIC = + V0LayerParameter_PoolMethod_STOCHASTIC; + static inline bool PoolMethod_IsValid(int value) { + return V0LayerParameter_PoolMethod_IsValid(value); + } + static constexpr PoolMethod PoolMethod_MIN = + V0LayerParameter_PoolMethod_PoolMethod_MIN; + static constexpr PoolMethod PoolMethod_MAX = + V0LayerParameter_PoolMethod_PoolMethod_MAX; + static constexpr int PoolMethod_ARRAYSIZE = + V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + PoolMethod_descriptor() { + return V0LayerParameter_PoolMethod_descriptor(); + } + template + static inline const std::string& PoolMethod_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PoolMethod_Name."); + return V0LayerParameter_PoolMethod_Name(enum_t_value); + } + static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + PoolMethod* value) { + return V0LayerParameter_PoolMethod_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kBlobsFieldNumber = 50, + kBlobsLrFieldNumber = 51, + kWeightDecayFieldNumber = 52, + kNameFieldNumber = 1, + kTypeFieldNumber = 2, + kSourceFieldNumber = 16, + kMeanfileFieldNumber = 18, + kDetCropModeFieldNumber = 59, + kWeightFillerFieldNumber = 5, + kBiasFillerFieldNumber = 6, + kHdf5OutputParamFieldNumber = 1001, + kNumOutputFieldNumber = 3, + kPadFieldNumber = 7, + kKernelsizeFieldNumber = 8, + kPoolFieldNumber = 11, + kBatchsizeFieldNumber = 19, + kCropsizeFieldNumber = 20, + kNewWidthFieldNumber = 63, + kMirrorFieldNumber = 21, + kShuffleImagesFieldNumber = 64, + kRandSkipFieldNumber = 53, + kDetContextPadFieldNumber = 58, + kNewNumFieldNumber = 60, + kNewChannelsFieldNumber = 61, + kNewHeightFieldNumber = 62, + kConcatDimFieldNumber = 65, + kBiastermFieldNumber = 4, + kGroupFieldNumber = 9, + kStrideFieldNumber = 10, + kDropoutRatioFieldNumber = 12, + kLocalSizeFieldNumber = 13, + kAlphaFieldNumber = 14, + kBetaFieldNumber = 15, + kScaleFieldNumber = 17, + kKFieldNumber = 22, + kDetFgThresholdFieldNumber = 54, + kDetBgThresholdFieldNumber = 55, + kDetFgFractionFieldNumber = 56, + }; + // repeated .opencv_caffe.BlobProto blobs = 50; + int blobs_size() const; + private: + int _internal_blobs_size() const; + public: + void clear_blobs(); + ::opencv_caffe::BlobProto* mutable_blobs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* + mutable_blobs(); + private: + const ::opencv_caffe::BlobProto& _internal_blobs(int index) const; + ::opencv_caffe::BlobProto* _internal_add_blobs(); + public: + const ::opencv_caffe::BlobProto& blobs(int index) const; + ::opencv_caffe::BlobProto* add_blobs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >& + blobs() const; + + // repeated float blobs_lr = 51; + int blobs_lr_size() const; + private: + int _internal_blobs_lr_size() const; + public: + void clear_blobs_lr(); + private: + float _internal_blobs_lr(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_blobs_lr() const; + void _internal_add_blobs_lr(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_blobs_lr(); + public: + float blobs_lr(int index) const; + void set_blobs_lr(int index, float value); + void add_blobs_lr(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + blobs_lr() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_blobs_lr(); + + // repeated float weight_decay = 52; + int weight_decay_size() const; + private: + int _internal_weight_decay_size() const; + public: + void clear_weight_decay(); + private: + float _internal_weight_decay(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_weight_decay() const; + void _internal_add_weight_decay(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_weight_decay(); + public: + float weight_decay(int index) const; + void set_weight_decay(int index, float value); + void add_weight_decay(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + weight_decay() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_weight_decay(); + + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string type = 2; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const std::string& type() const; + template + void set_type(ArgT0&& arg0, ArgT... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* type); + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value); + std::string* _internal_mutable_type(); + public: + + // optional string source = 16; + bool has_source() const; + private: + bool _internal_has_source() const; + public: + void clear_source(); + const std::string& source() const; + template + void set_source(ArgT0&& arg0, ArgT... args); + std::string* mutable_source(); + PROTOBUF_NODISCARD std::string* release_source(); + void set_allocated_source(std::string* source); + private: + const std::string& _internal_source() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value); + std::string* _internal_mutable_source(); + public: + + // optional string meanfile = 18; + bool has_meanfile() const; + private: + bool _internal_has_meanfile() const; + public: + void clear_meanfile(); + const std::string& meanfile() const; + template + void set_meanfile(ArgT0&& arg0, ArgT... args); + std::string* mutable_meanfile(); + PROTOBUF_NODISCARD std::string* release_meanfile(); + void set_allocated_meanfile(std::string* meanfile); + private: + const std::string& _internal_meanfile() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_meanfile(const std::string& value); + std::string* _internal_mutable_meanfile(); + public: + + // optional string det_crop_mode = 59 [default = "warp"]; + bool has_det_crop_mode() const; + private: + bool _internal_has_det_crop_mode() const; + public: + void clear_det_crop_mode(); + const std::string& det_crop_mode() const; + template + void set_det_crop_mode(ArgT0&& arg0, ArgT... args); + std::string* mutable_det_crop_mode(); + PROTOBUF_NODISCARD std::string* release_det_crop_mode(); + void set_allocated_det_crop_mode(std::string* det_crop_mode); + private: + const std::string& _internal_det_crop_mode() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_det_crop_mode(const std::string& value); + std::string* _internal_mutable_det_crop_mode(); + public: + + // optional .opencv_caffe.FillerParameter weight_filler = 5; + bool has_weight_filler() const; + private: + bool _internal_has_weight_filler() const; + public: + void clear_weight_filler(); + const ::opencv_caffe::FillerParameter& weight_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler(); + ::opencv_caffe::FillerParameter* mutable_weight_filler(); + void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_weight_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler(); + public: + void unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler(); + + // optional .opencv_caffe.FillerParameter bias_filler = 6; + bool has_bias_filler() const; + private: + bool _internal_has_bias_filler() const; + public: + void clear_bias_filler(); + const ::opencv_caffe::FillerParameter& bias_filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler(); + ::opencv_caffe::FillerParameter* mutable_bias_filler(); + void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler); + private: + const ::opencv_caffe::FillerParameter& _internal_bias_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler(); + public: + void unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler(); + + // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001; + bool has_hdf5_output_param() const; + private: + bool _internal_has_hdf5_output_param() const; + public: + void clear_hdf5_output_param(); + const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const; + PROTOBUF_NODISCARD ::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); + private: + const ::opencv_caffe::HDF5OutputParameter& _internal_hdf5_output_param() const; + ::opencv_caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param(); + public: + void unsafe_arena_set_allocated_hdf5_output_param( + ::opencv_caffe::HDF5OutputParameter* hdf5_output_param); + ::opencv_caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param(); + + // optional uint32 num_output = 3; + bool has_num_output() const; + private: + bool _internal_has_num_output() const; + public: + void clear_num_output(); + uint32_t num_output() const; + void set_num_output(uint32_t value); + private: + uint32_t _internal_num_output() const; + void _internal_set_num_output(uint32_t value); + public: + + // optional uint32 pad = 7 [default = 0]; + bool has_pad() const; + private: + bool _internal_has_pad() const; + public: + void clear_pad(); + uint32_t pad() const; + void set_pad(uint32_t value); + private: + uint32_t _internal_pad() const; + void _internal_set_pad(uint32_t value); + public: + + // optional uint32 kernelsize = 8; + bool has_kernelsize() const; + private: + bool _internal_has_kernelsize() const; + public: + void clear_kernelsize(); + uint32_t kernelsize() const; + void set_kernelsize(uint32_t value); + private: + uint32_t _internal_kernelsize() const; + void _internal_set_kernelsize(uint32_t value); + public: + + // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + bool has_pool() const; + private: + bool _internal_has_pool() const; + public: + void clear_pool(); + ::opencv_caffe::V0LayerParameter_PoolMethod pool() const; + void set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value); + private: + ::opencv_caffe::V0LayerParameter_PoolMethod _internal_pool() const; + void _internal_set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value); + public: + + // optional uint32 batchsize = 19; + bool has_batchsize() const; + private: + bool _internal_has_batchsize() const; + public: + void clear_batchsize(); + uint32_t batchsize() const; + void set_batchsize(uint32_t value); + private: + uint32_t _internal_batchsize() const; + void _internal_set_batchsize(uint32_t value); + public: + + // optional uint32 cropsize = 20 [default = 0]; + bool has_cropsize() const; + private: + bool _internal_has_cropsize() const; + public: + void clear_cropsize(); + uint32_t cropsize() const; + void set_cropsize(uint32_t value); + private: + uint32_t _internal_cropsize() const; + void _internal_set_cropsize(uint32_t value); + public: + + // optional int32 new_width = 63 [default = 0]; + bool has_new_width() const; + private: + bool _internal_has_new_width() const; + public: + void clear_new_width(); + int32_t new_width() const; + void set_new_width(int32_t value); + private: + int32_t _internal_new_width() const; + void _internal_set_new_width(int32_t value); + public: + + // optional bool mirror = 21 [default = false]; + bool has_mirror() const; + private: + bool _internal_has_mirror() const; + public: + void clear_mirror(); + bool mirror() const; + void set_mirror(bool value); + private: + bool _internal_mirror() const; + void _internal_set_mirror(bool value); + public: + + // optional bool shuffle_images = 64 [default = false]; + bool has_shuffle_images() const; + private: + bool _internal_has_shuffle_images() const; + public: + void clear_shuffle_images(); + bool shuffle_images() const; + void set_shuffle_images(bool value); + private: + bool _internal_shuffle_images() const; + void _internal_set_shuffle_images(bool value); + public: + + // optional uint32 rand_skip = 53 [default = 0]; + bool has_rand_skip() const; + private: + bool _internal_has_rand_skip() const; + public: + void clear_rand_skip(); + uint32_t rand_skip() const; + void set_rand_skip(uint32_t value); + private: + uint32_t _internal_rand_skip() const; + void _internal_set_rand_skip(uint32_t value); + public: + + // optional uint32 det_context_pad = 58 [default = 0]; + bool has_det_context_pad() const; + private: + bool _internal_has_det_context_pad() const; + public: + void clear_det_context_pad(); + uint32_t det_context_pad() const; + void set_det_context_pad(uint32_t value); + private: + uint32_t _internal_det_context_pad() const; + void _internal_set_det_context_pad(uint32_t value); + public: + + // optional int32 new_num = 60 [default = 0]; + bool has_new_num() const; + private: + bool _internal_has_new_num() const; + public: + void clear_new_num(); + int32_t new_num() const; + void set_new_num(int32_t value); + private: + int32_t _internal_new_num() const; + void _internal_set_new_num(int32_t value); + public: + + // optional int32 new_channels = 61 [default = 0]; + bool has_new_channels() const; + private: + bool _internal_has_new_channels() const; + public: + void clear_new_channels(); + int32_t new_channels() const; + void set_new_channels(int32_t value); + private: + int32_t _internal_new_channels() const; + void _internal_set_new_channels(int32_t value); + public: + + // optional int32 new_height = 62 [default = 0]; + bool has_new_height() const; + private: + bool _internal_has_new_height() const; + public: + void clear_new_height(); + int32_t new_height() const; + void set_new_height(int32_t value); + private: + int32_t _internal_new_height() const; + void _internal_set_new_height(int32_t value); + public: + + // optional uint32 concat_dim = 65 [default = 1]; + bool has_concat_dim() const; + private: + bool _internal_has_concat_dim() const; + public: + void clear_concat_dim(); + uint32_t concat_dim() const; + void set_concat_dim(uint32_t value); + private: + uint32_t _internal_concat_dim() const; + void _internal_set_concat_dim(uint32_t value); + public: + + // optional bool biasterm = 4 [default = true]; + bool has_biasterm() const; + private: + bool _internal_has_biasterm() const; + public: + void clear_biasterm(); + bool biasterm() const; + void set_biasterm(bool value); + private: + bool _internal_biasterm() const; + void _internal_set_biasterm(bool value); + public: + + // optional uint32 group = 9 [default = 1]; + bool has_group() const; + private: + bool _internal_has_group() const; + public: + void clear_group(); + uint32_t group() const; + void set_group(uint32_t value); + private: + uint32_t _internal_group() const; + void _internal_set_group(uint32_t value); + public: + + // optional uint32 stride = 10 [default = 1]; + bool has_stride() const; + private: + bool _internal_has_stride() const; + public: + void clear_stride(); + uint32_t stride() const; + void set_stride(uint32_t value); + private: + uint32_t _internal_stride() const; + void _internal_set_stride(uint32_t value); + public: + + // optional float dropout_ratio = 12 [default = 0.5]; + bool has_dropout_ratio() const; + private: + bool _internal_has_dropout_ratio() const; + public: + void clear_dropout_ratio(); + float dropout_ratio() const; + void set_dropout_ratio(float value); + private: + float _internal_dropout_ratio() const; + void _internal_set_dropout_ratio(float value); + public: + + // optional uint32 local_size = 13 [default = 5]; + bool has_local_size() const; + private: + bool _internal_has_local_size() const; + public: + void clear_local_size(); + uint32_t local_size() const; + void set_local_size(uint32_t value); + private: + uint32_t _internal_local_size() const; + void _internal_set_local_size(uint32_t value); + public: + + // optional float alpha = 14 [default = 1]; + bool has_alpha() const; + private: + bool _internal_has_alpha() const; + public: + void clear_alpha(); + float alpha() const; + void set_alpha(float value); + private: + float _internal_alpha() const; + void _internal_set_alpha(float value); + public: + + // optional float beta = 15 [default = 0.75]; + bool has_beta() const; + private: + bool _internal_has_beta() const; + public: + void clear_beta(); + float beta() const; + void set_beta(float value); + private: + float _internal_beta() const; + void _internal_set_beta(float value); + public: + + // optional float scale = 17 [default = 1]; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // optional float k = 22 [default = 1]; + bool has_k() const; + private: + bool _internal_has_k() const; + public: + void clear_k(); + float k() const; + void set_k(float value); + private: + float _internal_k() const; + void _internal_set_k(float value); + public: + + // optional float det_fg_threshold = 54 [default = 0.5]; + bool has_det_fg_threshold() const; + private: + bool _internal_has_det_fg_threshold() const; + public: + void clear_det_fg_threshold(); + float det_fg_threshold() const; + void set_det_fg_threshold(float value); + private: + float _internal_det_fg_threshold() const; + void _internal_set_det_fg_threshold(float value); + public: + + // optional float det_bg_threshold = 55 [default = 0.5]; + bool has_det_bg_threshold() const; + private: + bool _internal_has_det_bg_threshold() const; + public: + void clear_det_bg_threshold(); + float det_bg_threshold() const; + void set_det_bg_threshold(float value); + private: + float _internal_det_bg_threshold() const; + void _internal_set_det_bg_threshold(float value); + public: + + // optional float det_fg_fraction = 56 [default = 0.25]; + bool has_det_fg_fraction() const; + private: + bool _internal_has_det_fg_fraction() const; + public: + void clear_det_fg_fraction(); + float det_fg_fraction() const; + void set_det_fg_fraction(float value); + private: + float _internal_det_fg_fraction() const; + void _internal_set_det_fg_fraction(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.V0LayerParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > blobs_lr_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > weight_decay_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr meanfile_; + static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_det_crop_mode_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr det_crop_mode_; + ::opencv_caffe::FillerParameter* weight_filler_; + ::opencv_caffe::FillerParameter* bias_filler_; + ::opencv_caffe::HDF5OutputParameter* hdf5_output_param_; + uint32_t num_output_; + uint32_t pad_; + uint32_t kernelsize_; + int pool_; + uint32_t batchsize_; + uint32_t cropsize_; + int32_t new_width_; + bool mirror_; + bool shuffle_images_; + uint32_t rand_skip_; + uint32_t det_context_pad_; + int32_t new_num_; + int32_t new_channels_; + int32_t new_height_; + uint32_t concat_dim_; + bool biasterm_; + uint32_t group_; + uint32_t stride_; + float dropout_ratio_; + uint32_t local_size_; + float alpha_; + float beta_; + float scale_; + float k_; + float det_fg_threshold_; + float det_bg_threshold_; + float det_fg_fraction_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class PReLUParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PReLUParameter) */ { + public: + inline PReLUParameter() : PReLUParameter(nullptr) {} + ~PReLUParameter() override; + explicit constexpr PReLUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PReLUParameter(const PReLUParameter& from); + PReLUParameter(PReLUParameter&& from) noexcept + : PReLUParameter() { + *this = ::std::move(from); + } + + inline PReLUParameter& operator=(const PReLUParameter& from) { + CopyFrom(from); + return *this; + } + inline PReLUParameter& operator=(PReLUParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PReLUParameter& default_instance() { + return *internal_default_instance(); + } + static inline const PReLUParameter* internal_default_instance() { + return reinterpret_cast( + &_PReLUParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 66; + + friend void swap(PReLUParameter& a, PReLUParameter& b) { + a.Swap(&b); + } + inline void Swap(PReLUParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PReLUParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PReLUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PReLUParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const PReLUParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PReLUParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.PReLUParameter"; + } + protected: + explicit PReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFillerFieldNumber = 1, + kChannelSharedFieldNumber = 2, + }; + // optional .opencv_caffe.FillerParameter filler = 1; + bool has_filler() const; + private: + bool _internal_has_filler() const; + public: + void clear_filler(); + const ::opencv_caffe::FillerParameter& filler() const; + PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_filler(); + ::opencv_caffe::FillerParameter* mutable_filler(); + void set_allocated_filler(::opencv_caffe::FillerParameter* filler); + private: + const ::opencv_caffe::FillerParameter& _internal_filler() const; + ::opencv_caffe::FillerParameter* _internal_mutable_filler(); + public: + void unsafe_arena_set_allocated_filler( + ::opencv_caffe::FillerParameter* filler); + ::opencv_caffe::FillerParameter* unsafe_arena_release_filler(); + + // optional bool channel_shared = 2 [default = false]; + bool has_channel_shared() const; + private: + bool _internal_has_channel_shared() const; + public: + void clear_channel_shared(); + bool channel_shared() const; + void set_channel_shared(bool value); + private: + bool _internal_channel_shared() const; + void _internal_set_channel_shared(bool value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.PReLUParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::opencv_caffe::FillerParameter* filler_; + bool channel_shared_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class NormalizedBBox final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NormalizedBBox) */ { + public: + inline NormalizedBBox() : NormalizedBBox(nullptr) {} + ~NormalizedBBox() override; + explicit constexpr NormalizedBBox(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NormalizedBBox(const NormalizedBBox& from); + NormalizedBBox(NormalizedBBox&& from) noexcept + : NormalizedBBox() { + *this = ::std::move(from); + } + + inline NormalizedBBox& operator=(const NormalizedBBox& from) { + CopyFrom(from); + return *this; + } + inline NormalizedBBox& operator=(NormalizedBBox&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NormalizedBBox& default_instance() { + return *internal_default_instance(); + } + static inline const NormalizedBBox* internal_default_instance() { + return reinterpret_cast( + &_NormalizedBBox_default_instance_); + } + static constexpr int kIndexInFileMessages = + 67; + + friend void swap(NormalizedBBox& a, NormalizedBBox& b) { + a.Swap(&b); + } + inline void Swap(NormalizedBBox* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NormalizedBBox* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NormalizedBBox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NormalizedBBox& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const NormalizedBBox& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NormalizedBBox* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.NormalizedBBox"; + } + protected: + explicit NormalizedBBox(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kXminFieldNumber = 1, + kYminFieldNumber = 2, + kXmaxFieldNumber = 3, + kYmaxFieldNumber = 4, + kLabelFieldNumber = 5, + kDifficultFieldNumber = 6, + kScoreFieldNumber = 7, + kSizeFieldNumber = 8, + }; + // optional float xmin = 1; + bool has_xmin() const; + private: + bool _internal_has_xmin() const; + public: + void clear_xmin(); + float xmin() const; + void set_xmin(float value); + private: + float _internal_xmin() const; + void _internal_set_xmin(float value); + public: + + // optional float ymin = 2; + bool has_ymin() const; + private: + bool _internal_has_ymin() const; + public: + void clear_ymin(); + float ymin() const; + void set_ymin(float value); + private: + float _internal_ymin() const; + void _internal_set_ymin(float value); + public: + + // optional float xmax = 3; + bool has_xmax() const; + private: + bool _internal_has_xmax() const; + public: + void clear_xmax(); + float xmax() const; + void set_xmax(float value); + private: + float _internal_xmax() const; + void _internal_set_xmax(float value); + public: + + // optional float ymax = 4; + bool has_ymax() const; + private: + bool _internal_has_ymax() const; + public: + void clear_ymax(); + float ymax() const; + void set_ymax(float value); + private: + float _internal_ymax() const; + void _internal_set_ymax(float value); + public: + + // optional int32 label = 5; + bool has_label() const; + private: + bool _internal_has_label() const; + public: + void clear_label(); + int32_t label() const; + void set_label(int32_t value); + private: + int32_t _internal_label() const; + void _internal_set_label(int32_t value); + public: + + // optional bool difficult = 6; + bool has_difficult() const; + private: + bool _internal_has_difficult() const; + public: + void clear_difficult(); + bool difficult() const; + void set_difficult(bool value); + private: + bool _internal_difficult() const; + void _internal_set_difficult(bool value); + public: + + // optional float score = 7; + bool has_score() const; + private: + bool _internal_has_score() const; + public: + void clear_score(); + float score() const; + void set_score(float value); + private: + float _internal_score() const; + void _internal_set_score(float value); + public: + + // optional float size = 8; + bool has_size() const; + private: + bool _internal_has_size() const; + public: + void clear_size(); + float size() const; + void set_size(float value); + private: + float _internal_size() const; + void _internal_set_size(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.NormalizedBBox) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float xmin_; + float ymin_; + float xmax_; + float ymax_; + int32_t label_; + bool difficult_; + float score_; + float size_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ROIPoolingParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ROIPoolingParameter) */ { + public: + inline ROIPoolingParameter() : ROIPoolingParameter(nullptr) {} + ~ROIPoolingParameter() override; + explicit constexpr ROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ROIPoolingParameter(const ROIPoolingParameter& from); + ROIPoolingParameter(ROIPoolingParameter&& from) noexcept + : ROIPoolingParameter() { + *this = ::std::move(from); + } + + inline ROIPoolingParameter& operator=(const ROIPoolingParameter& from) { + CopyFrom(from); + return *this; + } + inline ROIPoolingParameter& operator=(ROIPoolingParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ROIPoolingParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ROIPoolingParameter* internal_default_instance() { + return reinterpret_cast( + &_ROIPoolingParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 68; + + friend void swap(ROIPoolingParameter& a, ROIPoolingParameter& b) { + a.Swap(&b); + } + inline void Swap(ROIPoolingParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ROIPoolingParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ROIPoolingParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ROIPoolingParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ROIPoolingParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ROIPoolingParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ROIPoolingParameter"; + } + protected: + explicit ROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPooledHFieldNumber = 1, + kPooledWFieldNumber = 2, + kSpatialScaleFieldNumber = 3, + }; + // optional uint32 pooled_h = 1 [default = 0]; + bool has_pooled_h() const; + private: + bool _internal_has_pooled_h() const; + public: + void clear_pooled_h(); + uint32_t pooled_h() const; + void set_pooled_h(uint32_t value); + private: + uint32_t _internal_pooled_h() const; + void _internal_set_pooled_h(uint32_t value); + public: + + // optional uint32 pooled_w = 2 [default = 0]; + bool has_pooled_w() const; + private: + bool _internal_has_pooled_w() const; + public: + void clear_pooled_w(); + uint32_t pooled_w() const; + void set_pooled_w(uint32_t value); + private: + uint32_t _internal_pooled_w() const; + void _internal_set_pooled_w(uint32_t value); + public: + + // optional float spatial_scale = 3 [default = 1]; + bool has_spatial_scale() const; + private: + bool _internal_has_spatial_scale() const; + public: + void clear_spatial_scale(); + float spatial_scale() const; + void set_spatial_scale(float value); + private: + float _internal_spatial_scale() const; + void _internal_set_spatial_scale(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ROIPoolingParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t pooled_h_; + uint32_t pooled_w_; + float spatial_scale_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class ProposalParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ProposalParameter) */ { + public: + inline ProposalParameter() : ProposalParameter(nullptr) {} + ~ProposalParameter() override; + explicit constexpr ProposalParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ProposalParameter(const ProposalParameter& from); + ProposalParameter(ProposalParameter&& from) noexcept + : ProposalParameter() { + *this = ::std::move(from); + } + + inline ProposalParameter& operator=(const ProposalParameter& from) { + CopyFrom(from); + return *this; + } + inline ProposalParameter& operator=(ProposalParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ProposalParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ProposalParameter* internal_default_instance() { + return reinterpret_cast( + &_ProposalParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 69; + + friend void swap(ProposalParameter& a, ProposalParameter& b) { + a.Swap(&b); + } + inline void Swap(ProposalParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ProposalParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ProposalParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ProposalParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const ProposalParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ProposalParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.ProposalParameter"; + } + protected: + explicit ProposalParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRatioFieldNumber = 4, + kScaleFieldNumber = 5, + kFeatStrideFieldNumber = 1, + kBaseSizeFieldNumber = 2, + kMinSizeFieldNumber = 3, + kPreNmsTopnFieldNumber = 6, + kPostNmsTopnFieldNumber = 7, + kNmsThreshFieldNumber = 8, + }; + // repeated float ratio = 4; + int ratio_size() const; + private: + int _internal_ratio_size() const; + public: + void clear_ratio(); + private: + float _internal_ratio(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_ratio() const; + void _internal_add_ratio(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_ratio(); + public: + float ratio(int index) const; + void set_ratio(int index, float value); + void add_ratio(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + ratio() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_ratio(); + + // repeated float scale = 5; + int scale_size() const; + private: + int _internal_scale_size() const; + public: + void clear_scale(); + private: + float _internal_scale(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_scale() const; + void _internal_add_scale(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_scale(); + public: + float scale(int index) const; + void set_scale(int index, float value); + void add_scale(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + scale() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_scale(); + + // optional uint32 feat_stride = 1 [default = 16]; + bool has_feat_stride() const; + private: + bool _internal_has_feat_stride() const; + public: + void clear_feat_stride(); + uint32_t feat_stride() const; + void set_feat_stride(uint32_t value); + private: + uint32_t _internal_feat_stride() const; + void _internal_set_feat_stride(uint32_t value); + public: + + // optional uint32 base_size = 2 [default = 16]; + bool has_base_size() const; + private: + bool _internal_has_base_size() const; + public: + void clear_base_size(); + uint32_t base_size() const; + void set_base_size(uint32_t value); + private: + uint32_t _internal_base_size() const; + void _internal_set_base_size(uint32_t value); + public: + + // optional uint32 min_size = 3 [default = 16]; + bool has_min_size() const; + private: + bool _internal_has_min_size() const; + public: + void clear_min_size(); + uint32_t min_size() const; + void set_min_size(uint32_t value); + private: + uint32_t _internal_min_size() const; + void _internal_set_min_size(uint32_t value); + public: + + // optional uint32 pre_nms_topn = 6 [default = 6000]; + bool has_pre_nms_topn() const; + private: + bool _internal_has_pre_nms_topn() const; + public: + void clear_pre_nms_topn(); + uint32_t pre_nms_topn() const; + void set_pre_nms_topn(uint32_t value); + private: + uint32_t _internal_pre_nms_topn() const; + void _internal_set_pre_nms_topn(uint32_t value); + public: + + // optional uint32 post_nms_topn = 7 [default = 300]; + bool has_post_nms_topn() const; + private: + bool _internal_has_post_nms_topn() const; + public: + void clear_post_nms_topn(); + uint32_t post_nms_topn() const; + void set_post_nms_topn(uint32_t value); + private: + uint32_t _internal_post_nms_topn() const; + void _internal_set_post_nms_topn(uint32_t value); + public: + + // optional float nms_thresh = 8 [default = 0.7]; + bool has_nms_thresh() const; + private: + bool _internal_has_nms_thresh() const; + public: + void clear_nms_thresh(); + float nms_thresh() const; + void set_nms_thresh(float value); + private: + float _internal_nms_thresh() const; + void _internal_set_nms_thresh(float value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.ProposalParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > ratio_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scale_; + uint32_t feat_stride_; + uint32_t base_size_; + uint32_t min_size_; + uint32_t pre_nms_topn_; + uint32_t post_nms_topn_; + float nms_thresh_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// ------------------------------------------------------------------- + +class PSROIPoolingParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PSROIPoolingParameter) */ { + public: + inline PSROIPoolingParameter() : PSROIPoolingParameter(nullptr) {} + ~PSROIPoolingParameter() override; + explicit constexpr PSROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PSROIPoolingParameter(const PSROIPoolingParameter& from); + PSROIPoolingParameter(PSROIPoolingParameter&& from) noexcept + : PSROIPoolingParameter() { + *this = ::std::move(from); + } + + inline PSROIPoolingParameter& operator=(const PSROIPoolingParameter& from) { + CopyFrom(from); + return *this; + } + inline PSROIPoolingParameter& operator=(PSROIPoolingParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PSROIPoolingParameter& default_instance() { + return *internal_default_instance(); + } + static inline const PSROIPoolingParameter* internal_default_instance() { + return reinterpret_cast( + &_PSROIPoolingParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 70; + + friend void swap(PSROIPoolingParameter& a, PSROIPoolingParameter& b) { + a.Swap(&b); + } + inline void Swap(PSROIPoolingParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PSROIPoolingParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PSROIPoolingParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PSROIPoolingParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const PSROIPoolingParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PSROIPoolingParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "opencv_caffe.PSROIPoolingParameter"; + } + protected: + explicit PSROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSpatialScaleFieldNumber = 1, + kOutputDimFieldNumber = 2, + kGroupSizeFieldNumber = 3, + }; + // required float spatial_scale = 1; + bool has_spatial_scale() const; + private: + bool _internal_has_spatial_scale() const; + public: + void clear_spatial_scale(); + float spatial_scale() const; + void set_spatial_scale(float value); + private: + float _internal_spatial_scale() const; + void _internal_set_spatial_scale(float value); + public: + + // required int32 output_dim = 2; + bool has_output_dim() const; + private: + bool _internal_has_output_dim() const; + public: + void clear_output_dim(); + int32_t output_dim() const; + void set_output_dim(int32_t value); + private: + int32_t _internal_output_dim() const; + void _internal_set_output_dim(int32_t value); + public: + + // required int32 group_size = 3; + bool has_group_size() const; + private: + bool _internal_has_group_size() const; + public: + void clear_group_size(); + int32_t group_size() const; + void set_group_size(int32_t value); + private: + int32_t _internal_group_size() const; + void _internal_set_group_size(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:opencv_caffe.PSROIPoolingParameter) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float spatial_scale_; + int32_t output_dim_; + int32_t group_size_; + friend struct ::TableStruct_opencv_2dcaffe_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// BlobShape + +// repeated int64 dim = 1 [packed = true]; +inline int BlobShape::_internal_dim_size() const { + return dim_.size(); +} +inline int BlobShape::dim_size() const { + return _internal_dim_size(); +} +inline void BlobShape::clear_dim() { + dim_.Clear(); +} +inline int64_t BlobShape::_internal_dim(int index) const { + return dim_.Get(index); +} +inline int64_t BlobShape::dim(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobShape.dim) + return _internal_dim(index); +} +inline void BlobShape::set_dim(int index, int64_t value) { + dim_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.BlobShape.dim) +} +inline void BlobShape::_internal_add_dim(int64_t value) { + dim_.Add(value); +} +inline void BlobShape::add_dim(int64_t value) { + _internal_add_dim(value); + // @@protoc_insertion_point(field_add:opencv_caffe.BlobShape.dim) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +BlobShape::_internal_dim() const { + return dim_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +BlobShape::dim() const { + // @@protoc_insertion_point(field_list:opencv_caffe.BlobShape.dim) + return _internal_dim(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +BlobShape::_internal_mutable_dim() { + return &dim_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +BlobShape::mutable_dim() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobShape.dim) + return _internal_mutable_dim(); +} + +// ------------------------------------------------------------------- + +// BlobProto + +// optional .opencv_caffe.BlobShape shape = 7; +inline bool BlobProto::_internal_has_shape() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || shape_ != nullptr); + return value; +} +inline bool BlobProto::has_shape() const { + return _internal_has_shape(); +} +inline void BlobProto::clear_shape() { + if (shape_ != nullptr) shape_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::BlobShape& BlobProto::_internal_shape() const { + const ::opencv_caffe::BlobShape* p = shape_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_BlobShape_default_instance_); +} +inline const ::opencv_caffe::BlobShape& BlobProto::shape() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.shape) + return _internal_shape(); +} +inline void BlobProto::unsafe_arena_set_allocated_shape( + ::opencv_caffe::BlobShape* shape) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_); + } + shape_ = shape; + if (shape) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.BlobProto.shape) +} +inline ::opencv_caffe::BlobShape* BlobProto::release_shape() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::BlobShape* temp = shape_; + shape_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::BlobShape* BlobProto::unsafe_arena_release_shape() { + // @@protoc_insertion_point(field_release:opencv_caffe.BlobProto.shape) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::BlobShape* temp = shape_; + shape_ = nullptr; + return temp; +} +inline ::opencv_caffe::BlobShape* BlobProto::_internal_mutable_shape() { + _has_bits_[0] |= 0x00000002u; + if (shape_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::BlobShape>(GetArenaForAllocation()); + shape_ = p; + } + return shape_; +} +inline ::opencv_caffe::BlobShape* BlobProto::mutable_shape() { + ::opencv_caffe::BlobShape* _msg = _internal_mutable_shape(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProto.shape) + return _msg; +} +inline void BlobProto::set_allocated_shape(::opencv_caffe::BlobShape* shape) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete shape_; + } + if (shape) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::BlobShape>::GetOwningArena(shape); + if (message_arena != submessage_arena) { + shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, shape, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + shape_ = shape; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.BlobProto.shape) +} + +// repeated float data = 5 [packed = true]; +inline int BlobProto::_internal_data_size() const { + return data_.size(); +} +inline int BlobProto::data_size() const { + return _internal_data_size(); +} +inline void BlobProto::clear_data() { + data_.Clear(); +} +inline float BlobProto::_internal_data(int index) const { + return data_.Get(index); +} +inline float BlobProto::data(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.data) + return _internal_data(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::_internal_add_data(float value) { + data_.Add(value); +} +inline void BlobProto::add_data(float value) { + _internal_add_data(value); + // @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +BlobProto::_internal_data() const { + return data_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +BlobProto::data() const { + // @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.data) + return _internal_data(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +BlobProto::_internal_mutable_data() { + return &data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +BlobProto::mutable_data() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.data) + return _internal_mutable_data(); +} + +// repeated float diff = 6 [packed = true]; +inline int BlobProto::_internal_diff_size() const { + return diff_.size(); +} +inline int BlobProto::diff_size() const { + return _internal_diff_size(); +} +inline void BlobProto::clear_diff() { + diff_.Clear(); +} +inline float BlobProto::_internal_diff(int index) const { + return diff_.Get(index); +} +inline float BlobProto::diff(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.diff) + return _internal_diff(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::_internal_add_diff(float value) { + diff_.Add(value); +} +inline void BlobProto::add_diff(float value) { + _internal_add_diff(value); + // @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.diff) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +BlobProto::_internal_diff() const { + return diff_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +BlobProto::diff() const { + // @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.diff) + return _internal_diff(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +BlobProto::_internal_mutable_diff() { + return &diff_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +BlobProto::mutable_diff() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.diff) + return _internal_mutable_diff(); +} + +// repeated double double_data = 8 [packed = true]; +inline int BlobProto::_internal_double_data_size() const { + return double_data_.size(); +} +inline int BlobProto::double_data_size() const { + return _internal_double_data_size(); +} +inline void BlobProto::clear_double_data() { + double_data_.Clear(); +} +inline double BlobProto::_internal_double_data(int index) const { + return double_data_.Get(index); +} +inline double BlobProto::double_data(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.double_data) + return _internal_double_data(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::_internal_add_double_data(double value) { + double_data_.Add(value); +} +inline void BlobProto::add_double_data(double value) { + _internal_add_double_data(value); + // @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.double_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& +BlobProto::_internal_double_data() const { + return double_data_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& +BlobProto::double_data() const { + // @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.double_data) + return _internal_double_data(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +BlobProto::_internal_mutable_double_data() { + return &double_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +BlobProto::mutable_double_data() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.double_data) + return _internal_mutable_double_data(); +} + +// repeated double double_diff = 9 [packed = true]; +inline int BlobProto::_internal_double_diff_size() const { + return double_diff_.size(); +} +inline int BlobProto::double_diff_size() const { + return _internal_double_diff_size(); +} +inline void BlobProto::clear_double_diff() { + double_diff_.Clear(); +} +inline double BlobProto::_internal_double_diff(int index) const { + return double_diff_.Get(index); +} +inline double BlobProto::double_diff(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.double_diff) + return _internal_double_diff(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::_internal_add_double_diff(double value) { + double_diff_.Add(value); +} +inline void BlobProto::add_double_diff(double value) { + _internal_add_double_diff(value); + // @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.double_diff) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& +BlobProto::_internal_double_diff() const { + return double_diff_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& +BlobProto::double_diff() const { + // @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.double_diff) + return _internal_double_diff(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +BlobProto::_internal_mutable_double_diff() { + return &double_diff_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +BlobProto::mutable_double_diff() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.double_diff) + return _internal_mutable_double_diff(); +} + +// optional .opencv_caffe.Type raw_data_type = 10; +inline bool BlobProto::_internal_has_raw_data_type() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool BlobProto::has_raw_data_type() const { + return _internal_has_raw_data_type(); +} +inline void BlobProto::clear_raw_data_type() { + raw_data_type_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline ::opencv_caffe::Type BlobProto::_internal_raw_data_type() const { + return static_cast< ::opencv_caffe::Type >(raw_data_type_); +} +inline ::opencv_caffe::Type BlobProto::raw_data_type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.raw_data_type) + return _internal_raw_data_type(); +} +inline void BlobProto::_internal_set_raw_data_type(::opencv_caffe::Type value) { + assert(::opencv_caffe::Type_IsValid(value)); + _has_bits_[0] |= 0x00000040u; + raw_data_type_ = value; +} +inline void BlobProto::set_raw_data_type(::opencv_caffe::Type value) { + _internal_set_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::_internal_has_raw_data() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BlobProto::has_raw_data() const { + return _internal_has_raw_data(); +} +inline void BlobProto::clear_raw_data() { + raw_data_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BlobProto::raw_data() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.raw_data) + return _internal_raw_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BlobProto::set_raw_data(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + raw_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.raw_data) +} +inline std::string* BlobProto::mutable_raw_data() { + std::string* _s = _internal_mutable_raw_data(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProto.raw_data) + return _s; +} +inline const std::string& BlobProto::_internal_raw_data() const { + return raw_data_.Get(); +} +inline void BlobProto::_internal_set_raw_data(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + raw_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BlobProto::_internal_mutable_raw_data() { + _has_bits_[0] |= 0x00000001u; + return raw_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BlobProto::release_raw_data() { + // @@protoc_insertion_point(field_release:opencv_caffe.BlobProto.raw_data) + if (!_internal_has_raw_data()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = raw_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (raw_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BlobProto::set_allocated_raw_data(std::string* raw_data) { + if (raw_data != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + raw_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), raw_data, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (raw_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.BlobProto.raw_data) +} + +// optional int32 num = 1 [default = 0]; +inline bool BlobProto::_internal_has_num() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BlobProto::has_num() const { + return _internal_has_num(); +} +inline void BlobProto::clear_num() { + num_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t BlobProto::_internal_num() const { + return num_; +} +inline int32_t BlobProto::num() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.num) + return _internal_num(); +} +inline void BlobProto::_internal_set_num(int32_t value) { + _has_bits_[0] |= 0x00000004u; + num_ = value; +} +inline void BlobProto::set_num(int32_t value) { + _internal_set_num(value); + // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.num) +} + +// optional int32 channels = 2 [default = 0]; +inline bool BlobProto::_internal_has_channels() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool BlobProto::has_channels() const { + return _internal_has_channels(); +} +inline void BlobProto::clear_channels() { + channels_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline int32_t BlobProto::_internal_channels() const { + return channels_; +} +inline int32_t BlobProto::channels() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.channels) + return _internal_channels(); +} +inline void BlobProto::_internal_set_channels(int32_t value) { + _has_bits_[0] |= 0x00000008u; + channels_ = value; +} +inline void BlobProto::set_channels(int32_t value) { + _internal_set_channels(value); + // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.channels) +} + +// optional int32 height = 3 [default = 0]; +inline bool BlobProto::_internal_has_height() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool BlobProto::has_height() const { + return _internal_has_height(); +} +inline void BlobProto::clear_height() { + height_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t BlobProto::_internal_height() const { + return height_; +} +inline int32_t BlobProto::height() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.height) + return _internal_height(); +} +inline void BlobProto::_internal_set_height(int32_t value) { + _has_bits_[0] |= 0x00000010u; + height_ = value; +} +inline void BlobProto::set_height(int32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.height) +} + +// optional int32 width = 4 [default = 0]; +inline bool BlobProto::_internal_has_width() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool BlobProto::has_width() const { + return _internal_has_width(); +} +inline void BlobProto::clear_width() { + width_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline int32_t BlobProto::_internal_width() const { + return width_; +} +inline int32_t BlobProto::width() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.width) + return _internal_width(); +} +inline void BlobProto::_internal_set_width(int32_t value) { + _has_bits_[0] |= 0x00000020u; + width_ = value; +} +inline void BlobProto::set_width(int32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.width) +} + +// ------------------------------------------------------------------- + +// BlobProtoVector + +// repeated .opencv_caffe.BlobProto blobs = 1; +inline int BlobProtoVector::_internal_blobs_size() const { + return blobs_.size(); +} +inline int BlobProtoVector::blobs_size() const { + return _internal_blobs_size(); +} +inline void BlobProtoVector::clear_blobs() { + blobs_.Clear(); +} +inline ::opencv_caffe::BlobProto* BlobProtoVector::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProtoVector.blobs) + return blobs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* +BlobProtoVector::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProtoVector.blobs) + return &blobs_; +} +inline const ::opencv_caffe::BlobProto& BlobProtoVector::_internal_blobs(int index) const { + return blobs_.Get(index); +} +inline const ::opencv_caffe::BlobProto& BlobProtoVector::blobs(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.BlobProtoVector.blobs) + return _internal_blobs(index); +} +inline ::opencv_caffe::BlobProto* BlobProtoVector::_internal_add_blobs() { + return blobs_.Add(); +} +inline ::opencv_caffe::BlobProto* BlobProtoVector::add_blobs() { + ::opencv_caffe::BlobProto* _add = _internal_add_blobs(); + // @@protoc_insertion_point(field_add:opencv_caffe.BlobProtoVector.blobs) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_order_size() const { + return order_.size(); +} +inline int PermuteParameter::order_size() const { + return _internal_order_size(); +} +inline void PermuteParameter::clear_order() { + order_.Clear(); +} +inline uint32_t PermuteParameter::_internal_order(int index) const { + return order_.Get(index); +} +inline uint32_t PermuteParameter::order(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PermuteParameter.order) + return _internal_order(index); +} +inline void PermuteParameter::set_order(int index, uint32_t value) { + order_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.PermuteParameter.order) +} +inline void PermuteParameter::_internal_add_order(uint32_t value) { + order_.Add(value); +} +inline void PermuteParameter::add_order(uint32_t value) { + _internal_add_order(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PermuteParameter.order) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +PermuteParameter::_internal_order() const { + return order_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +PermuteParameter::order() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PermuteParameter.order) + return _internal_order(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +PermuteParameter::_internal_mutable_order() { + return &order_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +PermuteParameter::mutable_order() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PermuteParameter.order) + return _internal_mutable_order(); +} + +// ------------------------------------------------------------------- + +// NormalizeBBoxParameter + +// optional bool across_spatial = 1 [default = true]; +inline bool NormalizeBBoxParameter::_internal_has_across_spatial() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool NormalizeBBoxParameter::has_across_spatial() const { + return _internal_has_across_spatial(); +} +inline void NormalizeBBoxParameter::clear_across_spatial() { + across_spatial_ = true; + _has_bits_[0] &= ~0x00000002u; +} +inline bool NormalizeBBoxParameter::_internal_across_spatial() const { + return across_spatial_; +} +inline bool NormalizeBBoxParameter::across_spatial() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.across_spatial) + return _internal_across_spatial(); +} +inline void NormalizeBBoxParameter::_internal_set_across_spatial(bool value) { + _has_bits_[0] |= 0x00000002u; + across_spatial_ = value; +} +inline void NormalizeBBoxParameter::set_across_spatial(bool value) { + _internal_set_across_spatial(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.across_spatial) +} + +// optional .opencv_caffe.FillerParameter scale_filler = 2; +inline bool NormalizeBBoxParameter::_internal_has_scale_filler() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || scale_filler_ != nullptr); + return value; +} +inline bool NormalizeBBoxParameter::has_scale_filler() const { + return _internal_has_scale_filler(); +} +inline void NormalizeBBoxParameter::clear_scale_filler() { + if (scale_filler_ != nullptr) scale_filler_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::FillerParameter& NormalizeBBoxParameter::_internal_scale_filler() const { + const ::opencv_caffe::FillerParameter* p = scale_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& NormalizeBBoxParameter::scale_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.scale_filler) + return _internal_scale_filler(); +} +inline void NormalizeBBoxParameter::unsafe_arena_set_allocated_scale_filler( + ::opencv_caffe::FillerParameter* scale_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_filler_); + } + scale_filler_ = scale_filler; + if (scale_filler) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.NormalizeBBoxParameter.scale_filler) +} +inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::release_scale_filler() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = scale_filler_; + scale_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::unsafe_arena_release_scale_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.NormalizeBBoxParameter.scale_filler) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = scale_filler_; + scale_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::_internal_mutable_scale_filler() { + _has_bits_[0] |= 0x00000001u; + if (scale_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + scale_filler_ = p; + } + return scale_filler_; +} +inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::mutable_scale_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_scale_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.NormalizeBBoxParameter.scale_filler) + return _msg; +} +inline void NormalizeBBoxParameter::set_allocated_scale_filler(::opencv_caffe::FillerParameter* scale_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete scale_filler_; + } + if (scale_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(scale_filler); + if (message_arena != submessage_arena) { + scale_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, scale_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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::_internal_has_channel_shared() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool NormalizeBBoxParameter::has_channel_shared() const { + return _internal_has_channel_shared(); +} +inline void NormalizeBBoxParameter::clear_channel_shared() { + channel_shared_ = true; + _has_bits_[0] &= ~0x00000004u; +} +inline bool NormalizeBBoxParameter::_internal_channel_shared() const { + return channel_shared_; +} +inline bool NormalizeBBoxParameter::channel_shared() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.channel_shared) + return _internal_channel_shared(); +} +inline void NormalizeBBoxParameter::_internal_set_channel_shared(bool value) { + _has_bits_[0] |= 0x00000004u; + channel_shared_ = value; +} +inline void NormalizeBBoxParameter::set_channel_shared(bool value) { + _internal_set_channel_shared(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.channel_shared) +} + +// optional float eps = 4 [default = 1e-10]; +inline bool NormalizeBBoxParameter::_internal_has_eps() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool NormalizeBBoxParameter::has_eps() const { + return _internal_has_eps(); +} +inline void NormalizeBBoxParameter::clear_eps() { + eps_ = 1e-10f; + _has_bits_[0] &= ~0x00000008u; +} +inline float NormalizeBBoxParameter::_internal_eps() const { + return eps_; +} +inline float NormalizeBBoxParameter::eps() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.eps) + return _internal_eps(); +} +inline void NormalizeBBoxParameter::_internal_set_eps(float value) { + _has_bits_[0] |= 0x00000008u; + eps_ = value; +} +inline void NormalizeBBoxParameter::set_eps(float value) { + _internal_set_eps(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.eps) +} + +// ------------------------------------------------------------------- + +// PriorBoxParameter + +// repeated float min_size = 1; +inline int PriorBoxParameter::_internal_min_size_size() const { + return min_size_.size(); +} +inline int PriorBoxParameter::min_size_size() const { + return _internal_min_size_size(); +} +inline void PriorBoxParameter::clear_min_size() { + min_size_.Clear(); +} +inline float PriorBoxParameter::_internal_min_size(int index) const { + return min_size_.Get(index); +} +inline float PriorBoxParameter::min_size(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.min_size) + return _internal_min_size(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::_internal_add_min_size(float value) { + min_size_.Add(value); +} +inline void PriorBoxParameter::add_min_size(float value) { + _internal_add_min_size(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.min_size) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::_internal_min_size() const { + return min_size_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::min_size() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.min_size) + return _internal_min_size(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::_internal_mutable_min_size() { + return &min_size_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::mutable_min_size() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.min_size) + return _internal_mutable_min_size(); +} + +// repeated float max_size = 2; +inline int PriorBoxParameter::_internal_max_size_size() const { + return max_size_.size(); +} +inline int PriorBoxParameter::max_size_size() const { + return _internal_max_size_size(); +} +inline void PriorBoxParameter::clear_max_size() { + max_size_.Clear(); +} +inline float PriorBoxParameter::_internal_max_size(int index) const { + return max_size_.Get(index); +} +inline float PriorBoxParameter::max_size(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.max_size) + return _internal_max_size(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::_internal_add_max_size(float value) { + max_size_.Add(value); +} +inline void PriorBoxParameter::add_max_size(float value) { + _internal_add_max_size(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.max_size) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::_internal_max_size() const { + return max_size_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::max_size() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.max_size) + return _internal_max_size(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::_internal_mutable_max_size() { + return &max_size_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::mutable_max_size() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.max_size) + return _internal_mutable_max_size(); +} + +// repeated float aspect_ratio = 3; +inline int PriorBoxParameter::_internal_aspect_ratio_size() const { + return aspect_ratio_.size(); +} +inline int PriorBoxParameter::aspect_ratio_size() const { + return _internal_aspect_ratio_size(); +} +inline void PriorBoxParameter::clear_aspect_ratio() { + aspect_ratio_.Clear(); +} +inline float PriorBoxParameter::_internal_aspect_ratio(int index) const { + return aspect_ratio_.Get(index); +} +inline float PriorBoxParameter::aspect_ratio(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.aspect_ratio) + return _internal_aspect_ratio(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::_internal_add_aspect_ratio(float value) { + aspect_ratio_.Add(value); +} +inline void PriorBoxParameter::add_aspect_ratio(float value) { + _internal_add_aspect_ratio(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.aspect_ratio) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::_internal_aspect_ratio() const { + return aspect_ratio_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::aspect_ratio() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.aspect_ratio) + return _internal_aspect_ratio(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::_internal_mutable_aspect_ratio() { + return &aspect_ratio_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::mutable_aspect_ratio() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.aspect_ratio) + return _internal_mutable_aspect_ratio(); +} + +// optional bool flip = 4 [default = true]; +inline bool PriorBoxParameter::_internal_has_flip() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool PriorBoxParameter::has_flip() const { + return _internal_has_flip(); +} +inline void PriorBoxParameter::clear_flip() { + flip_ = true; + _has_bits_[0] &= ~0x00000040u; +} +inline bool PriorBoxParameter::_internal_flip() const { + return flip_; +} +inline bool PriorBoxParameter::flip() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.flip) + return _internal_flip(); +} +inline void PriorBoxParameter::_internal_set_flip(bool value) { + _has_bits_[0] |= 0x00000040u; + flip_ = value; +} +inline void PriorBoxParameter::set_flip(bool value) { + _internal_set_flip(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.flip) +} + +// optional bool clip = 5 [default = true]; +inline bool PriorBoxParameter::_internal_has_clip() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool PriorBoxParameter::has_clip() const { + return _internal_has_clip(); +} +inline void PriorBoxParameter::clear_clip() { + clip_ = true; + _has_bits_[0] &= ~0x00000080u; +} +inline bool PriorBoxParameter::_internal_clip() const { + return clip_; +} +inline bool PriorBoxParameter::clip() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.clip) + return _internal_clip(); +} +inline void PriorBoxParameter::_internal_set_clip(bool value) { + _has_bits_[0] |= 0x00000080u; + clip_ = value; +} +inline void PriorBoxParameter::set_clip(bool value) { + _internal_set_clip(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.clip) +} + +// repeated float variance = 6; +inline int PriorBoxParameter::_internal_variance_size() const { + return variance_.size(); +} +inline int PriorBoxParameter::variance_size() const { + return _internal_variance_size(); +} +inline void PriorBoxParameter::clear_variance() { + variance_.Clear(); +} +inline float PriorBoxParameter::_internal_variance(int index) const { + return variance_.Get(index); +} +inline float PriorBoxParameter::variance(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.variance) + return _internal_variance(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::_internal_add_variance(float value) { + variance_.Add(value); +} +inline void PriorBoxParameter::add_variance(float value) { + _internal_add_variance(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.variance) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::_internal_variance() const { + return variance_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::variance() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.variance) + return _internal_variance(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::_internal_mutable_variance() { + return &variance_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::mutable_variance() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.variance) + return _internal_mutable_variance(); +} + +// optional uint32 img_size = 7; +inline bool PriorBoxParameter::_internal_has_img_size() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PriorBoxParameter::has_img_size() const { + return _internal_has_img_size(); +} +inline void PriorBoxParameter::clear_img_size() { + img_size_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline uint32_t PriorBoxParameter::_internal_img_size() const { + return img_size_; +} +inline uint32_t PriorBoxParameter::img_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_size) + return _internal_img_size(); +} +inline void PriorBoxParameter::_internal_set_img_size(uint32_t value) { + _has_bits_[0] |= 0x00000001u; + img_size_ = value; +} +inline void PriorBoxParameter::set_img_size(uint32_t value) { + _internal_set_img_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_size) +} + +// optional uint32 img_h = 8; +inline bool PriorBoxParameter::_internal_has_img_h() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PriorBoxParameter::has_img_h() const { + return _internal_has_img_h(); +} +inline void PriorBoxParameter::clear_img_h() { + img_h_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t PriorBoxParameter::_internal_img_h() const { + return img_h_; +} +inline uint32_t PriorBoxParameter::img_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_h) + return _internal_img_h(); +} +inline void PriorBoxParameter::_internal_set_img_h(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + img_h_ = value; +} +inline void PriorBoxParameter::set_img_h(uint32_t value) { + _internal_set_img_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_h) +} + +// optional uint32 img_w = 9; +inline bool PriorBoxParameter::_internal_has_img_w() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PriorBoxParameter::has_img_w() const { + return _internal_has_img_w(); +} +inline void PriorBoxParameter::clear_img_w() { + img_w_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t PriorBoxParameter::_internal_img_w() const { + return img_w_; +} +inline uint32_t PriorBoxParameter::img_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_w) + return _internal_img_w(); +} +inline void PriorBoxParameter::_internal_set_img_w(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + img_w_ = value; +} +inline void PriorBoxParameter::set_img_w(uint32_t value) { + _internal_set_img_w(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_w) +} + +// optional float step = 10; +inline bool PriorBoxParameter::_internal_has_step() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PriorBoxParameter::has_step() const { + return _internal_has_step(); +} +inline void PriorBoxParameter::clear_step() { + step_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline float PriorBoxParameter::_internal_step() const { + return step_; +} +inline float PriorBoxParameter::step() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step) + return _internal_step(); +} +inline void PriorBoxParameter::_internal_set_step(float value) { + _has_bits_[0] |= 0x00000008u; + step_ = value; +} +inline void PriorBoxParameter::set_step(float value) { + _internal_set_step(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step) +} + +// optional float step_h = 11; +inline bool PriorBoxParameter::_internal_has_step_h() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool PriorBoxParameter::has_step_h() const { + return _internal_has_step_h(); +} +inline void PriorBoxParameter::clear_step_h() { + step_h_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline float PriorBoxParameter::_internal_step_h() const { + return step_h_; +} +inline float PriorBoxParameter::step_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step_h) + return _internal_step_h(); +} +inline void PriorBoxParameter::_internal_set_step_h(float value) { + _has_bits_[0] |= 0x00000010u; + step_h_ = value; +} +inline void PriorBoxParameter::set_step_h(float value) { + _internal_set_step_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step_h) +} + +// optional float step_w = 12; +inline bool PriorBoxParameter::_internal_has_step_w() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool PriorBoxParameter::has_step_w() const { + return _internal_has_step_w(); +} +inline void PriorBoxParameter::clear_step_w() { + step_w_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline float PriorBoxParameter::_internal_step_w() const { + return step_w_; +} +inline float PriorBoxParameter::step_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step_w) + return _internal_step_w(); +} +inline void PriorBoxParameter::_internal_set_step_w(float value) { + _has_bits_[0] |= 0x00000020u; + step_w_ = value; +} +inline void PriorBoxParameter::set_step_w(float value) { + _internal_set_step_w(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step_w) +} + +// optional float offset = 13 [default = 0.5]; +inline bool PriorBoxParameter::_internal_has_offset() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool PriorBoxParameter::has_offset() const { + return _internal_has_offset(); +} +inline void PriorBoxParameter::clear_offset() { + offset_ = 0.5f; + _has_bits_[0] &= ~0x00000100u; +} +inline float PriorBoxParameter::_internal_offset() const { + return offset_; +} +inline float PriorBoxParameter::offset() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset) + return _internal_offset(); +} +inline void PriorBoxParameter::_internal_set_offset(float value) { + _has_bits_[0] |= 0x00000100u; + offset_ = value; +} +inline void PriorBoxParameter::set_offset(float value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.offset) +} + +// repeated float offset_h = 14; +inline int PriorBoxParameter::_internal_offset_h_size() const { + return offset_h_.size(); +} +inline int PriorBoxParameter::offset_h_size() const { + return _internal_offset_h_size(); +} +inline void PriorBoxParameter::clear_offset_h() { + offset_h_.Clear(); +} +inline float PriorBoxParameter::_internal_offset_h(int index) const { + return offset_h_.Get(index); +} +inline float PriorBoxParameter::offset_h(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset_h) + return _internal_offset_h(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::_internal_add_offset_h(float value) { + offset_h_.Add(value); +} +inline void PriorBoxParameter::add_offset_h(float value) { + _internal_add_offset_h(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.offset_h) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::_internal_offset_h() const { + return offset_h_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::offset_h() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.offset_h) + return _internal_offset_h(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::_internal_mutable_offset_h() { + return &offset_h_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::mutable_offset_h() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.offset_h) + return _internal_mutable_offset_h(); +} + +// repeated float offset_w = 15; +inline int PriorBoxParameter::_internal_offset_w_size() const { + return offset_w_.size(); +} +inline int PriorBoxParameter::offset_w_size() const { + return _internal_offset_w_size(); +} +inline void PriorBoxParameter::clear_offset_w() { + offset_w_.Clear(); +} +inline float PriorBoxParameter::_internal_offset_w(int index) const { + return offset_w_.Get(index); +} +inline float PriorBoxParameter::offset_w(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset_w) + return _internal_offset_w(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::_internal_add_offset_w(float value) { + offset_w_.Add(value); +} +inline void PriorBoxParameter::add_offset_w(float value) { + _internal_add_offset_w(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.offset_w) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::_internal_offset_w() const { + return offset_w_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::offset_w() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.offset_w) + return _internal_offset_w(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::_internal_mutable_offset_w() { + return &offset_w_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::mutable_offset_w() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.offset_w) + return _internal_mutable_offset_w(); +} + +// repeated float width = 16; +inline int PriorBoxParameter::_internal_width_size() const { + return width_.size(); +} +inline int PriorBoxParameter::width_size() const { + return _internal_width_size(); +} +inline void PriorBoxParameter::clear_width() { + width_.Clear(); +} +inline float PriorBoxParameter::_internal_width(int index) const { + return width_.Get(index); +} +inline float PriorBoxParameter::width(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.width) + return _internal_width(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::_internal_add_width(float value) { + width_.Add(value); +} +inline void PriorBoxParameter::add_width(float value) { + _internal_add_width(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.width) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::_internal_width() const { + return width_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::width() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.width) + return _internal_width(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::_internal_mutable_width() { + return &width_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::mutable_width() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.width) + return _internal_mutable_width(); +} + +// repeated float height = 17; +inline int PriorBoxParameter::_internal_height_size() const { + return height_.size(); +} +inline int PriorBoxParameter::height_size() const { + return _internal_height_size(); +} +inline void PriorBoxParameter::clear_height() { + height_.Clear(); +} +inline float PriorBoxParameter::_internal_height(int index) const { + return height_.Get(index); +} +inline float PriorBoxParameter::height(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.height) + return _internal_height(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::_internal_add_height(float value) { + height_.Add(value); +} +inline void PriorBoxParameter::add_height(float value) { + _internal_add_height(value); + // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.height) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::_internal_height() const { + return height_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +PriorBoxParameter::height() const { + // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.height) + return _internal_height(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::_internal_mutable_height() { + return &height_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +PriorBoxParameter::mutable_height() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.height) + return _internal_mutable_height(); +} + +// ------------------------------------------------------------------- + +// DetectionOutputParameter + +// optional uint32 num_classes = 1; +inline bool DetectionOutputParameter::_internal_has_num_classes() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_num_classes() const { + return _internal_has_num_classes(); +} +inline void DetectionOutputParameter::clear_num_classes() { + num_classes_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t DetectionOutputParameter::_internal_num_classes() const { + return num_classes_; +} +inline uint32_t DetectionOutputParameter::num_classes() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.num_classes) + return _internal_num_classes(); +} +inline void DetectionOutputParameter::_internal_set_num_classes(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + num_classes_ = value; +} +inline void DetectionOutputParameter::set_num_classes(uint32_t value) { + _internal_set_num_classes(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.num_classes) +} + +// optional bool share_location = 2 [default = true]; +inline bool DetectionOutputParameter::_internal_has_share_location() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_share_location() const { + return _internal_has_share_location(); +} +inline void DetectionOutputParameter::clear_share_location() { + share_location_ = true; + _has_bits_[0] &= ~0x00000200u; +} +inline bool DetectionOutputParameter::_internal_share_location() const { + return share_location_; +} +inline bool DetectionOutputParameter::share_location() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.share_location) + return _internal_share_location(); +} +inline void DetectionOutputParameter::_internal_set_share_location(bool value) { + _has_bits_[0] |= 0x00000200u; + share_location_ = value; +} +inline void DetectionOutputParameter::set_share_location(bool value) { + _internal_set_share_location(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.share_location) +} + +// optional int32 background_label_id = 3 [default = 0]; +inline bool DetectionOutputParameter::_internal_has_background_label_id() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_background_label_id() const { + return _internal_has_background_label_id(); +} +inline void DetectionOutputParameter::clear_background_label_id() { + background_label_id_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline int32_t DetectionOutputParameter::_internal_background_label_id() const { + return background_label_id_; +} +inline int32_t DetectionOutputParameter::background_label_id() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.background_label_id) + return _internal_background_label_id(); +} +inline void DetectionOutputParameter::_internal_set_background_label_id(int32_t value) { + _has_bits_[0] |= 0x00000008u; + background_label_id_ = value; +} +inline void DetectionOutputParameter::set_background_label_id(int32_t value) { + _internal_set_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::_internal_has_nms_param() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || nms_param_ != nullptr); + return value; +} +inline bool DetectionOutputParameter::has_nms_param() const { + return _internal_has_nms_param(); +} +inline void DetectionOutputParameter::clear_nms_param() { + if (nms_param_ != nullptr) nms_param_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::_internal_nms_param() const { + const ::opencv_caffe::NonMaximumSuppressionParameter* p = nms_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_NonMaximumSuppressionParameter_default_instance_); +} +inline const ::opencv_caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::nms_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.nms_param) + return _internal_nms_param(); +} +inline void DetectionOutputParameter::unsafe_arena_set_allocated_nms_param( + ::opencv_caffe::NonMaximumSuppressionParameter* nms_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(nms_param_); + } + nms_param_ = nms_param; + if (nms_param) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.DetectionOutputParameter.nms_param) +} +inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::release_nms_param() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::NonMaximumSuppressionParameter* temp = nms_param_; + nms_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::unsafe_arena_release_nms_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.DetectionOutputParameter.nms_param) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::NonMaximumSuppressionParameter* temp = nms_param_; + nms_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::_internal_mutable_nms_param() { + _has_bits_[0] |= 0x00000001u; + if (nms_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::NonMaximumSuppressionParameter>(GetArenaForAllocation()); + nms_param_ = p; + } + return nms_param_; +} +inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::mutable_nms_param() { + ::opencv_caffe::NonMaximumSuppressionParameter* _msg = _internal_mutable_nms_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.DetectionOutputParameter.nms_param) + return _msg; +} +inline void DetectionOutputParameter::set_allocated_nms_param(::opencv_caffe::NonMaximumSuppressionParameter* nms_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete nms_param_; + } + if (nms_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::NonMaximumSuppressionParameter>::GetOwningArena(nms_param); + if (message_arena != submessage_arena) { + nms_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, nms_param, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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::_internal_has_save_output_param() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || save_output_param_ != nullptr); + return value; +} +inline bool DetectionOutputParameter::has_save_output_param() const { + return _internal_has_save_output_param(); +} +inline void DetectionOutputParameter::clear_save_output_param() { + if (save_output_param_ != nullptr) save_output_param_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::SaveOutputParameter& DetectionOutputParameter::_internal_save_output_param() const { + const ::opencv_caffe::SaveOutputParameter* p = save_output_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_SaveOutputParameter_default_instance_); +} +inline const ::opencv_caffe::SaveOutputParameter& DetectionOutputParameter::save_output_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.save_output_param) + return _internal_save_output_param(); +} +inline void DetectionOutputParameter::unsafe_arena_set_allocated_save_output_param( + ::opencv_caffe::SaveOutputParameter* save_output_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(save_output_param_); + } + save_output_param_ = save_output_param; + if (save_output_param) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.DetectionOutputParameter.save_output_param) +} +inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::release_save_output_param() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::SaveOutputParameter* temp = save_output_param_; + save_output_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::unsafe_arena_release_save_output_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.DetectionOutputParameter.save_output_param) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::SaveOutputParameter* temp = save_output_param_; + save_output_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::_internal_mutable_save_output_param() { + _has_bits_[0] |= 0x00000002u; + if (save_output_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::SaveOutputParameter>(GetArenaForAllocation()); + save_output_param_ = p; + } + return save_output_param_; +} +inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::mutable_save_output_param() { + ::opencv_caffe::SaveOutputParameter* _msg = _internal_mutable_save_output_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.DetectionOutputParameter.save_output_param) + return _msg; +} +inline void DetectionOutputParameter::set_allocated_save_output_param(::opencv_caffe::SaveOutputParameter* save_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete save_output_param_; + } + if (save_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::SaveOutputParameter>::GetOwningArena(save_output_param); + if (message_arena != submessage_arena) { + save_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, save_output_param, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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::_internal_has_code_type() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_code_type() const { + return _internal_has_code_type(); +} +inline void DetectionOutputParameter::clear_code_type() { + code_type_ = 1; + _has_bits_[0] &= ~0x00000100u; +} +inline ::opencv_caffe::PriorBoxParameter_CodeType DetectionOutputParameter::_internal_code_type() const { + return static_cast< ::opencv_caffe::PriorBoxParameter_CodeType >(code_type_); +} +inline ::opencv_caffe::PriorBoxParameter_CodeType DetectionOutputParameter::code_type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.code_type) + return _internal_code_type(); +} +inline void DetectionOutputParameter::_internal_set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value) { + assert(::opencv_caffe::PriorBoxParameter_CodeType_IsValid(value)); + _has_bits_[0] |= 0x00000100u; + code_type_ = value; +} +inline void DetectionOutputParameter::set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value) { + _internal_set_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::_internal_has_variance_encoded_in_target() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_variance_encoded_in_target() const { + return _internal_has_variance_encoded_in_target(); +} +inline void DetectionOutputParameter::clear_variance_encoded_in_target() { + variance_encoded_in_target_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool DetectionOutputParameter::_internal_variance_encoded_in_target() const { + return 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 _internal_variance_encoded_in_target(); +} +inline void DetectionOutputParameter::_internal_set_variance_encoded_in_target(bool value) { + _has_bits_[0] |= 0x00000020u; + variance_encoded_in_target_ = value; +} +inline void DetectionOutputParameter::set_variance_encoded_in_target(bool value) { + _internal_set_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::_internal_has_keep_top_k() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_keep_top_k() const { + return _internal_has_keep_top_k(); +} +inline void DetectionOutputParameter::clear_keep_top_k() { + keep_top_k_ = -1; + _has_bits_[0] &= ~0x00000080u; +} +inline int32_t DetectionOutputParameter::_internal_keep_top_k() const { + return keep_top_k_; +} +inline int32_t DetectionOutputParameter::keep_top_k() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.keep_top_k) + return _internal_keep_top_k(); +} +inline void DetectionOutputParameter::_internal_set_keep_top_k(int32_t value) { + _has_bits_[0] |= 0x00000080u; + keep_top_k_ = value; +} +inline void DetectionOutputParameter::set_keep_top_k(int32_t value) { + _internal_set_keep_top_k(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.keep_top_k) +} + +// optional float confidence_threshold = 9; +inline bool DetectionOutputParameter::_internal_has_confidence_threshold() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_confidence_threshold() const { + return _internal_has_confidence_threshold(); +} +inline void DetectionOutputParameter::clear_confidence_threshold() { + confidence_threshold_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline float DetectionOutputParameter::_internal_confidence_threshold() const { + return confidence_threshold_; +} +inline float DetectionOutputParameter::confidence_threshold() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.confidence_threshold) + return _internal_confidence_threshold(); +} +inline void DetectionOutputParameter::_internal_set_confidence_threshold(float value) { + _has_bits_[0] |= 0x00000010u; + confidence_threshold_ = value; +} +inline void DetectionOutputParameter::set_confidence_threshold(float value) { + _internal_set_confidence_threshold(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.confidence_threshold) +} + +// optional bool normalized_bbox = 10 [default = true]; +inline bool DetectionOutputParameter::_internal_has_normalized_bbox() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_normalized_bbox() const { + return _internal_has_normalized_bbox(); +} +inline void DetectionOutputParameter::clear_normalized_bbox() { + normalized_bbox_ = true; + _has_bits_[0] &= ~0x00000400u; +} +inline bool DetectionOutputParameter::_internal_normalized_bbox() const { + return normalized_bbox_; +} +inline bool DetectionOutputParameter::normalized_bbox() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.normalized_bbox) + return _internal_normalized_bbox(); +} +inline void DetectionOutputParameter::_internal_set_normalized_bbox(bool value) { + _has_bits_[0] |= 0x00000400u; + normalized_bbox_ = value; +} +inline void DetectionOutputParameter::set_normalized_bbox(bool value) { + _internal_set_normalized_bbox(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.normalized_bbox) +} + +// optional bool clip = 1000 [default = false]; +inline bool DetectionOutputParameter::_internal_has_clip() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool DetectionOutputParameter::has_clip() const { + return _internal_has_clip(); +} +inline void DetectionOutputParameter::clear_clip() { + clip_ = false; + _has_bits_[0] &= ~0x00000040u; +} +inline bool DetectionOutputParameter::_internal_clip() const { + return clip_; +} +inline bool DetectionOutputParameter::clip() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.clip) + return _internal_clip(); +} +inline void DetectionOutputParameter::_internal_set_clip(bool value) { + _has_bits_[0] |= 0x00000040u; + clip_ = value; +} +inline void DetectionOutputParameter::set_clip(bool value) { + _internal_set_clip(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.clip) +} + +// ------------------------------------------------------------------- + +// Datum + +// optional int32 channels = 1; +inline bool Datum::_internal_has_channels() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Datum::has_channels() const { + return _internal_has_channels(); +} +inline void Datum::clear_channels() { + channels_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t Datum::_internal_channels() const { + return channels_; +} +inline int32_t Datum::channels() const { + // @@protoc_insertion_point(field_get:opencv_caffe.Datum.channels) + return _internal_channels(); +} +inline void Datum::_internal_set_channels(int32_t value) { + _has_bits_[0] |= 0x00000002u; + channels_ = value; +} +inline void Datum::set_channels(int32_t value) { + _internal_set_channels(value); + // @@protoc_insertion_point(field_set:opencv_caffe.Datum.channels) +} + +// optional int32 height = 2; +inline bool Datum::_internal_has_height() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Datum::has_height() const { + return _internal_has_height(); +} +inline void Datum::clear_height() { + height_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t Datum::_internal_height() const { + return height_; +} +inline int32_t Datum::height() const { + // @@protoc_insertion_point(field_get:opencv_caffe.Datum.height) + return _internal_height(); +} +inline void Datum::_internal_set_height(int32_t value) { + _has_bits_[0] |= 0x00000004u; + height_ = value; +} +inline void Datum::set_height(int32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:opencv_caffe.Datum.height) +} + +// optional int32 width = 3; +inline bool Datum::_internal_has_width() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Datum::has_width() const { + return _internal_has_width(); +} +inline void Datum::clear_width() { + width_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline int32_t Datum::_internal_width() const { + return width_; +} +inline int32_t Datum::width() const { + // @@protoc_insertion_point(field_get:opencv_caffe.Datum.width) + return _internal_width(); +} +inline void Datum::_internal_set_width(int32_t value) { + _has_bits_[0] |= 0x00000008u; + width_ = value; +} +inline void Datum::set_width(int32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:opencv_caffe.Datum.width) +} + +// optional bytes data = 4; +inline bool Datum::_internal_has_data() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Datum::has_data() const { + return _internal_has_data(); +} +inline void Datum::clear_data() { + data_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Datum::data() const { + // @@protoc_insertion_point(field_get:opencv_caffe.Datum.data) + return _internal_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Datum::set_data(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.Datum.data) +} +inline std::string* Datum::mutable_data() { + std::string* _s = _internal_mutable_data(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.Datum.data) + return _s; +} +inline const std::string& Datum::_internal_data() const { + return data_.Get(); +} +inline void Datum::_internal_set_data(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* Datum::_internal_mutable_data() { + _has_bits_[0] |= 0x00000001u; + return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* Datum::release_data() { + // @@protoc_insertion_point(field_release:opencv_caffe.Datum.data) + if (!_internal_has_data()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Datum::set_allocated_data(std::string* data) { + if (data != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.Datum.data) +} + +// optional int32 label = 5; +inline bool Datum::_internal_has_label() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Datum::has_label() const { + return _internal_has_label(); +} +inline void Datum::clear_label() { + label_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t Datum::_internal_label() const { + return label_; +} +inline int32_t Datum::label() const { + // @@protoc_insertion_point(field_get:opencv_caffe.Datum.label) + return _internal_label(); +} +inline void Datum::_internal_set_label(int32_t value) { + _has_bits_[0] |= 0x00000010u; + label_ = value; +} +inline void Datum::set_label(int32_t value) { + _internal_set_label(value); + // @@protoc_insertion_point(field_set:opencv_caffe.Datum.label) +} + +// repeated float float_data = 6; +inline int Datum::_internal_float_data_size() const { + return float_data_.size(); +} +inline int Datum::float_data_size() const { + return _internal_float_data_size(); +} +inline void Datum::clear_float_data() { + float_data_.Clear(); +} +inline float Datum::_internal_float_data(int index) const { + return float_data_.Get(index); +} +inline float Datum::float_data(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.Datum.float_data) + return _internal_float_data(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::_internal_add_float_data(float value) { + float_data_.Add(value); +} +inline void Datum::add_float_data(float value) { + _internal_add_float_data(value); + // @@protoc_insertion_point(field_add:opencv_caffe.Datum.float_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +Datum::_internal_float_data() const { + return float_data_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +Datum::float_data() const { + // @@protoc_insertion_point(field_list:opencv_caffe.Datum.float_data) + return _internal_float_data(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +Datum::_internal_mutable_float_data() { + return &float_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +Datum::mutable_float_data() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.Datum.float_data) + return _internal_mutable_float_data(); +} + +// optional bool encoded = 7 [default = false]; +inline bool Datum::_internal_has_encoded() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Datum::has_encoded() const { + return _internal_has_encoded(); +} +inline void Datum::clear_encoded() { + encoded_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool Datum::_internal_encoded() const { + return encoded_; +} +inline bool Datum::encoded() const { + // @@protoc_insertion_point(field_get:opencv_caffe.Datum.encoded) + return _internal_encoded(); +} +inline void Datum::_internal_set_encoded(bool value) { + _has_bits_[0] |= 0x00000020u; + encoded_ = value; +} +inline void Datum::set_encoded(bool value) { + _internal_set_encoded(value); + // @@protoc_insertion_point(field_set:opencv_caffe.Datum.encoded) +} + +// ------------------------------------------------------------------- + +// FillerParameter + +// optional string type = 1 [default = "constant"]; +inline bool FillerParameter::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool FillerParameter::has_type() const { + return _internal_has_type(); +} +inline void FillerParameter::clear_type() { + type_.ClearToDefault(::opencv_caffe::FillerParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& FillerParameter::type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.type) + if (type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_type_.get(); + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void FillerParameter::set_type(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.type) +} +inline std::string* FillerParameter::mutable_type() { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.FillerParameter.type) + return _s; +} +inline const std::string& FillerParameter::_internal_type() const { + return type_.Get(); +} +inline void FillerParameter::_internal_set_type(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* FillerParameter::_internal_mutable_type() { + _has_bits_[0] |= 0x00000001u; + return type_.Mutable(::opencv_caffe::FillerParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation()); +} +inline std::string* FillerParameter::release_type() { + // @@protoc_insertion_point(field_release:opencv_caffe.FillerParameter.type) + if (!_internal_has_type()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = type_.ReleaseNonDefault(nullptr, GetArenaForAllocation()); + return p; +} +inline void FillerParameter::set_allocated_type(std::string* type) { + if (type != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + type_.SetAllocated(nullptr, type, + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.FillerParameter.type) +} + +// optional float value = 2 [default = 0]; +inline bool FillerParameter::_internal_has_value() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool FillerParameter::has_value() const { + return _internal_has_value(); +} +inline void FillerParameter::clear_value() { + value_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float FillerParameter::_internal_value() const { + return value_; +} +inline float FillerParameter::value() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.value) + return _internal_value(); +} +inline void FillerParameter::_internal_set_value(float value) { + _has_bits_[0] |= 0x00000002u; + value_ = value; +} +inline void FillerParameter::set_value(float value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.value) +} + +// optional float min = 3 [default = 0]; +inline bool FillerParameter::_internal_has_min() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool FillerParameter::has_min() const { + return _internal_has_min(); +} +inline void FillerParameter::clear_min() { + min_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline float FillerParameter::_internal_min() const { + return min_; +} +inline float FillerParameter::min() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.min) + return _internal_min(); +} +inline void FillerParameter::_internal_set_min(float value) { + _has_bits_[0] |= 0x00000004u; + min_ = value; +} +inline void FillerParameter::set_min(float value) { + _internal_set_min(value); + // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.min) +} + +// optional float max = 4 [default = 1]; +inline bool FillerParameter::_internal_has_max() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool FillerParameter::has_max() const { + return _internal_has_max(); +} +inline void FillerParameter::clear_max() { + max_ = 1; + _has_bits_[0] &= ~0x00000040u; +} +inline float FillerParameter::_internal_max() const { + return max_; +} +inline float FillerParameter::max() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.max) + return _internal_max(); +} +inline void FillerParameter::_internal_set_max(float value) { + _has_bits_[0] |= 0x00000040u; + max_ = value; +} +inline void FillerParameter::set_max(float value) { + _internal_set_max(value); + // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.max) +} + +// optional float mean = 5 [default = 0]; +inline bool FillerParameter::_internal_has_mean() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool FillerParameter::has_mean() const { + return _internal_has_mean(); +} +inline void FillerParameter::clear_mean() { + mean_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline float FillerParameter::_internal_mean() const { + return mean_; +} +inline float FillerParameter::mean() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.mean) + return _internal_mean(); +} +inline void FillerParameter::_internal_set_mean(float value) { + _has_bits_[0] |= 0x00000008u; + mean_ = value; +} +inline void FillerParameter::set_mean(float value) { + _internal_set_mean(value); + // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.mean) +} + +// optional float std = 6 [default = 1]; +inline bool FillerParameter::_internal_has_std() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool FillerParameter::has_std() const { + return _internal_has_std(); +} +inline void FillerParameter::clear_std() { + std_ = 1; + _has_bits_[0] &= ~0x00000080u; +} +inline float FillerParameter::_internal_std() const { + return std_; +} +inline float FillerParameter::std() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.std) + return _internal_std(); +} +inline void FillerParameter::_internal_set_std(float value) { + _has_bits_[0] |= 0x00000080u; + std_ = value; +} +inline void FillerParameter::set_std(float value) { + _internal_set_std(value); + // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.std) +} + +// optional int32 sparse = 7 [default = -1]; +inline bool FillerParameter::_internal_has_sparse() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool FillerParameter::has_sparse() const { + return _internal_has_sparse(); +} +inline void FillerParameter::clear_sparse() { + sparse_ = -1; + _has_bits_[0] &= ~0x00000020u; +} +inline int32_t FillerParameter::_internal_sparse() const { + return sparse_; +} +inline int32_t FillerParameter::sparse() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.sparse) + return _internal_sparse(); +} +inline void FillerParameter::_internal_set_sparse(int32_t value) { + _has_bits_[0] |= 0x00000020u; + sparse_ = value; +} +inline void FillerParameter::set_sparse(int32_t value) { + _internal_set_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::_internal_has_variance_norm() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool FillerParameter::has_variance_norm() const { + return _internal_has_variance_norm(); +} +inline void FillerParameter::clear_variance_norm() { + variance_norm_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline ::opencv_caffe::FillerParameter_VarianceNorm FillerParameter::_internal_variance_norm() const { + return static_cast< ::opencv_caffe::FillerParameter_VarianceNorm >(variance_norm_); +} +inline ::opencv_caffe::FillerParameter_VarianceNorm FillerParameter::variance_norm() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.variance_norm) + return _internal_variance_norm(); +} +inline void FillerParameter::_internal_set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value) { + assert(::opencv_caffe::FillerParameter_VarianceNorm_IsValid(value)); + _has_bits_[0] |= 0x00000010u; + variance_norm_ = value; +} +inline void FillerParameter::set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value) { + _internal_set_variance_norm(value); + // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.variance_norm) +} + +// ------------------------------------------------------------------- + +// NetParameter + +// optional string name = 1; +inline bool NetParameter::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NetParameter::has_name() const { + return _internal_has_name(); +} +inline void NetParameter::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& NetParameter::name() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void NetParameter::set_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.name) +} +inline std::string* NetParameter::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.name) + return _s; +} +inline const std::string& NetParameter::_internal_name() const { + return name_.Get(); +} +inline void NetParameter::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* NetParameter::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* NetParameter::release_name() { + // @@protoc_insertion_point(field_release:opencv_caffe.NetParameter.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NetParameter::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.NetParameter.name) +} + +// repeated string input = 3; +inline int NetParameter::_internal_input_size() const { + return input_.size(); +} +inline int NetParameter::input_size() const { + return _internal_input_size(); +} +inline void NetParameter::clear_input() { + input_.Clear(); +} +inline std::string* NetParameter::add_input() { + std::string* _s = _internal_add_input(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetParameter.input) + return _s; +} +inline const std::string& NetParameter::_internal_input(int index) const { + return input_.Get(index); +} +inline const std::string& NetParameter::input(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input) + return _internal_input(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) { + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input) +} +inline void NetParameter::set_input(int index, std::string&& value) { + input_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input) +} +inline void NetParameter::set_input(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetParameter.input) +} +inline std::string* NetParameter::_internal_add_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) +} +inline void NetParameter::add_input(std::string&& value) { + input_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input) +} +inline void NetParameter::add_input(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetParameter.input) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +NetParameter::input() const { + // @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input) + return input_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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::_internal_input_shape_size() const { + return input_shape_.size(); +} +inline int NetParameter::input_shape_size() const { + return _internal_input_shape_size(); +} +inline void NetParameter::clear_input_shape() { + input_shape_.Clear(); +} +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 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >* +NetParameter::mutable_input_shape() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input_shape) + return &input_shape_; +} +inline const ::opencv_caffe::BlobShape& NetParameter::_internal_input_shape(int index) const { + return input_shape_.Get(index); +} +inline const ::opencv_caffe::BlobShape& NetParameter::input_shape(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input_shape) + return _internal_input_shape(index); +} +inline ::opencv_caffe::BlobShape* NetParameter::_internal_add_input_shape() { + return input_shape_.Add(); +} +inline ::opencv_caffe::BlobShape* NetParameter::add_input_shape() { + ::opencv_caffe::BlobShape* _add = _internal_add_input_shape(); + // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input_shape) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_input_dim_size() const { + return input_dim_.size(); +} +inline int NetParameter::input_dim_size() const { + return _internal_input_dim_size(); +} +inline void NetParameter::clear_input_dim() { + input_dim_.Clear(); +} +inline int32_t NetParameter::_internal_input_dim(int index) const { + return input_dim_.Get(index); +} +inline int32_t NetParameter::input_dim(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input_dim) + return _internal_input_dim(index); +} +inline void NetParameter::set_input_dim(int index, int32_t value) { + input_dim_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input_dim) +} +inline void NetParameter::_internal_add_input_dim(int32_t value) { + input_dim_.Add(value); +} +inline void NetParameter::add_input_dim(int32_t value) { + _internal_add_input_dim(value); + // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input_dim) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +NetParameter::_internal_input_dim() const { + return input_dim_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +NetParameter::input_dim() const { + // @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input_dim) + return _internal_input_dim(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +NetParameter::_internal_mutable_input_dim() { + return &input_dim_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +NetParameter::mutable_input_dim() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input_dim) + return _internal_mutable_input_dim(); +} + +// optional bool force_backward = 5 [default = false]; +inline bool NetParameter::_internal_has_force_backward() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool NetParameter::has_force_backward() const { + return _internal_has_force_backward(); +} +inline void NetParameter::clear_force_backward() { + force_backward_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool NetParameter::_internal_force_backward() const { + return force_backward_; +} +inline bool NetParameter::force_backward() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.force_backward) + return _internal_force_backward(); +} +inline void NetParameter::_internal_set_force_backward(bool value) { + _has_bits_[0] |= 0x00000004u; + force_backward_ = value; +} +inline void NetParameter::set_force_backward(bool value) { + _internal_set_force_backward(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.force_backward) +} + +// optional .opencv_caffe.NetState state = 6; +inline bool NetParameter::_internal_has_state() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || state_ != nullptr); + return value; +} +inline bool NetParameter::has_state() const { + return _internal_has_state(); +} +inline void NetParameter::clear_state() { + if (state_ != nullptr) state_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::NetState& NetParameter::_internal_state() const { + const ::opencv_caffe::NetState* p = state_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_NetState_default_instance_); +} +inline const ::opencv_caffe::NetState& NetParameter::state() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.state) + return _internal_state(); +} +inline void NetParameter::unsafe_arena_set_allocated_state( + ::opencv_caffe::NetState* state) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(state_); + } + state_ = state; + if (state) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.NetParameter.state) +} +inline ::opencv_caffe::NetState* NetParameter::release_state() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::NetState* temp = state_; + state_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::NetState* NetParameter::unsafe_arena_release_state() { + // @@protoc_insertion_point(field_release:opencv_caffe.NetParameter.state) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::NetState* temp = state_; + state_ = nullptr; + return temp; +} +inline ::opencv_caffe::NetState* NetParameter::_internal_mutable_state() { + _has_bits_[0] |= 0x00000002u; + if (state_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::NetState>(GetArenaForAllocation()); + state_ = p; + } + return state_; +} +inline ::opencv_caffe::NetState* NetParameter::mutable_state() { + ::opencv_caffe::NetState* _msg = _internal_mutable_state(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.state) + return _msg; +} +inline void NetParameter::set_allocated_state(::opencv_caffe::NetState* state) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete state_; + } + if (state) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::NetState>::GetOwningArena(state); + if (message_arena != submessage_arena) { + state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, state, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + state_ = state; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.NetParameter.state) +} + +// optional bool debug_info = 7 [default = false]; +inline bool NetParameter::_internal_has_debug_info() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool NetParameter::has_debug_info() const { + return _internal_has_debug_info(); +} +inline void NetParameter::clear_debug_info() { + debug_info_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool NetParameter::_internal_debug_info() const { + return debug_info_; +} +inline bool NetParameter::debug_info() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.debug_info) + return _internal_debug_info(); +} +inline void NetParameter::_internal_set_debug_info(bool value) { + _has_bits_[0] |= 0x00000008u; + debug_info_ = value; +} +inline void NetParameter::set_debug_info(bool value) { + _internal_set_debug_info(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.debug_info) +} + +// repeated .opencv_caffe.LayerParameter layer = 100; +inline int NetParameter::_internal_layer_size() const { + return layer_.size(); +} +inline int NetParameter::layer_size() const { + return _internal_layer_size(); +} +inline void NetParameter::clear_layer() { + layer_.Clear(); +} +inline ::opencv_caffe::LayerParameter* NetParameter::mutable_layer(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.layer) + return layer_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::LayerParameter >* +NetParameter::mutable_layer() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.layer) + return &layer_; +} +inline const ::opencv_caffe::LayerParameter& NetParameter::_internal_layer(int index) const { + return layer_.Get(index); +} +inline const ::opencv_caffe::LayerParameter& NetParameter::layer(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.layer) + return _internal_layer(index); +} +inline ::opencv_caffe::LayerParameter* NetParameter::_internal_add_layer() { + return layer_.Add(); +} +inline ::opencv_caffe::LayerParameter* NetParameter::add_layer() { + ::opencv_caffe::LayerParameter* _add = _internal_add_layer(); + // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.layer) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_layers_size() const { + return layers_.size(); +} +inline int NetParameter::layers_size() const { + return _internal_layers_size(); +} +inline void NetParameter::clear_layers() { + layers_.Clear(); +} +inline ::opencv_caffe::V1LayerParameter* NetParameter::mutable_layers(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.layers) + return layers_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >* +NetParameter::mutable_layers() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.layers) + return &layers_; +} +inline const ::opencv_caffe::V1LayerParameter& NetParameter::_internal_layers(int index) const { + return layers_.Get(index); +} +inline const ::opencv_caffe::V1LayerParameter& NetParameter::layers(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.layers) + return _internal_layers(index); +} +inline ::opencv_caffe::V1LayerParameter* NetParameter::_internal_add_layers() { + return layers_.Add(); +} +inline ::opencv_caffe::V1LayerParameter* NetParameter::add_layers() { + ::opencv_caffe::V1LayerParameter* _add = _internal_add_layers(); + // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.layers) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_has_net() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SolverParameter::has_net() const { + return _internal_has_net(); +} +inline void SolverParameter::clear_net() { + net_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& SolverParameter::net() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.net) + return _internal_net(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SolverParameter::set_net(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000008u; + net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.net) +} +inline std::string* SolverParameter::mutable_net() { + std::string* _s = _internal_mutable_net(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.net) + return _s; +} +inline const std::string& SolverParameter::_internal_net() const { + return net_.Get(); +} +inline void SolverParameter::_internal_set_net(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SolverParameter::_internal_mutable_net() { + _has_bits_[0] |= 0x00000008u; + return net_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SolverParameter::release_net() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.net) + if (!_internal_has_net()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto* p = net_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SolverParameter::set_allocated_net(std::string* net) { + if (net != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + net_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), net, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.net) +} + +// optional .opencv_caffe.NetParameter net_param = 25; +inline bool SolverParameter::_internal_has_net_param() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || net_param_ != nullptr); + return value; +} +inline bool SolverParameter::has_net_param() const { + return _internal_has_net_param(); +} +inline void SolverParameter::clear_net_param() { + if (net_param_ != nullptr) net_param_->Clear(); + _has_bits_[0] &= ~0x00000080u; +} +inline const ::opencv_caffe::NetParameter& SolverParameter::_internal_net_param() const { + const ::opencv_caffe::NetParameter* p = net_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_NetParameter_default_instance_); +} +inline const ::opencv_caffe::NetParameter& SolverParameter::net_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.net_param) + return _internal_net_param(); +} +inline void SolverParameter::unsafe_arena_set_allocated_net_param( + ::opencv_caffe::NetParameter* net_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(net_param_); + } + net_param_ = net_param; + if (net_param) { + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.SolverParameter.net_param) +} +inline ::opencv_caffe::NetParameter* SolverParameter::release_net_param() { + _has_bits_[0] &= ~0x00000080u; + ::opencv_caffe::NetParameter* temp = net_param_; + net_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::NetParameter* SolverParameter::unsafe_arena_release_net_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.net_param) + _has_bits_[0] &= ~0x00000080u; + ::opencv_caffe::NetParameter* temp = net_param_; + net_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::NetParameter* SolverParameter::_internal_mutable_net_param() { + _has_bits_[0] |= 0x00000080u; + if (net_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::NetParameter>(GetArenaForAllocation()); + net_param_ = p; + } + return net_param_; +} +inline ::opencv_caffe::NetParameter* SolverParameter::mutable_net_param() { + ::opencv_caffe::NetParameter* _msg = _internal_mutable_net_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.net_param) + return _msg; +} +inline void SolverParameter::set_allocated_net_param(::opencv_caffe::NetParameter* net_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete net_param_; + } + if (net_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::NetParameter>::GetOwningArena(net_param); + if (message_arena != submessage_arena) { + net_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, net_param, submessage_arena); + } + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + net_param_ = net_param; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.net_param) +} + +// optional string train_net = 1; +inline bool SolverParameter::_internal_has_train_net() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SolverParameter::has_train_net() const { + return _internal_has_train_net(); +} +inline void SolverParameter::clear_train_net() { + train_net_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SolverParameter::train_net() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_net) + return _internal_train_net(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SolverParameter::set_train_net(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + train_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.train_net) +} +inline std::string* SolverParameter::mutable_train_net() { + std::string* _s = _internal_mutable_train_net(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_net) + return _s; +} +inline const std::string& SolverParameter::_internal_train_net() const { + return train_net_.Get(); +} +inline void SolverParameter::_internal_set_train_net(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + train_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SolverParameter::_internal_mutable_train_net() { + _has_bits_[0] |= 0x00000001u; + return train_net_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SolverParameter::release_train_net() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_net) + if (!_internal_has_train_net()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = train_net_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (train_net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + train_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SolverParameter::set_allocated_train_net(std::string* train_net) { + if (train_net != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + train_net_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), train_net, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (train_net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + train_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.train_net) +} + +// repeated string test_net = 2; +inline int SolverParameter::_internal_test_net_size() const { + return test_net_.size(); +} +inline int SolverParameter::test_net_size() const { + return _internal_test_net_size(); +} +inline void SolverParameter::clear_test_net() { + test_net_.Clear(); +} +inline std::string* SolverParameter::add_test_net() { + std::string* _s = _internal_add_test_net(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.SolverParameter.test_net) + return _s; +} +inline const std::string& SolverParameter::_internal_test_net(int index) const { + return test_net_.Get(index); +} +inline const std::string& SolverParameter::test_net(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_net) + return _internal_test_net(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) { + test_net_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_net) +} +inline void SolverParameter::set_test_net(int index, std::string&& value) { + test_net_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_net) +} +inline void SolverParameter::set_test_net(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.test_net) +} +inline std::string* SolverParameter::_internal_add_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) +} +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) +} +inline void SolverParameter::add_test_net(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.SolverParameter.test_net) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SolverParameter::test_net() const { + // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_net) + return test_net_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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::_internal_has_train_net_param() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || train_net_param_ != nullptr); + return value; +} +inline bool SolverParameter::has_train_net_param() const { + return _internal_has_train_net_param(); +} +inline void SolverParameter::clear_train_net_param() { + if (train_net_param_ != nullptr) train_net_param_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::opencv_caffe::NetParameter& SolverParameter::_internal_train_net_param() const { + const ::opencv_caffe::NetParameter* p = train_net_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_NetParameter_default_instance_); +} +inline const ::opencv_caffe::NetParameter& SolverParameter::train_net_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_net_param) + return _internal_train_net_param(); +} +inline void SolverParameter::unsafe_arena_set_allocated_train_net_param( + ::opencv_caffe::NetParameter* train_net_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(train_net_param_); + } + train_net_param_ = train_net_param; + if (train_net_param) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.SolverParameter.train_net_param) +} +inline ::opencv_caffe::NetParameter* SolverParameter::release_train_net_param() { + _has_bits_[0] &= ~0x00000040u; + ::opencv_caffe::NetParameter* temp = train_net_param_; + train_net_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::NetParameter* SolverParameter::unsafe_arena_release_train_net_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_net_param) + _has_bits_[0] &= ~0x00000040u; + ::opencv_caffe::NetParameter* temp = train_net_param_; + train_net_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::NetParameter* SolverParameter::_internal_mutable_train_net_param() { + _has_bits_[0] |= 0x00000040u; + if (train_net_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::NetParameter>(GetArenaForAllocation()); + train_net_param_ = p; + } + return train_net_param_; +} +inline ::opencv_caffe::NetParameter* SolverParameter::mutable_train_net_param() { + ::opencv_caffe::NetParameter* _msg = _internal_mutable_train_net_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_net_param) + return _msg; +} +inline void SolverParameter::set_allocated_train_net_param(::opencv_caffe::NetParameter* train_net_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete train_net_param_; + } + if (train_net_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::NetParameter>::GetOwningArena(train_net_param); + if (message_arena != submessage_arena) { + train_net_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, train_net_param, submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + 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::_internal_test_net_param_size() const { + return test_net_param_.size(); +} +inline int SolverParameter::test_net_param_size() const { + return _internal_test_net_param_size(); +} +inline void SolverParameter::clear_test_net_param() { + test_net_param_.Clear(); +} +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 ::PROTOBUF_NAMESPACE_ID::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 ::opencv_caffe::NetParameter& SolverParameter::_internal_test_net_param(int index) const { + return test_net_param_.Get(index); +} +inline const ::opencv_caffe::NetParameter& SolverParameter::test_net_param(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_net_param) + return _internal_test_net_param(index); +} +inline ::opencv_caffe::NetParameter* SolverParameter::_internal_add_test_net_param() { + return test_net_param_.Add(); +} +inline ::opencv_caffe::NetParameter* SolverParameter::add_test_net_param() { + ::opencv_caffe::NetParameter* _add = _internal_add_test_net_param(); + // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_net_param) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_has_train_state() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || train_state_ != nullptr); + return value; +} +inline bool SolverParameter::has_train_state() const { + return _internal_has_train_state(); +} +inline void SolverParameter::clear_train_state() { + if (train_state_ != nullptr) train_state_->Clear(); + _has_bits_[0] &= ~0x00000100u; +} +inline const ::opencv_caffe::NetState& SolverParameter::_internal_train_state() const { + const ::opencv_caffe::NetState* p = train_state_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_NetState_default_instance_); +} +inline const ::opencv_caffe::NetState& SolverParameter::train_state() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_state) + return _internal_train_state(); +} +inline void SolverParameter::unsafe_arena_set_allocated_train_state( + ::opencv_caffe::NetState* train_state) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(train_state_); + } + train_state_ = train_state; + if (train_state) { + _has_bits_[0] |= 0x00000100u; + } else { + _has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.SolverParameter.train_state) +} +inline ::opencv_caffe::NetState* SolverParameter::release_train_state() { + _has_bits_[0] &= ~0x00000100u; + ::opencv_caffe::NetState* temp = train_state_; + train_state_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::NetState* SolverParameter::unsafe_arena_release_train_state() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_state) + _has_bits_[0] &= ~0x00000100u; + ::opencv_caffe::NetState* temp = train_state_; + train_state_ = nullptr; + return temp; +} +inline ::opencv_caffe::NetState* SolverParameter::_internal_mutable_train_state() { + _has_bits_[0] |= 0x00000100u; + if (train_state_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::NetState>(GetArenaForAllocation()); + train_state_ = p; + } + return train_state_; +} +inline ::opencv_caffe::NetState* SolverParameter::mutable_train_state() { + ::opencv_caffe::NetState* _msg = _internal_mutable_train_state(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_state) + return _msg; +} +inline void SolverParameter::set_allocated_train_state(::opencv_caffe::NetState* train_state) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete train_state_; + } + if (train_state) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::NetState>::GetOwningArena(train_state); + if (message_arena != submessage_arena) { + train_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, train_state, submessage_arena); + } + _has_bits_[0] |= 0x00000100u; + } else { + _has_bits_[0] &= ~0x00000100u; + } + 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::_internal_test_state_size() const { + return test_state_.size(); +} +inline int SolverParameter::test_state_size() const { + return _internal_test_state_size(); +} +inline void SolverParameter::clear_test_state() { + test_state_.Clear(); +} +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 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState >* +SolverParameter::mutable_test_state() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_state) + return &test_state_; +} +inline const ::opencv_caffe::NetState& SolverParameter::_internal_test_state(int index) const { + return test_state_.Get(index); +} +inline const ::opencv_caffe::NetState& SolverParameter::test_state(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_state) + return _internal_test_state(index); +} +inline ::opencv_caffe::NetState* SolverParameter::_internal_add_test_state() { + return test_state_.Add(); +} +inline ::opencv_caffe::NetState* SolverParameter::add_test_state() { + ::opencv_caffe::NetState* _add = _internal_add_test_state(); + // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_state) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_test_iter_size() const { + return test_iter_.size(); +} +inline int SolverParameter::test_iter_size() const { + return _internal_test_iter_size(); +} +inline void SolverParameter::clear_test_iter() { + test_iter_.Clear(); +} +inline int32_t SolverParameter::_internal_test_iter(int index) const { + return test_iter_.Get(index); +} +inline int32_t SolverParameter::test_iter(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_iter) + return _internal_test_iter(index); +} +inline void SolverParameter::set_test_iter(int index, int32_t value) { + test_iter_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_iter) +} +inline void SolverParameter::_internal_add_test_iter(int32_t value) { + test_iter_.Add(value); +} +inline void SolverParameter::add_test_iter(int32_t value) { + _internal_add_test_iter(value); + // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_iter) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +SolverParameter::_internal_test_iter() const { + return test_iter_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +SolverParameter::test_iter() const { + // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_iter) + return _internal_test_iter(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +SolverParameter::_internal_mutable_test_iter() { + return &test_iter_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +SolverParameter::mutable_test_iter() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_iter) + return _internal_mutable_test_iter(); +} + +// optional int32 test_interval = 4 [default = 0]; +inline bool SolverParameter::_internal_has_test_interval() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool SolverParameter::has_test_interval() const { + return _internal_has_test_interval(); +} +inline void SolverParameter::clear_test_interval() { + test_interval_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline int32_t SolverParameter::_internal_test_interval() const { + return test_interval_; +} +inline int32_t SolverParameter::test_interval() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_interval) + return _internal_test_interval(); +} +inline void SolverParameter::_internal_set_test_interval(int32_t value) { + _has_bits_[0] |= 0x00000200u; + test_interval_ = value; +} +inline void SolverParameter::set_test_interval(int32_t value) { + _internal_set_test_interval(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_interval) +} + +// optional bool test_compute_loss = 19 [default = false]; +inline bool SolverParameter::_internal_has_test_compute_loss() const { + bool value = (_has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool SolverParameter::has_test_compute_loss() const { + return _internal_has_test_compute_loss(); +} +inline void SolverParameter::clear_test_compute_loss() { + test_compute_loss_ = false; + _has_bits_[0] &= ~0x00100000u; +} +inline bool SolverParameter::_internal_test_compute_loss() const { + return test_compute_loss_; +} +inline bool SolverParameter::test_compute_loss() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_compute_loss) + return _internal_test_compute_loss(); +} +inline void SolverParameter::_internal_set_test_compute_loss(bool value) { + _has_bits_[0] |= 0x00100000u; + test_compute_loss_ = value; +} +inline void SolverParameter::set_test_compute_loss(bool value) { + _internal_set_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::_internal_has_test_initialization() const { + bool value = (_has_bits_[0] & 0x08000000u) != 0; + return value; +} +inline bool SolverParameter::has_test_initialization() const { + return _internal_has_test_initialization(); +} +inline void SolverParameter::clear_test_initialization() { + test_initialization_ = true; + _has_bits_[0] &= ~0x08000000u; +} +inline bool SolverParameter::_internal_test_initialization() const { + return test_initialization_; +} +inline bool SolverParameter::test_initialization() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_initialization) + return _internal_test_initialization(); +} +inline void SolverParameter::_internal_set_test_initialization(bool value) { + _has_bits_[0] |= 0x08000000u; + test_initialization_ = value; +} +inline void SolverParameter::set_test_initialization(bool value) { + _internal_set_test_initialization(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_initialization) +} + +// optional float base_lr = 5; +inline bool SolverParameter::_internal_has_base_lr() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool SolverParameter::has_base_lr() const { + return _internal_has_base_lr(); +} +inline void SolverParameter::clear_base_lr() { + base_lr_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline float SolverParameter::_internal_base_lr() const { + return base_lr_; +} +inline float SolverParameter::base_lr() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.base_lr) + return _internal_base_lr(); +} +inline void SolverParameter::_internal_set_base_lr(float value) { + _has_bits_[0] |= 0x00000400u; + base_lr_ = value; +} +inline void SolverParameter::set_base_lr(float value) { + _internal_set_base_lr(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.base_lr) +} + +// optional int32 display = 6; +inline bool SolverParameter::_internal_has_display() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool SolverParameter::has_display() const { + return _internal_has_display(); +} +inline void SolverParameter::clear_display() { + display_ = 0; + _has_bits_[0] &= ~0x00000800u; +} +inline int32_t SolverParameter::_internal_display() const { + return display_; +} +inline int32_t SolverParameter::display() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.display) + return _internal_display(); +} +inline void SolverParameter::_internal_set_display(int32_t value) { + _has_bits_[0] |= 0x00000800u; + display_ = value; +} +inline void SolverParameter::set_display(int32_t value) { + _internal_set_display(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.display) +} + +// optional int32 average_loss = 33 [default = 1]; +inline bool SolverParameter::_internal_has_average_loss() const { + bool value = (_has_bits_[0] & 0x40000000u) != 0; + return value; +} +inline bool SolverParameter::has_average_loss() const { + return _internal_has_average_loss(); +} +inline void SolverParameter::clear_average_loss() { + average_loss_ = 1; + _has_bits_[0] &= ~0x40000000u; +} +inline int32_t SolverParameter::_internal_average_loss() const { + return average_loss_; +} +inline int32_t SolverParameter::average_loss() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.average_loss) + return _internal_average_loss(); +} +inline void SolverParameter::_internal_set_average_loss(int32_t value) { + _has_bits_[0] |= 0x40000000u; + average_loss_ = value; +} +inline void SolverParameter::set_average_loss(int32_t value) { + _internal_set_average_loss(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.average_loss) +} + +// optional int32 max_iter = 7; +inline bool SolverParameter::_internal_has_max_iter() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool SolverParameter::has_max_iter() const { + return _internal_has_max_iter(); +} +inline void SolverParameter::clear_max_iter() { + max_iter_ = 0; + _has_bits_[0] &= ~0x00001000u; +} +inline int32_t SolverParameter::_internal_max_iter() const { + return max_iter_; +} +inline int32_t SolverParameter::max_iter() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.max_iter) + return _internal_max_iter(); +} +inline void SolverParameter::_internal_set_max_iter(int32_t value) { + _has_bits_[0] |= 0x00001000u; + max_iter_ = value; +} +inline void SolverParameter::set_max_iter(int32_t value) { + _internal_set_max_iter(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.max_iter) +} + +// optional int32 iter_size = 36 [default = 1]; +inline bool SolverParameter::_internal_has_iter_size() const { + bool value = (_has_bits_[1] & 0x00000001u) != 0; + return value; +} +inline bool SolverParameter::has_iter_size() const { + return _internal_has_iter_size(); +} +inline void SolverParameter::clear_iter_size() { + iter_size_ = 1; + _has_bits_[1] &= ~0x00000001u; +} +inline int32_t SolverParameter::_internal_iter_size() const { + return iter_size_; +} +inline int32_t SolverParameter::iter_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.iter_size) + return _internal_iter_size(); +} +inline void SolverParameter::_internal_set_iter_size(int32_t value) { + _has_bits_[1] |= 0x00000001u; + iter_size_ = value; +} +inline void SolverParameter::set_iter_size(int32_t value) { + _internal_set_iter_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.iter_size) +} + +// optional string lr_policy = 8; +inline bool SolverParameter::_internal_has_lr_policy() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SolverParameter::has_lr_policy() const { + return _internal_has_lr_policy(); +} +inline void SolverParameter::clear_lr_policy() { + lr_policy_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SolverParameter::lr_policy() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.lr_policy) + return _internal_lr_policy(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SolverParameter::set_lr_policy(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + lr_policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.lr_policy) +} +inline std::string* SolverParameter::mutable_lr_policy() { + std::string* _s = _internal_mutable_lr_policy(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.lr_policy) + return _s; +} +inline const std::string& SolverParameter::_internal_lr_policy() const { + return lr_policy_.Get(); +} +inline void SolverParameter::_internal_set_lr_policy(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + lr_policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SolverParameter::_internal_mutable_lr_policy() { + _has_bits_[0] |= 0x00000002u; + return lr_policy_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SolverParameter::release_lr_policy() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.lr_policy) + if (!_internal_has_lr_policy()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = lr_policy_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (lr_policy_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + lr_policy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SolverParameter::set_allocated_lr_policy(std::string* lr_policy) { + if (lr_policy != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + lr_policy_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), lr_policy, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (lr_policy_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + lr_policy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.lr_policy) +} + +// optional float gamma = 9; +inline bool SolverParameter::_internal_has_gamma() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool SolverParameter::has_gamma() const { + return _internal_has_gamma(); +} +inline void SolverParameter::clear_gamma() { + gamma_ = 0; + _has_bits_[0] &= ~0x00002000u; +} +inline float SolverParameter::_internal_gamma() const { + return gamma_; +} +inline float SolverParameter::gamma() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.gamma) + return _internal_gamma(); +} +inline void SolverParameter::_internal_set_gamma(float value) { + _has_bits_[0] |= 0x00002000u; + gamma_ = value; +} +inline void SolverParameter::set_gamma(float value) { + _internal_set_gamma(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.gamma) +} + +// optional float power = 10; +inline bool SolverParameter::_internal_has_power() const { + bool value = (_has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool SolverParameter::has_power() const { + return _internal_has_power(); +} +inline void SolverParameter::clear_power() { + power_ = 0; + _has_bits_[0] &= ~0x00004000u; +} +inline float SolverParameter::_internal_power() const { + return power_; +} +inline float SolverParameter::power() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.power) + return _internal_power(); +} +inline void SolverParameter::_internal_set_power(float value) { + _has_bits_[0] |= 0x00004000u; + power_ = value; +} +inline void SolverParameter::set_power(float value) { + _internal_set_power(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.power) +} + +// optional float momentum = 11; +inline bool SolverParameter::_internal_has_momentum() const { + bool value = (_has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool SolverParameter::has_momentum() const { + return _internal_has_momentum(); +} +inline void SolverParameter::clear_momentum() { + momentum_ = 0; + _has_bits_[0] &= ~0x00008000u; +} +inline float SolverParameter::_internal_momentum() const { + return momentum_; +} +inline float SolverParameter::momentum() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.momentum) + return _internal_momentum(); +} +inline void SolverParameter::_internal_set_momentum(float value) { + _has_bits_[0] |= 0x00008000u; + momentum_ = value; +} +inline void SolverParameter::set_momentum(float value) { + _internal_set_momentum(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.momentum) +} + +// optional float weight_decay = 12; +inline bool SolverParameter::_internal_has_weight_decay() const { + bool value = (_has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool SolverParameter::has_weight_decay() const { + return _internal_has_weight_decay(); +} +inline void SolverParameter::clear_weight_decay() { + weight_decay_ = 0; + _has_bits_[0] &= ~0x00010000u; +} +inline float SolverParameter::_internal_weight_decay() const { + return weight_decay_; +} +inline float SolverParameter::weight_decay() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.weight_decay) + return _internal_weight_decay(); +} +inline void SolverParameter::_internal_set_weight_decay(float value) { + _has_bits_[0] |= 0x00010000u; + weight_decay_ = value; +} +inline void SolverParameter::set_weight_decay(float value) { + _internal_set_weight_decay(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.weight_decay) +} + +// optional string regularization_type = 29 [default = "L2"]; +inline bool SolverParameter::_internal_has_regularization_type() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool SolverParameter::has_regularization_type() const { + return _internal_has_regularization_type(); +} +inline void SolverParameter::clear_regularization_type() { + regularization_type_.ClearToDefault(::opencv_caffe::SolverParameter::_i_give_permission_to_break_this_code_default_regularization_type_, GetArenaForAllocation()); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& SolverParameter::regularization_type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.regularization_type) + if (regularization_type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_regularization_type_.get(); + return _internal_regularization_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SolverParameter::set_regularization_type(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000010u; + regularization_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.regularization_type) +} +inline std::string* SolverParameter::mutable_regularization_type() { + std::string* _s = _internal_mutable_regularization_type(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.regularization_type) + return _s; +} +inline const std::string& SolverParameter::_internal_regularization_type() const { + return regularization_type_.Get(); +} +inline void SolverParameter::_internal_set_regularization_type(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + regularization_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SolverParameter::_internal_mutable_regularization_type() { + _has_bits_[0] |= 0x00000010u; + return regularization_type_.Mutable(::opencv_caffe::SolverParameter::_i_give_permission_to_break_this_code_default_regularization_type_, GetArenaForAllocation()); +} +inline std::string* SolverParameter::release_regularization_type() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.regularization_type) + if (!_internal_has_regularization_type()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + auto* p = regularization_type_.ReleaseNonDefault(nullptr, GetArenaForAllocation()); + return p; +} +inline void SolverParameter::set_allocated_regularization_type(std::string* regularization_type) { + if (regularization_type != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + regularization_type_.SetAllocated(nullptr, regularization_type, + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.regularization_type) +} + +// optional int32 stepsize = 13; +inline bool SolverParameter::_internal_has_stepsize() const { + bool value = (_has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool SolverParameter::has_stepsize() const { + return _internal_has_stepsize(); +} +inline void SolverParameter::clear_stepsize() { + stepsize_ = 0; + _has_bits_[0] &= ~0x00020000u; +} +inline int32_t SolverParameter::_internal_stepsize() const { + return stepsize_; +} +inline int32_t SolverParameter::stepsize() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.stepsize) + return _internal_stepsize(); +} +inline void SolverParameter::_internal_set_stepsize(int32_t value) { + _has_bits_[0] |= 0x00020000u; + stepsize_ = value; +} +inline void SolverParameter::set_stepsize(int32_t value) { + _internal_set_stepsize(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.stepsize) +} + +// repeated int32 stepvalue = 34; +inline int SolverParameter::_internal_stepvalue_size() const { + return stepvalue_.size(); +} +inline int SolverParameter::stepvalue_size() const { + return _internal_stepvalue_size(); +} +inline void SolverParameter::clear_stepvalue() { + stepvalue_.Clear(); +} +inline int32_t SolverParameter::_internal_stepvalue(int index) const { + return stepvalue_.Get(index); +} +inline int32_t SolverParameter::stepvalue(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.stepvalue) + return _internal_stepvalue(index); +} +inline void SolverParameter::set_stepvalue(int index, int32_t value) { + stepvalue_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.stepvalue) +} +inline void SolverParameter::_internal_add_stepvalue(int32_t value) { + stepvalue_.Add(value); +} +inline void SolverParameter::add_stepvalue(int32_t value) { + _internal_add_stepvalue(value); + // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.stepvalue) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +SolverParameter::_internal_stepvalue() const { + return stepvalue_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +SolverParameter::stepvalue() const { + // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.stepvalue) + return _internal_stepvalue(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +SolverParameter::_internal_mutable_stepvalue() { + return &stepvalue_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +SolverParameter::mutable_stepvalue() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.stepvalue) + return _internal_mutable_stepvalue(); +} + +// optional float clip_gradients = 35 [default = -1]; +inline bool SolverParameter::_internal_has_clip_gradients() const { + bool value = (_has_bits_[0] & 0x80000000u) != 0; + return value; +} +inline bool SolverParameter::has_clip_gradients() const { + return _internal_has_clip_gradients(); +} +inline void SolverParameter::clear_clip_gradients() { + clip_gradients_ = -1; + _has_bits_[0] &= ~0x80000000u; +} +inline float SolverParameter::_internal_clip_gradients() const { + return clip_gradients_; +} +inline float SolverParameter::clip_gradients() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.clip_gradients) + return _internal_clip_gradients(); +} +inline void SolverParameter::_internal_set_clip_gradients(float value) { + _has_bits_[0] |= 0x80000000u; + clip_gradients_ = value; +} +inline void SolverParameter::set_clip_gradients(float value) { + _internal_set_clip_gradients(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.clip_gradients) +} + +// optional int32 snapshot = 14 [default = 0]; +inline bool SolverParameter::_internal_has_snapshot() const { + bool value = (_has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool SolverParameter::has_snapshot() const { + return _internal_has_snapshot(); +} +inline void SolverParameter::clear_snapshot() { + snapshot_ = 0; + _has_bits_[0] &= ~0x00040000u; +} +inline int32_t SolverParameter::_internal_snapshot() const { + return snapshot_; +} +inline int32_t SolverParameter::snapshot() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot) + return _internal_snapshot(); +} +inline void SolverParameter::_internal_set_snapshot(int32_t value) { + _has_bits_[0] |= 0x00040000u; + snapshot_ = value; +} +inline void SolverParameter::set_snapshot(int32_t value) { + _internal_set_snapshot(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot) +} + +// optional string snapshot_prefix = 15; +inline bool SolverParameter::_internal_has_snapshot_prefix() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SolverParameter::has_snapshot_prefix() const { + return _internal_has_snapshot_prefix(); +} +inline void SolverParameter::clear_snapshot_prefix() { + snapshot_prefix_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& SolverParameter::snapshot_prefix() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_prefix) + return _internal_snapshot_prefix(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SolverParameter::set_snapshot_prefix(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + snapshot_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_prefix) +} +inline std::string* SolverParameter::mutable_snapshot_prefix() { + std::string* _s = _internal_mutable_snapshot_prefix(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.snapshot_prefix) + return _s; +} +inline const std::string& SolverParameter::_internal_snapshot_prefix() const { + return snapshot_prefix_.Get(); +} +inline void SolverParameter::_internal_set_snapshot_prefix(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + snapshot_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SolverParameter::_internal_mutable_snapshot_prefix() { + _has_bits_[0] |= 0x00000004u; + return snapshot_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SolverParameter::release_snapshot_prefix() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.snapshot_prefix) + if (!_internal_has_snapshot_prefix()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = snapshot_prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (snapshot_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + snapshot_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SolverParameter::set_allocated_snapshot_prefix(std::string* snapshot_prefix) { + if (snapshot_prefix != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + snapshot_prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), snapshot_prefix, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (snapshot_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + snapshot_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.snapshot_prefix) +} + +// optional bool snapshot_diff = 16 [default = false]; +inline bool SolverParameter::_internal_has_snapshot_diff() const { + bool value = (_has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool SolverParameter::has_snapshot_diff() const { + return _internal_has_snapshot_diff(); +} +inline void SolverParameter::clear_snapshot_diff() { + snapshot_diff_ = false; + _has_bits_[0] &= ~0x00200000u; +} +inline bool SolverParameter::_internal_snapshot_diff() const { + return snapshot_diff_; +} +inline bool SolverParameter::snapshot_diff() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_diff) + return _internal_snapshot_diff(); +} +inline void SolverParameter::_internal_set_snapshot_diff(bool value) { + _has_bits_[0] |= 0x00200000u; + snapshot_diff_ = value; +} +inline void SolverParameter::set_snapshot_diff(bool value) { + _internal_set_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::_internal_has_snapshot_format() const { + bool value = (_has_bits_[1] & 0x00000002u) != 0; + return value; +} +inline bool SolverParameter::has_snapshot_format() const { + return _internal_has_snapshot_format(); +} +inline void SolverParameter::clear_snapshot_format() { + snapshot_format_ = 1; + _has_bits_[1] &= ~0x00000002u; +} +inline ::opencv_caffe::SolverParameter_SnapshotFormat SolverParameter::_internal_snapshot_format() const { + return static_cast< ::opencv_caffe::SolverParameter_SnapshotFormat >(snapshot_format_); +} +inline ::opencv_caffe::SolverParameter_SnapshotFormat SolverParameter::snapshot_format() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_format) + return _internal_snapshot_format(); +} +inline void SolverParameter::_internal_set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value) { + assert(::opencv_caffe::SolverParameter_SnapshotFormat_IsValid(value)); + _has_bits_[1] |= 0x00000002u; + snapshot_format_ = value; +} +inline void SolverParameter::set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value) { + _internal_set_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::_internal_has_solver_mode() const { + bool value = (_has_bits_[0] & 0x04000000u) != 0; + return value; +} +inline bool SolverParameter::has_solver_mode() const { + return _internal_has_solver_mode(); +} +inline void SolverParameter::clear_solver_mode() { + solver_mode_ = 1; + _has_bits_[0] &= ~0x04000000u; +} +inline ::opencv_caffe::SolverParameter_SolverMode SolverParameter::_internal_solver_mode() const { + return static_cast< ::opencv_caffe::SolverParameter_SolverMode >(solver_mode_); +} +inline ::opencv_caffe::SolverParameter_SolverMode SolverParameter::solver_mode() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.solver_mode) + return _internal_solver_mode(); +} +inline void SolverParameter::_internal_set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value) { + assert(::opencv_caffe::SolverParameter_SolverMode_IsValid(value)); + _has_bits_[0] |= 0x04000000u; + solver_mode_ = value; +} +inline void SolverParameter::set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value) { + _internal_set_solver_mode(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.solver_mode) +} + +// optional int32 device_id = 18 [default = 0]; +inline bool SolverParameter::_internal_has_device_id() const { + bool value = (_has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool SolverParameter::has_device_id() const { + return _internal_has_device_id(); +} +inline void SolverParameter::clear_device_id() { + device_id_ = 0; + _has_bits_[0] &= ~0x00080000u; +} +inline int32_t SolverParameter::_internal_device_id() const { + return device_id_; +} +inline int32_t SolverParameter::device_id() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.device_id) + return _internal_device_id(); +} +inline void SolverParameter::_internal_set_device_id(int32_t value) { + _has_bits_[0] |= 0x00080000u; + device_id_ = value; +} +inline void SolverParameter::set_device_id(int32_t value) { + _internal_set_device_id(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.device_id) +} + +// optional int64 random_seed = 20 [default = -1]; +inline bool SolverParameter::_internal_has_random_seed() const { + bool value = (_has_bits_[0] & 0x02000000u) != 0; + return value; +} +inline bool SolverParameter::has_random_seed() const { + return _internal_has_random_seed(); +} +inline void SolverParameter::clear_random_seed() { + random_seed_ = int64_t{-1}; + _has_bits_[0] &= ~0x02000000u; +} +inline int64_t SolverParameter::_internal_random_seed() const { + return random_seed_; +} +inline int64_t SolverParameter::random_seed() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.random_seed) + return _internal_random_seed(); +} +inline void SolverParameter::_internal_set_random_seed(int64_t value) { + _has_bits_[0] |= 0x02000000u; + random_seed_ = value; +} +inline void SolverParameter::set_random_seed(int64_t value) { + _internal_set_random_seed(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.random_seed) +} + +// optional string type = 40 [default = "SGD"]; +inline bool SolverParameter::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool SolverParameter::has_type() const { + return _internal_has_type(); +} +inline void SolverParameter::clear_type() { + type_.ClearToDefault(::opencv_caffe::SolverParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation()); + _has_bits_[0] &= ~0x00000020u; +} +inline const std::string& SolverParameter::type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.type) + if (type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_type_.get(); + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SolverParameter::set_type(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000020u; + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.type) +} +inline std::string* SolverParameter::mutable_type() { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.type) + return _s; +} +inline const std::string& SolverParameter::_internal_type() const { + return type_.Get(); +} +inline void SolverParameter::_internal_set_type(const std::string& value) { + _has_bits_[0] |= 0x00000020u; + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SolverParameter::_internal_mutable_type() { + _has_bits_[0] |= 0x00000020u; + return type_.Mutable(::opencv_caffe::SolverParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation()); +} +inline std::string* SolverParameter::release_type() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.type) + if (!_internal_has_type()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000020u; + auto* p = type_.ReleaseNonDefault(nullptr, GetArenaForAllocation()); + return p; +} +inline void SolverParameter::set_allocated_type(std::string* type) { + if (type != nullptr) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + type_.SetAllocated(nullptr, type, + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.type) +} + +// optional float delta = 31 [default = 1e-08]; +inline bool SolverParameter::_internal_has_delta() const { + bool value = (_has_bits_[0] & 0x20000000u) != 0; + return value; +} +inline bool SolverParameter::has_delta() const { + return _internal_has_delta(); +} +inline void SolverParameter::clear_delta() { + delta_ = 1e-08f; + _has_bits_[0] &= ~0x20000000u; +} +inline float SolverParameter::_internal_delta() const { + return delta_; +} +inline float SolverParameter::delta() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.delta) + return _internal_delta(); +} +inline void SolverParameter::_internal_set_delta(float value) { + _has_bits_[0] |= 0x20000000u; + delta_ = value; +} +inline void SolverParameter::set_delta(float value) { + _internal_set_delta(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.delta) +} + +// optional float momentum2 = 39 [default = 0.999]; +inline bool SolverParameter::_internal_has_momentum2() const { + bool value = (_has_bits_[0] & 0x01000000u) != 0; + return value; +} +inline bool SolverParameter::has_momentum2() const { + return _internal_has_momentum2(); +} +inline void SolverParameter::clear_momentum2() { + momentum2_ = 0.999f; + _has_bits_[0] &= ~0x01000000u; +} +inline float SolverParameter::_internal_momentum2() const { + return momentum2_; +} +inline float SolverParameter::momentum2() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.momentum2) + return _internal_momentum2(); +} +inline void SolverParameter::_internal_set_momentum2(float value) { + _has_bits_[0] |= 0x01000000u; + momentum2_ = value; +} +inline void SolverParameter::set_momentum2(float value) { + _internal_set_momentum2(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.momentum2) +} + +// optional float rms_decay = 38 [default = 0.99]; +inline bool SolverParameter::_internal_has_rms_decay() const { + bool value = (_has_bits_[1] & 0x00000004u) != 0; + return value; +} +inline bool SolverParameter::has_rms_decay() const { + return _internal_has_rms_decay(); +} +inline void SolverParameter::clear_rms_decay() { + rms_decay_ = 0.99f; + _has_bits_[1] &= ~0x00000004u; +} +inline float SolverParameter::_internal_rms_decay() const { + return rms_decay_; +} +inline float SolverParameter::rms_decay() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.rms_decay) + return _internal_rms_decay(); +} +inline void SolverParameter::_internal_set_rms_decay(float value) { + _has_bits_[1] |= 0x00000004u; + rms_decay_ = value; +} +inline void SolverParameter::set_rms_decay(float value) { + _internal_set_rms_decay(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.rms_decay) +} + +// optional bool debug_info = 23 [default = false]; +inline bool SolverParameter::_internal_has_debug_info() const { + bool value = (_has_bits_[0] & 0x00400000u) != 0; + return value; +} +inline bool SolverParameter::has_debug_info() const { + return _internal_has_debug_info(); +} +inline void SolverParameter::clear_debug_info() { + debug_info_ = false; + _has_bits_[0] &= ~0x00400000u; +} +inline bool SolverParameter::_internal_debug_info() const { + return debug_info_; +} +inline bool SolverParameter::debug_info() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.debug_info) + return _internal_debug_info(); +} +inline void SolverParameter::_internal_set_debug_info(bool value) { + _has_bits_[0] |= 0x00400000u; + debug_info_ = value; +} +inline void SolverParameter::set_debug_info(bool value) { + _internal_set_debug_info(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.debug_info) +} + +// optional bool snapshot_after_train = 28 [default = true]; +inline bool SolverParameter::_internal_has_snapshot_after_train() const { + bool value = (_has_bits_[0] & 0x10000000u) != 0; + return value; +} +inline bool SolverParameter::has_snapshot_after_train() const { + return _internal_has_snapshot_after_train(); +} +inline void SolverParameter::clear_snapshot_after_train() { + snapshot_after_train_ = true; + _has_bits_[0] &= ~0x10000000u; +} +inline bool SolverParameter::_internal_snapshot_after_train() const { + return snapshot_after_train_; +} +inline bool SolverParameter::snapshot_after_train() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_after_train) + return _internal_snapshot_after_train(); +} +inline void SolverParameter::_internal_set_snapshot_after_train(bool value) { + _has_bits_[0] |= 0x10000000u; + snapshot_after_train_ = value; +} +inline void SolverParameter::set_snapshot_after_train(bool value) { + _internal_set_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::_internal_has_solver_type() const { + bool value = (_has_bits_[0] & 0x00800000u) != 0; + return value; +} +inline bool SolverParameter::has_solver_type() const { + return _internal_has_solver_type(); +} +inline void SolverParameter::clear_solver_type() { + solver_type_ = 0; + _has_bits_[0] &= ~0x00800000u; +} +inline ::opencv_caffe::SolverParameter_SolverType SolverParameter::_internal_solver_type() const { + return static_cast< ::opencv_caffe::SolverParameter_SolverType >(solver_type_); +} +inline ::opencv_caffe::SolverParameter_SolverType SolverParameter::solver_type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.solver_type) + return _internal_solver_type(); +} +inline void SolverParameter::_internal_set_solver_type(::opencv_caffe::SolverParameter_SolverType value) { + assert(::opencv_caffe::SolverParameter_SolverType_IsValid(value)); + _has_bits_[0] |= 0x00800000u; + solver_type_ = value; +} +inline void SolverParameter::set_solver_type(::opencv_caffe::SolverParameter_SolverType value) { + _internal_set_solver_type(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.solver_type) +} + +// ------------------------------------------------------------------- + +// SolverState + +// optional int32 iter = 1; +inline bool SolverState::_internal_has_iter() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SolverState::has_iter() const { + return _internal_has_iter(); +} +inline void SolverState::clear_iter() { + iter_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t SolverState::_internal_iter() const { + return iter_; +} +inline int32_t SolverState::iter() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverState.iter) + return _internal_iter(); +} +inline void SolverState::_internal_set_iter(int32_t value) { + _has_bits_[0] |= 0x00000002u; + iter_ = value; +} +inline void SolverState::set_iter(int32_t value) { + _internal_set_iter(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverState.iter) +} + +// optional string learned_net = 2; +inline bool SolverState::_internal_has_learned_net() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SolverState::has_learned_net() const { + return _internal_has_learned_net(); +} +inline void SolverState::clear_learned_net() { + learned_net_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SolverState::learned_net() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverState.learned_net) + return _internal_learned_net(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SolverState::set_learned_net(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + learned_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SolverState.learned_net) +} +inline std::string* SolverState::mutable_learned_net() { + std::string* _s = _internal_mutable_learned_net(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverState.learned_net) + return _s; +} +inline const std::string& SolverState::_internal_learned_net() const { + return learned_net_.Get(); +} +inline void SolverState::_internal_set_learned_net(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + learned_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SolverState::_internal_mutable_learned_net() { + _has_bits_[0] |= 0x00000001u; + return learned_net_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SolverState::release_learned_net() { + // @@protoc_insertion_point(field_release:opencv_caffe.SolverState.learned_net) + if (!_internal_has_learned_net()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = learned_net_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (learned_net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + learned_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SolverState::set_allocated_learned_net(std::string* learned_net) { + if (learned_net != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + learned_net_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), learned_net, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (learned_net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + learned_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverState.learned_net) +} + +// repeated .opencv_caffe.BlobProto history = 3; +inline int SolverState::_internal_history_size() const { + return history_.size(); +} +inline int SolverState::history_size() const { + return _internal_history_size(); +} +inline void SolverState::clear_history() { + history_.Clear(); +} +inline ::opencv_caffe::BlobProto* SolverState::mutable_history(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverState.history) + return history_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* +SolverState::mutable_history() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverState.history) + return &history_; +} +inline const ::opencv_caffe::BlobProto& SolverState::_internal_history(int index) const { + return history_.Get(index); +} +inline const ::opencv_caffe::BlobProto& SolverState::history(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverState.history) + return _internal_history(index); +} +inline ::opencv_caffe::BlobProto* SolverState::_internal_add_history() { + return history_.Add(); +} +inline ::opencv_caffe::BlobProto* SolverState::add_history() { + ::opencv_caffe::BlobProto* _add = _internal_add_history(); + // @@protoc_insertion_point(field_add:opencv_caffe.SolverState.history) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_has_current_step() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SolverState::has_current_step() const { + return _internal_has_current_step(); +} +inline void SolverState::clear_current_step() { + current_step_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t SolverState::_internal_current_step() const { + return current_step_; +} +inline int32_t SolverState::current_step() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SolverState.current_step) + return _internal_current_step(); +} +inline void SolverState::_internal_set_current_step(int32_t value) { + _has_bits_[0] |= 0x00000004u; + current_step_ = value; +} +inline void SolverState::set_current_step(int32_t value) { + _internal_set_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::_internal_has_phase() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool NetState::has_phase() const { + return _internal_has_phase(); +} +inline void NetState::clear_phase() { + phase_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline ::opencv_caffe::Phase NetState::_internal_phase() const { + return static_cast< ::opencv_caffe::Phase >(phase_); +} +inline ::opencv_caffe::Phase NetState::phase() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetState.phase) + return _internal_phase(); +} +inline void NetState::_internal_set_phase(::opencv_caffe::Phase value) { + assert(::opencv_caffe::Phase_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + phase_ = value; +} +inline void NetState::set_phase(::opencv_caffe::Phase value) { + _internal_set_phase(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetState.phase) +} + +// optional int32 level = 2 [default = 0]; +inline bool NetState::_internal_has_level() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NetState::has_level() const { + return _internal_has_level(); +} +inline void NetState::clear_level() { + level_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t NetState::_internal_level() const { + return level_; +} +inline int32_t NetState::level() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetState.level) + return _internal_level(); +} +inline void NetState::_internal_set_level(int32_t value) { + _has_bits_[0] |= 0x00000001u; + level_ = value; +} +inline void NetState::set_level(int32_t value) { + _internal_set_level(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetState.level) +} + +// repeated string stage = 3; +inline int NetState::_internal_stage_size() const { + return stage_.size(); +} +inline int NetState::stage_size() const { + return _internal_stage_size(); +} +inline void NetState::clear_stage() { + stage_.Clear(); +} +inline std::string* NetState::add_stage() { + std::string* _s = _internal_add_stage(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetState.stage) + return _s; +} +inline const std::string& NetState::_internal_stage(int index) const { + return stage_.Get(index); +} +inline const std::string& NetState::stage(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetState.stage) + return _internal_stage(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) { + stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetState.stage) +} +inline void NetState::set_stage(int index, std::string&& value) { + stage_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.NetState.stage) +} +inline void NetState::set_stage(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetState.stage) +} +inline std::string* NetState::_internal_add_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) +} +inline void NetState::add_stage(std::string&& value) { + stage_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:opencv_caffe.NetState.stage) +} +inline void NetState::add_stage(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetState.stage) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +NetState::stage() const { + // @@protoc_insertion_point(field_list:opencv_caffe.NetState.stage) + return stage_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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::_internal_has_phase() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NetStateRule::has_phase() const { + return _internal_has_phase(); +} +inline void NetStateRule::clear_phase() { + phase_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::opencv_caffe::Phase NetStateRule::_internal_phase() const { + return static_cast< ::opencv_caffe::Phase >(phase_); +} +inline ::opencv_caffe::Phase NetStateRule::phase() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.phase) + return _internal_phase(); +} +inline void NetStateRule::_internal_set_phase(::opencv_caffe::Phase value) { + assert(::opencv_caffe::Phase_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + phase_ = value; +} +inline void NetStateRule::set_phase(::opencv_caffe::Phase value) { + _internal_set_phase(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.phase) +} + +// optional int32 min_level = 2; +inline bool NetStateRule::_internal_has_min_level() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool NetStateRule::has_min_level() const { + return _internal_has_min_level(); +} +inline void NetStateRule::clear_min_level() { + min_level_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t NetStateRule::_internal_min_level() const { + return min_level_; +} +inline int32_t NetStateRule::min_level() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.min_level) + return _internal_min_level(); +} +inline void NetStateRule::_internal_set_min_level(int32_t value) { + _has_bits_[0] |= 0x00000002u; + min_level_ = value; +} +inline void NetStateRule::set_min_level(int32_t value) { + _internal_set_min_level(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.min_level) +} + +// optional int32 max_level = 3; +inline bool NetStateRule::_internal_has_max_level() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool NetStateRule::has_max_level() const { + return _internal_has_max_level(); +} +inline void NetStateRule::clear_max_level() { + max_level_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t NetStateRule::_internal_max_level() const { + return max_level_; +} +inline int32_t NetStateRule::max_level() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.max_level) + return _internal_max_level(); +} +inline void NetStateRule::_internal_set_max_level(int32_t value) { + _has_bits_[0] |= 0x00000004u; + max_level_ = value; +} +inline void NetStateRule::set_max_level(int32_t value) { + _internal_set_max_level(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.max_level) +} + +// repeated string stage = 4; +inline int NetStateRule::_internal_stage_size() const { + return stage_.size(); +} +inline int NetStateRule::stage_size() const { + return _internal_stage_size(); +} +inline void NetStateRule::clear_stage() { + stage_.Clear(); +} +inline std::string* NetStateRule::add_stage() { + std::string* _s = _internal_add_stage(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetStateRule.stage) + return _s; +} +inline const std::string& NetStateRule::_internal_stage(int index) const { + return stage_.Get(index); +} +inline const std::string& NetStateRule::stage(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.stage) + return _internal_stage(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) { + stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.stage) +} +inline void NetStateRule::set_stage(int index, std::string&& value) { + stage_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.stage) +} +inline void NetStateRule::set_stage(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetStateRule.stage) +} +inline std::string* NetStateRule::_internal_add_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) +} +inline void NetStateRule::add_stage(std::string&& value) { + stage_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.stage) +} +inline void NetStateRule::add_stage(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetStateRule.stage) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +NetStateRule::stage() const { + // @@protoc_insertion_point(field_list:opencv_caffe.NetStateRule.stage) + return stage_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +NetStateRule::mutable_stage() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetStateRule.stage) + return &stage_; +} + +// repeated string not_stage = 5; +inline int NetStateRule::_internal_not_stage_size() const { + return not_stage_.size(); +} +inline int NetStateRule::not_stage_size() const { + return _internal_not_stage_size(); +} +inline void NetStateRule::clear_not_stage() { + not_stage_.Clear(); +} +inline std::string* NetStateRule::add_not_stage() { + std::string* _s = _internal_add_not_stage(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetStateRule.not_stage) + return _s; +} +inline const std::string& NetStateRule::_internal_not_stage(int index) const { + return not_stage_.Get(index); +} +inline const std::string& NetStateRule::not_stage(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.not_stage) + return _internal_not_stage(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) { + not_stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.not_stage) +} +inline void NetStateRule::set_not_stage(int index, std::string&& value) { + not_stage_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.not_stage) +} +inline void NetStateRule::set_not_stage(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetStateRule.not_stage) +} +inline std::string* NetStateRule::_internal_add_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) +} +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) +} +inline void NetStateRule::add_not_stage(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetStateRule.not_stage) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +NetStateRule::not_stage() const { + // @@protoc_insertion_point(field_list:opencv_caffe.NetStateRule.not_stage) + return not_stage_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +NetStateRule::mutable_not_stage() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetStateRule.not_stage) + return ¬_stage_; +} + +// ------------------------------------------------------------------- + +// ParamSpec + +// optional string name = 1; +inline bool ParamSpec::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ParamSpec::has_name() const { + return _internal_has_name(); +} +inline void ParamSpec::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ParamSpec::name() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ParamSpec::set_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.name) +} +inline std::string* ParamSpec::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ParamSpec.name) + return _s; +} +inline const std::string& ParamSpec::_internal_name() const { + return name_.Get(); +} +inline void ParamSpec::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ParamSpec::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ParamSpec::release_name() { + // @@protoc_insertion_point(field_release:opencv_caffe.ParamSpec.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ParamSpec::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ParamSpec.name) +} + +// optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2; +inline bool ParamSpec::_internal_has_share_mode() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ParamSpec::has_share_mode() const { + return _internal_has_share_mode(); +} +inline void ParamSpec::clear_share_mode() { + share_mode_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::opencv_caffe::ParamSpec_DimCheckMode ParamSpec::_internal_share_mode() const { + return static_cast< ::opencv_caffe::ParamSpec_DimCheckMode >(share_mode_); +} +inline ::opencv_caffe::ParamSpec_DimCheckMode ParamSpec::share_mode() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.share_mode) + return _internal_share_mode(); +} +inline void ParamSpec::_internal_set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value) { + assert(::opencv_caffe::ParamSpec_DimCheckMode_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + share_mode_ = value; +} +inline void ParamSpec::set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value) { + _internal_set_share_mode(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.share_mode) +} + +// optional float lr_mult = 3 [default = 1]; +inline bool ParamSpec::_internal_has_lr_mult() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ParamSpec::has_lr_mult() const { + return _internal_has_lr_mult(); +} +inline void ParamSpec::clear_lr_mult() { + lr_mult_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline float ParamSpec::_internal_lr_mult() const { + return lr_mult_; +} +inline float ParamSpec::lr_mult() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.lr_mult) + return _internal_lr_mult(); +} +inline void ParamSpec::_internal_set_lr_mult(float value) { + _has_bits_[0] |= 0x00000004u; + lr_mult_ = value; +} +inline void ParamSpec::set_lr_mult(float value) { + _internal_set_lr_mult(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.lr_mult) +} + +// optional float decay_mult = 4 [default = 1]; +inline bool ParamSpec::_internal_has_decay_mult() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ParamSpec::has_decay_mult() const { + return _internal_has_decay_mult(); +} +inline void ParamSpec::clear_decay_mult() { + decay_mult_ = 1; + _has_bits_[0] &= ~0x00000008u; +} +inline float ParamSpec::_internal_decay_mult() const { + return decay_mult_; +} +inline float ParamSpec::decay_mult() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.decay_mult) + return _internal_decay_mult(); +} +inline void ParamSpec::_internal_set_decay_mult(float value) { + _has_bits_[0] |= 0x00000008u; + decay_mult_ = value; +} +inline void ParamSpec::set_decay_mult(float value) { + _internal_set_decay_mult(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.decay_mult) +} + +// ------------------------------------------------------------------- + +// LayerParameter + +// optional string name = 1; +inline bool LayerParameter::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool LayerParameter::has_name() const { + return _internal_has_name(); +} +inline void LayerParameter::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& LayerParameter::name() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void LayerParameter::set_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.name) +} +inline std::string* LayerParameter::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.name) + return _s; +} +inline const std::string& LayerParameter::_internal_name() const { + return name_.Get(); +} +inline void LayerParameter::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* LayerParameter::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void LayerParameter::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.name) +} + +// optional string type = 2; +inline bool LayerParameter::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool LayerParameter::has_type() const { + return _internal_has_type(); +} +inline void LayerParameter::clear_type() { + type_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& LayerParameter::type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void LayerParameter::set_type(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.type) +} +inline std::string* LayerParameter::mutable_type() { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.type) + return _s; +} +inline const std::string& LayerParameter::_internal_type() const { + return type_.Get(); +} +inline void LayerParameter::_internal_set_type(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* LayerParameter::_internal_mutable_type() { + _has_bits_[0] |= 0x00000002u; + return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* LayerParameter::release_type() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.type) + if (!_internal_has_type()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void LayerParameter::set_allocated_type(std::string* type) { + if (type != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.type) +} + +// repeated string bottom = 3; +inline int LayerParameter::_internal_bottom_size() const { + return bottom_.size(); +} +inline int LayerParameter::bottom_size() const { + return _internal_bottom_size(); +} +inline void LayerParameter::clear_bottom() { + bottom_.Clear(); +} +inline std::string* LayerParameter::add_bottom() { + std::string* _s = _internal_add_bottom(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.LayerParameter.bottom) + return _s; +} +inline const std::string& LayerParameter::_internal_bottom(int index) const { + return bottom_.Get(index); +} +inline const std::string& LayerParameter::bottom(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.bottom) + return _internal_bottom(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) { + bottom_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.bottom) +} +inline void LayerParameter::set_bottom(int index, std::string&& value) { + bottom_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.bottom) +} +inline void LayerParameter::set_bottom(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.LayerParameter.bottom) +} +inline std::string* LayerParameter::_internal_add_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) +} +inline void LayerParameter::add_bottom(std::string&& value) { + bottom_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.bottom) +} +inline void LayerParameter::add_bottom(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.LayerParameter.bottom) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +LayerParameter::bottom() const { + // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.bottom) + return bottom_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +LayerParameter::mutable_bottom() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.bottom) + return &bottom_; +} + +// repeated string top = 4; +inline int LayerParameter::_internal_top_size() const { + return top_.size(); +} +inline int LayerParameter::top_size() const { + return _internal_top_size(); +} +inline void LayerParameter::clear_top() { + top_.Clear(); +} +inline std::string* LayerParameter::add_top() { + std::string* _s = _internal_add_top(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.LayerParameter.top) + return _s; +} +inline const std::string& LayerParameter::_internal_top(int index) const { + return top_.Get(index); +} +inline const std::string& LayerParameter::top(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.top) + return _internal_top(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) { + top_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.top) +} +inline void LayerParameter::set_top(int index, std::string&& value) { + top_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.top) +} +inline void LayerParameter::set_top(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.LayerParameter.top) +} +inline std::string* LayerParameter::_internal_add_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) +} +inline void LayerParameter::add_top(std::string&& value) { + top_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.top) +} +inline void LayerParameter::add_top(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.LayerParameter.top) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +LayerParameter::top() const { + // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.top) + return top_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +LayerParameter::mutable_top() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.top) + return &top_; +} + +// optional .opencv_caffe.Phase phase = 10; +inline bool LayerParameter::_internal_has_phase() const { + bool value = (_has_bits_[1] & 0x01000000u) != 0; + return value; +} +inline bool LayerParameter::has_phase() const { + return _internal_has_phase(); +} +inline void LayerParameter::clear_phase() { + phase_ = 0; + _has_bits_[1] &= ~0x01000000u; +} +inline ::opencv_caffe::Phase LayerParameter::_internal_phase() const { + return static_cast< ::opencv_caffe::Phase >(phase_); +} +inline ::opencv_caffe::Phase LayerParameter::phase() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.phase) + return _internal_phase(); +} +inline void LayerParameter::_internal_set_phase(::opencv_caffe::Phase value) { + assert(::opencv_caffe::Phase_IsValid(value)); + _has_bits_[1] |= 0x01000000u; + phase_ = value; +} +inline void LayerParameter::set_phase(::opencv_caffe::Phase value) { + _internal_set_phase(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.phase) +} + +// repeated float loss_weight = 5; +inline int LayerParameter::_internal_loss_weight_size() const { + return loss_weight_.size(); +} +inline int LayerParameter::loss_weight_size() const { + return _internal_loss_weight_size(); +} +inline void LayerParameter::clear_loss_weight() { + loss_weight_.Clear(); +} +inline float LayerParameter::_internal_loss_weight(int index) const { + return loss_weight_.Get(index); +} +inline float LayerParameter::loss_weight(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.loss_weight) + return _internal_loss_weight(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::_internal_add_loss_weight(float value) { + loss_weight_.Add(value); +} +inline void LayerParameter::add_loss_weight(float value) { + _internal_add_loss_weight(value); + // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.loss_weight) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +LayerParameter::_internal_loss_weight() const { + return loss_weight_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +LayerParameter::loss_weight() const { + // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.loss_weight) + return _internal_loss_weight(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +LayerParameter::_internal_mutable_loss_weight() { + return &loss_weight_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +LayerParameter::mutable_loss_weight() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.loss_weight) + return _internal_mutable_loss_weight(); +} + +// repeated .opencv_caffe.ParamSpec param = 6; +inline int LayerParameter::_internal_param_size() const { + return param_.size(); +} +inline int LayerParameter::param_size() const { + return _internal_param_size(); +} +inline void LayerParameter::clear_param() { + param_.Clear(); +} +inline ::opencv_caffe::ParamSpec* LayerParameter::mutable_param(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.param) + return param_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec >* +LayerParameter::mutable_param() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.param) + return ¶m_; +} +inline const ::opencv_caffe::ParamSpec& LayerParameter::_internal_param(int index) const { + return param_.Get(index); +} +inline const ::opencv_caffe::ParamSpec& LayerParameter::param(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.param) + return _internal_param(index); +} +inline ::opencv_caffe::ParamSpec* LayerParameter::_internal_add_param() { + return param_.Add(); +} +inline ::opencv_caffe::ParamSpec* LayerParameter::add_param() { + ::opencv_caffe::ParamSpec* _add = _internal_add_param(); + // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.param) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_blobs_size() const { + return blobs_.size(); +} +inline int LayerParameter::blobs_size() const { + return _internal_blobs_size(); +} +inline void LayerParameter::clear_blobs() { + blobs_.Clear(); +} +inline ::opencv_caffe::BlobProto* LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.blobs) + return blobs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* +LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.blobs) + return &blobs_; +} +inline const ::opencv_caffe::BlobProto& LayerParameter::_internal_blobs(int index) const { + return blobs_.Get(index); +} +inline const ::opencv_caffe::BlobProto& LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.blobs) + return _internal_blobs(index); +} +inline ::opencv_caffe::BlobProto* LayerParameter::_internal_add_blobs() { + return blobs_.Add(); +} +inline ::opencv_caffe::BlobProto* LayerParameter::add_blobs() { + ::opencv_caffe::BlobProto* _add = _internal_add_blobs(); + // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.blobs) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_propagate_down_size() const { + return propagate_down_.size(); +} +inline int LayerParameter::propagate_down_size() const { + return _internal_propagate_down_size(); +} +inline void LayerParameter::clear_propagate_down() { + propagate_down_.Clear(); +} +inline bool LayerParameter::_internal_propagate_down(int index) const { + return propagate_down_.Get(index); +} +inline bool LayerParameter::propagate_down(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.propagate_down) + return _internal_propagate_down(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::_internal_add_propagate_down(bool value) { + propagate_down_.Add(value); +} +inline void LayerParameter::add_propagate_down(bool value) { + _internal_add_propagate_down(value); + // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.propagate_down) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& +LayerParameter::_internal_propagate_down() const { + return propagate_down_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& +LayerParameter::propagate_down() const { + // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.propagate_down) + return _internal_propagate_down(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* +LayerParameter::_internal_mutable_propagate_down() { + return &propagate_down_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* +LayerParameter::mutable_propagate_down() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.propagate_down) + return _internal_mutable_propagate_down(); +} + +// repeated .opencv_caffe.NetStateRule include = 8; +inline int LayerParameter::_internal_include_size() const { + return include_.size(); +} +inline int LayerParameter::include_size() const { + return _internal_include_size(); +} +inline void LayerParameter::clear_include() { + include_.Clear(); +} +inline ::opencv_caffe::NetStateRule* LayerParameter::mutable_include(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.include) + return include_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >* +LayerParameter::mutable_include() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.include) + return &include_; +} +inline const ::opencv_caffe::NetStateRule& LayerParameter::_internal_include(int index) const { + return include_.Get(index); +} +inline const ::opencv_caffe::NetStateRule& LayerParameter::include(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.include) + return _internal_include(index); +} +inline ::opencv_caffe::NetStateRule* LayerParameter::_internal_add_include() { + return include_.Add(); +} +inline ::opencv_caffe::NetStateRule* LayerParameter::add_include() { + ::opencv_caffe::NetStateRule* _add = _internal_add_include(); + // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.include) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_exclude_size() const { + return exclude_.size(); +} +inline int LayerParameter::exclude_size() const { + return _internal_exclude_size(); +} +inline void LayerParameter::clear_exclude() { + exclude_.Clear(); +} +inline ::opencv_caffe::NetStateRule* LayerParameter::mutable_exclude(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.exclude) + return exclude_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >* +LayerParameter::mutable_exclude() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.exclude) + return &exclude_; +} +inline const ::opencv_caffe::NetStateRule& LayerParameter::_internal_exclude(int index) const { + return exclude_.Get(index); +} +inline const ::opencv_caffe::NetStateRule& LayerParameter::exclude(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.exclude) + return _internal_exclude(index); +} +inline ::opencv_caffe::NetStateRule* LayerParameter::_internal_add_exclude() { + return exclude_.Add(); +} +inline ::opencv_caffe::NetStateRule* LayerParameter::add_exclude() { + ::opencv_caffe::NetStateRule* _add = _internal_add_exclude(); + // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.exclude) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_has_transform_param() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || transform_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_transform_param() const { + return _internal_has_transform_param(); +} +inline void LayerParameter::clear_transform_param() { + if (transform_param_ != nullptr) transform_param_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::opencv_caffe::TransformationParameter& LayerParameter::_internal_transform_param() const { + const ::opencv_caffe::TransformationParameter* p = transform_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_TransformationParameter_default_instance_); +} +inline const ::opencv_caffe::TransformationParameter& LayerParameter::transform_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.transform_param) + return _internal_transform_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_transform_param( + ::opencv_caffe::TransformationParameter* transform_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(transform_param_); + } + transform_param_ = transform_param; + if (transform_param) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.transform_param) +} +inline ::opencv_caffe::TransformationParameter* LayerParameter::release_transform_param() { + _has_bits_[0] &= ~0x00000004u; + ::opencv_caffe::TransformationParameter* temp = transform_param_; + transform_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::TransformationParameter* LayerParameter::unsafe_arena_release_transform_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.transform_param) + _has_bits_[0] &= ~0x00000004u; + ::opencv_caffe::TransformationParameter* temp = transform_param_; + transform_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::TransformationParameter* LayerParameter::_internal_mutable_transform_param() { + _has_bits_[0] |= 0x00000004u; + if (transform_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::TransformationParameter>(GetArenaForAllocation()); + transform_param_ = p; + } + return transform_param_; +} +inline ::opencv_caffe::TransformationParameter* LayerParameter::mutable_transform_param() { + ::opencv_caffe::TransformationParameter* _msg = _internal_mutable_transform_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.transform_param) + return _msg; +} +inline void LayerParameter::set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete transform_param_; + } + if (transform_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::TransformationParameter>::GetOwningArena(transform_param); + if (message_arena != submessage_arena) { + transform_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, transform_param, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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::_internal_has_loss_param() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || loss_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_loss_param() const { + return _internal_has_loss_param(); +} +inline void LayerParameter::clear_loss_param() { + if (loss_param_ != nullptr) loss_param_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::opencv_caffe::LossParameter& LayerParameter::_internal_loss_param() const { + const ::opencv_caffe::LossParameter* p = loss_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_LossParameter_default_instance_); +} +inline const ::opencv_caffe::LossParameter& LayerParameter::loss_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.loss_param) + return _internal_loss_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_loss_param( + ::opencv_caffe::LossParameter* loss_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(loss_param_); + } + loss_param_ = loss_param; + if (loss_param) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.loss_param) +} +inline ::opencv_caffe::LossParameter* LayerParameter::release_loss_param() { + _has_bits_[0] &= ~0x00000008u; + ::opencv_caffe::LossParameter* temp = loss_param_; + loss_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::LossParameter* LayerParameter::unsafe_arena_release_loss_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.loss_param) + _has_bits_[0] &= ~0x00000008u; + ::opencv_caffe::LossParameter* temp = loss_param_; + loss_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::LossParameter* LayerParameter::_internal_mutable_loss_param() { + _has_bits_[0] |= 0x00000008u; + if (loss_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::LossParameter>(GetArenaForAllocation()); + loss_param_ = p; + } + return loss_param_; +} +inline ::opencv_caffe::LossParameter* LayerParameter::mutable_loss_param() { + ::opencv_caffe::LossParameter* _msg = _internal_mutable_loss_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.loss_param) + return _msg; +} +inline void LayerParameter::set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete loss_param_; + } + if (loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::LossParameter>::GetOwningArena(loss_param); + if (message_arena != submessage_arena) { + loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, loss_param, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + 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::_internal_has_accuracy_param() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || accuracy_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_accuracy_param() const { + return _internal_has_accuracy_param(); +} +inline void LayerParameter::clear_accuracy_param() { + if (accuracy_param_ != nullptr) accuracy_param_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::opencv_caffe::AccuracyParameter& LayerParameter::_internal_accuracy_param() const { + const ::opencv_caffe::AccuracyParameter* p = accuracy_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_AccuracyParameter_default_instance_); +} +inline const ::opencv_caffe::AccuracyParameter& LayerParameter::accuracy_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.accuracy_param) + return _internal_accuracy_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_accuracy_param( + ::opencv_caffe::AccuracyParameter* accuracy_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(accuracy_param_); + } + accuracy_param_ = accuracy_param; + if (accuracy_param) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.accuracy_param) +} +inline ::opencv_caffe::AccuracyParameter* LayerParameter::release_accuracy_param() { + _has_bits_[0] &= ~0x00000010u; + ::opencv_caffe::AccuracyParameter* temp = accuracy_param_; + accuracy_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::AccuracyParameter* LayerParameter::unsafe_arena_release_accuracy_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.accuracy_param) + _has_bits_[0] &= ~0x00000010u; + ::opencv_caffe::AccuracyParameter* temp = accuracy_param_; + accuracy_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::AccuracyParameter* LayerParameter::_internal_mutable_accuracy_param() { + _has_bits_[0] |= 0x00000010u; + if (accuracy_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::AccuracyParameter>(GetArenaForAllocation()); + accuracy_param_ = p; + } + return accuracy_param_; +} +inline ::opencv_caffe::AccuracyParameter* LayerParameter::mutable_accuracy_param() { + ::opencv_caffe::AccuracyParameter* _msg = _internal_mutable_accuracy_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.accuracy_param) + return _msg; +} +inline void LayerParameter::set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete accuracy_param_; + } + if (accuracy_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::AccuracyParameter>::GetOwningArena(accuracy_param); + if (message_arena != submessage_arena) { + accuracy_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, accuracy_param, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + 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::_internal_has_argmax_param() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || argmax_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_argmax_param() const { + return _internal_has_argmax_param(); +} +inline void LayerParameter::clear_argmax_param() { + if (argmax_param_ != nullptr) argmax_param_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::opencv_caffe::ArgMaxParameter& LayerParameter::_internal_argmax_param() const { + const ::opencv_caffe::ArgMaxParameter* p = argmax_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ArgMaxParameter_default_instance_); +} +inline const ::opencv_caffe::ArgMaxParameter& LayerParameter::argmax_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.argmax_param) + return _internal_argmax_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_argmax_param( + ::opencv_caffe::ArgMaxParameter* argmax_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(argmax_param_); + } + argmax_param_ = argmax_param; + if (argmax_param) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.argmax_param) +} +inline ::opencv_caffe::ArgMaxParameter* LayerParameter::release_argmax_param() { + _has_bits_[0] &= ~0x00000020u; + ::opencv_caffe::ArgMaxParameter* temp = argmax_param_; + argmax_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ArgMaxParameter* LayerParameter::unsafe_arena_release_argmax_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.argmax_param) + _has_bits_[0] &= ~0x00000020u; + ::opencv_caffe::ArgMaxParameter* temp = argmax_param_; + argmax_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ArgMaxParameter* LayerParameter::_internal_mutable_argmax_param() { + _has_bits_[0] |= 0x00000020u; + if (argmax_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ArgMaxParameter>(GetArenaForAllocation()); + argmax_param_ = p; + } + return argmax_param_; +} +inline ::opencv_caffe::ArgMaxParameter* LayerParameter::mutable_argmax_param() { + ::opencv_caffe::ArgMaxParameter* _msg = _internal_mutable_argmax_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.argmax_param) + return _msg; +} +inline void LayerParameter::set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete argmax_param_; + } + if (argmax_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ArgMaxParameter>::GetOwningArena(argmax_param); + if (message_arena != submessage_arena) { + argmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, argmax_param, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + 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::_internal_has_batch_norm_param() const { + bool value = (_has_bits_[1] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || batch_norm_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_batch_norm_param() const { + return _internal_has_batch_norm_param(); +} +inline void LayerParameter::clear_batch_norm_param() { + if (batch_norm_param_ != nullptr) batch_norm_param_->Clear(); + _has_bits_[1] &= ~0x00000200u; +} +inline const ::opencv_caffe::BatchNormParameter& LayerParameter::_internal_batch_norm_param() const { + const ::opencv_caffe::BatchNormParameter* p = batch_norm_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_BatchNormParameter_default_instance_); +} +inline const ::opencv_caffe::BatchNormParameter& LayerParameter::batch_norm_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.batch_norm_param) + return _internal_batch_norm_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_batch_norm_param( + ::opencv_caffe::BatchNormParameter* batch_norm_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(batch_norm_param_); + } + batch_norm_param_ = batch_norm_param; + if (batch_norm_param) { + _has_bits_[1] |= 0x00000200u; + } else { + _has_bits_[1] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.batch_norm_param) +} +inline ::opencv_caffe::BatchNormParameter* LayerParameter::release_batch_norm_param() { + _has_bits_[1] &= ~0x00000200u; + ::opencv_caffe::BatchNormParameter* temp = batch_norm_param_; + batch_norm_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::BatchNormParameter* LayerParameter::unsafe_arena_release_batch_norm_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.batch_norm_param) + _has_bits_[1] &= ~0x00000200u; + ::opencv_caffe::BatchNormParameter* temp = batch_norm_param_; + batch_norm_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::BatchNormParameter* LayerParameter::_internal_mutable_batch_norm_param() { + _has_bits_[1] |= 0x00000200u; + if (batch_norm_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::BatchNormParameter>(GetArenaForAllocation()); + batch_norm_param_ = p; + } + return batch_norm_param_; +} +inline ::opencv_caffe::BatchNormParameter* LayerParameter::mutable_batch_norm_param() { + ::opencv_caffe::BatchNormParameter* _msg = _internal_mutable_batch_norm_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.batch_norm_param) + return _msg; +} +inline void LayerParameter::set_allocated_batch_norm_param(::opencv_caffe::BatchNormParameter* batch_norm_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete batch_norm_param_; + } + if (batch_norm_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::BatchNormParameter>::GetOwningArena(batch_norm_param); + if (message_arena != submessage_arena) { + batch_norm_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, batch_norm_param, submessage_arena); + } + _has_bits_[1] |= 0x00000200u; + } else { + _has_bits_[1] &= ~0x00000200u; + } + 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::_internal_has_bias_param() const { + bool value = (_has_bits_[1] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || bias_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_bias_param() const { + return _internal_has_bias_param(); +} +inline void LayerParameter::clear_bias_param() { + if (bias_param_ != nullptr) bias_param_->Clear(); + _has_bits_[1] &= ~0x00000800u; +} +inline const ::opencv_caffe::BiasParameter& LayerParameter::_internal_bias_param() const { + const ::opencv_caffe::BiasParameter* p = bias_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_BiasParameter_default_instance_); +} +inline const ::opencv_caffe::BiasParameter& LayerParameter::bias_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.bias_param) + return _internal_bias_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_bias_param( + ::opencv_caffe::BiasParameter* bias_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_param_); + } + bias_param_ = bias_param; + if (bias_param) { + _has_bits_[1] |= 0x00000800u; + } else { + _has_bits_[1] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.bias_param) +} +inline ::opencv_caffe::BiasParameter* LayerParameter::release_bias_param() { + _has_bits_[1] &= ~0x00000800u; + ::opencv_caffe::BiasParameter* temp = bias_param_; + bias_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::BiasParameter* LayerParameter::unsafe_arena_release_bias_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.bias_param) + _has_bits_[1] &= ~0x00000800u; + ::opencv_caffe::BiasParameter* temp = bias_param_; + bias_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::BiasParameter* LayerParameter::_internal_mutable_bias_param() { + _has_bits_[1] |= 0x00000800u; + if (bias_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::BiasParameter>(GetArenaForAllocation()); + bias_param_ = p; + } + return bias_param_; +} +inline ::opencv_caffe::BiasParameter* LayerParameter::mutable_bias_param() { + ::opencv_caffe::BiasParameter* _msg = _internal_mutable_bias_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.bias_param) + return _msg; +} +inline void LayerParameter::set_allocated_bias_param(::opencv_caffe::BiasParameter* bias_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bias_param_; + } + if (bias_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::BiasParameter>::GetOwningArena(bias_param); + if (message_arena != submessage_arena) { + bias_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bias_param, submessage_arena); + } + _has_bits_[1] |= 0x00000800u; + } else { + _has_bits_[1] &= ~0x00000800u; + } + 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::_internal_has_concat_param() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || concat_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_concat_param() const { + return _internal_has_concat_param(); +} +inline void LayerParameter::clear_concat_param() { + if (concat_param_ != nullptr) concat_param_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::opencv_caffe::ConcatParameter& LayerParameter::_internal_concat_param() const { + const ::opencv_caffe::ConcatParameter* p = concat_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ConcatParameter_default_instance_); +} +inline const ::opencv_caffe::ConcatParameter& LayerParameter::concat_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.concat_param) + return _internal_concat_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_concat_param( + ::opencv_caffe::ConcatParameter* concat_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(concat_param_); + } + concat_param_ = concat_param; + if (concat_param) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.concat_param) +} +inline ::opencv_caffe::ConcatParameter* LayerParameter::release_concat_param() { + _has_bits_[0] &= ~0x00000040u; + ::opencv_caffe::ConcatParameter* temp = concat_param_; + concat_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ConcatParameter* LayerParameter::unsafe_arena_release_concat_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.concat_param) + _has_bits_[0] &= ~0x00000040u; + ::opencv_caffe::ConcatParameter* temp = concat_param_; + concat_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ConcatParameter* LayerParameter::_internal_mutable_concat_param() { + _has_bits_[0] |= 0x00000040u; + if (concat_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ConcatParameter>(GetArenaForAllocation()); + concat_param_ = p; + } + return concat_param_; +} +inline ::opencv_caffe::ConcatParameter* LayerParameter::mutable_concat_param() { + ::opencv_caffe::ConcatParameter* _msg = _internal_mutable_concat_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.concat_param) + return _msg; +} +inline void LayerParameter::set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete concat_param_; + } + if (concat_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ConcatParameter>::GetOwningArena(concat_param); + if (message_arena != submessage_arena) { + concat_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, concat_param, submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + 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::_internal_has_contrastive_loss_param() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || contrastive_loss_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_contrastive_loss_param() const { + return _internal_has_contrastive_loss_param(); +} +inline void LayerParameter::clear_contrastive_loss_param() { + if (contrastive_loss_param_ != nullptr) contrastive_loss_param_->Clear(); + _has_bits_[0] &= ~0x00000080u; +} +inline const ::opencv_caffe::ContrastiveLossParameter& LayerParameter::_internal_contrastive_loss_param() const { + const ::opencv_caffe::ContrastiveLossParameter* p = contrastive_loss_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ContrastiveLossParameter_default_instance_); +} +inline const ::opencv_caffe::ContrastiveLossParameter& LayerParameter::contrastive_loss_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.contrastive_loss_param) + return _internal_contrastive_loss_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_contrastive_loss_param( + ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(contrastive_loss_param_); + } + contrastive_loss_param_ = contrastive_loss_param; + if (contrastive_loss_param) { + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.contrastive_loss_param) +} +inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::release_contrastive_loss_param() { + _has_bits_[0] &= ~0x00000080u; + ::opencv_caffe::ContrastiveLossParameter* temp = contrastive_loss_param_; + contrastive_loss_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::unsafe_arena_release_contrastive_loss_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.contrastive_loss_param) + _has_bits_[0] &= ~0x00000080u; + ::opencv_caffe::ContrastiveLossParameter* temp = contrastive_loss_param_; + contrastive_loss_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::_internal_mutable_contrastive_loss_param() { + _has_bits_[0] |= 0x00000080u; + if (contrastive_loss_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ContrastiveLossParameter>(GetArenaForAllocation()); + contrastive_loss_param_ = p; + } + return contrastive_loss_param_; +} +inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::mutable_contrastive_loss_param() { + ::opencv_caffe::ContrastiveLossParameter* _msg = _internal_mutable_contrastive_loss_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.contrastive_loss_param) + return _msg; +} +inline void LayerParameter::set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete contrastive_loss_param_; + } + if (contrastive_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ContrastiveLossParameter>::GetOwningArena(contrastive_loss_param); + if (message_arena != submessage_arena) { + contrastive_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contrastive_loss_param, submessage_arena); + } + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + 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::_internal_has_convolution_param() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || convolution_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_convolution_param() const { + return _internal_has_convolution_param(); +} +inline void LayerParameter::clear_convolution_param() { + if (convolution_param_ != nullptr) convolution_param_->Clear(); + _has_bits_[0] &= ~0x00000100u; +} +inline const ::opencv_caffe::ConvolutionParameter& LayerParameter::_internal_convolution_param() const { + const ::opencv_caffe::ConvolutionParameter* p = convolution_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ConvolutionParameter_default_instance_); +} +inline const ::opencv_caffe::ConvolutionParameter& LayerParameter::convolution_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.convolution_param) + return _internal_convolution_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_convolution_param( + ::opencv_caffe::ConvolutionParameter* convolution_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(convolution_param_); + } + convolution_param_ = convolution_param; + if (convolution_param) { + _has_bits_[0] |= 0x00000100u; + } else { + _has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.convolution_param) +} +inline ::opencv_caffe::ConvolutionParameter* LayerParameter::release_convolution_param() { + _has_bits_[0] &= ~0x00000100u; + ::opencv_caffe::ConvolutionParameter* temp = convolution_param_; + convolution_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ConvolutionParameter* LayerParameter::unsafe_arena_release_convolution_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.convolution_param) + _has_bits_[0] &= ~0x00000100u; + ::opencv_caffe::ConvolutionParameter* temp = convolution_param_; + convolution_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ConvolutionParameter* LayerParameter::_internal_mutable_convolution_param() { + _has_bits_[0] |= 0x00000100u; + if (convolution_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ConvolutionParameter>(GetArenaForAllocation()); + convolution_param_ = p; + } + return convolution_param_; +} +inline ::opencv_caffe::ConvolutionParameter* LayerParameter::mutable_convolution_param() { + ::opencv_caffe::ConvolutionParameter* _msg = _internal_mutable_convolution_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.convolution_param) + return _msg; +} +inline void LayerParameter::set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete convolution_param_; + } + if (convolution_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ConvolutionParameter>::GetOwningArena(convolution_param); + if (message_arena != submessage_arena) { + convolution_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, convolution_param, submessage_arena); + } + _has_bits_[0] |= 0x00000100u; + } else { + _has_bits_[0] &= ~0x00000100u; + } + 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::_internal_has_crop_param() const { + bool value = (_has_bits_[1] & 0x00004000u) != 0; + PROTOBUF_ASSUME(!value || crop_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_crop_param() const { + return _internal_has_crop_param(); +} +inline void LayerParameter::clear_crop_param() { + if (crop_param_ != nullptr) crop_param_->Clear(); + _has_bits_[1] &= ~0x00004000u; +} +inline const ::opencv_caffe::CropParameter& LayerParameter::_internal_crop_param() const { + const ::opencv_caffe::CropParameter* p = crop_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_CropParameter_default_instance_); +} +inline const ::opencv_caffe::CropParameter& LayerParameter::crop_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.crop_param) + return _internal_crop_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_crop_param( + ::opencv_caffe::CropParameter* crop_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(crop_param_); + } + crop_param_ = crop_param; + if (crop_param) { + _has_bits_[1] |= 0x00004000u; + } else { + _has_bits_[1] &= ~0x00004000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.crop_param) +} +inline ::opencv_caffe::CropParameter* LayerParameter::release_crop_param() { + _has_bits_[1] &= ~0x00004000u; + ::opencv_caffe::CropParameter* temp = crop_param_; + crop_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::CropParameter* LayerParameter::unsafe_arena_release_crop_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.crop_param) + _has_bits_[1] &= ~0x00004000u; + ::opencv_caffe::CropParameter* temp = crop_param_; + crop_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::CropParameter* LayerParameter::_internal_mutable_crop_param() { + _has_bits_[1] |= 0x00004000u; + if (crop_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::CropParameter>(GetArenaForAllocation()); + crop_param_ = p; + } + return crop_param_; +} +inline ::opencv_caffe::CropParameter* LayerParameter::mutable_crop_param() { + ::opencv_caffe::CropParameter* _msg = _internal_mutable_crop_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.crop_param) + return _msg; +} +inline void LayerParameter::set_allocated_crop_param(::opencv_caffe::CropParameter* crop_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete crop_param_; + } + if (crop_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::CropParameter>::GetOwningArena(crop_param); + if (message_arena != submessage_arena) { + crop_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, crop_param, submessage_arena); + } + _has_bits_[1] |= 0x00004000u; + } else { + _has_bits_[1] &= ~0x00004000u; + } + 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::_internal_has_data_param() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || data_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_data_param() const { + return _internal_has_data_param(); +} +inline void LayerParameter::clear_data_param() { + if (data_param_ != nullptr) data_param_->Clear(); + _has_bits_[0] &= ~0x00000200u; +} +inline const ::opencv_caffe::DataParameter& LayerParameter::_internal_data_param() const { + const ::opencv_caffe::DataParameter* p = data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_DataParameter_default_instance_); +} +inline const ::opencv_caffe::DataParameter& LayerParameter::data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.data_param) + return _internal_data_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_data_param( + ::opencv_caffe::DataParameter* data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(data_param_); + } + data_param_ = data_param; + if (data_param) { + _has_bits_[0] |= 0x00000200u; + } else { + _has_bits_[0] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.data_param) +} +inline ::opencv_caffe::DataParameter* LayerParameter::release_data_param() { + _has_bits_[0] &= ~0x00000200u; + ::opencv_caffe::DataParameter* temp = data_param_; + data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::DataParameter* LayerParameter::unsafe_arena_release_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.data_param) + _has_bits_[0] &= ~0x00000200u; + ::opencv_caffe::DataParameter* temp = data_param_; + data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::DataParameter* LayerParameter::_internal_mutable_data_param() { + _has_bits_[0] |= 0x00000200u; + if (data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::DataParameter>(GetArenaForAllocation()); + data_param_ = p; + } + return data_param_; +} +inline ::opencv_caffe::DataParameter* LayerParameter::mutable_data_param() { + ::opencv_caffe::DataParameter* _msg = _internal_mutable_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.data_param) + return _msg; +} +inline void LayerParameter::set_allocated_data_param(::opencv_caffe::DataParameter* data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete data_param_; + } + if (data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::DataParameter>::GetOwningArena(data_param); + if (message_arena != submessage_arena) { + data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, data_param, submessage_arena); + } + _has_bits_[0] |= 0x00000200u; + } else { + _has_bits_[0] &= ~0x00000200u; + } + 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::_internal_has_detection_output_param() const { + bool value = (_has_bits_[1] & 0x00020000u) != 0; + PROTOBUF_ASSUME(!value || detection_output_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_detection_output_param() const { + return _internal_has_detection_output_param(); +} +inline void LayerParameter::clear_detection_output_param() { + if (detection_output_param_ != nullptr) detection_output_param_->Clear(); + _has_bits_[1] &= ~0x00020000u; +} +inline const ::opencv_caffe::DetectionOutputParameter& LayerParameter::_internal_detection_output_param() const { + const ::opencv_caffe::DetectionOutputParameter* p = detection_output_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_DetectionOutputParameter_default_instance_); +} +inline const ::opencv_caffe::DetectionOutputParameter& LayerParameter::detection_output_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.detection_output_param) + return _internal_detection_output_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_detection_output_param( + ::opencv_caffe::DetectionOutputParameter* detection_output_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detection_output_param_); + } + detection_output_param_ = detection_output_param; + if (detection_output_param) { + _has_bits_[1] |= 0x00020000u; + } else { + _has_bits_[1] &= ~0x00020000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.detection_output_param) +} +inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::release_detection_output_param() { + _has_bits_[1] &= ~0x00020000u; + ::opencv_caffe::DetectionOutputParameter* temp = detection_output_param_; + detection_output_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::unsafe_arena_release_detection_output_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.detection_output_param) + _has_bits_[1] &= ~0x00020000u; + ::opencv_caffe::DetectionOutputParameter* temp = detection_output_param_; + detection_output_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::_internal_mutable_detection_output_param() { + _has_bits_[1] |= 0x00020000u; + if (detection_output_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::DetectionOutputParameter>(GetArenaForAllocation()); + detection_output_param_ = p; + } + return detection_output_param_; +} +inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::mutable_detection_output_param() { + ::opencv_caffe::DetectionOutputParameter* _msg = _internal_mutable_detection_output_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.detection_output_param) + return _msg; +} +inline void LayerParameter::set_allocated_detection_output_param(::opencv_caffe::DetectionOutputParameter* detection_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete detection_output_param_; + } + if (detection_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::DetectionOutputParameter>::GetOwningArena(detection_output_param); + if (message_arena != submessage_arena) { + detection_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, detection_output_param, submessage_arena); + } + _has_bits_[1] |= 0x00020000u; + } else { + _has_bits_[1] &= ~0x00020000u; + } + 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::_internal_has_dropout_param() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || dropout_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_dropout_param() const { + return _internal_has_dropout_param(); +} +inline void LayerParameter::clear_dropout_param() { + if (dropout_param_ != nullptr) dropout_param_->Clear(); + _has_bits_[0] &= ~0x00000400u; +} +inline const ::opencv_caffe::DropoutParameter& LayerParameter::_internal_dropout_param() const { + const ::opencv_caffe::DropoutParameter* p = dropout_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_DropoutParameter_default_instance_); +} +inline const ::opencv_caffe::DropoutParameter& LayerParameter::dropout_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.dropout_param) + return _internal_dropout_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_dropout_param( + ::opencv_caffe::DropoutParameter* dropout_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dropout_param_); + } + dropout_param_ = dropout_param; + if (dropout_param) { + _has_bits_[0] |= 0x00000400u; + } else { + _has_bits_[0] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.dropout_param) +} +inline ::opencv_caffe::DropoutParameter* LayerParameter::release_dropout_param() { + _has_bits_[0] &= ~0x00000400u; + ::opencv_caffe::DropoutParameter* temp = dropout_param_; + dropout_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::DropoutParameter* LayerParameter::unsafe_arena_release_dropout_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.dropout_param) + _has_bits_[0] &= ~0x00000400u; + ::opencv_caffe::DropoutParameter* temp = dropout_param_; + dropout_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::DropoutParameter* LayerParameter::_internal_mutable_dropout_param() { + _has_bits_[0] |= 0x00000400u; + if (dropout_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::DropoutParameter>(GetArenaForAllocation()); + dropout_param_ = p; + } + return dropout_param_; +} +inline ::opencv_caffe::DropoutParameter* LayerParameter::mutable_dropout_param() { + ::opencv_caffe::DropoutParameter* _msg = _internal_mutable_dropout_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.dropout_param) + return _msg; +} +inline void LayerParameter::set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete dropout_param_; + } + if (dropout_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::DropoutParameter>::GetOwningArena(dropout_param); + if (message_arena != submessage_arena) { + dropout_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, dropout_param, submessage_arena); + } + _has_bits_[0] |= 0x00000400u; + } else { + _has_bits_[0] &= ~0x00000400u; + } + 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::_internal_has_dummy_data_param() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || dummy_data_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_dummy_data_param() const { + return _internal_has_dummy_data_param(); +} +inline void LayerParameter::clear_dummy_data_param() { + if (dummy_data_param_ != nullptr) dummy_data_param_->Clear(); + _has_bits_[0] &= ~0x00000800u; +} +inline const ::opencv_caffe::DummyDataParameter& LayerParameter::_internal_dummy_data_param() const { + const ::opencv_caffe::DummyDataParameter* p = dummy_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_DummyDataParameter_default_instance_); +} +inline const ::opencv_caffe::DummyDataParameter& LayerParameter::dummy_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.dummy_data_param) + return _internal_dummy_data_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_dummy_data_param( + ::opencv_caffe::DummyDataParameter* dummy_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dummy_data_param_); + } + dummy_data_param_ = dummy_data_param; + if (dummy_data_param) { + _has_bits_[0] |= 0x00000800u; + } else { + _has_bits_[0] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.dummy_data_param) +} +inline ::opencv_caffe::DummyDataParameter* LayerParameter::release_dummy_data_param() { + _has_bits_[0] &= ~0x00000800u; + ::opencv_caffe::DummyDataParameter* temp = dummy_data_param_; + dummy_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::DummyDataParameter* LayerParameter::unsafe_arena_release_dummy_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.dummy_data_param) + _has_bits_[0] &= ~0x00000800u; + ::opencv_caffe::DummyDataParameter* temp = dummy_data_param_; + dummy_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::DummyDataParameter* LayerParameter::_internal_mutable_dummy_data_param() { + _has_bits_[0] |= 0x00000800u; + if (dummy_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::DummyDataParameter>(GetArenaForAllocation()); + dummy_data_param_ = p; + } + return dummy_data_param_; +} +inline ::opencv_caffe::DummyDataParameter* LayerParameter::mutable_dummy_data_param() { + ::opencv_caffe::DummyDataParameter* _msg = _internal_mutable_dummy_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.dummy_data_param) + return _msg; +} +inline void LayerParameter::set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete dummy_data_param_; + } + if (dummy_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::DummyDataParameter>::GetOwningArena(dummy_data_param); + if (message_arena != submessage_arena) { + dummy_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, dummy_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00000800u; + } else { + _has_bits_[0] &= ~0x00000800u; + } + 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::_internal_has_eltwise_param() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || eltwise_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_eltwise_param() const { + return _internal_has_eltwise_param(); +} +inline void LayerParameter::clear_eltwise_param() { + if (eltwise_param_ != nullptr) eltwise_param_->Clear(); + _has_bits_[0] &= ~0x00001000u; +} +inline const ::opencv_caffe::EltwiseParameter& LayerParameter::_internal_eltwise_param() const { + const ::opencv_caffe::EltwiseParameter* p = eltwise_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_EltwiseParameter_default_instance_); +} +inline const ::opencv_caffe::EltwiseParameter& LayerParameter::eltwise_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.eltwise_param) + return _internal_eltwise_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_eltwise_param( + ::opencv_caffe::EltwiseParameter* eltwise_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(eltwise_param_); + } + eltwise_param_ = eltwise_param; + if (eltwise_param) { + _has_bits_[0] |= 0x00001000u; + } else { + _has_bits_[0] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.eltwise_param) +} +inline ::opencv_caffe::EltwiseParameter* LayerParameter::release_eltwise_param() { + _has_bits_[0] &= ~0x00001000u; + ::opencv_caffe::EltwiseParameter* temp = eltwise_param_; + eltwise_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::EltwiseParameter* LayerParameter::unsafe_arena_release_eltwise_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.eltwise_param) + _has_bits_[0] &= ~0x00001000u; + ::opencv_caffe::EltwiseParameter* temp = eltwise_param_; + eltwise_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::EltwiseParameter* LayerParameter::_internal_mutable_eltwise_param() { + _has_bits_[0] |= 0x00001000u; + if (eltwise_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::EltwiseParameter>(GetArenaForAllocation()); + eltwise_param_ = p; + } + return eltwise_param_; +} +inline ::opencv_caffe::EltwiseParameter* LayerParameter::mutable_eltwise_param() { + ::opencv_caffe::EltwiseParameter* _msg = _internal_mutable_eltwise_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.eltwise_param) + return _msg; +} +inline void LayerParameter::set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete eltwise_param_; + } + if (eltwise_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::EltwiseParameter>::GetOwningArena(eltwise_param); + if (message_arena != submessage_arena) { + eltwise_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, eltwise_param, submessage_arena); + } + _has_bits_[0] |= 0x00001000u; + } else { + _has_bits_[0] &= ~0x00001000u; + } + 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::_internal_has_elu_param() const { + bool value = (_has_bits_[1] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || elu_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_elu_param() const { + return _internal_has_elu_param(); +} +inline void LayerParameter::clear_elu_param() { + if (elu_param_ != nullptr) elu_param_->Clear(); + _has_bits_[1] &= ~0x00000400u; +} +inline const ::opencv_caffe::ELUParameter& LayerParameter::_internal_elu_param() const { + const ::opencv_caffe::ELUParameter* p = elu_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ELUParameter_default_instance_); +} +inline const ::opencv_caffe::ELUParameter& LayerParameter::elu_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.elu_param) + return _internal_elu_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_elu_param( + ::opencv_caffe::ELUParameter* elu_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elu_param_); + } + elu_param_ = elu_param; + if (elu_param) { + _has_bits_[1] |= 0x00000400u; + } else { + _has_bits_[1] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.elu_param) +} +inline ::opencv_caffe::ELUParameter* LayerParameter::release_elu_param() { + _has_bits_[1] &= ~0x00000400u; + ::opencv_caffe::ELUParameter* temp = elu_param_; + elu_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ELUParameter* LayerParameter::unsafe_arena_release_elu_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.elu_param) + _has_bits_[1] &= ~0x00000400u; + ::opencv_caffe::ELUParameter* temp = elu_param_; + elu_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ELUParameter* LayerParameter::_internal_mutable_elu_param() { + _has_bits_[1] |= 0x00000400u; + if (elu_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ELUParameter>(GetArenaForAllocation()); + elu_param_ = p; + } + return elu_param_; +} +inline ::opencv_caffe::ELUParameter* LayerParameter::mutable_elu_param() { + ::opencv_caffe::ELUParameter* _msg = _internal_mutable_elu_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.elu_param) + return _msg; +} +inline void LayerParameter::set_allocated_elu_param(::opencv_caffe::ELUParameter* elu_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete elu_param_; + } + if (elu_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ELUParameter>::GetOwningArena(elu_param); + if (message_arena != submessage_arena) { + elu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, elu_param, submessage_arena); + } + _has_bits_[1] |= 0x00000400u; + } else { + _has_bits_[1] &= ~0x00000400u; + } + 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::_internal_has_embed_param() const { + bool value = (_has_bits_[1] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || embed_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_embed_param() const { + return _internal_has_embed_param(); +} +inline void LayerParameter::clear_embed_param() { + if (embed_param_ != nullptr) embed_param_->Clear(); + _has_bits_[1] &= ~0x00000080u; +} +inline const ::opencv_caffe::EmbedParameter& LayerParameter::_internal_embed_param() const { + const ::opencv_caffe::EmbedParameter* p = embed_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_EmbedParameter_default_instance_); +} +inline const ::opencv_caffe::EmbedParameter& LayerParameter::embed_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.embed_param) + return _internal_embed_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_embed_param( + ::opencv_caffe::EmbedParameter* embed_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(embed_param_); + } + embed_param_ = embed_param; + if (embed_param) { + _has_bits_[1] |= 0x00000080u; + } else { + _has_bits_[1] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.embed_param) +} +inline ::opencv_caffe::EmbedParameter* LayerParameter::release_embed_param() { + _has_bits_[1] &= ~0x00000080u; + ::opencv_caffe::EmbedParameter* temp = embed_param_; + embed_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::EmbedParameter* LayerParameter::unsafe_arena_release_embed_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.embed_param) + _has_bits_[1] &= ~0x00000080u; + ::opencv_caffe::EmbedParameter* temp = embed_param_; + embed_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::EmbedParameter* LayerParameter::_internal_mutable_embed_param() { + _has_bits_[1] |= 0x00000080u; + if (embed_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::EmbedParameter>(GetArenaForAllocation()); + embed_param_ = p; + } + return embed_param_; +} +inline ::opencv_caffe::EmbedParameter* LayerParameter::mutable_embed_param() { + ::opencv_caffe::EmbedParameter* _msg = _internal_mutable_embed_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.embed_param) + return _msg; +} +inline void LayerParameter::set_allocated_embed_param(::opencv_caffe::EmbedParameter* embed_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete embed_param_; + } + if (embed_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::EmbedParameter>::GetOwningArena(embed_param); + if (message_arena != submessage_arena) { + embed_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, embed_param, submessage_arena); + } + _has_bits_[1] |= 0x00000080u; + } else { + _has_bits_[1] &= ~0x00000080u; + } + 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::_internal_has_exp_param() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || exp_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_exp_param() const { + return _internal_has_exp_param(); +} +inline void LayerParameter::clear_exp_param() { + if (exp_param_ != nullptr) exp_param_->Clear(); + _has_bits_[0] &= ~0x00002000u; +} +inline const ::opencv_caffe::ExpParameter& LayerParameter::_internal_exp_param() const { + const ::opencv_caffe::ExpParameter* p = exp_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ExpParameter_default_instance_); +} +inline const ::opencv_caffe::ExpParameter& LayerParameter::exp_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.exp_param) + return _internal_exp_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_exp_param( + ::opencv_caffe::ExpParameter* exp_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(exp_param_); + } + exp_param_ = exp_param; + if (exp_param) { + _has_bits_[0] |= 0x00002000u; + } else { + _has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.exp_param) +} +inline ::opencv_caffe::ExpParameter* LayerParameter::release_exp_param() { + _has_bits_[0] &= ~0x00002000u; + ::opencv_caffe::ExpParameter* temp = exp_param_; + exp_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ExpParameter* LayerParameter::unsafe_arena_release_exp_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.exp_param) + _has_bits_[0] &= ~0x00002000u; + ::opencv_caffe::ExpParameter* temp = exp_param_; + exp_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ExpParameter* LayerParameter::_internal_mutable_exp_param() { + _has_bits_[0] |= 0x00002000u; + if (exp_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ExpParameter>(GetArenaForAllocation()); + exp_param_ = p; + } + return exp_param_; +} +inline ::opencv_caffe::ExpParameter* LayerParameter::mutable_exp_param() { + ::opencv_caffe::ExpParameter* _msg = _internal_mutable_exp_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.exp_param) + return _msg; +} +inline void LayerParameter::set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete exp_param_; + } + if (exp_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ExpParameter>::GetOwningArena(exp_param); + if (message_arena != submessage_arena) { + exp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, exp_param, submessage_arena); + } + _has_bits_[0] |= 0x00002000u; + } else { + _has_bits_[0] &= ~0x00002000u; + } + 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::_internal_has_flatten_param() const { + bool value = (_has_bits_[1] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || flatten_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_flatten_param() const { + return _internal_has_flatten_param(); +} +inline void LayerParameter::clear_flatten_param() { + if (flatten_param_ != nullptr) flatten_param_->Clear(); + _has_bits_[1] &= ~0x00000020u; +} +inline const ::opencv_caffe::FlattenParameter& LayerParameter::_internal_flatten_param() const { + const ::opencv_caffe::FlattenParameter* p = flatten_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FlattenParameter_default_instance_); +} +inline const ::opencv_caffe::FlattenParameter& LayerParameter::flatten_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.flatten_param) + return _internal_flatten_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_flatten_param( + ::opencv_caffe::FlattenParameter* flatten_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(flatten_param_); + } + flatten_param_ = flatten_param; + if (flatten_param) { + _has_bits_[1] |= 0x00000020u; + } else { + _has_bits_[1] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.flatten_param) +} +inline ::opencv_caffe::FlattenParameter* LayerParameter::release_flatten_param() { + _has_bits_[1] &= ~0x00000020u; + ::opencv_caffe::FlattenParameter* temp = flatten_param_; + flatten_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FlattenParameter* LayerParameter::unsafe_arena_release_flatten_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.flatten_param) + _has_bits_[1] &= ~0x00000020u; + ::opencv_caffe::FlattenParameter* temp = flatten_param_; + flatten_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::FlattenParameter* LayerParameter::_internal_mutable_flatten_param() { + _has_bits_[1] |= 0x00000020u; + if (flatten_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FlattenParameter>(GetArenaForAllocation()); + flatten_param_ = p; + } + return flatten_param_; +} +inline ::opencv_caffe::FlattenParameter* LayerParameter::mutable_flatten_param() { + ::opencv_caffe::FlattenParameter* _msg = _internal_mutable_flatten_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.flatten_param) + return _msg; +} +inline void LayerParameter::set_allocated_flatten_param(::opencv_caffe::FlattenParameter* flatten_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete flatten_param_; + } + if (flatten_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FlattenParameter>::GetOwningArena(flatten_param); + if (message_arena != submessage_arena) { + flatten_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, flatten_param, submessage_arena); + } + _has_bits_[1] |= 0x00000020u; + } else { + _has_bits_[1] &= ~0x00000020u; + } + 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::_internal_has_hdf5_data_param() const { + bool value = (_has_bits_[0] & 0x00004000u) != 0; + PROTOBUF_ASSUME(!value || hdf5_data_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_hdf5_data_param() const { + return _internal_has_hdf5_data_param(); +} +inline void LayerParameter::clear_hdf5_data_param() { + if (hdf5_data_param_ != nullptr) hdf5_data_param_->Clear(); + _has_bits_[0] &= ~0x00004000u; +} +inline const ::opencv_caffe::HDF5DataParameter& LayerParameter::_internal_hdf5_data_param() const { + const ::opencv_caffe::HDF5DataParameter* p = hdf5_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_HDF5DataParameter_default_instance_); +} +inline const ::opencv_caffe::HDF5DataParameter& LayerParameter::hdf5_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hdf5_data_param) + return _internal_hdf5_data_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_hdf5_data_param( + ::opencv_caffe::HDF5DataParameter* hdf5_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_data_param_); + } + hdf5_data_param_ = hdf5_data_param; + if (hdf5_data_param) { + _has_bits_[0] |= 0x00004000u; + } else { + _has_bits_[0] &= ~0x00004000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.hdf5_data_param) +} +inline ::opencv_caffe::HDF5DataParameter* LayerParameter::release_hdf5_data_param() { + _has_bits_[0] &= ~0x00004000u; + ::opencv_caffe::HDF5DataParameter* temp = hdf5_data_param_; + hdf5_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::HDF5DataParameter* LayerParameter::unsafe_arena_release_hdf5_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hdf5_data_param) + _has_bits_[0] &= ~0x00004000u; + ::opencv_caffe::HDF5DataParameter* temp = hdf5_data_param_; + hdf5_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::HDF5DataParameter* LayerParameter::_internal_mutable_hdf5_data_param() { + _has_bits_[0] |= 0x00004000u; + if (hdf5_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::HDF5DataParameter>(GetArenaForAllocation()); + hdf5_data_param_ = p; + } + return hdf5_data_param_; +} +inline ::opencv_caffe::HDF5DataParameter* LayerParameter::mutable_hdf5_data_param() { + ::opencv_caffe::HDF5DataParameter* _msg = _internal_mutable_hdf5_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hdf5_data_param) + return _msg; +} +inline void LayerParameter::set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete hdf5_data_param_; + } + if (hdf5_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::HDF5DataParameter>::GetOwningArena(hdf5_data_param); + if (message_arena != submessage_arena) { + hdf5_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hdf5_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00004000u; + } else { + _has_bits_[0] &= ~0x00004000u; + } + 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::_internal_has_hdf5_output_param() const { + bool value = (_has_bits_[0] & 0x00008000u) != 0; + PROTOBUF_ASSUME(!value || hdf5_output_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_hdf5_output_param() const { + return _internal_has_hdf5_output_param(); +} +inline void LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != nullptr) hdf5_output_param_->Clear(); + _has_bits_[0] &= ~0x00008000u; +} +inline const ::opencv_caffe::HDF5OutputParameter& LayerParameter::_internal_hdf5_output_param() const { + const ::opencv_caffe::HDF5OutputParameter* p = hdf5_output_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_HDF5OutputParameter_default_instance_); +} +inline const ::opencv_caffe::HDF5OutputParameter& LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hdf5_output_param) + return _internal_hdf5_output_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_hdf5_output_param( + ::opencv_caffe::HDF5OutputParameter* hdf5_output_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_output_param_); + } + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + _has_bits_[0] |= 0x00008000u; + } else { + _has_bits_[0] &= ~0x00008000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.hdf5_output_param) +} +inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::release_hdf5_output_param() { + _has_bits_[0] &= ~0x00008000u; + ::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::unsafe_arena_release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hdf5_output_param) + _has_bits_[0] &= ~0x00008000u; + ::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::_internal_mutable_hdf5_output_param() { + _has_bits_[0] |= 0x00008000u; + if (hdf5_output_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::HDF5OutputParameter>(GetArenaForAllocation()); + hdf5_output_param_ = p; + } + return hdf5_output_param_; +} +inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::mutable_hdf5_output_param() { + ::opencv_caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hdf5_output_param) + return _msg; +} +inline void LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete hdf5_output_param_; + } + if (hdf5_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::HDF5OutputParameter>::GetOwningArena(hdf5_output_param); + if (message_arena != submessage_arena) { + hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hdf5_output_param, submessage_arena); + } + _has_bits_[0] |= 0x00008000u; + } else { + _has_bits_[0] &= ~0x00008000u; + } + 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::_internal_has_hinge_loss_param() const { + bool value = (_has_bits_[0] & 0x00010000u) != 0; + PROTOBUF_ASSUME(!value || hinge_loss_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_hinge_loss_param() const { + return _internal_has_hinge_loss_param(); +} +inline void LayerParameter::clear_hinge_loss_param() { + if (hinge_loss_param_ != nullptr) hinge_loss_param_->Clear(); + _has_bits_[0] &= ~0x00010000u; +} +inline const ::opencv_caffe::HingeLossParameter& LayerParameter::_internal_hinge_loss_param() const { + const ::opencv_caffe::HingeLossParameter* p = hinge_loss_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_HingeLossParameter_default_instance_); +} +inline const ::opencv_caffe::HingeLossParameter& LayerParameter::hinge_loss_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hinge_loss_param) + return _internal_hinge_loss_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_hinge_loss_param( + ::opencv_caffe::HingeLossParameter* hinge_loss_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hinge_loss_param_); + } + hinge_loss_param_ = hinge_loss_param; + if (hinge_loss_param) { + _has_bits_[0] |= 0x00010000u; + } else { + _has_bits_[0] &= ~0x00010000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.hinge_loss_param) +} +inline ::opencv_caffe::HingeLossParameter* LayerParameter::release_hinge_loss_param() { + _has_bits_[0] &= ~0x00010000u; + ::opencv_caffe::HingeLossParameter* temp = hinge_loss_param_; + hinge_loss_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::HingeLossParameter* LayerParameter::unsafe_arena_release_hinge_loss_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hinge_loss_param) + _has_bits_[0] &= ~0x00010000u; + ::opencv_caffe::HingeLossParameter* temp = hinge_loss_param_; + hinge_loss_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::HingeLossParameter* LayerParameter::_internal_mutable_hinge_loss_param() { + _has_bits_[0] |= 0x00010000u; + if (hinge_loss_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::HingeLossParameter>(GetArenaForAllocation()); + hinge_loss_param_ = p; + } + return hinge_loss_param_; +} +inline ::opencv_caffe::HingeLossParameter* LayerParameter::mutable_hinge_loss_param() { + ::opencv_caffe::HingeLossParameter* _msg = _internal_mutable_hinge_loss_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hinge_loss_param) + return _msg; +} +inline void LayerParameter::set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete hinge_loss_param_; + } + if (hinge_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::HingeLossParameter>::GetOwningArena(hinge_loss_param); + if (message_arena != submessage_arena) { + hinge_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hinge_loss_param, submessage_arena); + } + _has_bits_[0] |= 0x00010000u; + } else { + _has_bits_[0] &= ~0x00010000u; + } + 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::_internal_has_image_data_param() const { + bool value = (_has_bits_[0] & 0x00020000u) != 0; + PROTOBUF_ASSUME(!value || image_data_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_image_data_param() const { + return _internal_has_image_data_param(); +} +inline void LayerParameter::clear_image_data_param() { + if (image_data_param_ != nullptr) image_data_param_->Clear(); + _has_bits_[0] &= ~0x00020000u; +} +inline const ::opencv_caffe::ImageDataParameter& LayerParameter::_internal_image_data_param() const { + const ::opencv_caffe::ImageDataParameter* p = image_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ImageDataParameter_default_instance_); +} +inline const ::opencv_caffe::ImageDataParameter& LayerParameter::image_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.image_data_param) + return _internal_image_data_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_image_data_param( + ::opencv_caffe::ImageDataParameter* image_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(image_data_param_); + } + image_data_param_ = image_data_param; + if (image_data_param) { + _has_bits_[0] |= 0x00020000u; + } else { + _has_bits_[0] &= ~0x00020000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.image_data_param) +} +inline ::opencv_caffe::ImageDataParameter* LayerParameter::release_image_data_param() { + _has_bits_[0] &= ~0x00020000u; + ::opencv_caffe::ImageDataParameter* temp = image_data_param_; + image_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ImageDataParameter* LayerParameter::unsafe_arena_release_image_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.image_data_param) + _has_bits_[0] &= ~0x00020000u; + ::opencv_caffe::ImageDataParameter* temp = image_data_param_; + image_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ImageDataParameter* LayerParameter::_internal_mutable_image_data_param() { + _has_bits_[0] |= 0x00020000u; + if (image_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ImageDataParameter>(GetArenaForAllocation()); + image_data_param_ = p; + } + return image_data_param_; +} +inline ::opencv_caffe::ImageDataParameter* LayerParameter::mutable_image_data_param() { + ::opencv_caffe::ImageDataParameter* _msg = _internal_mutable_image_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.image_data_param) + return _msg; +} +inline void LayerParameter::set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete image_data_param_; + } + if (image_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ImageDataParameter>::GetOwningArena(image_data_param); + if (message_arena != submessage_arena) { + image_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, image_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00020000u; + } else { + _has_bits_[0] &= ~0x00020000u; + } + 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::_internal_has_infogain_loss_param() const { + bool value = (_has_bits_[0] & 0x00040000u) != 0; + PROTOBUF_ASSUME(!value || infogain_loss_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_infogain_loss_param() const { + return _internal_has_infogain_loss_param(); +} +inline void LayerParameter::clear_infogain_loss_param() { + if (infogain_loss_param_ != nullptr) infogain_loss_param_->Clear(); + _has_bits_[0] &= ~0x00040000u; +} +inline const ::opencv_caffe::InfogainLossParameter& LayerParameter::_internal_infogain_loss_param() const { + const ::opencv_caffe::InfogainLossParameter* p = infogain_loss_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_InfogainLossParameter_default_instance_); +} +inline const ::opencv_caffe::InfogainLossParameter& LayerParameter::infogain_loss_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.infogain_loss_param) + return _internal_infogain_loss_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_infogain_loss_param( + ::opencv_caffe::InfogainLossParameter* infogain_loss_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(infogain_loss_param_); + } + infogain_loss_param_ = infogain_loss_param; + if (infogain_loss_param) { + _has_bits_[0] |= 0x00040000u; + } else { + _has_bits_[0] &= ~0x00040000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.infogain_loss_param) +} +inline ::opencv_caffe::InfogainLossParameter* LayerParameter::release_infogain_loss_param() { + _has_bits_[0] &= ~0x00040000u; + ::opencv_caffe::InfogainLossParameter* temp = infogain_loss_param_; + infogain_loss_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::InfogainLossParameter* LayerParameter::unsafe_arena_release_infogain_loss_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.infogain_loss_param) + _has_bits_[0] &= ~0x00040000u; + ::opencv_caffe::InfogainLossParameter* temp = infogain_loss_param_; + infogain_loss_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::InfogainLossParameter* LayerParameter::_internal_mutable_infogain_loss_param() { + _has_bits_[0] |= 0x00040000u; + if (infogain_loss_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::InfogainLossParameter>(GetArenaForAllocation()); + infogain_loss_param_ = p; + } + return infogain_loss_param_; +} +inline ::opencv_caffe::InfogainLossParameter* LayerParameter::mutable_infogain_loss_param() { + ::opencv_caffe::InfogainLossParameter* _msg = _internal_mutable_infogain_loss_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.infogain_loss_param) + return _msg; +} +inline void LayerParameter::set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete infogain_loss_param_; + } + if (infogain_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::InfogainLossParameter>::GetOwningArena(infogain_loss_param); + if (message_arena != submessage_arena) { + infogain_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, infogain_loss_param, submessage_arena); + } + _has_bits_[0] |= 0x00040000u; + } else { + _has_bits_[0] &= ~0x00040000u; + } + 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::_internal_has_inner_product_param() const { + bool value = (_has_bits_[0] & 0x00080000u) != 0; + PROTOBUF_ASSUME(!value || inner_product_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_inner_product_param() const { + return _internal_has_inner_product_param(); +} +inline void LayerParameter::clear_inner_product_param() { + if (inner_product_param_ != nullptr) inner_product_param_->Clear(); + _has_bits_[0] &= ~0x00080000u; +} +inline const ::opencv_caffe::InnerProductParameter& LayerParameter::_internal_inner_product_param() const { + const ::opencv_caffe::InnerProductParameter* p = inner_product_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_InnerProductParameter_default_instance_); +} +inline const ::opencv_caffe::InnerProductParameter& LayerParameter::inner_product_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.inner_product_param) + return _internal_inner_product_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_inner_product_param( + ::opencv_caffe::InnerProductParameter* inner_product_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(inner_product_param_); + } + inner_product_param_ = inner_product_param; + if (inner_product_param) { + _has_bits_[0] |= 0x00080000u; + } else { + _has_bits_[0] &= ~0x00080000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.inner_product_param) +} +inline ::opencv_caffe::InnerProductParameter* LayerParameter::release_inner_product_param() { + _has_bits_[0] &= ~0x00080000u; + ::opencv_caffe::InnerProductParameter* temp = inner_product_param_; + inner_product_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::InnerProductParameter* LayerParameter::unsafe_arena_release_inner_product_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.inner_product_param) + _has_bits_[0] &= ~0x00080000u; + ::opencv_caffe::InnerProductParameter* temp = inner_product_param_; + inner_product_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::InnerProductParameter* LayerParameter::_internal_mutable_inner_product_param() { + _has_bits_[0] |= 0x00080000u; + if (inner_product_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::InnerProductParameter>(GetArenaForAllocation()); + inner_product_param_ = p; + } + return inner_product_param_; +} +inline ::opencv_caffe::InnerProductParameter* LayerParameter::mutable_inner_product_param() { + ::opencv_caffe::InnerProductParameter* _msg = _internal_mutable_inner_product_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.inner_product_param) + return _msg; +} +inline void LayerParameter::set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete inner_product_param_; + } + if (inner_product_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::InnerProductParameter>::GetOwningArena(inner_product_param); + if (message_arena != submessage_arena) { + inner_product_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, inner_product_param, submessage_arena); + } + _has_bits_[0] |= 0x00080000u; + } else { + _has_bits_[0] &= ~0x00080000u; + } + 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::_internal_has_input_param() const { + bool value = (_has_bits_[1] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || input_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_input_param() const { + return _internal_has_input_param(); +} +inline void LayerParameter::clear_input_param() { + if (input_param_ != nullptr) input_param_->Clear(); + _has_bits_[1] &= ~0x00002000u; +} +inline const ::opencv_caffe::InputParameter& LayerParameter::_internal_input_param() const { + const ::opencv_caffe::InputParameter* p = input_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_InputParameter_default_instance_); +} +inline const ::opencv_caffe::InputParameter& LayerParameter::input_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.input_param) + return _internal_input_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_input_param( + ::opencv_caffe::InputParameter* input_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_param_); + } + input_param_ = input_param; + if (input_param) { + _has_bits_[1] |= 0x00002000u; + } else { + _has_bits_[1] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.input_param) +} +inline ::opencv_caffe::InputParameter* LayerParameter::release_input_param() { + _has_bits_[1] &= ~0x00002000u; + ::opencv_caffe::InputParameter* temp = input_param_; + input_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::InputParameter* LayerParameter::unsafe_arena_release_input_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.input_param) + _has_bits_[1] &= ~0x00002000u; + ::opencv_caffe::InputParameter* temp = input_param_; + input_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::InputParameter* LayerParameter::_internal_mutable_input_param() { + _has_bits_[1] |= 0x00002000u; + if (input_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::InputParameter>(GetArenaForAllocation()); + input_param_ = p; + } + return input_param_; +} +inline ::opencv_caffe::InputParameter* LayerParameter::mutable_input_param() { + ::opencv_caffe::InputParameter* _msg = _internal_mutable_input_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.input_param) + return _msg; +} +inline void LayerParameter::set_allocated_input_param(::opencv_caffe::InputParameter* input_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete input_param_; + } + if (input_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::InputParameter>::GetOwningArena(input_param); + if (message_arena != submessage_arena) { + input_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input_param, submessage_arena); + } + _has_bits_[1] |= 0x00002000u; + } else { + _has_bits_[1] &= ~0x00002000u; + } + 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::_internal_has_log_param() const { + bool value = (_has_bits_[1] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || log_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_log_param() const { + return _internal_has_log_param(); +} +inline void LayerParameter::clear_log_param() { + if (log_param_ != nullptr) log_param_->Clear(); + _has_bits_[1] &= ~0x00000010u; +} +inline const ::opencv_caffe::LogParameter& LayerParameter::_internal_log_param() const { + const ::opencv_caffe::LogParameter* p = log_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_LogParameter_default_instance_); +} +inline const ::opencv_caffe::LogParameter& LayerParameter::log_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.log_param) + return _internal_log_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_log_param( + ::opencv_caffe::LogParameter* log_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(log_param_); + } + log_param_ = log_param; + if (log_param) { + _has_bits_[1] |= 0x00000010u; + } else { + _has_bits_[1] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.log_param) +} +inline ::opencv_caffe::LogParameter* LayerParameter::release_log_param() { + _has_bits_[1] &= ~0x00000010u; + ::opencv_caffe::LogParameter* temp = log_param_; + log_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::LogParameter* LayerParameter::unsafe_arena_release_log_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.log_param) + _has_bits_[1] &= ~0x00000010u; + ::opencv_caffe::LogParameter* temp = log_param_; + log_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::LogParameter* LayerParameter::_internal_mutable_log_param() { + _has_bits_[1] |= 0x00000010u; + if (log_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::LogParameter>(GetArenaForAllocation()); + log_param_ = p; + } + return log_param_; +} +inline ::opencv_caffe::LogParameter* LayerParameter::mutable_log_param() { + ::opencv_caffe::LogParameter* _msg = _internal_mutable_log_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.log_param) + return _msg; +} +inline void LayerParameter::set_allocated_log_param(::opencv_caffe::LogParameter* log_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete log_param_; + } + if (log_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::LogParameter>::GetOwningArena(log_param); + if (message_arena != submessage_arena) { + log_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, log_param, submessage_arena); + } + _has_bits_[1] |= 0x00000010u; + } else { + _has_bits_[1] &= ~0x00000010u; + } + 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::_internal_has_lrn_param() const { + bool value = (_has_bits_[0] & 0x00100000u) != 0; + PROTOBUF_ASSUME(!value || lrn_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_lrn_param() const { + return _internal_has_lrn_param(); +} +inline void LayerParameter::clear_lrn_param() { + if (lrn_param_ != nullptr) lrn_param_->Clear(); + _has_bits_[0] &= ~0x00100000u; +} +inline const ::opencv_caffe::LRNParameter& LayerParameter::_internal_lrn_param() const { + const ::opencv_caffe::LRNParameter* p = lrn_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_LRNParameter_default_instance_); +} +inline const ::opencv_caffe::LRNParameter& LayerParameter::lrn_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.lrn_param) + return _internal_lrn_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_lrn_param( + ::opencv_caffe::LRNParameter* lrn_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lrn_param_); + } + lrn_param_ = lrn_param; + if (lrn_param) { + _has_bits_[0] |= 0x00100000u; + } else { + _has_bits_[0] &= ~0x00100000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.lrn_param) +} +inline ::opencv_caffe::LRNParameter* LayerParameter::release_lrn_param() { + _has_bits_[0] &= ~0x00100000u; + ::opencv_caffe::LRNParameter* temp = lrn_param_; + lrn_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::LRNParameter* LayerParameter::unsafe_arena_release_lrn_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.lrn_param) + _has_bits_[0] &= ~0x00100000u; + ::opencv_caffe::LRNParameter* temp = lrn_param_; + lrn_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::LRNParameter* LayerParameter::_internal_mutable_lrn_param() { + _has_bits_[0] |= 0x00100000u; + if (lrn_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::LRNParameter>(GetArenaForAllocation()); + lrn_param_ = p; + } + return lrn_param_; +} +inline ::opencv_caffe::LRNParameter* LayerParameter::mutable_lrn_param() { + ::opencv_caffe::LRNParameter* _msg = _internal_mutable_lrn_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.lrn_param) + return _msg; +} +inline void LayerParameter::set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete lrn_param_; + } + if (lrn_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::LRNParameter>::GetOwningArena(lrn_param); + if (message_arena != submessage_arena) { + lrn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, lrn_param, submessage_arena); + } + _has_bits_[0] |= 0x00100000u; + } else { + _has_bits_[0] &= ~0x00100000u; + } + 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::_internal_has_memory_data_param() const { + bool value = (_has_bits_[0] & 0x00200000u) != 0; + PROTOBUF_ASSUME(!value || memory_data_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_memory_data_param() const { + return _internal_has_memory_data_param(); +} +inline void LayerParameter::clear_memory_data_param() { + if (memory_data_param_ != nullptr) memory_data_param_->Clear(); + _has_bits_[0] &= ~0x00200000u; +} +inline const ::opencv_caffe::MemoryDataParameter& LayerParameter::_internal_memory_data_param() const { + const ::opencv_caffe::MemoryDataParameter* p = memory_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_MemoryDataParameter_default_instance_); +} +inline const ::opencv_caffe::MemoryDataParameter& LayerParameter::memory_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.memory_data_param) + return _internal_memory_data_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_memory_data_param( + ::opencv_caffe::MemoryDataParameter* memory_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(memory_data_param_); + } + memory_data_param_ = memory_data_param; + if (memory_data_param) { + _has_bits_[0] |= 0x00200000u; + } else { + _has_bits_[0] &= ~0x00200000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.memory_data_param) +} +inline ::opencv_caffe::MemoryDataParameter* LayerParameter::release_memory_data_param() { + _has_bits_[0] &= ~0x00200000u; + ::opencv_caffe::MemoryDataParameter* temp = memory_data_param_; + memory_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::MemoryDataParameter* LayerParameter::unsafe_arena_release_memory_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.memory_data_param) + _has_bits_[0] &= ~0x00200000u; + ::opencv_caffe::MemoryDataParameter* temp = memory_data_param_; + memory_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::MemoryDataParameter* LayerParameter::_internal_mutable_memory_data_param() { + _has_bits_[0] |= 0x00200000u; + if (memory_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::MemoryDataParameter>(GetArenaForAllocation()); + memory_data_param_ = p; + } + return memory_data_param_; +} +inline ::opencv_caffe::MemoryDataParameter* LayerParameter::mutable_memory_data_param() { + ::opencv_caffe::MemoryDataParameter* _msg = _internal_mutable_memory_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.memory_data_param) + return _msg; +} +inline void LayerParameter::set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete memory_data_param_; + } + if (memory_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::MemoryDataParameter>::GetOwningArena(memory_data_param); + if (message_arena != submessage_arena) { + memory_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, memory_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00200000u; + } else { + _has_bits_[0] &= ~0x00200000u; + } + 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::_internal_has_mvn_param() const { + bool value = (_has_bits_[0] & 0x00400000u) != 0; + PROTOBUF_ASSUME(!value || mvn_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_mvn_param() const { + return _internal_has_mvn_param(); +} +inline void LayerParameter::clear_mvn_param() { + if (mvn_param_ != nullptr) mvn_param_->Clear(); + _has_bits_[0] &= ~0x00400000u; +} +inline const ::opencv_caffe::MVNParameter& LayerParameter::_internal_mvn_param() const { + const ::opencv_caffe::MVNParameter* p = mvn_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_MVNParameter_default_instance_); +} +inline const ::opencv_caffe::MVNParameter& LayerParameter::mvn_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.mvn_param) + return _internal_mvn_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_mvn_param( + ::opencv_caffe::MVNParameter* mvn_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mvn_param_); + } + mvn_param_ = mvn_param; + if (mvn_param) { + _has_bits_[0] |= 0x00400000u; + } else { + _has_bits_[0] &= ~0x00400000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.mvn_param) +} +inline ::opencv_caffe::MVNParameter* LayerParameter::release_mvn_param() { + _has_bits_[0] &= ~0x00400000u; + ::opencv_caffe::MVNParameter* temp = mvn_param_; + mvn_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::MVNParameter* LayerParameter::unsafe_arena_release_mvn_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.mvn_param) + _has_bits_[0] &= ~0x00400000u; + ::opencv_caffe::MVNParameter* temp = mvn_param_; + mvn_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::MVNParameter* LayerParameter::_internal_mutable_mvn_param() { + _has_bits_[0] |= 0x00400000u; + if (mvn_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::MVNParameter>(GetArenaForAllocation()); + mvn_param_ = p; + } + return mvn_param_; +} +inline ::opencv_caffe::MVNParameter* LayerParameter::mutable_mvn_param() { + ::opencv_caffe::MVNParameter* _msg = _internal_mutable_mvn_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.mvn_param) + return _msg; +} +inline void LayerParameter::set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete mvn_param_; + } + if (mvn_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::MVNParameter>::GetOwningArena(mvn_param); + if (message_arena != submessage_arena) { + mvn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, mvn_param, submessage_arena); + } + _has_bits_[0] |= 0x00400000u; + } else { + _has_bits_[0] &= ~0x00400000u; + } + 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::_internal_has_norm_param() const { + bool value = (_has_bits_[1] & 0x00080000u) != 0; + PROTOBUF_ASSUME(!value || norm_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_norm_param() const { + return _internal_has_norm_param(); +} +inline void LayerParameter::clear_norm_param() { + if (norm_param_ != nullptr) norm_param_->Clear(); + _has_bits_[1] &= ~0x00080000u; +} +inline const ::opencv_caffe::NormalizeBBoxParameter& LayerParameter::_internal_norm_param() const { + const ::opencv_caffe::NormalizeBBoxParameter* p = norm_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_NormalizeBBoxParameter_default_instance_); +} +inline const ::opencv_caffe::NormalizeBBoxParameter& LayerParameter::norm_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.norm_param) + return _internal_norm_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_norm_param( + ::opencv_caffe::NormalizeBBoxParameter* norm_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(norm_param_); + } + norm_param_ = norm_param; + if (norm_param) { + _has_bits_[1] |= 0x00080000u; + } else { + _has_bits_[1] &= ~0x00080000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.norm_param) +} +inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::release_norm_param() { + _has_bits_[1] &= ~0x00080000u; + ::opencv_caffe::NormalizeBBoxParameter* temp = norm_param_; + norm_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::unsafe_arena_release_norm_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.norm_param) + _has_bits_[1] &= ~0x00080000u; + ::opencv_caffe::NormalizeBBoxParameter* temp = norm_param_; + norm_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::_internal_mutable_norm_param() { + _has_bits_[1] |= 0x00080000u; + if (norm_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::NormalizeBBoxParameter>(GetArenaForAllocation()); + norm_param_ = p; + } + return norm_param_; +} +inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::mutable_norm_param() { + ::opencv_caffe::NormalizeBBoxParameter* _msg = _internal_mutable_norm_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.norm_param) + return _msg; +} +inline void LayerParameter::set_allocated_norm_param(::opencv_caffe::NormalizeBBoxParameter* norm_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete norm_param_; + } + if (norm_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::NormalizeBBoxParameter>::GetOwningArena(norm_param); + if (message_arena != submessage_arena) { + norm_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, norm_param, submessage_arena); + } + _has_bits_[1] |= 0x00080000u; + } else { + _has_bits_[1] &= ~0x00080000u; + } + 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::_internal_has_permute_param() const { + bool value = (_has_bits_[1] & 0x00040000u) != 0; + PROTOBUF_ASSUME(!value || permute_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_permute_param() const { + return _internal_has_permute_param(); +} +inline void LayerParameter::clear_permute_param() { + if (permute_param_ != nullptr) permute_param_->Clear(); + _has_bits_[1] &= ~0x00040000u; +} +inline const ::opencv_caffe::PermuteParameter& LayerParameter::_internal_permute_param() const { + const ::opencv_caffe::PermuteParameter* p = permute_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PermuteParameter_default_instance_); +} +inline const ::opencv_caffe::PermuteParameter& LayerParameter::permute_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.permute_param) + return _internal_permute_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_permute_param( + ::opencv_caffe::PermuteParameter* permute_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(permute_param_); + } + permute_param_ = permute_param; + if (permute_param) { + _has_bits_[1] |= 0x00040000u; + } else { + _has_bits_[1] &= ~0x00040000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.permute_param) +} +inline ::opencv_caffe::PermuteParameter* LayerParameter::release_permute_param() { + _has_bits_[1] &= ~0x00040000u; + ::opencv_caffe::PermuteParameter* temp = permute_param_; + permute_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PermuteParameter* LayerParameter::unsafe_arena_release_permute_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.permute_param) + _has_bits_[1] &= ~0x00040000u; + ::opencv_caffe::PermuteParameter* temp = permute_param_; + permute_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PermuteParameter* LayerParameter::_internal_mutable_permute_param() { + _has_bits_[1] |= 0x00040000u; + if (permute_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PermuteParameter>(GetArenaForAllocation()); + permute_param_ = p; + } + return permute_param_; +} +inline ::opencv_caffe::PermuteParameter* LayerParameter::mutable_permute_param() { + ::opencv_caffe::PermuteParameter* _msg = _internal_mutable_permute_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.permute_param) + return _msg; +} +inline void LayerParameter::set_allocated_permute_param(::opencv_caffe::PermuteParameter* permute_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete permute_param_; + } + if (permute_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PermuteParameter>::GetOwningArena(permute_param); + if (message_arena != submessage_arena) { + permute_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, permute_param, submessage_arena); + } + _has_bits_[1] |= 0x00040000u; + } else { + _has_bits_[1] &= ~0x00040000u; + } + 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::_internal_has_parameter_param() const { + bool value = (_has_bits_[1] & 0x00008000u) != 0; + PROTOBUF_ASSUME(!value || parameter_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_parameter_param() const { + return _internal_has_parameter_param(); +} +inline void LayerParameter::clear_parameter_param() { + if (parameter_param_ != nullptr) parameter_param_->Clear(); + _has_bits_[1] &= ~0x00008000u; +} +inline const ::opencv_caffe::ParameterParameter& LayerParameter::_internal_parameter_param() const { + const ::opencv_caffe::ParameterParameter* p = parameter_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ParameterParameter_default_instance_); +} +inline const ::opencv_caffe::ParameterParameter& LayerParameter::parameter_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.parameter_param) + return _internal_parameter_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_parameter_param( + ::opencv_caffe::ParameterParameter* parameter_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameter_param_); + } + parameter_param_ = parameter_param; + if (parameter_param) { + _has_bits_[1] |= 0x00008000u; + } else { + _has_bits_[1] &= ~0x00008000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.parameter_param) +} +inline ::opencv_caffe::ParameterParameter* LayerParameter::release_parameter_param() { + _has_bits_[1] &= ~0x00008000u; + ::opencv_caffe::ParameterParameter* temp = parameter_param_; + parameter_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ParameterParameter* LayerParameter::unsafe_arena_release_parameter_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.parameter_param) + _has_bits_[1] &= ~0x00008000u; + ::opencv_caffe::ParameterParameter* temp = parameter_param_; + parameter_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ParameterParameter* LayerParameter::_internal_mutable_parameter_param() { + _has_bits_[1] |= 0x00008000u; + if (parameter_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ParameterParameter>(GetArenaForAllocation()); + parameter_param_ = p; + } + return parameter_param_; +} +inline ::opencv_caffe::ParameterParameter* LayerParameter::mutable_parameter_param() { + ::opencv_caffe::ParameterParameter* _msg = _internal_mutable_parameter_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.parameter_param) + return _msg; +} +inline void LayerParameter::set_allocated_parameter_param(::opencv_caffe::ParameterParameter* parameter_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete parameter_param_; + } + if (parameter_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ParameterParameter>::GetOwningArena(parameter_param); + if (message_arena != submessage_arena) { + parameter_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, parameter_param, submessage_arena); + } + _has_bits_[1] |= 0x00008000u; + } else { + _has_bits_[1] &= ~0x00008000u; + } + 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::_internal_has_pooling_param() const { + bool value = (_has_bits_[0] & 0x00800000u) != 0; + PROTOBUF_ASSUME(!value || pooling_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_pooling_param() const { + return _internal_has_pooling_param(); +} +inline void LayerParameter::clear_pooling_param() { + if (pooling_param_ != nullptr) pooling_param_->Clear(); + _has_bits_[0] &= ~0x00800000u; +} +inline const ::opencv_caffe::PoolingParameter& LayerParameter::_internal_pooling_param() const { + const ::opencv_caffe::PoolingParameter* p = pooling_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PoolingParameter_default_instance_); +} +inline const ::opencv_caffe::PoolingParameter& LayerParameter::pooling_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.pooling_param) + return _internal_pooling_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_pooling_param( + ::opencv_caffe::PoolingParameter* pooling_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pooling_param_); + } + pooling_param_ = pooling_param; + if (pooling_param) { + _has_bits_[0] |= 0x00800000u; + } else { + _has_bits_[0] &= ~0x00800000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.pooling_param) +} +inline ::opencv_caffe::PoolingParameter* LayerParameter::release_pooling_param() { + _has_bits_[0] &= ~0x00800000u; + ::opencv_caffe::PoolingParameter* temp = pooling_param_; + pooling_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PoolingParameter* LayerParameter::unsafe_arena_release_pooling_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.pooling_param) + _has_bits_[0] &= ~0x00800000u; + ::opencv_caffe::PoolingParameter* temp = pooling_param_; + pooling_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PoolingParameter* LayerParameter::_internal_mutable_pooling_param() { + _has_bits_[0] |= 0x00800000u; + if (pooling_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PoolingParameter>(GetArenaForAllocation()); + pooling_param_ = p; + } + return pooling_param_; +} +inline ::opencv_caffe::PoolingParameter* LayerParameter::mutable_pooling_param() { + ::opencv_caffe::PoolingParameter* _msg = _internal_mutable_pooling_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.pooling_param) + return _msg; +} +inline void LayerParameter::set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete pooling_param_; + } + if (pooling_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PoolingParameter>::GetOwningArena(pooling_param); + if (message_arena != submessage_arena) { + pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pooling_param, submessage_arena); + } + _has_bits_[0] |= 0x00800000u; + } else { + _has_bits_[0] &= ~0x00800000u; + } + 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::_internal_has_power_param() const { + bool value = (_has_bits_[0] & 0x01000000u) != 0; + PROTOBUF_ASSUME(!value || power_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_power_param() const { + return _internal_has_power_param(); +} +inline void LayerParameter::clear_power_param() { + if (power_param_ != nullptr) power_param_->Clear(); + _has_bits_[0] &= ~0x01000000u; +} +inline const ::opencv_caffe::PowerParameter& LayerParameter::_internal_power_param() const { + const ::opencv_caffe::PowerParameter* p = power_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PowerParameter_default_instance_); +} +inline const ::opencv_caffe::PowerParameter& LayerParameter::power_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.power_param) + return _internal_power_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_power_param( + ::opencv_caffe::PowerParameter* power_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(power_param_); + } + power_param_ = power_param; + if (power_param) { + _has_bits_[0] |= 0x01000000u; + } else { + _has_bits_[0] &= ~0x01000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.power_param) +} +inline ::opencv_caffe::PowerParameter* LayerParameter::release_power_param() { + _has_bits_[0] &= ~0x01000000u; + ::opencv_caffe::PowerParameter* temp = power_param_; + power_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PowerParameter* LayerParameter::unsafe_arena_release_power_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.power_param) + _has_bits_[0] &= ~0x01000000u; + ::opencv_caffe::PowerParameter* temp = power_param_; + power_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PowerParameter* LayerParameter::_internal_mutable_power_param() { + _has_bits_[0] |= 0x01000000u; + if (power_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PowerParameter>(GetArenaForAllocation()); + power_param_ = p; + } + return power_param_; +} +inline ::opencv_caffe::PowerParameter* LayerParameter::mutable_power_param() { + ::opencv_caffe::PowerParameter* _msg = _internal_mutable_power_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.power_param) + return _msg; +} +inline void LayerParameter::set_allocated_power_param(::opencv_caffe::PowerParameter* power_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete power_param_; + } + if (power_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PowerParameter>::GetOwningArena(power_param); + if (message_arena != submessage_arena) { + power_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, power_param, submessage_arena); + } + _has_bits_[0] |= 0x01000000u; + } else { + _has_bits_[0] &= ~0x01000000u; + } + 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::_internal_has_prelu_param() const { + bool value = (_has_bits_[1] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || prelu_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_prelu_param() const { + return _internal_has_prelu_param(); +} +inline void LayerParameter::clear_prelu_param() { + if (prelu_param_ != nullptr) prelu_param_->Clear(); + _has_bits_[1] &= ~0x00000002u; +} +inline const ::opencv_caffe::PReLUParameter& LayerParameter::_internal_prelu_param() const { + const ::opencv_caffe::PReLUParameter* p = prelu_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PReLUParameter_default_instance_); +} +inline const ::opencv_caffe::PReLUParameter& LayerParameter::prelu_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.prelu_param) + return _internal_prelu_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_prelu_param( + ::opencv_caffe::PReLUParameter* prelu_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(prelu_param_); + } + prelu_param_ = prelu_param; + if (prelu_param) { + _has_bits_[1] |= 0x00000002u; + } else { + _has_bits_[1] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.prelu_param) +} +inline ::opencv_caffe::PReLUParameter* LayerParameter::release_prelu_param() { + _has_bits_[1] &= ~0x00000002u; + ::opencv_caffe::PReLUParameter* temp = prelu_param_; + prelu_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PReLUParameter* LayerParameter::unsafe_arena_release_prelu_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.prelu_param) + _has_bits_[1] &= ~0x00000002u; + ::opencv_caffe::PReLUParameter* temp = prelu_param_; + prelu_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PReLUParameter* LayerParameter::_internal_mutable_prelu_param() { + _has_bits_[1] |= 0x00000002u; + if (prelu_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PReLUParameter>(GetArenaForAllocation()); + prelu_param_ = p; + } + return prelu_param_; +} +inline ::opencv_caffe::PReLUParameter* LayerParameter::mutable_prelu_param() { + ::opencv_caffe::PReLUParameter* _msg = _internal_mutable_prelu_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.prelu_param) + return _msg; +} +inline void LayerParameter::set_allocated_prelu_param(::opencv_caffe::PReLUParameter* prelu_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete prelu_param_; + } + if (prelu_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PReLUParameter>::GetOwningArena(prelu_param); + if (message_arena != submessage_arena) { + prelu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, prelu_param, submessage_arena); + } + _has_bits_[1] |= 0x00000002u; + } else { + _has_bits_[1] &= ~0x00000002u; + } + 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::_internal_has_prior_box_param() const { + bool value = (_has_bits_[1] & 0x00100000u) != 0; + PROTOBUF_ASSUME(!value || prior_box_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_prior_box_param() const { + return _internal_has_prior_box_param(); +} +inline void LayerParameter::clear_prior_box_param() { + if (prior_box_param_ != nullptr) prior_box_param_->Clear(); + _has_bits_[1] &= ~0x00100000u; +} +inline const ::opencv_caffe::PriorBoxParameter& LayerParameter::_internal_prior_box_param() const { + const ::opencv_caffe::PriorBoxParameter* p = prior_box_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PriorBoxParameter_default_instance_); +} +inline const ::opencv_caffe::PriorBoxParameter& LayerParameter::prior_box_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.prior_box_param) + return _internal_prior_box_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_prior_box_param( + ::opencv_caffe::PriorBoxParameter* prior_box_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(prior_box_param_); + } + prior_box_param_ = prior_box_param; + if (prior_box_param) { + _has_bits_[1] |= 0x00100000u; + } else { + _has_bits_[1] &= ~0x00100000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.prior_box_param) +} +inline ::opencv_caffe::PriorBoxParameter* LayerParameter::release_prior_box_param() { + _has_bits_[1] &= ~0x00100000u; + ::opencv_caffe::PriorBoxParameter* temp = prior_box_param_; + prior_box_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PriorBoxParameter* LayerParameter::unsafe_arena_release_prior_box_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.prior_box_param) + _has_bits_[1] &= ~0x00100000u; + ::opencv_caffe::PriorBoxParameter* temp = prior_box_param_; + prior_box_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PriorBoxParameter* LayerParameter::_internal_mutable_prior_box_param() { + _has_bits_[1] |= 0x00100000u; + if (prior_box_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PriorBoxParameter>(GetArenaForAllocation()); + prior_box_param_ = p; + } + return prior_box_param_; +} +inline ::opencv_caffe::PriorBoxParameter* LayerParameter::mutable_prior_box_param() { + ::opencv_caffe::PriorBoxParameter* _msg = _internal_mutable_prior_box_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.prior_box_param) + return _msg; +} +inline void LayerParameter::set_allocated_prior_box_param(::opencv_caffe::PriorBoxParameter* prior_box_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete prior_box_param_; + } + if (prior_box_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PriorBoxParameter>::GetOwningArena(prior_box_param); + if (message_arena != submessage_arena) { + prior_box_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, prior_box_param, submessage_arena); + } + _has_bits_[1] |= 0x00100000u; + } else { + _has_bits_[1] &= ~0x00100000u; + } + 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::_internal_has_proposal_param() const { + bool value = (_has_bits_[1] & 0x00200000u) != 0; + PROTOBUF_ASSUME(!value || proposal_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_proposal_param() const { + return _internal_has_proposal_param(); +} +inline void LayerParameter::clear_proposal_param() { + if (proposal_param_ != nullptr) proposal_param_->Clear(); + _has_bits_[1] &= ~0x00200000u; +} +inline const ::opencv_caffe::ProposalParameter& LayerParameter::_internal_proposal_param() const { + const ::opencv_caffe::ProposalParameter* p = proposal_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ProposalParameter_default_instance_); +} +inline const ::opencv_caffe::ProposalParameter& LayerParameter::proposal_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.proposal_param) + return _internal_proposal_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_proposal_param( + ::opencv_caffe::ProposalParameter* proposal_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(proposal_param_); + } + proposal_param_ = proposal_param; + if (proposal_param) { + _has_bits_[1] |= 0x00200000u; + } else { + _has_bits_[1] &= ~0x00200000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.proposal_param) +} +inline ::opencv_caffe::ProposalParameter* LayerParameter::release_proposal_param() { + _has_bits_[1] &= ~0x00200000u; + ::opencv_caffe::ProposalParameter* temp = proposal_param_; + proposal_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ProposalParameter* LayerParameter::unsafe_arena_release_proposal_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.proposal_param) + _has_bits_[1] &= ~0x00200000u; + ::opencv_caffe::ProposalParameter* temp = proposal_param_; + proposal_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ProposalParameter* LayerParameter::_internal_mutable_proposal_param() { + _has_bits_[1] |= 0x00200000u; + if (proposal_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ProposalParameter>(GetArenaForAllocation()); + proposal_param_ = p; + } + return proposal_param_; +} +inline ::opencv_caffe::ProposalParameter* LayerParameter::mutable_proposal_param() { + ::opencv_caffe::ProposalParameter* _msg = _internal_mutable_proposal_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.proposal_param) + return _msg; +} +inline void LayerParameter::set_allocated_proposal_param(::opencv_caffe::ProposalParameter* proposal_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete proposal_param_; + } + if (proposal_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ProposalParameter>::GetOwningArena(proposal_param); + if (message_arena != submessage_arena) { + proposal_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, proposal_param, submessage_arena); + } + _has_bits_[1] |= 0x00200000u; + } else { + _has_bits_[1] &= ~0x00200000u; + } + 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::_internal_has_psroi_pooling_param() const { + bool value = (_has_bits_[1] & 0x00400000u) != 0; + PROTOBUF_ASSUME(!value || psroi_pooling_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_psroi_pooling_param() const { + return _internal_has_psroi_pooling_param(); +} +inline void LayerParameter::clear_psroi_pooling_param() { + if (psroi_pooling_param_ != nullptr) psroi_pooling_param_->Clear(); + _has_bits_[1] &= ~0x00400000u; +} +inline const ::opencv_caffe::PSROIPoolingParameter& LayerParameter::_internal_psroi_pooling_param() const { + const ::opencv_caffe::PSROIPoolingParameter* p = psroi_pooling_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PSROIPoolingParameter_default_instance_); +} +inline const ::opencv_caffe::PSROIPoolingParameter& LayerParameter::psroi_pooling_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.psroi_pooling_param) + return _internal_psroi_pooling_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_psroi_pooling_param( + ::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(psroi_pooling_param_); + } + psroi_pooling_param_ = psroi_pooling_param; + if (psroi_pooling_param) { + _has_bits_[1] |= 0x00400000u; + } else { + _has_bits_[1] &= ~0x00400000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.psroi_pooling_param) +} +inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::release_psroi_pooling_param() { + _has_bits_[1] &= ~0x00400000u; + ::opencv_caffe::PSROIPoolingParameter* temp = psroi_pooling_param_; + psroi_pooling_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::unsafe_arena_release_psroi_pooling_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.psroi_pooling_param) + _has_bits_[1] &= ~0x00400000u; + ::opencv_caffe::PSROIPoolingParameter* temp = psroi_pooling_param_; + psroi_pooling_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::_internal_mutable_psroi_pooling_param() { + _has_bits_[1] |= 0x00400000u; + if (psroi_pooling_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PSROIPoolingParameter>(GetArenaForAllocation()); + psroi_pooling_param_ = p; + } + return psroi_pooling_param_; +} +inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::mutable_psroi_pooling_param() { + ::opencv_caffe::PSROIPoolingParameter* _msg = _internal_mutable_psroi_pooling_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.psroi_pooling_param) + return _msg; +} +inline void LayerParameter::set_allocated_psroi_pooling_param(::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete psroi_pooling_param_; + } + if (psroi_pooling_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PSROIPoolingParameter>::GetOwningArena(psroi_pooling_param); + if (message_arena != submessage_arena) { + psroi_pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, psroi_pooling_param, submessage_arena); + } + _has_bits_[1] |= 0x00400000u; + } else { + _has_bits_[1] &= ~0x00400000u; + } + 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::_internal_has_python_param() const { + bool value = (_has_bits_[1] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || python_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_python_param() const { + return _internal_has_python_param(); +} +inline void LayerParameter::clear_python_param() { + if (python_param_ != nullptr) python_param_->Clear(); + _has_bits_[1] &= ~0x00000001u; +} +inline const ::opencv_caffe::PythonParameter& LayerParameter::_internal_python_param() const { + const ::opencv_caffe::PythonParameter* p = python_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PythonParameter_default_instance_); +} +inline const ::opencv_caffe::PythonParameter& LayerParameter::python_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.python_param) + return _internal_python_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_python_param( + ::opencv_caffe::PythonParameter* python_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(python_param_); + } + python_param_ = python_param; + if (python_param) { + _has_bits_[1] |= 0x00000001u; + } else { + _has_bits_[1] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.python_param) +} +inline ::opencv_caffe::PythonParameter* LayerParameter::release_python_param() { + _has_bits_[1] &= ~0x00000001u; + ::opencv_caffe::PythonParameter* temp = python_param_; + python_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PythonParameter* LayerParameter::unsafe_arena_release_python_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.python_param) + _has_bits_[1] &= ~0x00000001u; + ::opencv_caffe::PythonParameter* temp = python_param_; + python_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PythonParameter* LayerParameter::_internal_mutable_python_param() { + _has_bits_[1] |= 0x00000001u; + if (python_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PythonParameter>(GetArenaForAllocation()); + python_param_ = p; + } + return python_param_; +} +inline ::opencv_caffe::PythonParameter* LayerParameter::mutable_python_param() { + ::opencv_caffe::PythonParameter* _msg = _internal_mutable_python_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.python_param) + return _msg; +} +inline void LayerParameter::set_allocated_python_param(::opencv_caffe::PythonParameter* python_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete python_param_; + } + if (python_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PythonParameter>::GetOwningArena(python_param); + if (message_arena != submessage_arena) { + python_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, python_param, submessage_arena); + } + _has_bits_[1] |= 0x00000001u; + } else { + _has_bits_[1] &= ~0x00000001u; + } + 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::_internal_has_recurrent_param() const { + bool value = (_has_bits_[1] & 0x00010000u) != 0; + PROTOBUF_ASSUME(!value || recurrent_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_recurrent_param() const { + return _internal_has_recurrent_param(); +} +inline void LayerParameter::clear_recurrent_param() { + if (recurrent_param_ != nullptr) recurrent_param_->Clear(); + _has_bits_[1] &= ~0x00010000u; +} +inline const ::opencv_caffe::RecurrentParameter& LayerParameter::_internal_recurrent_param() const { + const ::opencv_caffe::RecurrentParameter* p = recurrent_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_RecurrentParameter_default_instance_); +} +inline const ::opencv_caffe::RecurrentParameter& LayerParameter::recurrent_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.recurrent_param) + return _internal_recurrent_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_recurrent_param( + ::opencv_caffe::RecurrentParameter* recurrent_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(recurrent_param_); + } + recurrent_param_ = recurrent_param; + if (recurrent_param) { + _has_bits_[1] |= 0x00010000u; + } else { + _has_bits_[1] &= ~0x00010000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.recurrent_param) +} +inline ::opencv_caffe::RecurrentParameter* LayerParameter::release_recurrent_param() { + _has_bits_[1] &= ~0x00010000u; + ::opencv_caffe::RecurrentParameter* temp = recurrent_param_; + recurrent_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::RecurrentParameter* LayerParameter::unsafe_arena_release_recurrent_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.recurrent_param) + _has_bits_[1] &= ~0x00010000u; + ::opencv_caffe::RecurrentParameter* temp = recurrent_param_; + recurrent_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::RecurrentParameter* LayerParameter::_internal_mutable_recurrent_param() { + _has_bits_[1] |= 0x00010000u; + if (recurrent_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::RecurrentParameter>(GetArenaForAllocation()); + recurrent_param_ = p; + } + return recurrent_param_; +} +inline ::opencv_caffe::RecurrentParameter* LayerParameter::mutable_recurrent_param() { + ::opencv_caffe::RecurrentParameter* _msg = _internal_mutable_recurrent_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.recurrent_param) + return _msg; +} +inline void LayerParameter::set_allocated_recurrent_param(::opencv_caffe::RecurrentParameter* recurrent_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete recurrent_param_; + } + if (recurrent_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::RecurrentParameter>::GetOwningArena(recurrent_param); + if (message_arena != submessage_arena) { + recurrent_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, recurrent_param, submessage_arena); + } + _has_bits_[1] |= 0x00010000u; + } else { + _has_bits_[1] &= ~0x00010000u; + } + 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::_internal_has_reduction_param() const { + bool value = (_has_bits_[1] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || reduction_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_reduction_param() const { + return _internal_has_reduction_param(); +} +inline void LayerParameter::clear_reduction_param() { + if (reduction_param_ != nullptr) reduction_param_->Clear(); + _has_bits_[1] &= ~0x00000040u; +} +inline const ::opencv_caffe::ReductionParameter& LayerParameter::_internal_reduction_param() const { + const ::opencv_caffe::ReductionParameter* p = reduction_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ReductionParameter_default_instance_); +} +inline const ::opencv_caffe::ReductionParameter& LayerParameter::reduction_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.reduction_param) + return _internal_reduction_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_reduction_param( + ::opencv_caffe::ReductionParameter* reduction_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reduction_param_); + } + reduction_param_ = reduction_param; + if (reduction_param) { + _has_bits_[1] |= 0x00000040u; + } else { + _has_bits_[1] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.reduction_param) +} +inline ::opencv_caffe::ReductionParameter* LayerParameter::release_reduction_param() { + _has_bits_[1] &= ~0x00000040u; + ::opencv_caffe::ReductionParameter* temp = reduction_param_; + reduction_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ReductionParameter* LayerParameter::unsafe_arena_release_reduction_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.reduction_param) + _has_bits_[1] &= ~0x00000040u; + ::opencv_caffe::ReductionParameter* temp = reduction_param_; + reduction_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ReductionParameter* LayerParameter::_internal_mutable_reduction_param() { + _has_bits_[1] |= 0x00000040u; + if (reduction_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ReductionParameter>(GetArenaForAllocation()); + reduction_param_ = p; + } + return reduction_param_; +} +inline ::opencv_caffe::ReductionParameter* LayerParameter::mutable_reduction_param() { + ::opencv_caffe::ReductionParameter* _msg = _internal_mutable_reduction_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.reduction_param) + return _msg; +} +inline void LayerParameter::set_allocated_reduction_param(::opencv_caffe::ReductionParameter* reduction_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reduction_param_; + } + if (reduction_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ReductionParameter>::GetOwningArena(reduction_param); + if (message_arena != submessage_arena) { + reduction_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, reduction_param, submessage_arena); + } + _has_bits_[1] |= 0x00000040u; + } else { + _has_bits_[1] &= ~0x00000040u; + } + 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::_internal_has_relu_param() const { + bool value = (_has_bits_[0] & 0x02000000u) != 0; + PROTOBUF_ASSUME(!value || relu_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_relu_param() const { + return _internal_has_relu_param(); +} +inline void LayerParameter::clear_relu_param() { + if (relu_param_ != nullptr) relu_param_->Clear(); + _has_bits_[0] &= ~0x02000000u; +} +inline const ::opencv_caffe::ReLUParameter& LayerParameter::_internal_relu_param() const { + const ::opencv_caffe::ReLUParameter* p = relu_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ReLUParameter_default_instance_); +} +inline const ::opencv_caffe::ReLUParameter& LayerParameter::relu_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.relu_param) + return _internal_relu_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_relu_param( + ::opencv_caffe::ReLUParameter* relu_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relu_param_); + } + relu_param_ = relu_param; + if (relu_param) { + _has_bits_[0] |= 0x02000000u; + } else { + _has_bits_[0] &= ~0x02000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.relu_param) +} +inline ::opencv_caffe::ReLUParameter* LayerParameter::release_relu_param() { + _has_bits_[0] &= ~0x02000000u; + ::opencv_caffe::ReLUParameter* temp = relu_param_; + relu_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ReLUParameter* LayerParameter::unsafe_arena_release_relu_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.relu_param) + _has_bits_[0] &= ~0x02000000u; + ::opencv_caffe::ReLUParameter* temp = relu_param_; + relu_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ReLUParameter* LayerParameter::_internal_mutable_relu_param() { + _has_bits_[0] |= 0x02000000u; + if (relu_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ReLUParameter>(GetArenaForAllocation()); + relu_param_ = p; + } + return relu_param_; +} +inline ::opencv_caffe::ReLUParameter* LayerParameter::mutable_relu_param() { + ::opencv_caffe::ReLUParameter* _msg = _internal_mutable_relu_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.relu_param) + return _msg; +} +inline void LayerParameter::set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete relu_param_; + } + if (relu_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ReLUParameter>::GetOwningArena(relu_param); + if (message_arena != submessage_arena) { + relu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, relu_param, submessage_arena); + } + _has_bits_[0] |= 0x02000000u; + } else { + _has_bits_[0] &= ~0x02000000u; + } + 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::_internal_has_reshape_param() const { + bool value = (_has_bits_[1] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || reshape_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_reshape_param() const { + return _internal_has_reshape_param(); +} +inline void LayerParameter::clear_reshape_param() { + if (reshape_param_ != nullptr) reshape_param_->Clear(); + _has_bits_[1] &= ~0x00000008u; +} +inline const ::opencv_caffe::ReshapeParameter& LayerParameter::_internal_reshape_param() const { + const ::opencv_caffe::ReshapeParameter* p = reshape_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ReshapeParameter_default_instance_); +} +inline const ::opencv_caffe::ReshapeParameter& LayerParameter::reshape_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.reshape_param) + return _internal_reshape_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_reshape_param( + ::opencv_caffe::ReshapeParameter* reshape_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reshape_param_); + } + reshape_param_ = reshape_param; + if (reshape_param) { + _has_bits_[1] |= 0x00000008u; + } else { + _has_bits_[1] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.reshape_param) +} +inline ::opencv_caffe::ReshapeParameter* LayerParameter::release_reshape_param() { + _has_bits_[1] &= ~0x00000008u; + ::opencv_caffe::ReshapeParameter* temp = reshape_param_; + reshape_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ReshapeParameter* LayerParameter::unsafe_arena_release_reshape_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.reshape_param) + _has_bits_[1] &= ~0x00000008u; + ::opencv_caffe::ReshapeParameter* temp = reshape_param_; + reshape_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ReshapeParameter* LayerParameter::_internal_mutable_reshape_param() { + _has_bits_[1] |= 0x00000008u; + if (reshape_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ReshapeParameter>(GetArenaForAllocation()); + reshape_param_ = p; + } + return reshape_param_; +} +inline ::opencv_caffe::ReshapeParameter* LayerParameter::mutable_reshape_param() { + ::opencv_caffe::ReshapeParameter* _msg = _internal_mutable_reshape_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.reshape_param) + return _msg; +} +inline void LayerParameter::set_allocated_reshape_param(::opencv_caffe::ReshapeParameter* reshape_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reshape_param_; + } + if (reshape_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ReshapeParameter>::GetOwningArena(reshape_param); + if (message_arena != submessage_arena) { + reshape_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, reshape_param, submessage_arena); + } + _has_bits_[1] |= 0x00000008u; + } else { + _has_bits_[1] &= ~0x00000008u; + } + 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::_internal_has_roi_pooling_param() const { + bool value = (_has_bits_[1] & 0x00800000u) != 0; + PROTOBUF_ASSUME(!value || roi_pooling_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_roi_pooling_param() const { + return _internal_has_roi_pooling_param(); +} +inline void LayerParameter::clear_roi_pooling_param() { + if (roi_pooling_param_ != nullptr) roi_pooling_param_->Clear(); + _has_bits_[1] &= ~0x00800000u; +} +inline const ::opencv_caffe::ROIPoolingParameter& LayerParameter::_internal_roi_pooling_param() const { + const ::opencv_caffe::ROIPoolingParameter* p = roi_pooling_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ROIPoolingParameter_default_instance_); +} +inline const ::opencv_caffe::ROIPoolingParameter& LayerParameter::roi_pooling_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.roi_pooling_param) + return _internal_roi_pooling_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_roi_pooling_param( + ::opencv_caffe::ROIPoolingParameter* roi_pooling_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(roi_pooling_param_); + } + roi_pooling_param_ = roi_pooling_param; + if (roi_pooling_param) { + _has_bits_[1] |= 0x00800000u; + } else { + _has_bits_[1] &= ~0x00800000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.roi_pooling_param) +} +inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::release_roi_pooling_param() { + _has_bits_[1] &= ~0x00800000u; + ::opencv_caffe::ROIPoolingParameter* temp = roi_pooling_param_; + roi_pooling_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::unsafe_arena_release_roi_pooling_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.roi_pooling_param) + _has_bits_[1] &= ~0x00800000u; + ::opencv_caffe::ROIPoolingParameter* temp = roi_pooling_param_; + roi_pooling_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::_internal_mutable_roi_pooling_param() { + _has_bits_[1] |= 0x00800000u; + if (roi_pooling_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ROIPoolingParameter>(GetArenaForAllocation()); + roi_pooling_param_ = p; + } + return roi_pooling_param_; +} +inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::mutable_roi_pooling_param() { + ::opencv_caffe::ROIPoolingParameter* _msg = _internal_mutable_roi_pooling_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.roi_pooling_param) + return _msg; +} +inline void LayerParameter::set_allocated_roi_pooling_param(::opencv_caffe::ROIPoolingParameter* roi_pooling_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete roi_pooling_param_; + } + if (roi_pooling_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ROIPoolingParameter>::GetOwningArena(roi_pooling_param); + if (message_arena != submessage_arena) { + roi_pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, roi_pooling_param, submessage_arena); + } + _has_bits_[1] |= 0x00800000u; + } else { + _has_bits_[1] &= ~0x00800000u; + } + 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::_internal_has_scale_param() const { + bool value = (_has_bits_[1] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || scale_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_scale_param() const { + return _internal_has_scale_param(); +} +inline void LayerParameter::clear_scale_param() { + if (scale_param_ != nullptr) scale_param_->Clear(); + _has_bits_[1] &= ~0x00001000u; +} +inline const ::opencv_caffe::ScaleParameter& LayerParameter::_internal_scale_param() const { + const ::opencv_caffe::ScaleParameter* p = scale_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ScaleParameter_default_instance_); +} +inline const ::opencv_caffe::ScaleParameter& LayerParameter::scale_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.scale_param) + return _internal_scale_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_scale_param( + ::opencv_caffe::ScaleParameter* scale_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_param_); + } + scale_param_ = scale_param; + if (scale_param) { + _has_bits_[1] |= 0x00001000u; + } else { + _has_bits_[1] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.scale_param) +} +inline ::opencv_caffe::ScaleParameter* LayerParameter::release_scale_param() { + _has_bits_[1] &= ~0x00001000u; + ::opencv_caffe::ScaleParameter* temp = scale_param_; + scale_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ScaleParameter* LayerParameter::unsafe_arena_release_scale_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.scale_param) + _has_bits_[1] &= ~0x00001000u; + ::opencv_caffe::ScaleParameter* temp = scale_param_; + scale_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ScaleParameter* LayerParameter::_internal_mutable_scale_param() { + _has_bits_[1] |= 0x00001000u; + if (scale_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ScaleParameter>(GetArenaForAllocation()); + scale_param_ = p; + } + return scale_param_; +} +inline ::opencv_caffe::ScaleParameter* LayerParameter::mutable_scale_param() { + ::opencv_caffe::ScaleParameter* _msg = _internal_mutable_scale_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.scale_param) + return _msg; +} +inline void LayerParameter::set_allocated_scale_param(::opencv_caffe::ScaleParameter* scale_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete scale_param_; + } + if (scale_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ScaleParameter>::GetOwningArena(scale_param); + if (message_arena != submessage_arena) { + scale_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, scale_param, submessage_arena); + } + _has_bits_[1] |= 0x00001000u; + } else { + _has_bits_[1] &= ~0x00001000u; + } + 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::_internal_has_sigmoid_param() const { + bool value = (_has_bits_[0] & 0x04000000u) != 0; + PROTOBUF_ASSUME(!value || sigmoid_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_sigmoid_param() const { + return _internal_has_sigmoid_param(); +} +inline void LayerParameter::clear_sigmoid_param() { + if (sigmoid_param_ != nullptr) sigmoid_param_->Clear(); + _has_bits_[0] &= ~0x04000000u; +} +inline const ::opencv_caffe::SigmoidParameter& LayerParameter::_internal_sigmoid_param() const { + const ::opencv_caffe::SigmoidParameter* p = sigmoid_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_SigmoidParameter_default_instance_); +} +inline const ::opencv_caffe::SigmoidParameter& LayerParameter::sigmoid_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.sigmoid_param) + return _internal_sigmoid_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_sigmoid_param( + ::opencv_caffe::SigmoidParameter* sigmoid_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sigmoid_param_); + } + sigmoid_param_ = sigmoid_param; + if (sigmoid_param) { + _has_bits_[0] |= 0x04000000u; + } else { + _has_bits_[0] &= ~0x04000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.sigmoid_param) +} +inline ::opencv_caffe::SigmoidParameter* LayerParameter::release_sigmoid_param() { + _has_bits_[0] &= ~0x04000000u; + ::opencv_caffe::SigmoidParameter* temp = sigmoid_param_; + sigmoid_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::SigmoidParameter* LayerParameter::unsafe_arena_release_sigmoid_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.sigmoid_param) + _has_bits_[0] &= ~0x04000000u; + ::opencv_caffe::SigmoidParameter* temp = sigmoid_param_; + sigmoid_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::SigmoidParameter* LayerParameter::_internal_mutable_sigmoid_param() { + _has_bits_[0] |= 0x04000000u; + if (sigmoid_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::SigmoidParameter>(GetArenaForAllocation()); + sigmoid_param_ = p; + } + return sigmoid_param_; +} +inline ::opencv_caffe::SigmoidParameter* LayerParameter::mutable_sigmoid_param() { + ::opencv_caffe::SigmoidParameter* _msg = _internal_mutable_sigmoid_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.sigmoid_param) + return _msg; +} +inline void LayerParameter::set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete sigmoid_param_; + } + if (sigmoid_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::SigmoidParameter>::GetOwningArena(sigmoid_param); + if (message_arena != submessage_arena) { + sigmoid_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, sigmoid_param, submessage_arena); + } + _has_bits_[0] |= 0x04000000u; + } else { + _has_bits_[0] &= ~0x04000000u; + } + 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::_internal_has_softmax_param() const { + bool value = (_has_bits_[0] & 0x08000000u) != 0; + PROTOBUF_ASSUME(!value || softmax_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_softmax_param() const { + return _internal_has_softmax_param(); +} +inline void LayerParameter::clear_softmax_param() { + if (softmax_param_ != nullptr) softmax_param_->Clear(); + _has_bits_[0] &= ~0x08000000u; +} +inline const ::opencv_caffe::SoftmaxParameter& LayerParameter::_internal_softmax_param() const { + const ::opencv_caffe::SoftmaxParameter* p = softmax_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_SoftmaxParameter_default_instance_); +} +inline const ::opencv_caffe::SoftmaxParameter& LayerParameter::softmax_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.softmax_param) + return _internal_softmax_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_softmax_param( + ::opencv_caffe::SoftmaxParameter* softmax_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(softmax_param_); + } + softmax_param_ = softmax_param; + if (softmax_param) { + _has_bits_[0] |= 0x08000000u; + } else { + _has_bits_[0] &= ~0x08000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.softmax_param) +} +inline ::opencv_caffe::SoftmaxParameter* LayerParameter::release_softmax_param() { + _has_bits_[0] &= ~0x08000000u; + ::opencv_caffe::SoftmaxParameter* temp = softmax_param_; + softmax_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::SoftmaxParameter* LayerParameter::unsafe_arena_release_softmax_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.softmax_param) + _has_bits_[0] &= ~0x08000000u; + ::opencv_caffe::SoftmaxParameter* temp = softmax_param_; + softmax_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::SoftmaxParameter* LayerParameter::_internal_mutable_softmax_param() { + _has_bits_[0] |= 0x08000000u; + if (softmax_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::SoftmaxParameter>(GetArenaForAllocation()); + softmax_param_ = p; + } + return softmax_param_; +} +inline ::opencv_caffe::SoftmaxParameter* LayerParameter::mutable_softmax_param() { + ::opencv_caffe::SoftmaxParameter* _msg = _internal_mutable_softmax_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.softmax_param) + return _msg; +} +inline void LayerParameter::set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete softmax_param_; + } + if (softmax_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::SoftmaxParameter>::GetOwningArena(softmax_param); + if (message_arena != submessage_arena) { + softmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, softmax_param, submessage_arena); + } + _has_bits_[0] |= 0x08000000u; + } else { + _has_bits_[0] &= ~0x08000000u; + } + 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::_internal_has_spp_param() const { + bool value = (_has_bits_[1] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || spp_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_spp_param() const { + return _internal_has_spp_param(); +} +inline void LayerParameter::clear_spp_param() { + if (spp_param_ != nullptr) spp_param_->Clear(); + _has_bits_[1] &= ~0x00000004u; +} +inline const ::opencv_caffe::SPPParameter& LayerParameter::_internal_spp_param() const { + const ::opencv_caffe::SPPParameter* p = spp_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_SPPParameter_default_instance_); +} +inline const ::opencv_caffe::SPPParameter& LayerParameter::spp_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.spp_param) + return _internal_spp_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_spp_param( + ::opencv_caffe::SPPParameter* spp_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(spp_param_); + } + spp_param_ = spp_param; + if (spp_param) { + _has_bits_[1] |= 0x00000004u; + } else { + _has_bits_[1] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.spp_param) +} +inline ::opencv_caffe::SPPParameter* LayerParameter::release_spp_param() { + _has_bits_[1] &= ~0x00000004u; + ::opencv_caffe::SPPParameter* temp = spp_param_; + spp_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::SPPParameter* LayerParameter::unsafe_arena_release_spp_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.spp_param) + _has_bits_[1] &= ~0x00000004u; + ::opencv_caffe::SPPParameter* temp = spp_param_; + spp_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::SPPParameter* LayerParameter::_internal_mutable_spp_param() { + _has_bits_[1] |= 0x00000004u; + if (spp_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::SPPParameter>(GetArenaForAllocation()); + spp_param_ = p; + } + return spp_param_; +} +inline ::opencv_caffe::SPPParameter* LayerParameter::mutable_spp_param() { + ::opencv_caffe::SPPParameter* _msg = _internal_mutable_spp_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.spp_param) + return _msg; +} +inline void LayerParameter::set_allocated_spp_param(::opencv_caffe::SPPParameter* spp_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete spp_param_; + } + if (spp_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::SPPParameter>::GetOwningArena(spp_param); + if (message_arena != submessage_arena) { + spp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, spp_param, submessage_arena); + } + _has_bits_[1] |= 0x00000004u; + } else { + _has_bits_[1] &= ~0x00000004u; + } + 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::_internal_has_slice_param() const { + bool value = (_has_bits_[0] & 0x10000000u) != 0; + PROTOBUF_ASSUME(!value || slice_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_slice_param() const { + return _internal_has_slice_param(); +} +inline void LayerParameter::clear_slice_param() { + if (slice_param_ != nullptr) slice_param_->Clear(); + _has_bits_[0] &= ~0x10000000u; +} +inline const ::opencv_caffe::SliceParameter& LayerParameter::_internal_slice_param() const { + const ::opencv_caffe::SliceParameter* p = slice_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_SliceParameter_default_instance_); +} +inline const ::opencv_caffe::SliceParameter& LayerParameter::slice_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.slice_param) + return _internal_slice_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_slice_param( + ::opencv_caffe::SliceParameter* slice_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(slice_param_); + } + slice_param_ = slice_param; + if (slice_param) { + _has_bits_[0] |= 0x10000000u; + } else { + _has_bits_[0] &= ~0x10000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.slice_param) +} +inline ::opencv_caffe::SliceParameter* LayerParameter::release_slice_param() { + _has_bits_[0] &= ~0x10000000u; + ::opencv_caffe::SliceParameter* temp = slice_param_; + slice_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::SliceParameter* LayerParameter::unsafe_arena_release_slice_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.slice_param) + _has_bits_[0] &= ~0x10000000u; + ::opencv_caffe::SliceParameter* temp = slice_param_; + slice_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::SliceParameter* LayerParameter::_internal_mutable_slice_param() { + _has_bits_[0] |= 0x10000000u; + if (slice_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::SliceParameter>(GetArenaForAllocation()); + slice_param_ = p; + } + return slice_param_; +} +inline ::opencv_caffe::SliceParameter* LayerParameter::mutable_slice_param() { + ::opencv_caffe::SliceParameter* _msg = _internal_mutable_slice_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.slice_param) + return _msg; +} +inline void LayerParameter::set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete slice_param_; + } + if (slice_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::SliceParameter>::GetOwningArena(slice_param); + if (message_arena != submessage_arena) { + slice_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, slice_param, submessage_arena); + } + _has_bits_[0] |= 0x10000000u; + } else { + _has_bits_[0] &= ~0x10000000u; + } + 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::_internal_has_tanh_param() const { + bool value = (_has_bits_[0] & 0x20000000u) != 0; + PROTOBUF_ASSUME(!value || tanh_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_tanh_param() const { + return _internal_has_tanh_param(); +} +inline void LayerParameter::clear_tanh_param() { + if (tanh_param_ != nullptr) tanh_param_->Clear(); + _has_bits_[0] &= ~0x20000000u; +} +inline const ::opencv_caffe::TanHParameter& LayerParameter::_internal_tanh_param() const { + const ::opencv_caffe::TanHParameter* p = tanh_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_TanHParameter_default_instance_); +} +inline const ::opencv_caffe::TanHParameter& LayerParameter::tanh_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.tanh_param) + return _internal_tanh_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_tanh_param( + ::opencv_caffe::TanHParameter* tanh_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tanh_param_); + } + tanh_param_ = tanh_param; + if (tanh_param) { + _has_bits_[0] |= 0x20000000u; + } else { + _has_bits_[0] &= ~0x20000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.tanh_param) +} +inline ::opencv_caffe::TanHParameter* LayerParameter::release_tanh_param() { + _has_bits_[0] &= ~0x20000000u; + ::opencv_caffe::TanHParameter* temp = tanh_param_; + tanh_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::TanHParameter* LayerParameter::unsafe_arena_release_tanh_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.tanh_param) + _has_bits_[0] &= ~0x20000000u; + ::opencv_caffe::TanHParameter* temp = tanh_param_; + tanh_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::TanHParameter* LayerParameter::_internal_mutable_tanh_param() { + _has_bits_[0] |= 0x20000000u; + if (tanh_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::TanHParameter>(GetArenaForAllocation()); + tanh_param_ = p; + } + return tanh_param_; +} +inline ::opencv_caffe::TanHParameter* LayerParameter::mutable_tanh_param() { + ::opencv_caffe::TanHParameter* _msg = _internal_mutable_tanh_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.tanh_param) + return _msg; +} +inline void LayerParameter::set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete tanh_param_; + } + if (tanh_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::TanHParameter>::GetOwningArena(tanh_param); + if (message_arena != submessage_arena) { + tanh_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, tanh_param, submessage_arena); + } + _has_bits_[0] |= 0x20000000u; + } else { + _has_bits_[0] &= ~0x20000000u; + } + 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::_internal_has_threshold_param() const { + bool value = (_has_bits_[0] & 0x40000000u) != 0; + PROTOBUF_ASSUME(!value || threshold_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_threshold_param() const { + return _internal_has_threshold_param(); +} +inline void LayerParameter::clear_threshold_param() { + if (threshold_param_ != nullptr) threshold_param_->Clear(); + _has_bits_[0] &= ~0x40000000u; +} +inline const ::opencv_caffe::ThresholdParameter& LayerParameter::_internal_threshold_param() const { + const ::opencv_caffe::ThresholdParameter* p = threshold_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ThresholdParameter_default_instance_); +} +inline const ::opencv_caffe::ThresholdParameter& LayerParameter::threshold_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.threshold_param) + return _internal_threshold_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_threshold_param( + ::opencv_caffe::ThresholdParameter* threshold_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(threshold_param_); + } + threshold_param_ = threshold_param; + if (threshold_param) { + _has_bits_[0] |= 0x40000000u; + } else { + _has_bits_[0] &= ~0x40000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.threshold_param) +} +inline ::opencv_caffe::ThresholdParameter* LayerParameter::release_threshold_param() { + _has_bits_[0] &= ~0x40000000u; + ::opencv_caffe::ThresholdParameter* temp = threshold_param_; + threshold_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ThresholdParameter* LayerParameter::unsafe_arena_release_threshold_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.threshold_param) + _has_bits_[0] &= ~0x40000000u; + ::opencv_caffe::ThresholdParameter* temp = threshold_param_; + threshold_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ThresholdParameter* LayerParameter::_internal_mutable_threshold_param() { + _has_bits_[0] |= 0x40000000u; + if (threshold_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ThresholdParameter>(GetArenaForAllocation()); + threshold_param_ = p; + } + return threshold_param_; +} +inline ::opencv_caffe::ThresholdParameter* LayerParameter::mutable_threshold_param() { + ::opencv_caffe::ThresholdParameter* _msg = _internal_mutable_threshold_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.threshold_param) + return _msg; +} +inline void LayerParameter::set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete threshold_param_; + } + if (threshold_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ThresholdParameter>::GetOwningArena(threshold_param); + if (message_arena != submessage_arena) { + threshold_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, threshold_param, submessage_arena); + } + _has_bits_[0] |= 0x40000000u; + } else { + _has_bits_[0] &= ~0x40000000u; + } + 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::_internal_has_tile_param() const { + bool value = (_has_bits_[1] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || tile_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_tile_param() const { + return _internal_has_tile_param(); +} +inline void LayerParameter::clear_tile_param() { + if (tile_param_ != nullptr) tile_param_->Clear(); + _has_bits_[1] &= ~0x00000100u; +} +inline const ::opencv_caffe::TileParameter& LayerParameter::_internal_tile_param() const { + const ::opencv_caffe::TileParameter* p = tile_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_TileParameter_default_instance_); +} +inline const ::opencv_caffe::TileParameter& LayerParameter::tile_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.tile_param) + return _internal_tile_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_tile_param( + ::opencv_caffe::TileParameter* tile_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tile_param_); + } + tile_param_ = tile_param; + if (tile_param) { + _has_bits_[1] |= 0x00000100u; + } else { + _has_bits_[1] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.tile_param) +} +inline ::opencv_caffe::TileParameter* LayerParameter::release_tile_param() { + _has_bits_[1] &= ~0x00000100u; + ::opencv_caffe::TileParameter* temp = tile_param_; + tile_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::TileParameter* LayerParameter::unsafe_arena_release_tile_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.tile_param) + _has_bits_[1] &= ~0x00000100u; + ::opencv_caffe::TileParameter* temp = tile_param_; + tile_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::TileParameter* LayerParameter::_internal_mutable_tile_param() { + _has_bits_[1] |= 0x00000100u; + if (tile_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::TileParameter>(GetArenaForAllocation()); + tile_param_ = p; + } + return tile_param_; +} +inline ::opencv_caffe::TileParameter* LayerParameter::mutable_tile_param() { + ::opencv_caffe::TileParameter* _msg = _internal_mutable_tile_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.tile_param) + return _msg; +} +inline void LayerParameter::set_allocated_tile_param(::opencv_caffe::TileParameter* tile_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete tile_param_; + } + if (tile_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::TileParameter>::GetOwningArena(tile_param); + if (message_arena != submessage_arena) { + tile_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, tile_param, submessage_arena); + } + _has_bits_[1] |= 0x00000100u; + } else { + _has_bits_[1] &= ~0x00000100u; + } + 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::_internal_has_window_data_param() const { + bool value = (_has_bits_[0] & 0x80000000u) != 0; + PROTOBUF_ASSUME(!value || window_data_param_ != nullptr); + return value; +} +inline bool LayerParameter::has_window_data_param() const { + return _internal_has_window_data_param(); +} +inline void LayerParameter::clear_window_data_param() { + if (window_data_param_ != nullptr) window_data_param_->Clear(); + _has_bits_[0] &= ~0x80000000u; +} +inline const ::opencv_caffe::WindowDataParameter& LayerParameter::_internal_window_data_param() const { + const ::opencv_caffe::WindowDataParameter* p = window_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_WindowDataParameter_default_instance_); +} +inline const ::opencv_caffe::WindowDataParameter& LayerParameter::window_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.window_data_param) + return _internal_window_data_param(); +} +inline void LayerParameter::unsafe_arena_set_allocated_window_data_param( + ::opencv_caffe::WindowDataParameter* window_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(window_data_param_); + } + window_data_param_ = window_data_param; + if (window_data_param) { + _has_bits_[0] |= 0x80000000u; + } else { + _has_bits_[0] &= ~0x80000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.window_data_param) +} +inline ::opencv_caffe::WindowDataParameter* LayerParameter::release_window_data_param() { + _has_bits_[0] &= ~0x80000000u; + ::opencv_caffe::WindowDataParameter* temp = window_data_param_; + window_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::WindowDataParameter* LayerParameter::unsafe_arena_release_window_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.window_data_param) + _has_bits_[0] &= ~0x80000000u; + ::opencv_caffe::WindowDataParameter* temp = window_data_param_; + window_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::WindowDataParameter* LayerParameter::_internal_mutable_window_data_param() { + _has_bits_[0] |= 0x80000000u; + if (window_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::WindowDataParameter>(GetArenaForAllocation()); + window_data_param_ = p; + } + return window_data_param_; +} +inline ::opencv_caffe::WindowDataParameter* LayerParameter::mutable_window_data_param() { + ::opencv_caffe::WindowDataParameter* _msg = _internal_mutable_window_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.window_data_param) + return _msg; +} +inline void LayerParameter::set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete window_data_param_; + } + if (window_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::WindowDataParameter>::GetOwningArena(window_data_param); + if (message_arena != submessage_arena) { + window_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, window_data_param, submessage_arena); + } + _has_bits_[0] |= 0x80000000u; + } else { + _has_bits_[0] &= ~0x80000000u; + } + 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::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool TransformationParameter::has_scale() const { + return _internal_has_scale(); +} +inline void TransformationParameter::clear_scale() { + scale_ = 1; + _has_bits_[0] &= ~0x00000020u; +} +inline float TransformationParameter::_internal_scale() const { + return scale_; +} +inline float TransformationParameter::scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.scale) + return _internal_scale(); +} +inline void TransformationParameter::_internal_set_scale(float value) { + _has_bits_[0] |= 0x00000020u; + scale_ = value; +} +inline void TransformationParameter::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.scale) +} + +// optional bool mirror = 2 [default = false]; +inline bool TransformationParameter::_internal_has_mirror() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool TransformationParameter::has_mirror() const { + return _internal_has_mirror(); +} +inline void TransformationParameter::clear_mirror() { + mirror_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool TransformationParameter::_internal_mirror() const { + return mirror_; +} +inline bool TransformationParameter::mirror() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mirror) + return _internal_mirror(); +} +inline void TransformationParameter::_internal_set_mirror(bool value) { + _has_bits_[0] |= 0x00000004u; + mirror_ = value; +} +inline void TransformationParameter::set_mirror(bool value) { + _internal_set_mirror(value); + // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.mirror) +} + +// optional uint32 crop_size = 3 [default = 0]; +inline bool TransformationParameter::_internal_has_crop_size() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TransformationParameter::has_crop_size() const { + return _internal_has_crop_size(); +} +inline void TransformationParameter::clear_crop_size() { + crop_size_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t TransformationParameter::_internal_crop_size() const { + return crop_size_; +} +inline uint32_t TransformationParameter::crop_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.crop_size) + return _internal_crop_size(); +} +inline void TransformationParameter::_internal_set_crop_size(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + crop_size_ = value; +} +inline void TransformationParameter::set_crop_size(uint32_t value) { + _internal_set_crop_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.crop_size) +} + +// optional string mean_file = 4; +inline bool TransformationParameter::_internal_has_mean_file() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TransformationParameter::has_mean_file() const { + return _internal_has_mean_file(); +} +inline void TransformationParameter::clear_mean_file() { + mean_file_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& TransformationParameter::mean_file() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mean_file) + return _internal_mean_file(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void TransformationParameter::set_mean_file(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.mean_file) +} +inline std::string* TransformationParameter::mutable_mean_file() { + std::string* _s = _internal_mutable_mean_file(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.TransformationParameter.mean_file) + return _s; +} +inline const std::string& TransformationParameter::_internal_mean_file() const { + return mean_file_.Get(); +} +inline void TransformationParameter::_internal_set_mean_file(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* TransformationParameter::_internal_mutable_mean_file() { + _has_bits_[0] |= 0x00000001u; + return mean_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* TransformationParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:opencv_caffe.TransformationParameter.mean_file) + if (!_internal_has_mean_file()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = mean_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void TransformationParameter::set_allocated_mean_file(std::string* mean_file) { + if (mean_file != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + mean_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mean_file, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.TransformationParameter.mean_file) +} + +// repeated float mean_value = 5; +inline int TransformationParameter::_internal_mean_value_size() const { + return mean_value_.size(); +} +inline int TransformationParameter::mean_value_size() const { + return _internal_mean_value_size(); +} +inline void TransformationParameter::clear_mean_value() { + mean_value_.Clear(); +} +inline float TransformationParameter::_internal_mean_value(int index) const { + return mean_value_.Get(index); +} +inline float TransformationParameter::mean_value(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mean_value) + return _internal_mean_value(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::_internal_add_mean_value(float value) { + mean_value_.Add(value); +} +inline void TransformationParameter::add_mean_value(float value) { + _internal_add_mean_value(value); + // @@protoc_insertion_point(field_add:opencv_caffe.TransformationParameter.mean_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +TransformationParameter::_internal_mean_value() const { + return mean_value_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +TransformationParameter::mean_value() const { + // @@protoc_insertion_point(field_list:opencv_caffe.TransformationParameter.mean_value) + return _internal_mean_value(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +TransformationParameter::_internal_mutable_mean_value() { + return &mean_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +TransformationParameter::mutable_mean_value() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.TransformationParameter.mean_value) + return _internal_mutable_mean_value(); +} + +// optional bool force_color = 6 [default = false]; +inline bool TransformationParameter::_internal_has_force_color() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool TransformationParameter::has_force_color() const { + return _internal_has_force_color(); +} +inline void TransformationParameter::clear_force_color() { + force_color_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool TransformationParameter::_internal_force_color() const { + return force_color_; +} +inline bool TransformationParameter::force_color() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.force_color) + return _internal_force_color(); +} +inline void TransformationParameter::_internal_set_force_color(bool value) { + _has_bits_[0] |= 0x00000008u; + force_color_ = value; +} +inline void TransformationParameter::set_force_color(bool value) { + _internal_set_force_color(value); + // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.force_color) +} + +// optional bool force_gray = 7 [default = false]; +inline bool TransformationParameter::_internal_has_force_gray() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool TransformationParameter::has_force_gray() const { + return _internal_has_force_gray(); +} +inline void TransformationParameter::clear_force_gray() { + force_gray_ = false; + _has_bits_[0] &= ~0x00000010u; +} +inline bool TransformationParameter::_internal_force_gray() const { + return force_gray_; +} +inline bool TransformationParameter::force_gray() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.force_gray) + return _internal_force_gray(); +} +inline void TransformationParameter::_internal_set_force_gray(bool value) { + _has_bits_[0] |= 0x00000010u; + force_gray_ = value; +} +inline void TransformationParameter::set_force_gray(bool value) { + _internal_set_force_gray(value); + // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.force_gray) +} + +// ------------------------------------------------------------------- + +// LossParameter + +// optional int32 ignore_label = 1; +inline bool LossParameter::_internal_has_ignore_label() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool LossParameter::has_ignore_label() const { + return _internal_has_ignore_label(); +} +inline void LossParameter::clear_ignore_label() { + ignore_label_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t LossParameter::_internal_ignore_label() const { + return ignore_label_; +} +inline int32_t LossParameter::ignore_label() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.ignore_label) + return _internal_ignore_label(); +} +inline void LossParameter::_internal_set_ignore_label(int32_t value) { + _has_bits_[0] |= 0x00000001u; + ignore_label_ = value; +} +inline void LossParameter::set_ignore_label(int32_t value) { + _internal_set_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::_internal_has_normalization() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool LossParameter::has_normalization() const { + return _internal_has_normalization(); +} +inline void LossParameter::clear_normalization() { + normalization_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline ::opencv_caffe::LossParameter_NormalizationMode LossParameter::_internal_normalization() const { + return static_cast< ::opencv_caffe::LossParameter_NormalizationMode >(normalization_); +} +inline ::opencv_caffe::LossParameter_NormalizationMode LossParameter::normalization() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.normalization) + return _internal_normalization(); +} +inline void LossParameter::_internal_set_normalization(::opencv_caffe::LossParameter_NormalizationMode value) { + assert(::opencv_caffe::LossParameter_NormalizationMode_IsValid(value)); + _has_bits_[0] |= 0x00000004u; + normalization_ = value; +} +inline void LossParameter::set_normalization(::opencv_caffe::LossParameter_NormalizationMode value) { + _internal_set_normalization(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LossParameter.normalization) +} + +// optional bool normalize = 2; +inline bool LossParameter::_internal_has_normalize() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool LossParameter::has_normalize() const { + return _internal_has_normalize(); +} +inline void LossParameter::clear_normalize() { + normalize_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool LossParameter::_internal_normalize() const { + return normalize_; +} +inline bool LossParameter::normalize() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.normalize) + return _internal_normalize(); +} +inline void LossParameter::_internal_set_normalize(bool value) { + _has_bits_[0] |= 0x00000002u; + normalize_ = value; +} +inline void LossParameter::set_normalize(bool value) { + _internal_set_normalize(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LossParameter.normalize) +} + +// ------------------------------------------------------------------- + +// AccuracyParameter + +// optional uint32 top_k = 1 [default = 1]; +inline bool AccuracyParameter::_internal_has_top_k() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool AccuracyParameter::has_top_k() const { + return _internal_has_top_k(); +} +inline void AccuracyParameter::clear_top_k() { + top_k_ = 1u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t AccuracyParameter::_internal_top_k() const { + return top_k_; +} +inline uint32_t AccuracyParameter::top_k() const { + // @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.top_k) + return _internal_top_k(); +} +inline void AccuracyParameter::_internal_set_top_k(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + top_k_ = value; +} +inline void AccuracyParameter::set_top_k(uint32_t value) { + _internal_set_top_k(value); + // @@protoc_insertion_point(field_set:opencv_caffe.AccuracyParameter.top_k) +} + +// optional int32 axis = 2 [default = 1]; +inline bool AccuracyParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool AccuracyParameter::has_axis() const { + return _internal_has_axis(); +} +inline void AccuracyParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t AccuracyParameter::_internal_axis() const { + return axis_; +} +inline int32_t AccuracyParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.axis) + return _internal_axis(); +} +inline void AccuracyParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000004u; + axis_ = value; +} +inline void AccuracyParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.AccuracyParameter.axis) +} + +// optional int32 ignore_label = 3; +inline bool AccuracyParameter::_internal_has_ignore_label() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool AccuracyParameter::has_ignore_label() const { + return _internal_has_ignore_label(); +} +inline void AccuracyParameter::clear_ignore_label() { + ignore_label_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t AccuracyParameter::_internal_ignore_label() const { + return ignore_label_; +} +inline int32_t AccuracyParameter::ignore_label() const { + // @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.ignore_label) + return _internal_ignore_label(); +} +inline void AccuracyParameter::_internal_set_ignore_label(int32_t value) { + _has_bits_[0] |= 0x00000001u; + ignore_label_ = value; +} +inline void AccuracyParameter::set_ignore_label(int32_t value) { + _internal_set_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::_internal_has_out_max_val() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ArgMaxParameter::has_out_max_val() const { + return _internal_has_out_max_val(); +} +inline void ArgMaxParameter::clear_out_max_val() { + out_max_val_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool ArgMaxParameter::_internal_out_max_val() const { + return out_max_val_; +} +inline bool ArgMaxParameter::out_max_val() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.out_max_val) + return _internal_out_max_val(); +} +inline void ArgMaxParameter::_internal_set_out_max_val(bool value) { + _has_bits_[0] |= 0x00000001u; + out_max_val_ = value; +} +inline void ArgMaxParameter::set_out_max_val(bool value) { + _internal_set_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::_internal_has_top_k() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ArgMaxParameter::has_top_k() const { + return _internal_has_top_k(); +} +inline void ArgMaxParameter::clear_top_k() { + top_k_ = 1u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t ArgMaxParameter::_internal_top_k() const { + return top_k_; +} +inline uint32_t ArgMaxParameter::top_k() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.top_k) + return _internal_top_k(); +} +inline void ArgMaxParameter::_internal_set_top_k(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + top_k_ = value; +} +inline void ArgMaxParameter::set_top_k(uint32_t value) { + _internal_set_top_k(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ArgMaxParameter.top_k) +} + +// optional int32 axis = 3; +inline bool ArgMaxParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ArgMaxParameter::has_axis() const { + return _internal_has_axis(); +} +inline void ArgMaxParameter::clear_axis() { + axis_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t ArgMaxParameter::_internal_axis() const { + return axis_; +} +inline int32_t ArgMaxParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.axis) + return _internal_axis(); +} +inline void ArgMaxParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000002u; + axis_ = value; +} +inline void ArgMaxParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ArgMaxParameter.axis) +} + +// ------------------------------------------------------------------- + +// ConcatParameter + +// optional int32 axis = 2 [default = 1]; +inline bool ConcatParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ConcatParameter::has_axis() const { + return _internal_has_axis(); +} +inline void ConcatParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t ConcatParameter::_internal_axis() const { + return axis_; +} +inline int32_t ConcatParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConcatParameter.axis) + return _internal_axis(); +} +inline void ConcatParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000002u; + axis_ = value; +} +inline void ConcatParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConcatParameter.axis) +} + +// optional uint32 concat_dim = 1 [default = 1]; +inline bool ConcatParameter::_internal_has_concat_dim() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ConcatParameter::has_concat_dim() const { + return _internal_has_concat_dim(); +} +inline void ConcatParameter::clear_concat_dim() { + concat_dim_ = 1u; + _has_bits_[0] &= ~0x00000001u; +} +inline uint32_t ConcatParameter::_internal_concat_dim() const { + return concat_dim_; +} +inline uint32_t ConcatParameter::concat_dim() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConcatParameter.concat_dim) + return _internal_concat_dim(); +} +inline void ConcatParameter::_internal_set_concat_dim(uint32_t value) { + _has_bits_[0] |= 0x00000001u; + concat_dim_ = value; +} +inline void ConcatParameter::set_concat_dim(uint32_t value) { + _internal_set_concat_dim(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConcatParameter.concat_dim) +} + +// ------------------------------------------------------------------- + +// BatchNormParameter + +// optional bool use_global_stats = 1; +inline bool BatchNormParameter::_internal_has_use_global_stats() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BatchNormParameter::has_use_global_stats() const { + return _internal_has_use_global_stats(); +} +inline void BatchNormParameter::clear_use_global_stats() { + use_global_stats_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool BatchNormParameter::_internal_use_global_stats() const { + return use_global_stats_; +} +inline bool BatchNormParameter::use_global_stats() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.use_global_stats) + return _internal_use_global_stats(); +} +inline void BatchNormParameter::_internal_set_use_global_stats(bool value) { + _has_bits_[0] |= 0x00000001u; + use_global_stats_ = value; +} +inline void BatchNormParameter::set_use_global_stats(bool value) { + _internal_set_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::_internal_has_moving_average_fraction() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BatchNormParameter::has_moving_average_fraction() const { + return _internal_has_moving_average_fraction(); +} +inline void BatchNormParameter::clear_moving_average_fraction() { + moving_average_fraction_ = 0.999f; + _has_bits_[0] &= ~0x00000004u; +} +inline float BatchNormParameter::_internal_moving_average_fraction() const { + return moving_average_fraction_; +} +inline float BatchNormParameter::moving_average_fraction() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.moving_average_fraction) + return _internal_moving_average_fraction(); +} +inline void BatchNormParameter::_internal_set_moving_average_fraction(float value) { + _has_bits_[0] |= 0x00000004u; + moving_average_fraction_ = value; +} +inline void BatchNormParameter::set_moving_average_fraction(float value) { + _internal_set_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::_internal_has_eps() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool BatchNormParameter::has_eps() const { + return _internal_has_eps(); +} +inline void BatchNormParameter::clear_eps() { + eps_ = 1e-05f; + _has_bits_[0] &= ~0x00000008u; +} +inline float BatchNormParameter::_internal_eps() const { + return eps_; +} +inline float BatchNormParameter::eps() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.eps) + return _internal_eps(); +} +inline void BatchNormParameter::_internal_set_eps(float value) { + _has_bits_[0] |= 0x00000008u; + eps_ = value; +} +inline void BatchNormParameter::set_eps(float value) { + _internal_set_eps(value); + // @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.eps) +} + +// optional bool scale_bias = 7 [default = false]; +inline bool BatchNormParameter::_internal_has_scale_bias() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BatchNormParameter::has_scale_bias() const { + return _internal_has_scale_bias(); +} +inline void BatchNormParameter::clear_scale_bias() { + scale_bias_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool BatchNormParameter::_internal_scale_bias() const { + return scale_bias_; +} +inline bool BatchNormParameter::scale_bias() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.scale_bias) + return _internal_scale_bias(); +} +inline void BatchNormParameter::_internal_set_scale_bias(bool value) { + _has_bits_[0] |= 0x00000002u; + scale_bias_ = value; +} +inline void BatchNormParameter::set_scale_bias(bool value) { + _internal_set_scale_bias(value); + // @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.scale_bias) +} + +// ------------------------------------------------------------------- + +// BiasParameter + +// optional int32 axis = 1 [default = 1]; +inline bool BiasParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BiasParameter::has_axis() const { + return _internal_has_axis(); +} +inline void BiasParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t BiasParameter::_internal_axis() const { + return axis_; +} +inline int32_t BiasParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.axis) + return _internal_axis(); +} +inline void BiasParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000002u; + axis_ = value; +} +inline void BiasParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.BiasParameter.axis) +} + +// optional int32 num_axes = 2 [default = 1]; +inline bool BiasParameter::_internal_has_num_axes() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BiasParameter::has_num_axes() const { + return _internal_has_num_axes(); +} +inline void BiasParameter::clear_num_axes() { + num_axes_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t BiasParameter::_internal_num_axes() const { + return num_axes_; +} +inline int32_t BiasParameter::num_axes() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.num_axes) + return _internal_num_axes(); +} +inline void BiasParameter::_internal_set_num_axes(int32_t value) { + _has_bits_[0] |= 0x00000004u; + num_axes_ = value; +} +inline void BiasParameter::set_num_axes(int32_t value) { + _internal_set_num_axes(value); + // @@protoc_insertion_point(field_set:opencv_caffe.BiasParameter.num_axes) +} + +// optional .opencv_caffe.FillerParameter filler = 3; +inline bool BiasParameter::_internal_has_filler() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || filler_ != nullptr); + return value; +} +inline bool BiasParameter::has_filler() const { + return _internal_has_filler(); +} +inline void BiasParameter::clear_filler() { + if (filler_ != nullptr) filler_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::FillerParameter& BiasParameter::_internal_filler() const { + const ::opencv_caffe::FillerParameter* p = filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& BiasParameter::filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.filler) + return _internal_filler(); +} +inline void BiasParameter::unsafe_arena_set_allocated_filler( + ::opencv_caffe::FillerParameter* filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filler_); + } + filler_ = filler; + if (filler) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.BiasParameter.filler) +} +inline ::opencv_caffe::FillerParameter* BiasParameter::release_filler() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = filler_; + filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* BiasParameter::unsafe_arena_release_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.BiasParameter.filler) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = filler_; + filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* BiasParameter::_internal_mutable_filler() { + _has_bits_[0] |= 0x00000001u; + if (filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + filler_ = p; + } + return filler_; +} +inline ::opencv_caffe::FillerParameter* BiasParameter::mutable_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.BiasParameter.filler) + return _msg; +} +inline void BiasParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete filler_; + } + if (filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(filler); + if (message_arena != submessage_arena) { + filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, filler, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + filler_ = filler; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.BiasParameter.filler) +} + +// ------------------------------------------------------------------- + +// ContrastiveLossParameter + +// optional float margin = 1 [default = 1]; +inline bool ContrastiveLossParameter::_internal_has_margin() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ContrastiveLossParameter::has_margin() const { + return _internal_has_margin(); +} +inline void ContrastiveLossParameter::clear_margin() { + margin_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline float ContrastiveLossParameter::_internal_margin() const { + return margin_; +} +inline float ContrastiveLossParameter::margin() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ContrastiveLossParameter.margin) + return _internal_margin(); +} +inline void ContrastiveLossParameter::_internal_set_margin(float value) { + _has_bits_[0] |= 0x00000002u; + margin_ = value; +} +inline void ContrastiveLossParameter::set_margin(float value) { + _internal_set_margin(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ContrastiveLossParameter.margin) +} + +// optional bool legacy_version = 2 [default = false]; +inline bool ContrastiveLossParameter::_internal_has_legacy_version() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ContrastiveLossParameter::has_legacy_version() const { + return _internal_has_legacy_version(); +} +inline void ContrastiveLossParameter::clear_legacy_version() { + legacy_version_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool ContrastiveLossParameter::_internal_legacy_version() const { + return legacy_version_; +} +inline bool ContrastiveLossParameter::legacy_version() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ContrastiveLossParameter.legacy_version) + return _internal_legacy_version(); +} +inline void ContrastiveLossParameter::_internal_set_legacy_version(bool value) { + _has_bits_[0] |= 0x00000001u; + legacy_version_ = value; +} +inline void ContrastiveLossParameter::set_legacy_version(bool value) { + _internal_set_legacy_version(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ContrastiveLossParameter.legacy_version) +} + +// ------------------------------------------------------------------- + +// ConvolutionParameter + +// optional uint32 num_output = 1; +inline bool ConvolutionParameter::_internal_has_num_output() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ConvolutionParameter::has_num_output() const { + return _internal_has_num_output(); +} +inline void ConvolutionParameter::clear_num_output() { + num_output_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t ConvolutionParameter::_internal_num_output() const { + return num_output_; +} +inline uint32_t ConvolutionParameter::num_output() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.num_output) + return _internal_num_output(); +} +inline void ConvolutionParameter::_internal_set_num_output(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + num_output_ = value; +} +inline void ConvolutionParameter::set_num_output(uint32_t value) { + _internal_set_num_output(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.num_output) +} + +// optional bool bias_term = 2 [default = true]; +inline bool ConvolutionParameter::_internal_has_bias_term() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool ConvolutionParameter::has_bias_term() const { + return _internal_has_bias_term(); +} +inline void ConvolutionParameter::clear_bias_term() { + bias_term_ = true; + _has_bits_[0] &= ~0x00001000u; +} +inline bool ConvolutionParameter::_internal_bias_term() const { + return bias_term_; +} +inline bool ConvolutionParameter::bias_term() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.bias_term) + return _internal_bias_term(); +} +inline void ConvolutionParameter::_internal_set_bias_term(bool value) { + _has_bits_[0] |= 0x00001000u; + bias_term_ = value; +} +inline void ConvolutionParameter::set_bias_term(bool value) { + _internal_set_bias_term(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.bias_term) +} + +// repeated uint32 pad = 3; +inline int ConvolutionParameter::_internal_pad_size() const { + return pad_.size(); +} +inline int ConvolutionParameter::pad_size() const { + return _internal_pad_size(); +} +inline void ConvolutionParameter::clear_pad() { + pad_.Clear(); +} +inline uint32_t ConvolutionParameter::_internal_pad(int index) const { + return pad_.Get(index); +} +inline uint32_t ConvolutionParameter::pad(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad) + return _internal_pad(index); +} +inline void ConvolutionParameter::set_pad(int index, uint32_t value) { + pad_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad) +} +inline void ConvolutionParameter::_internal_add_pad(uint32_t value) { + pad_.Add(value); +} +inline void ConvolutionParameter::add_pad(uint32_t value) { + _internal_add_pad(value); + // @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.pad) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ConvolutionParameter::_internal_pad() const { + return pad_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ConvolutionParameter::pad() const { + // @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.pad) + return _internal_pad(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ConvolutionParameter::_internal_mutable_pad() { + return &pad_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ConvolutionParameter::mutable_pad() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.pad) + return _internal_mutable_pad(); +} + +// repeated uint32 kernel_size = 4; +inline int ConvolutionParameter::_internal_kernel_size_size() const { + return kernel_size_.size(); +} +inline int ConvolutionParameter::kernel_size_size() const { + return _internal_kernel_size_size(); +} +inline void ConvolutionParameter::clear_kernel_size() { + kernel_size_.Clear(); +} +inline uint32_t ConvolutionParameter::_internal_kernel_size(int index) const { + return kernel_size_.Get(index); +} +inline uint32_t ConvolutionParameter::kernel_size(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_size) + return _internal_kernel_size(index); +} +inline void ConvolutionParameter::set_kernel_size(int index, uint32_t value) { + kernel_size_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_size) +} +inline void ConvolutionParameter::_internal_add_kernel_size(uint32_t value) { + kernel_size_.Add(value); +} +inline void ConvolutionParameter::add_kernel_size(uint32_t value) { + _internal_add_kernel_size(value); + // @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.kernel_size) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ConvolutionParameter::_internal_kernel_size() const { + return kernel_size_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ConvolutionParameter::kernel_size() const { + // @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.kernel_size) + return _internal_kernel_size(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ConvolutionParameter::_internal_mutable_kernel_size() { + return &kernel_size_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ConvolutionParameter::mutable_kernel_size() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.kernel_size) + return _internal_mutable_kernel_size(); +} + +// repeated uint32 stride = 6; +inline int ConvolutionParameter::_internal_stride_size() const { + return stride_.size(); +} +inline int ConvolutionParameter::stride_size() const { + return _internal_stride_size(); +} +inline void ConvolutionParameter::clear_stride() { + stride_.Clear(); +} +inline uint32_t ConvolutionParameter::_internal_stride(int index) const { + return stride_.Get(index); +} +inline uint32_t ConvolutionParameter::stride(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride) + return _internal_stride(index); +} +inline void ConvolutionParameter::set_stride(int index, uint32_t value) { + stride_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride) +} +inline void ConvolutionParameter::_internal_add_stride(uint32_t value) { + stride_.Add(value); +} +inline void ConvolutionParameter::add_stride(uint32_t value) { + _internal_add_stride(value); + // @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.stride) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ConvolutionParameter::_internal_stride() const { + return stride_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ConvolutionParameter::stride() const { + // @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.stride) + return _internal_stride(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ConvolutionParameter::_internal_mutable_stride() { + return &stride_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ConvolutionParameter::mutable_stride() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.stride) + return _internal_mutable_stride(); +} + +// repeated uint32 dilation = 18; +inline int ConvolutionParameter::_internal_dilation_size() const { + return dilation_.size(); +} +inline int ConvolutionParameter::dilation_size() const { + return _internal_dilation_size(); +} +inline void ConvolutionParameter::clear_dilation() { + dilation_.Clear(); +} +inline uint32_t ConvolutionParameter::_internal_dilation(int index) const { + return dilation_.Get(index); +} +inline uint32_t ConvolutionParameter::dilation(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.dilation) + return _internal_dilation(index); +} +inline void ConvolutionParameter::set_dilation(int index, uint32_t value) { + dilation_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.dilation) +} +inline void ConvolutionParameter::_internal_add_dilation(uint32_t value) { + dilation_.Add(value); +} +inline void ConvolutionParameter::add_dilation(uint32_t value) { + _internal_add_dilation(value); + // @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.dilation) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ConvolutionParameter::_internal_dilation() const { + return dilation_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ConvolutionParameter::dilation() const { + // @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.dilation) + return _internal_dilation(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ConvolutionParameter::_internal_mutable_dilation() { + return &dilation_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ConvolutionParameter::mutable_dilation() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.dilation) + return _internal_mutable_dilation(); +} + +// optional uint32 pad_h = 9 [default = 0]; +inline bool ConvolutionParameter::_internal_has_pad_h() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ConvolutionParameter::has_pad_h() const { + return _internal_has_pad_h(); +} +inline void ConvolutionParameter::clear_pad_h() { + pad_h_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline uint32_t ConvolutionParameter::_internal_pad_h() const { + return pad_h_; +} +inline uint32_t ConvolutionParameter::pad_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad_h) + return _internal_pad_h(); +} +inline void ConvolutionParameter::_internal_set_pad_h(uint32_t value) { + _has_bits_[0] |= 0x00000008u; + pad_h_ = value; +} +inline void ConvolutionParameter::set_pad_h(uint32_t value) { + _internal_set_pad_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad_h) +} + +// optional uint32 pad_w = 10 [default = 0]; +inline bool ConvolutionParameter::_internal_has_pad_w() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ConvolutionParameter::has_pad_w() const { + return _internal_has_pad_w(); +} +inline void ConvolutionParameter::clear_pad_w() { + pad_w_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline uint32_t ConvolutionParameter::_internal_pad_w() const { + return pad_w_; +} +inline uint32_t ConvolutionParameter::pad_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad_w) + return _internal_pad_w(); +} +inline void ConvolutionParameter::_internal_set_pad_w(uint32_t value) { + _has_bits_[0] |= 0x00000010u; + pad_w_ = value; +} +inline void ConvolutionParameter::set_pad_w(uint32_t value) { + _internal_set_pad_w(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad_w) +} + +// optional uint32 kernel_h = 11; +inline bool ConvolutionParameter::_internal_has_kernel_h() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ConvolutionParameter::has_kernel_h() const { + return _internal_has_kernel_h(); +} +inline void ConvolutionParameter::clear_kernel_h() { + kernel_h_ = 0u; + _has_bits_[0] &= ~0x00000020u; +} +inline uint32_t ConvolutionParameter::_internal_kernel_h() const { + return kernel_h_; +} +inline uint32_t ConvolutionParameter::kernel_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_h) + return _internal_kernel_h(); +} +inline void ConvolutionParameter::_internal_set_kernel_h(uint32_t value) { + _has_bits_[0] |= 0x00000020u; + kernel_h_ = value; +} +inline void ConvolutionParameter::set_kernel_h(uint32_t value) { + _internal_set_kernel_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_h) +} + +// optional uint32 kernel_w = 12; +inline bool ConvolutionParameter::_internal_has_kernel_w() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ConvolutionParameter::has_kernel_w() const { + return _internal_has_kernel_w(); +} +inline void ConvolutionParameter::clear_kernel_w() { + kernel_w_ = 0u; + _has_bits_[0] &= ~0x00000040u; +} +inline uint32_t ConvolutionParameter::_internal_kernel_w() const { + return kernel_w_; +} +inline uint32_t ConvolutionParameter::kernel_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_w) + return _internal_kernel_w(); +} +inline void ConvolutionParameter::_internal_set_kernel_w(uint32_t value) { + _has_bits_[0] |= 0x00000040u; + kernel_w_ = value; +} +inline void ConvolutionParameter::set_kernel_w(uint32_t value) { + _internal_set_kernel_w(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_w) +} + +// optional uint32 stride_h = 13; +inline bool ConvolutionParameter::_internal_has_stride_h() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ConvolutionParameter::has_stride_h() const { + return _internal_has_stride_h(); +} +inline void ConvolutionParameter::clear_stride_h() { + stride_h_ = 0u; + _has_bits_[0] &= ~0x00000080u; +} +inline uint32_t ConvolutionParameter::_internal_stride_h() const { + return stride_h_; +} +inline uint32_t ConvolutionParameter::stride_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride_h) + return _internal_stride_h(); +} +inline void ConvolutionParameter::_internal_set_stride_h(uint32_t value) { + _has_bits_[0] |= 0x00000080u; + stride_h_ = value; +} +inline void ConvolutionParameter::set_stride_h(uint32_t value) { + _internal_set_stride_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride_h) +} + +// optional uint32 stride_w = 14; +inline bool ConvolutionParameter::_internal_has_stride_w() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool ConvolutionParameter::has_stride_w() const { + return _internal_has_stride_w(); +} +inline void ConvolutionParameter::clear_stride_w() { + stride_w_ = 0u; + _has_bits_[0] &= ~0x00000100u; +} +inline uint32_t ConvolutionParameter::_internal_stride_w() const { + return stride_w_; +} +inline uint32_t ConvolutionParameter::stride_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride_w) + return _internal_stride_w(); +} +inline void ConvolutionParameter::_internal_set_stride_w(uint32_t value) { + _has_bits_[0] |= 0x00000100u; + stride_w_ = value; +} +inline void ConvolutionParameter::set_stride_w(uint32_t value) { + _internal_set_stride_w(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride_w) +} + +// optional uint32 group = 5 [default = 1]; +inline bool ConvolutionParameter::_internal_has_group() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool ConvolutionParameter::has_group() const { + return _internal_has_group(); +} +inline void ConvolutionParameter::clear_group() { + group_ = 1u; + _has_bits_[0] &= ~0x00002000u; +} +inline uint32_t ConvolutionParameter::_internal_group() const { + return group_; +} +inline uint32_t ConvolutionParameter::group() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.group) + return _internal_group(); +} +inline void ConvolutionParameter::_internal_set_group(uint32_t value) { + _has_bits_[0] |= 0x00002000u; + group_ = value; +} +inline void ConvolutionParameter::set_group(uint32_t value) { + _internal_set_group(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.group) +} + +// optional .opencv_caffe.FillerParameter weight_filler = 7; +inline bool ConvolutionParameter::_internal_has_weight_filler() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || weight_filler_ != nullptr); + return value; +} +inline bool ConvolutionParameter::has_weight_filler() const { + return _internal_has_weight_filler(); +} +inline void ConvolutionParameter::clear_weight_filler() { + if (weight_filler_ != nullptr) weight_filler_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::_internal_weight_filler() const { + const ::opencv_caffe::FillerParameter* p = weight_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.weight_filler) + return _internal_weight_filler(); +} +inline void ConvolutionParameter::unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_); + } + weight_filler_ = weight_filler; + if (weight_filler) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ConvolutionParameter.weight_filler) +} +inline ::opencv_caffe::FillerParameter* ConvolutionParameter::release_weight_filler() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* ConvolutionParameter::unsafe_arena_release_weight_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.ConvolutionParameter.weight_filler) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* ConvolutionParameter::_internal_mutable_weight_filler() { + _has_bits_[0] |= 0x00000001u; + if (weight_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + weight_filler_ = p; + } + return weight_filler_; +} +inline ::opencv_caffe::FillerParameter* ConvolutionParameter::mutable_weight_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ConvolutionParameter.weight_filler) + return _msg; +} +inline void ConvolutionParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete weight_filler_; + } + if (weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(weight_filler); + if (message_arena != submessage_arena) { + weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, weight_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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::_internal_has_bias_filler() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || bias_filler_ != nullptr); + return value; +} +inline bool ConvolutionParameter::has_bias_filler() const { + return _internal_has_bias_filler(); +} +inline void ConvolutionParameter::clear_bias_filler() { + if (bias_filler_ != nullptr) bias_filler_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::_internal_bias_filler() const { + const ::opencv_caffe::FillerParameter* p = bias_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.bias_filler) + return _internal_bias_filler(); +} +inline void ConvolutionParameter::unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_); + } + bias_filler_ = bias_filler; + if (bias_filler) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ConvolutionParameter.bias_filler) +} +inline ::opencv_caffe::FillerParameter* ConvolutionParameter::release_bias_filler() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* ConvolutionParameter::unsafe_arena_release_bias_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.ConvolutionParameter.bias_filler) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* ConvolutionParameter::_internal_mutable_bias_filler() { + _has_bits_[0] |= 0x00000002u; + if (bias_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + bias_filler_ = p; + } + return bias_filler_; +} +inline ::opencv_caffe::FillerParameter* ConvolutionParameter::mutable_bias_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ConvolutionParameter.bias_filler) + return _msg; +} +inline void ConvolutionParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bias_filler_; + } + if (bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(bias_filler); + if (message_arena != submessage_arena) { + bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bias_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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::_internal_has_engine() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool ConvolutionParameter::has_engine() const { + return _internal_has_engine(); +} +inline void ConvolutionParameter::clear_engine() { + engine_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline ::opencv_caffe::ConvolutionParameter_Engine ConvolutionParameter::_internal_engine() const { + return static_cast< ::opencv_caffe::ConvolutionParameter_Engine >(engine_); +} +inline ::opencv_caffe::ConvolutionParameter_Engine ConvolutionParameter::engine() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.engine) + return _internal_engine(); +} +inline void ConvolutionParameter::_internal_set_engine(::opencv_caffe::ConvolutionParameter_Engine value) { + assert(::opencv_caffe::ConvolutionParameter_Engine_IsValid(value)); + _has_bits_[0] |= 0x00000200u; + engine_ = value; +} +inline void ConvolutionParameter::set_engine(::opencv_caffe::ConvolutionParameter_Engine value) { + _internal_set_engine(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.engine) +} + +// optional int32 axis = 16 [default = 1]; +inline bool ConvolutionParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool ConvolutionParameter::has_axis() const { + return _internal_has_axis(); +} +inline void ConvolutionParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000800u; +} +inline int32_t ConvolutionParameter::_internal_axis() const { + return axis_; +} +inline int32_t ConvolutionParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.axis) + return _internal_axis(); +} +inline void ConvolutionParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000800u; + axis_ = value; +} +inline void ConvolutionParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.axis) +} + +// optional bool force_nd_im2col = 17 [default = false]; +inline bool ConvolutionParameter::_internal_has_force_nd_im2col() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool ConvolutionParameter::has_force_nd_im2col() const { + return _internal_has_force_nd_im2col(); +} +inline void ConvolutionParameter::clear_force_nd_im2col() { + force_nd_im2col_ = false; + _has_bits_[0] &= ~0x00000400u; +} +inline bool ConvolutionParameter::_internal_force_nd_im2col() const { + return force_nd_im2col_; +} +inline bool ConvolutionParameter::force_nd_im2col() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.force_nd_im2col) + return _internal_force_nd_im2col(); +} +inline void ConvolutionParameter::_internal_set_force_nd_im2col(bool value) { + _has_bits_[0] |= 0x00000400u; + force_nd_im2col_ = value; +} +inline void ConvolutionParameter::set_force_nd_im2col(bool value) { + _internal_set_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::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool CropParameter::has_axis() const { + return _internal_has_axis(); +} +inline void CropParameter::clear_axis() { + axis_ = 2; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t CropParameter::_internal_axis() const { + return axis_; +} +inline int32_t CropParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.CropParameter.axis) + return _internal_axis(); +} +inline void CropParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000001u; + axis_ = value; +} +inline void CropParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.CropParameter.axis) +} + +// repeated uint32 offset = 2; +inline int CropParameter::_internal_offset_size() const { + return offset_.size(); +} +inline int CropParameter::offset_size() const { + return _internal_offset_size(); +} +inline void CropParameter::clear_offset() { + offset_.Clear(); +} +inline uint32_t CropParameter::_internal_offset(int index) const { + return offset_.Get(index); +} +inline uint32_t CropParameter::offset(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.CropParameter.offset) + return _internal_offset(index); +} +inline void CropParameter::set_offset(int index, uint32_t value) { + offset_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.CropParameter.offset) +} +inline void CropParameter::_internal_add_offset(uint32_t value) { + offset_.Add(value); +} +inline void CropParameter::add_offset(uint32_t value) { + _internal_add_offset(value); + // @@protoc_insertion_point(field_add:opencv_caffe.CropParameter.offset) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +CropParameter::_internal_offset() const { + return offset_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +CropParameter::offset() const { + // @@protoc_insertion_point(field_list:opencv_caffe.CropParameter.offset) + return _internal_offset(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +CropParameter::_internal_mutable_offset() { + return &offset_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +CropParameter::mutable_offset() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.CropParameter.offset) + return _internal_mutable_offset(); +} + +// ------------------------------------------------------------------- + +// DataParameter + +// optional string source = 1; +inline bool DataParameter::_internal_has_source() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool DataParameter::has_source() const { + return _internal_has_source(); +} +inline void DataParameter::clear_source() { + source_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& DataParameter::source() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.source) + return _internal_source(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void DataParameter::set_source(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.source) +} +inline std::string* DataParameter::mutable_source() { + std::string* _s = _internal_mutable_source(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.DataParameter.source) + return _s; +} +inline const std::string& DataParameter::_internal_source() const { + return source_.Get(); +} +inline void DataParameter::_internal_set_source(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* DataParameter::_internal_mutable_source() { + _has_bits_[0] |= 0x00000001u; + return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* DataParameter::release_source() { + // @@protoc_insertion_point(field_release:opencv_caffe.DataParameter.source) + if (!_internal_has_source()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void DataParameter::set_allocated_source(std::string* source) { + if (source != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.DataParameter.source) +} + +// optional uint32 batch_size = 4; +inline bool DataParameter::_internal_has_batch_size() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool DataParameter::has_batch_size() const { + return _internal_has_batch_size(); +} +inline void DataParameter::clear_batch_size() { + batch_size_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t DataParameter::_internal_batch_size() const { + return batch_size_; +} +inline uint32_t DataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.batch_size) + return _internal_batch_size(); +} +inline void DataParameter::_internal_set_batch_size(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + batch_size_ = value; +} +inline void DataParameter::set_batch_size(uint32_t value) { + _internal_set_batch_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.batch_size) +} + +// optional uint32 rand_skip = 7 [default = 0]; +inline bool DataParameter::_internal_has_rand_skip() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool DataParameter::has_rand_skip() const { + return _internal_has_rand_skip(); +} +inline void DataParameter::clear_rand_skip() { + rand_skip_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline uint32_t DataParameter::_internal_rand_skip() const { + return rand_skip_; +} +inline uint32_t DataParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.rand_skip) + return _internal_rand_skip(); +} +inline void DataParameter::_internal_set_rand_skip(uint32_t value) { + _has_bits_[0] |= 0x00000010u; + rand_skip_ = value; +} +inline void DataParameter::set_rand_skip(uint32_t value) { + _internal_set_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::_internal_has_backend() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool DataParameter::has_backend() const { + return _internal_has_backend(); +} +inline void DataParameter::clear_backend() { + backend_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline ::opencv_caffe::DataParameter_DB DataParameter::_internal_backend() const { + return static_cast< ::opencv_caffe::DataParameter_DB >(backend_); +} +inline ::opencv_caffe::DataParameter_DB DataParameter::backend() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.backend) + return _internal_backend(); +} +inline void DataParameter::_internal_set_backend(::opencv_caffe::DataParameter_DB value) { + assert(::opencv_caffe::DataParameter_DB_IsValid(value)); + _has_bits_[0] |= 0x00000080u; + backend_ = value; +} +inline void DataParameter::set_backend(::opencv_caffe::DataParameter_DB value) { + _internal_set_backend(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.backend) +} + +// optional float scale = 2 [default = 1]; +inline bool DataParameter::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool DataParameter::has_scale() const { + return _internal_has_scale(); +} +inline void DataParameter::clear_scale() { + scale_ = 1; + _has_bits_[0] &= ~0x00000100u; +} +inline float DataParameter::_internal_scale() const { + return scale_; +} +inline float DataParameter::scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.scale) + return _internal_scale(); +} +inline void DataParameter::_internal_set_scale(float value) { + _has_bits_[0] |= 0x00000100u; + scale_ = value; +} +inline void DataParameter::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.scale) +} + +// optional string mean_file = 3; +inline bool DataParameter::_internal_has_mean_file() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool DataParameter::has_mean_file() const { + return _internal_has_mean_file(); +} +inline void DataParameter::clear_mean_file() { + mean_file_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& DataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.mean_file) + return _internal_mean_file(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void DataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.mean_file) +} +inline std::string* DataParameter::mutable_mean_file() { + std::string* _s = _internal_mutable_mean_file(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.DataParameter.mean_file) + return _s; +} +inline const std::string& DataParameter::_internal_mean_file() const { + return mean_file_.Get(); +} +inline void DataParameter::_internal_set_mean_file(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* DataParameter::_internal_mutable_mean_file() { + _has_bits_[0] |= 0x00000002u; + return mean_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* DataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:opencv_caffe.DataParameter.mean_file) + if (!_internal_has_mean_file()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = mean_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void DataParameter::set_allocated_mean_file(std::string* mean_file) { + if (mean_file != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + mean_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mean_file, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.DataParameter.mean_file) +} + +// optional uint32 crop_size = 5 [default = 0]; +inline bool DataParameter::_internal_has_crop_size() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool DataParameter::has_crop_size() const { + return _internal_has_crop_size(); +} +inline void DataParameter::clear_crop_size() { + crop_size_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline uint32_t DataParameter::_internal_crop_size() const { + return crop_size_; +} +inline uint32_t DataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.crop_size) + return _internal_crop_size(); +} +inline void DataParameter::_internal_set_crop_size(uint32_t value) { + _has_bits_[0] |= 0x00000008u; + crop_size_ = value; +} +inline void DataParameter::set_crop_size(uint32_t value) { + _internal_set_crop_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +inline bool DataParameter::_internal_has_mirror() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool DataParameter::has_mirror() const { + return _internal_has_mirror(); +} +inline void DataParameter::clear_mirror() { + mirror_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool DataParameter::_internal_mirror() const { + return mirror_; +} +inline bool DataParameter::mirror() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.mirror) + return _internal_mirror(); +} +inline void DataParameter::_internal_set_mirror(bool value) { + _has_bits_[0] |= 0x00000020u; + mirror_ = value; +} +inline void DataParameter::set_mirror(bool value) { + _internal_set_mirror(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.mirror) +} + +// optional bool force_encoded_color = 9 [default = false]; +inline bool DataParameter::_internal_has_force_encoded_color() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool DataParameter::has_force_encoded_color() const { + return _internal_has_force_encoded_color(); +} +inline void DataParameter::clear_force_encoded_color() { + force_encoded_color_ = false; + _has_bits_[0] &= ~0x00000040u; +} +inline bool DataParameter::_internal_force_encoded_color() const { + return force_encoded_color_; +} +inline bool DataParameter::force_encoded_color() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.force_encoded_color) + return _internal_force_encoded_color(); +} +inline void DataParameter::_internal_set_force_encoded_color(bool value) { + _has_bits_[0] |= 0x00000040u; + force_encoded_color_ = value; +} +inline void DataParameter::set_force_encoded_color(bool value) { + _internal_set_force_encoded_color(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.force_encoded_color) +} + +// optional uint32 prefetch = 10 [default = 4]; +inline bool DataParameter::_internal_has_prefetch() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool DataParameter::has_prefetch() const { + return _internal_has_prefetch(); +} +inline void DataParameter::clear_prefetch() { + prefetch_ = 4u; + _has_bits_[0] &= ~0x00000200u; +} +inline uint32_t DataParameter::_internal_prefetch() const { + return prefetch_; +} +inline uint32_t DataParameter::prefetch() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.prefetch) + return _internal_prefetch(); +} +inline void DataParameter::_internal_set_prefetch(uint32_t value) { + _has_bits_[0] |= 0x00000200u; + prefetch_ = value; +} +inline void DataParameter::set_prefetch(uint32_t value) { + _internal_set_prefetch(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.prefetch) +} + +// ------------------------------------------------------------------- + +// NonMaximumSuppressionParameter + +// optional float nms_threshold = 1 [default = 0.3]; +inline bool NonMaximumSuppressionParameter::_internal_has_nms_threshold() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool NonMaximumSuppressionParameter::has_nms_threshold() const { + return _internal_has_nms_threshold(); +} +inline void NonMaximumSuppressionParameter::clear_nms_threshold() { + nms_threshold_ = 0.3f; + _has_bits_[0] &= ~0x00000002u; +} +inline float NonMaximumSuppressionParameter::_internal_nms_threshold() const { + return nms_threshold_; +} +inline float NonMaximumSuppressionParameter::nms_threshold() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.nms_threshold) + return _internal_nms_threshold(); +} +inline void NonMaximumSuppressionParameter::_internal_set_nms_threshold(float value) { + _has_bits_[0] |= 0x00000002u; + nms_threshold_ = value; +} +inline void NonMaximumSuppressionParameter::set_nms_threshold(float value) { + _internal_set_nms_threshold(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.nms_threshold) +} + +// optional int32 top_k = 2; +inline bool NonMaximumSuppressionParameter::_internal_has_top_k() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NonMaximumSuppressionParameter::has_top_k() const { + return _internal_has_top_k(); +} +inline void NonMaximumSuppressionParameter::clear_top_k() { + top_k_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t NonMaximumSuppressionParameter::_internal_top_k() const { + return top_k_; +} +inline int32_t NonMaximumSuppressionParameter::top_k() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.top_k) + return _internal_top_k(); +} +inline void NonMaximumSuppressionParameter::_internal_set_top_k(int32_t value) { + _has_bits_[0] |= 0x00000001u; + top_k_ = value; +} +inline void NonMaximumSuppressionParameter::set_top_k(int32_t value) { + _internal_set_top_k(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.top_k) +} + +// optional float eta = 3 [default = 1]; +inline bool NonMaximumSuppressionParameter::_internal_has_eta() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool NonMaximumSuppressionParameter::has_eta() const { + return _internal_has_eta(); +} +inline void NonMaximumSuppressionParameter::clear_eta() { + eta_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline float NonMaximumSuppressionParameter::_internal_eta() const { + return eta_; +} +inline float NonMaximumSuppressionParameter::eta() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.eta) + return _internal_eta(); +} +inline void NonMaximumSuppressionParameter::_internal_set_eta(float value) { + _has_bits_[0] |= 0x00000004u; + eta_ = value; +} +inline void NonMaximumSuppressionParameter::set_eta(float value) { + _internal_set_eta(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.eta) +} + +// ------------------------------------------------------------------- + +// SaveOutputParameter + +// optional string output_directory = 1; +inline bool SaveOutputParameter::_internal_has_output_directory() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SaveOutputParameter::has_output_directory() const { + return _internal_has_output_directory(); +} +inline void SaveOutputParameter::clear_output_directory() { + output_directory_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SaveOutputParameter::output_directory() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_directory) + return _internal_output_directory(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SaveOutputParameter::set_output_directory(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + output_directory_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_directory) +} +inline std::string* SaveOutputParameter::mutable_output_directory() { + std::string* _s = _internal_mutable_output_directory(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_directory) + return _s; +} +inline const std::string& SaveOutputParameter::_internal_output_directory() const { + return output_directory_.Get(); +} +inline void SaveOutputParameter::_internal_set_output_directory(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + output_directory_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::_internal_mutable_output_directory() { + _has_bits_[0] |= 0x00000001u; + return output_directory_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::release_output_directory() { + // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_directory) + if (!_internal_has_output_directory()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = output_directory_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (output_directory_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + output_directory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SaveOutputParameter::set_allocated_output_directory(std::string* output_directory) { + if (output_directory != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + output_directory_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), output_directory, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (output_directory_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + output_directory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_directory) +} + +// optional string output_name_prefix = 2; +inline bool SaveOutputParameter::_internal_has_output_name_prefix() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SaveOutputParameter::has_output_name_prefix() const { + return _internal_has_output_name_prefix(); +} +inline void SaveOutputParameter::clear_output_name_prefix() { + output_name_prefix_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SaveOutputParameter::output_name_prefix() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_name_prefix) + return _internal_output_name_prefix(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SaveOutputParameter::set_output_name_prefix(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + output_name_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_name_prefix) +} +inline std::string* SaveOutputParameter::mutable_output_name_prefix() { + std::string* _s = _internal_mutable_output_name_prefix(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_name_prefix) + return _s; +} +inline const std::string& SaveOutputParameter::_internal_output_name_prefix() const { + return output_name_prefix_.Get(); +} +inline void SaveOutputParameter::_internal_set_output_name_prefix(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + output_name_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::_internal_mutable_output_name_prefix() { + _has_bits_[0] |= 0x00000002u; + return output_name_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::release_output_name_prefix() { + // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_name_prefix) + if (!_internal_has_output_name_prefix()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = output_name_prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (output_name_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + output_name_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SaveOutputParameter::set_allocated_output_name_prefix(std::string* output_name_prefix) { + if (output_name_prefix != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + output_name_prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), output_name_prefix, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (output_name_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + output_name_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_name_prefix) +} + +// optional string output_format = 3; +inline bool SaveOutputParameter::_internal_has_output_format() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SaveOutputParameter::has_output_format() const { + return _internal_has_output_format(); +} +inline void SaveOutputParameter::clear_output_format() { + output_format_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& SaveOutputParameter::output_format() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_format) + return _internal_output_format(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SaveOutputParameter::set_output_format(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + output_format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_format) +} +inline std::string* SaveOutputParameter::mutable_output_format() { + std::string* _s = _internal_mutable_output_format(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_format) + return _s; +} +inline const std::string& SaveOutputParameter::_internal_output_format() const { + return output_format_.Get(); +} +inline void SaveOutputParameter::_internal_set_output_format(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + output_format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::_internal_mutable_output_format() { + _has_bits_[0] |= 0x00000004u; + return output_format_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::release_output_format() { + // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_format) + if (!_internal_has_output_format()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = output_format_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (output_format_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + output_format_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SaveOutputParameter::set_allocated_output_format(std::string* output_format) { + if (output_format != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + output_format_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), output_format, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (output_format_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + output_format_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_format) +} + +// optional string label_map_file = 4; +inline bool SaveOutputParameter::_internal_has_label_map_file() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SaveOutputParameter::has_label_map_file() const { + return _internal_has_label_map_file(); +} +inline void SaveOutputParameter::clear_label_map_file() { + label_map_file_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& SaveOutputParameter::label_map_file() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.label_map_file) + return _internal_label_map_file(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SaveOutputParameter::set_label_map_file(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000008u; + label_map_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.label_map_file) +} +inline std::string* SaveOutputParameter::mutable_label_map_file() { + std::string* _s = _internal_mutable_label_map_file(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.label_map_file) + return _s; +} +inline const std::string& SaveOutputParameter::_internal_label_map_file() const { + return label_map_file_.Get(); +} +inline void SaveOutputParameter::_internal_set_label_map_file(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + label_map_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::_internal_mutable_label_map_file() { + _has_bits_[0] |= 0x00000008u; + return label_map_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::release_label_map_file() { + // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.label_map_file) + if (!_internal_has_label_map_file()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto* p = label_map_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (label_map_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SaveOutputParameter::set_allocated_label_map_file(std::string* label_map_file) { + if (label_map_file != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + label_map_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), label_map_file, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (label_map_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.label_map_file) +} + +// optional string name_size_file = 5; +inline bool SaveOutputParameter::_internal_has_name_size_file() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool SaveOutputParameter::has_name_size_file() const { + return _internal_has_name_size_file(); +} +inline void SaveOutputParameter::clear_name_size_file() { + name_size_file_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& SaveOutputParameter::name_size_file() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.name_size_file) + return _internal_name_size_file(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SaveOutputParameter::set_name_size_file(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000010u; + name_size_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.name_size_file) +} +inline std::string* SaveOutputParameter::mutable_name_size_file() { + std::string* _s = _internal_mutable_name_size_file(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.name_size_file) + return _s; +} +inline const std::string& SaveOutputParameter::_internal_name_size_file() const { + return name_size_file_.Get(); +} +inline void SaveOutputParameter::_internal_set_name_size_file(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + name_size_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::_internal_mutable_name_size_file() { + _has_bits_[0] |= 0x00000010u; + return name_size_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SaveOutputParameter::release_name_size_file() { + // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.name_size_file) + if (!_internal_has_name_size_file()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + auto* p = name_size_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_size_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SaveOutputParameter::set_allocated_name_size_file(std::string* name_size_file) { + if (name_size_file != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + name_size_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name_size_file, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_size_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.name_size_file) +} + +// optional uint32 num_test_image = 6; +inline bool SaveOutputParameter::_internal_has_num_test_image() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool SaveOutputParameter::has_num_test_image() const { + return _internal_has_num_test_image(); +} +inline void SaveOutputParameter::clear_num_test_image() { + num_test_image_ = 0u; + _has_bits_[0] &= ~0x00000020u; +} +inline uint32_t SaveOutputParameter::_internal_num_test_image() const { + return num_test_image_; +} +inline uint32_t SaveOutputParameter::num_test_image() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.num_test_image) + return _internal_num_test_image(); +} +inline void SaveOutputParameter::_internal_set_num_test_image(uint32_t value) { + _has_bits_[0] |= 0x00000020u; + num_test_image_ = value; +} +inline void SaveOutputParameter::set_num_test_image(uint32_t value) { + _internal_set_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::_internal_has_dropout_ratio() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool DropoutParameter::has_dropout_ratio() const { + return _internal_has_dropout_ratio(); +} +inline void DropoutParameter::clear_dropout_ratio() { + dropout_ratio_ = 0.5f; + _has_bits_[0] &= ~0x00000001u; +} +inline float DropoutParameter::_internal_dropout_ratio() const { + return dropout_ratio_; +} +inline float DropoutParameter::dropout_ratio() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DropoutParameter.dropout_ratio) + return _internal_dropout_ratio(); +} +inline void DropoutParameter::_internal_set_dropout_ratio(float value) { + _has_bits_[0] |= 0x00000001u; + dropout_ratio_ = value; +} +inline void DropoutParameter::set_dropout_ratio(float value) { + _internal_set_dropout_ratio(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DropoutParameter.dropout_ratio) +} + +// optional bool scale_train = 2 [default = true]; +inline bool DropoutParameter::_internal_has_scale_train() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool DropoutParameter::has_scale_train() const { + return _internal_has_scale_train(); +} +inline void DropoutParameter::clear_scale_train() { + scale_train_ = true; + _has_bits_[0] &= ~0x00000002u; +} +inline bool DropoutParameter::_internal_scale_train() const { + return scale_train_; +} +inline bool DropoutParameter::scale_train() const { + // @@protoc_insertion_point(field_get:opencv_caffe.DropoutParameter.scale_train) + return _internal_scale_train(); +} +inline void DropoutParameter::_internal_set_scale_train(bool value) { + _has_bits_[0] |= 0x00000002u; + scale_train_ = value; +} +inline void DropoutParameter::set_scale_train(bool value) { + _internal_set_scale_train(value); + // @@protoc_insertion_point(field_set:opencv_caffe.DropoutParameter.scale_train) +} + +// ------------------------------------------------------------------- + +// DummyDataParameter + +// repeated .opencv_caffe.FillerParameter data_filler = 1; +inline int DummyDataParameter::_internal_data_filler_size() const { + return data_filler_.size(); +} +inline int DummyDataParameter::data_filler_size() const { + return _internal_data_filler_size(); +} +inline void DummyDataParameter::clear_data_filler() { + data_filler_.Clear(); +} +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 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter >* +DummyDataParameter::mutable_data_filler() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.data_filler) + return &data_filler_; +} +inline const ::opencv_caffe::FillerParameter& DummyDataParameter::_internal_data_filler(int index) const { + return data_filler_.Get(index); +} +inline const ::opencv_caffe::FillerParameter& DummyDataParameter::data_filler(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.data_filler) + return _internal_data_filler(index); +} +inline ::opencv_caffe::FillerParameter* DummyDataParameter::_internal_add_data_filler() { + return data_filler_.Add(); +} +inline ::opencv_caffe::FillerParameter* DummyDataParameter::add_data_filler() { + ::opencv_caffe::FillerParameter* _add = _internal_add_data_filler(); + // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.data_filler) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_shape_size() const { + return shape_.size(); +} +inline int DummyDataParameter::shape_size() const { + return _internal_shape_size(); +} +inline void DummyDataParameter::clear_shape() { + shape_.Clear(); +} +inline ::opencv_caffe::BlobShape* DummyDataParameter::mutable_shape(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.DummyDataParameter.shape) + return shape_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >* +DummyDataParameter::mutable_shape() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.shape) + return &shape_; +} +inline const ::opencv_caffe::BlobShape& DummyDataParameter::_internal_shape(int index) const { + return shape_.Get(index); +} +inline const ::opencv_caffe::BlobShape& DummyDataParameter::shape(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.shape) + return _internal_shape(index); +} +inline ::opencv_caffe::BlobShape* DummyDataParameter::_internal_add_shape() { + return shape_.Add(); +} +inline ::opencv_caffe::BlobShape* DummyDataParameter::add_shape() { + ::opencv_caffe::BlobShape* _add = _internal_add_shape(); + // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.shape) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_num_size() const { + return num_.size(); +} +inline int DummyDataParameter::num_size() const { + return _internal_num_size(); +} +inline void DummyDataParameter::clear_num() { + num_.Clear(); +} +inline uint32_t DummyDataParameter::_internal_num(int index) const { + return num_.Get(index); +} +inline uint32_t DummyDataParameter::num(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.num) + return _internal_num(index); +} +inline void DummyDataParameter::set_num(int index, uint32_t value) { + num_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.num) +} +inline void DummyDataParameter::_internal_add_num(uint32_t value) { + num_.Add(value); +} +inline void DummyDataParameter::add_num(uint32_t value) { + _internal_add_num(value); + // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.num) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DummyDataParameter::_internal_num() const { + return num_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DummyDataParameter::num() const { + // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.num) + return _internal_num(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DummyDataParameter::_internal_mutable_num() { + return &num_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DummyDataParameter::mutable_num() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.num) + return _internal_mutable_num(); +} + +// repeated uint32 channels = 3; +inline int DummyDataParameter::_internal_channels_size() const { + return channels_.size(); +} +inline int DummyDataParameter::channels_size() const { + return _internal_channels_size(); +} +inline void DummyDataParameter::clear_channels() { + channels_.Clear(); +} +inline uint32_t DummyDataParameter::_internal_channels(int index) const { + return channels_.Get(index); +} +inline uint32_t DummyDataParameter::channels(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.channels) + return _internal_channels(index); +} +inline void DummyDataParameter::set_channels(int index, uint32_t value) { + channels_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.channels) +} +inline void DummyDataParameter::_internal_add_channels(uint32_t value) { + channels_.Add(value); +} +inline void DummyDataParameter::add_channels(uint32_t value) { + _internal_add_channels(value); + // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.channels) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DummyDataParameter::_internal_channels() const { + return channels_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DummyDataParameter::channels() const { + // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.channels) + return _internal_channels(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DummyDataParameter::_internal_mutable_channels() { + return &channels_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DummyDataParameter::mutable_channels() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.channels) + return _internal_mutable_channels(); +} + +// repeated uint32 height = 4; +inline int DummyDataParameter::_internal_height_size() const { + return height_.size(); +} +inline int DummyDataParameter::height_size() const { + return _internal_height_size(); +} +inline void DummyDataParameter::clear_height() { + height_.Clear(); +} +inline uint32_t DummyDataParameter::_internal_height(int index) const { + return height_.Get(index); +} +inline uint32_t DummyDataParameter::height(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.height) + return _internal_height(index); +} +inline void DummyDataParameter::set_height(int index, uint32_t value) { + height_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.height) +} +inline void DummyDataParameter::_internal_add_height(uint32_t value) { + height_.Add(value); +} +inline void DummyDataParameter::add_height(uint32_t value) { + _internal_add_height(value); + // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.height) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DummyDataParameter::_internal_height() const { + return height_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DummyDataParameter::height() const { + // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.height) + return _internal_height(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DummyDataParameter::_internal_mutable_height() { + return &height_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DummyDataParameter::mutable_height() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.height) + return _internal_mutable_height(); +} + +// repeated uint32 width = 5; +inline int DummyDataParameter::_internal_width_size() const { + return width_.size(); +} +inline int DummyDataParameter::width_size() const { + return _internal_width_size(); +} +inline void DummyDataParameter::clear_width() { + width_.Clear(); +} +inline uint32_t DummyDataParameter::_internal_width(int index) const { + return width_.Get(index); +} +inline uint32_t DummyDataParameter::width(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.width) + return _internal_width(index); +} +inline void DummyDataParameter::set_width(int index, uint32_t value) { + width_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.width) +} +inline void DummyDataParameter::_internal_add_width(uint32_t value) { + width_.Add(value); +} +inline void DummyDataParameter::add_width(uint32_t value) { + _internal_add_width(value); + // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.width) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DummyDataParameter::_internal_width() const { + return width_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DummyDataParameter::width() const { + // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.width) + return _internal_width(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DummyDataParameter::_internal_mutable_width() { + return &width_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DummyDataParameter::mutable_width() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.width) + return _internal_mutable_width(); +} + +// ------------------------------------------------------------------- + +// EltwiseParameter + +// optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; +inline bool EltwiseParameter::_internal_has_operation() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool EltwiseParameter::has_operation() const { + return _internal_has_operation(); +} +inline void EltwiseParameter::clear_operation() { + operation_ = 1; + _has_bits_[0] &= ~0x00000001u; +} +inline ::opencv_caffe::EltwiseParameter_EltwiseOp EltwiseParameter::_internal_operation() const { + return static_cast< ::opencv_caffe::EltwiseParameter_EltwiseOp >(operation_); +} +inline ::opencv_caffe::EltwiseParameter_EltwiseOp EltwiseParameter::operation() const { + // @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.operation) + return _internal_operation(); +} +inline void EltwiseParameter::_internal_set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value) { + assert(::opencv_caffe::EltwiseParameter_EltwiseOp_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + operation_ = value; +} +inline void EltwiseParameter::set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value) { + _internal_set_operation(value); + // @@protoc_insertion_point(field_set:opencv_caffe.EltwiseParameter.operation) +} + +// repeated float coeff = 2; +inline int EltwiseParameter::_internal_coeff_size() const { + return coeff_.size(); +} +inline int EltwiseParameter::coeff_size() const { + return _internal_coeff_size(); +} +inline void EltwiseParameter::clear_coeff() { + coeff_.Clear(); +} +inline float EltwiseParameter::_internal_coeff(int index) const { + return coeff_.Get(index); +} +inline float EltwiseParameter::coeff(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.coeff) + return _internal_coeff(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::_internal_add_coeff(float value) { + coeff_.Add(value); +} +inline void EltwiseParameter::add_coeff(float value) { + _internal_add_coeff(value); + // @@protoc_insertion_point(field_add:opencv_caffe.EltwiseParameter.coeff) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +EltwiseParameter::_internal_coeff() const { + return coeff_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +EltwiseParameter::coeff() const { + // @@protoc_insertion_point(field_list:opencv_caffe.EltwiseParameter.coeff) + return _internal_coeff(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +EltwiseParameter::_internal_mutable_coeff() { + return &coeff_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +EltwiseParameter::mutable_coeff() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.EltwiseParameter.coeff) + return _internal_mutable_coeff(); +} + +// optional bool stable_prod_grad = 3 [default = true]; +inline bool EltwiseParameter::_internal_has_stable_prod_grad() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool EltwiseParameter::has_stable_prod_grad() const { + return _internal_has_stable_prod_grad(); +} +inline void EltwiseParameter::clear_stable_prod_grad() { + stable_prod_grad_ = true; + _has_bits_[0] &= ~0x00000002u; +} +inline bool EltwiseParameter::_internal_stable_prod_grad() const { + return stable_prod_grad_; +} +inline bool EltwiseParameter::stable_prod_grad() const { + // @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.stable_prod_grad) + return _internal_stable_prod_grad(); +} +inline void EltwiseParameter::_internal_set_stable_prod_grad(bool value) { + _has_bits_[0] |= 0x00000002u; + stable_prod_grad_ = value; +} +inline void EltwiseParameter::set_stable_prod_grad(bool value) { + _internal_set_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::_internal_has_alpha() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ELUParameter::has_alpha() const { + return _internal_has_alpha(); +} +inline void ELUParameter::clear_alpha() { + alpha_ = 1; + _has_bits_[0] &= ~0x00000001u; +} +inline float ELUParameter::_internal_alpha() const { + return alpha_; +} +inline float ELUParameter::alpha() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ELUParameter.alpha) + return _internal_alpha(); +} +inline void ELUParameter::_internal_set_alpha(float value) { + _has_bits_[0] |= 0x00000001u; + alpha_ = value; +} +inline void ELUParameter::set_alpha(float value) { + _internal_set_alpha(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ELUParameter.alpha) +} + +// ------------------------------------------------------------------- + +// EmbedParameter + +// optional uint32 num_output = 1; +inline bool EmbedParameter::_internal_has_num_output() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool EmbedParameter::has_num_output() const { + return _internal_has_num_output(); +} +inline void EmbedParameter::clear_num_output() { + num_output_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t EmbedParameter::_internal_num_output() const { + return num_output_; +} +inline uint32_t EmbedParameter::num_output() const { + // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.num_output) + return _internal_num_output(); +} +inline void EmbedParameter::_internal_set_num_output(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + num_output_ = value; +} +inline void EmbedParameter::set_num_output(uint32_t value) { + _internal_set_num_output(value); + // @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.num_output) +} + +// optional uint32 input_dim = 2; +inline bool EmbedParameter::_internal_has_input_dim() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool EmbedParameter::has_input_dim() const { + return _internal_has_input_dim(); +} +inline void EmbedParameter::clear_input_dim() { + input_dim_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline uint32_t EmbedParameter::_internal_input_dim() const { + return input_dim_; +} +inline uint32_t EmbedParameter::input_dim() const { + // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.input_dim) + return _internal_input_dim(); +} +inline void EmbedParameter::_internal_set_input_dim(uint32_t value) { + _has_bits_[0] |= 0x00000008u; + input_dim_ = value; +} +inline void EmbedParameter::set_input_dim(uint32_t value) { + _internal_set_input_dim(value); + // @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.input_dim) +} + +// optional bool bias_term = 3 [default = true]; +inline bool EmbedParameter::_internal_has_bias_term() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool EmbedParameter::has_bias_term() const { + return _internal_has_bias_term(); +} +inline void EmbedParameter::clear_bias_term() { + bias_term_ = true; + _has_bits_[0] &= ~0x00000010u; +} +inline bool EmbedParameter::_internal_bias_term() const { + return bias_term_; +} +inline bool EmbedParameter::bias_term() const { + // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.bias_term) + return _internal_bias_term(); +} +inline void EmbedParameter::_internal_set_bias_term(bool value) { + _has_bits_[0] |= 0x00000010u; + bias_term_ = value; +} +inline void EmbedParameter::set_bias_term(bool value) { + _internal_set_bias_term(value); + // @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.bias_term) +} + +// optional .opencv_caffe.FillerParameter weight_filler = 4; +inline bool EmbedParameter::_internal_has_weight_filler() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || weight_filler_ != nullptr); + return value; +} +inline bool EmbedParameter::has_weight_filler() const { + return _internal_has_weight_filler(); +} +inline void EmbedParameter::clear_weight_filler() { + if (weight_filler_ != nullptr) weight_filler_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::FillerParameter& EmbedParameter::_internal_weight_filler() const { + const ::opencv_caffe::FillerParameter* p = weight_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& EmbedParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.weight_filler) + return _internal_weight_filler(); +} +inline void EmbedParameter::unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_); + } + weight_filler_ = weight_filler; + if (weight_filler) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.EmbedParameter.weight_filler) +} +inline ::opencv_caffe::FillerParameter* EmbedParameter::release_weight_filler() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* EmbedParameter::unsafe_arena_release_weight_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.EmbedParameter.weight_filler) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* EmbedParameter::_internal_mutable_weight_filler() { + _has_bits_[0] |= 0x00000001u; + if (weight_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + weight_filler_ = p; + } + return weight_filler_; +} +inline ::opencv_caffe::FillerParameter* EmbedParameter::mutable_weight_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.EmbedParameter.weight_filler) + return _msg; +} +inline void EmbedParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete weight_filler_; + } + if (weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(weight_filler); + if (message_arena != submessage_arena) { + weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, weight_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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::_internal_has_bias_filler() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || bias_filler_ != nullptr); + return value; +} +inline bool EmbedParameter::has_bias_filler() const { + return _internal_has_bias_filler(); +} +inline void EmbedParameter::clear_bias_filler() { + if (bias_filler_ != nullptr) bias_filler_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::FillerParameter& EmbedParameter::_internal_bias_filler() const { + const ::opencv_caffe::FillerParameter* p = bias_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& EmbedParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.bias_filler) + return _internal_bias_filler(); +} +inline void EmbedParameter::unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_); + } + bias_filler_ = bias_filler; + if (bias_filler) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.EmbedParameter.bias_filler) +} +inline ::opencv_caffe::FillerParameter* EmbedParameter::release_bias_filler() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* EmbedParameter::unsafe_arena_release_bias_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.EmbedParameter.bias_filler) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* EmbedParameter::_internal_mutable_bias_filler() { + _has_bits_[0] |= 0x00000002u; + if (bias_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + bias_filler_ = p; + } + return bias_filler_; +} +inline ::opencv_caffe::FillerParameter* EmbedParameter::mutable_bias_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.EmbedParameter.bias_filler) + return _msg; +} +inline void EmbedParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bias_filler_; + } + if (bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(bias_filler); + if (message_arena != submessage_arena) { + bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bias_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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::_internal_has_base() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ExpParameter::has_base() const { + return _internal_has_base(); +} +inline void ExpParameter::clear_base() { + base_ = -1; + _has_bits_[0] &= ~0x00000002u; +} +inline float ExpParameter::_internal_base() const { + return base_; +} +inline float ExpParameter::base() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.base) + return _internal_base(); +} +inline void ExpParameter::_internal_set_base(float value) { + _has_bits_[0] |= 0x00000002u; + base_ = value; +} +inline void ExpParameter::set_base(float value) { + _internal_set_base(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.base) +} + +// optional float scale = 2 [default = 1]; +inline bool ExpParameter::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ExpParameter::has_scale() const { + return _internal_has_scale(); +} +inline void ExpParameter::clear_scale() { + scale_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline float ExpParameter::_internal_scale() const { + return scale_; +} +inline float ExpParameter::scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.scale) + return _internal_scale(); +} +inline void ExpParameter::_internal_set_scale(float value) { + _has_bits_[0] |= 0x00000004u; + scale_ = value; +} +inline void ExpParameter::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.scale) +} + +// optional float shift = 3 [default = 0]; +inline bool ExpParameter::_internal_has_shift() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ExpParameter::has_shift() const { + return _internal_has_shift(); +} +inline void ExpParameter::clear_shift() { + shift_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float ExpParameter::_internal_shift() const { + return shift_; +} +inline float ExpParameter::shift() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.shift) + return _internal_shift(); +} +inline void ExpParameter::_internal_set_shift(float value) { + _has_bits_[0] |= 0x00000001u; + shift_ = value; +} +inline void ExpParameter::set_shift(float value) { + _internal_set_shift(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.shift) +} + +// ------------------------------------------------------------------- + +// FlattenParameter + +// optional int32 axis = 1 [default = 1]; +inline bool FlattenParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool FlattenParameter::has_axis() const { + return _internal_has_axis(); +} +inline void FlattenParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t FlattenParameter::_internal_axis() const { + return axis_; +} +inline int32_t FlattenParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FlattenParameter.axis) + return _internal_axis(); +} +inline void FlattenParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000001u; + axis_ = value; +} +inline void FlattenParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.FlattenParameter.axis) +} + +// optional int32 end_axis = 2 [default = -1]; +inline bool FlattenParameter::_internal_has_end_axis() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool FlattenParameter::has_end_axis() const { + return _internal_has_end_axis(); +} +inline void FlattenParameter::clear_end_axis() { + end_axis_ = -1; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t FlattenParameter::_internal_end_axis() const { + return end_axis_; +} +inline int32_t FlattenParameter::end_axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.FlattenParameter.end_axis) + return _internal_end_axis(); +} +inline void FlattenParameter::_internal_set_end_axis(int32_t value) { + _has_bits_[0] |= 0x00000002u; + end_axis_ = value; +} +inline void FlattenParameter::set_end_axis(int32_t value) { + _internal_set_end_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.FlattenParameter.end_axis) +} + +// ------------------------------------------------------------------- + +// HDF5DataParameter + +// optional string source = 1; +inline bool HDF5DataParameter::_internal_has_source() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HDF5DataParameter::has_source() const { + return _internal_has_source(); +} +inline void HDF5DataParameter::clear_source() { + source_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HDF5DataParameter::source() const { + // @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.source) + return _internal_source(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HDF5DataParameter::set_source(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.source) +} +inline std::string* HDF5DataParameter::mutable_source() { + std::string* _s = _internal_mutable_source(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.HDF5DataParameter.source) + return _s; +} +inline const std::string& HDF5DataParameter::_internal_source() const { + return source_.Get(); +} +inline void HDF5DataParameter::_internal_set_source(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* HDF5DataParameter::_internal_mutable_source() { + _has_bits_[0] |= 0x00000001u; + return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* HDF5DataParameter::release_source() { + // @@protoc_insertion_point(field_release:opencv_caffe.HDF5DataParameter.source) + if (!_internal_has_source()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HDF5DataParameter::set_allocated_source(std::string* source) { + if (source != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.HDF5DataParameter.source) +} + +// optional uint32 batch_size = 2; +inline bool HDF5DataParameter::_internal_has_batch_size() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HDF5DataParameter::has_batch_size() const { + return _internal_has_batch_size(); +} +inline void HDF5DataParameter::clear_batch_size() { + batch_size_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t HDF5DataParameter::_internal_batch_size() const { + return batch_size_; +} +inline uint32_t HDF5DataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.batch_size) + return _internal_batch_size(); +} +inline void HDF5DataParameter::_internal_set_batch_size(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + batch_size_ = value; +} +inline void HDF5DataParameter::set_batch_size(uint32_t value) { + _internal_set_batch_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.batch_size) +} + +// optional bool shuffle = 3 [default = false]; +inline bool HDF5DataParameter::_internal_has_shuffle() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool HDF5DataParameter::has_shuffle() const { + return _internal_has_shuffle(); +} +inline void HDF5DataParameter::clear_shuffle() { + shuffle_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool HDF5DataParameter::_internal_shuffle() const { + return shuffle_; +} +inline bool HDF5DataParameter::shuffle() const { + // @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.shuffle) + return _internal_shuffle(); +} +inline void HDF5DataParameter::_internal_set_shuffle(bool value) { + _has_bits_[0] |= 0x00000004u; + shuffle_ = value; +} +inline void HDF5DataParameter::set_shuffle(bool value) { + _internal_set_shuffle(value); + // @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.shuffle) +} + +// ------------------------------------------------------------------- + +// HDF5OutputParameter + +// optional string file_name = 1; +inline bool HDF5OutputParameter::_internal_has_file_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HDF5OutputParameter::has_file_name() const { + return _internal_has_file_name(); +} +inline void HDF5OutputParameter::clear_file_name() { + file_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HDF5OutputParameter::file_name() const { + // @@protoc_insertion_point(field_get:opencv_caffe.HDF5OutputParameter.file_name) + return _internal_file_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HDF5OutputParameter::set_file_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.HDF5OutputParameter.file_name) +} +inline std::string* HDF5OutputParameter::mutable_file_name() { + std::string* _s = _internal_mutable_file_name(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.HDF5OutputParameter.file_name) + return _s; +} +inline const std::string& HDF5OutputParameter::_internal_file_name() const { + return file_name_.Get(); +} +inline void HDF5OutputParameter::_internal_set_file_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* HDF5OutputParameter::_internal_mutable_file_name() { + _has_bits_[0] |= 0x00000001u; + return file_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* HDF5OutputParameter::release_file_name() { + // @@protoc_insertion_point(field_release:opencv_caffe.HDF5OutputParameter.file_name) + if (!_internal_has_file_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = file_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (file_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HDF5OutputParameter::set_allocated_file_name(std::string* file_name) { + if (file_name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + file_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (file_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.HDF5OutputParameter.file_name) +} + +// ------------------------------------------------------------------- + +// HingeLossParameter + +// optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1]; +inline bool HingeLossParameter::_internal_has_norm() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HingeLossParameter::has_norm() const { + return _internal_has_norm(); +} +inline void HingeLossParameter::clear_norm() { + norm_ = 1; + _has_bits_[0] &= ~0x00000001u; +} +inline ::opencv_caffe::HingeLossParameter_Norm HingeLossParameter::_internal_norm() const { + return static_cast< ::opencv_caffe::HingeLossParameter_Norm >(norm_); +} +inline ::opencv_caffe::HingeLossParameter_Norm HingeLossParameter::norm() const { + // @@protoc_insertion_point(field_get:opencv_caffe.HingeLossParameter.norm) + return _internal_norm(); +} +inline void HingeLossParameter::_internal_set_norm(::opencv_caffe::HingeLossParameter_Norm value) { + assert(::opencv_caffe::HingeLossParameter_Norm_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + norm_ = value; +} +inline void HingeLossParameter::set_norm(::opencv_caffe::HingeLossParameter_Norm value) { + _internal_set_norm(value); + // @@protoc_insertion_point(field_set:opencv_caffe.HingeLossParameter.norm) +} + +// ------------------------------------------------------------------- + +// ImageDataParameter + +// optional string source = 1; +inline bool ImageDataParameter::_internal_has_source() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ImageDataParameter::has_source() const { + return _internal_has_source(); +} +inline void ImageDataParameter::clear_source() { + source_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ImageDataParameter::source() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.source) + return _internal_source(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ImageDataParameter::set_source(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.source) +} +inline std::string* ImageDataParameter::mutable_source() { + std::string* _s = _internal_mutable_source(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.source) + return _s; +} +inline const std::string& ImageDataParameter::_internal_source() const { + return source_.Get(); +} +inline void ImageDataParameter::_internal_set_source(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ImageDataParameter::_internal_mutable_source() { + _has_bits_[0] |= 0x00000001u; + return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ImageDataParameter::release_source() { + // @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.source) + if (!_internal_has_source()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ImageDataParameter::set_allocated_source(std::string* source) { + if (source != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.source) +} + +// optional uint32 batch_size = 4 [default = 1]; +inline bool ImageDataParameter::_internal_has_batch_size() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool ImageDataParameter::has_batch_size() const { + return _internal_has_batch_size(); +} +inline void ImageDataParameter::clear_batch_size() { + batch_size_ = 1u; + _has_bits_[0] &= ~0x00000800u; +} +inline uint32_t ImageDataParameter::_internal_batch_size() const { + return batch_size_; +} +inline uint32_t ImageDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.batch_size) + return _internal_batch_size(); +} +inline void ImageDataParameter::_internal_set_batch_size(uint32_t value) { + _has_bits_[0] |= 0x00000800u; + batch_size_ = value; +} +inline void ImageDataParameter::set_batch_size(uint32_t value) { + _internal_set_batch_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.batch_size) +} + +// optional uint32 rand_skip = 7 [default = 0]; +inline bool ImageDataParameter::_internal_has_rand_skip() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ImageDataParameter::has_rand_skip() const { + return _internal_has_rand_skip(); +} +inline void ImageDataParameter::clear_rand_skip() { + rand_skip_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline uint32_t ImageDataParameter::_internal_rand_skip() const { + return rand_skip_; +} +inline uint32_t ImageDataParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.rand_skip) + return _internal_rand_skip(); +} +inline void ImageDataParameter::_internal_set_rand_skip(uint32_t value) { + _has_bits_[0] |= 0x00000010u; + rand_skip_ = value; +} +inline void ImageDataParameter::set_rand_skip(uint32_t value) { + _internal_set_rand_skip(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.rand_skip) +} + +// optional bool shuffle = 8 [default = false]; +inline bool ImageDataParameter::_internal_has_shuffle() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ImageDataParameter::has_shuffle() const { + return _internal_has_shuffle(); +} +inline void ImageDataParameter::clear_shuffle() { + shuffle_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool ImageDataParameter::_internal_shuffle() const { + return shuffle_; +} +inline bool ImageDataParameter::shuffle() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.shuffle) + return _internal_shuffle(); +} +inline void ImageDataParameter::_internal_set_shuffle(bool value) { + _has_bits_[0] |= 0x00000020u; + shuffle_ = value; +} +inline void ImageDataParameter::set_shuffle(bool value) { + _internal_set_shuffle(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.shuffle) +} + +// optional uint32 new_height = 9 [default = 0]; +inline bool ImageDataParameter::_internal_has_new_height() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ImageDataParameter::has_new_height() const { + return _internal_has_new_height(); +} +inline void ImageDataParameter::clear_new_height() { + new_height_ = 0u; + _has_bits_[0] &= ~0x00000080u; +} +inline uint32_t ImageDataParameter::_internal_new_height() const { + return new_height_; +} +inline uint32_t ImageDataParameter::new_height() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.new_height) + return _internal_new_height(); +} +inline void ImageDataParameter::_internal_set_new_height(uint32_t value) { + _has_bits_[0] |= 0x00000080u; + new_height_ = value; +} +inline void ImageDataParameter::set_new_height(uint32_t value) { + _internal_set_new_height(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.new_height) +} + +// optional uint32 new_width = 10 [default = 0]; +inline bool ImageDataParameter::_internal_has_new_width() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool ImageDataParameter::has_new_width() const { + return _internal_has_new_width(); +} +inline void ImageDataParameter::clear_new_width() { + new_width_ = 0u; + _has_bits_[0] &= ~0x00000100u; +} +inline uint32_t ImageDataParameter::_internal_new_width() const { + return new_width_; +} +inline uint32_t ImageDataParameter::new_width() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.new_width) + return _internal_new_width(); +} +inline void ImageDataParameter::_internal_set_new_width(uint32_t value) { + _has_bits_[0] |= 0x00000100u; + new_width_ = value; +} +inline void ImageDataParameter::set_new_width(uint32_t value) { + _internal_set_new_width(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.new_width) +} + +// optional bool is_color = 11 [default = true]; +inline bool ImageDataParameter::_internal_has_is_color() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool ImageDataParameter::has_is_color() const { + return _internal_has_is_color(); +} +inline void ImageDataParameter::clear_is_color() { + is_color_ = true; + _has_bits_[0] &= ~0x00000200u; +} +inline bool ImageDataParameter::_internal_is_color() const { + return is_color_; +} +inline bool ImageDataParameter::is_color() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.is_color) + return _internal_is_color(); +} +inline void ImageDataParameter::_internal_set_is_color(bool value) { + _has_bits_[0] |= 0x00000200u; + is_color_ = value; +} +inline void ImageDataParameter::set_is_color(bool value) { + _internal_set_is_color(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.is_color) +} + +// optional float scale = 2 [default = 1]; +inline bool ImageDataParameter::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool ImageDataParameter::has_scale() const { + return _internal_has_scale(); +} +inline void ImageDataParameter::clear_scale() { + scale_ = 1; + _has_bits_[0] &= ~0x00000400u; +} +inline float ImageDataParameter::_internal_scale() const { + return scale_; +} +inline float ImageDataParameter::scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.scale) + return _internal_scale(); +} +inline void ImageDataParameter::_internal_set_scale(float value) { + _has_bits_[0] |= 0x00000400u; + scale_ = value; +} +inline void ImageDataParameter::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.scale) +} + +// optional string mean_file = 3; +inline bool ImageDataParameter::_internal_has_mean_file() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ImageDataParameter::has_mean_file() const { + return _internal_has_mean_file(); +} +inline void ImageDataParameter::clear_mean_file() { + mean_file_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ImageDataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.mean_file) + return _internal_mean_file(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ImageDataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.mean_file) +} +inline std::string* ImageDataParameter::mutable_mean_file() { + std::string* _s = _internal_mutable_mean_file(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.mean_file) + return _s; +} +inline const std::string& ImageDataParameter::_internal_mean_file() const { + return mean_file_.Get(); +} +inline void ImageDataParameter::_internal_set_mean_file(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ImageDataParameter::_internal_mutable_mean_file() { + _has_bits_[0] |= 0x00000002u; + return mean_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ImageDataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.mean_file) + if (!_internal_has_mean_file()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = mean_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ImageDataParameter::set_allocated_mean_file(std::string* mean_file) { + if (mean_file != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + mean_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mean_file, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.mean_file) +} + +// optional uint32 crop_size = 5 [default = 0]; +inline bool ImageDataParameter::_internal_has_crop_size() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ImageDataParameter::has_crop_size() const { + return _internal_has_crop_size(); +} +inline void ImageDataParameter::clear_crop_size() { + crop_size_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline uint32_t ImageDataParameter::_internal_crop_size() const { + return crop_size_; +} +inline uint32_t ImageDataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.crop_size) + return _internal_crop_size(); +} +inline void ImageDataParameter::_internal_set_crop_size(uint32_t value) { + _has_bits_[0] |= 0x00000008u; + crop_size_ = value; +} +inline void ImageDataParameter::set_crop_size(uint32_t value) { + _internal_set_crop_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +inline bool ImageDataParameter::_internal_has_mirror() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ImageDataParameter::has_mirror() const { + return _internal_has_mirror(); +} +inline void ImageDataParameter::clear_mirror() { + mirror_ = false; + _has_bits_[0] &= ~0x00000040u; +} +inline bool ImageDataParameter::_internal_mirror() const { + return mirror_; +} +inline bool ImageDataParameter::mirror() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.mirror) + return _internal_mirror(); +} +inline void ImageDataParameter::_internal_set_mirror(bool value) { + _has_bits_[0] |= 0x00000040u; + mirror_ = value; +} +inline void ImageDataParameter::set_mirror(bool value) { + _internal_set_mirror(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.mirror) +} + +// optional string root_folder = 12 [default = ""]; +inline bool ImageDataParameter::_internal_has_root_folder() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ImageDataParameter::has_root_folder() const { + return _internal_has_root_folder(); +} +inline void ImageDataParameter::clear_root_folder() { + root_folder_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ImageDataParameter::root_folder() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.root_folder) + return _internal_root_folder(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ImageDataParameter::set_root_folder(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.root_folder) +} +inline std::string* ImageDataParameter::mutable_root_folder() { + std::string* _s = _internal_mutable_root_folder(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.root_folder) + return _s; +} +inline const std::string& ImageDataParameter::_internal_root_folder() const { + return root_folder_.Get(); +} +inline void ImageDataParameter::_internal_set_root_folder(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ImageDataParameter::_internal_mutable_root_folder() { + _has_bits_[0] |= 0x00000004u; + return root_folder_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ImageDataParameter::release_root_folder() { + // @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.root_folder) + if (!_internal_has_root_folder()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = root_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (root_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ImageDataParameter::set_allocated_root_folder(std::string* root_folder) { + if (root_folder != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + root_folder_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), root_folder, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (root_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.root_folder) +} + +// ------------------------------------------------------------------- + +// InfogainLossParameter + +// optional string source = 1; +inline bool InfogainLossParameter::_internal_has_source() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool InfogainLossParameter::has_source() const { + return _internal_has_source(); +} +inline void InfogainLossParameter::clear_source() { + source_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& InfogainLossParameter::source() const { + // @@protoc_insertion_point(field_get:opencv_caffe.InfogainLossParameter.source) + return _internal_source(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void InfogainLossParameter::set_source(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.InfogainLossParameter.source) +} +inline std::string* InfogainLossParameter::mutable_source() { + std::string* _s = _internal_mutable_source(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.InfogainLossParameter.source) + return _s; +} +inline const std::string& InfogainLossParameter::_internal_source() const { + return source_.Get(); +} +inline void InfogainLossParameter::_internal_set_source(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* InfogainLossParameter::_internal_mutable_source() { + _has_bits_[0] |= 0x00000001u; + return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* InfogainLossParameter::release_source() { + // @@protoc_insertion_point(field_release:opencv_caffe.InfogainLossParameter.source) + if (!_internal_has_source()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void InfogainLossParameter::set_allocated_source(std::string* source) { + if (source != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.InfogainLossParameter.source) +} + +// ------------------------------------------------------------------- + +// InnerProductParameter + +// optional uint32 num_output = 1; +inline bool InnerProductParameter::_internal_has_num_output() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool InnerProductParameter::has_num_output() const { + return _internal_has_num_output(); +} +inline void InnerProductParameter::clear_num_output() { + num_output_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t InnerProductParameter::_internal_num_output() const { + return num_output_; +} +inline uint32_t InnerProductParameter::num_output() const { + // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.num_output) + return _internal_num_output(); +} +inline void InnerProductParameter::_internal_set_num_output(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + num_output_ = value; +} +inline void InnerProductParameter::set_num_output(uint32_t value) { + _internal_set_num_output(value); + // @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.num_output) +} + +// optional bool bias_term = 2 [default = true]; +inline bool InnerProductParameter::_internal_has_bias_term() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool InnerProductParameter::has_bias_term() const { + return _internal_has_bias_term(); +} +inline void InnerProductParameter::clear_bias_term() { + bias_term_ = true; + _has_bits_[0] &= ~0x00000010u; +} +inline bool InnerProductParameter::_internal_bias_term() const { + return bias_term_; +} +inline bool InnerProductParameter::bias_term() const { + // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.bias_term) + return _internal_bias_term(); +} +inline void InnerProductParameter::_internal_set_bias_term(bool value) { + _has_bits_[0] |= 0x00000010u; + bias_term_ = value; +} +inline void InnerProductParameter::set_bias_term(bool value) { + _internal_set_bias_term(value); + // @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.bias_term) +} + +// optional .opencv_caffe.FillerParameter weight_filler = 3; +inline bool InnerProductParameter::_internal_has_weight_filler() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || weight_filler_ != nullptr); + return value; +} +inline bool InnerProductParameter::has_weight_filler() const { + return _internal_has_weight_filler(); +} +inline void InnerProductParameter::clear_weight_filler() { + if (weight_filler_ != nullptr) weight_filler_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::FillerParameter& InnerProductParameter::_internal_weight_filler() const { + const ::opencv_caffe::FillerParameter* p = weight_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& InnerProductParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.weight_filler) + return _internal_weight_filler(); +} +inline void InnerProductParameter::unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_); + } + weight_filler_ = weight_filler; + if (weight_filler) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.InnerProductParameter.weight_filler) +} +inline ::opencv_caffe::FillerParameter* InnerProductParameter::release_weight_filler() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* InnerProductParameter::unsafe_arena_release_weight_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.InnerProductParameter.weight_filler) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* InnerProductParameter::_internal_mutable_weight_filler() { + _has_bits_[0] |= 0x00000001u; + if (weight_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + weight_filler_ = p; + } + return weight_filler_; +} +inline ::opencv_caffe::FillerParameter* InnerProductParameter::mutable_weight_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.InnerProductParameter.weight_filler) + return _msg; +} +inline void InnerProductParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete weight_filler_; + } + if (weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(weight_filler); + if (message_arena != submessage_arena) { + weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, weight_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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::_internal_has_bias_filler() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || bias_filler_ != nullptr); + return value; +} +inline bool InnerProductParameter::has_bias_filler() const { + return _internal_has_bias_filler(); +} +inline void InnerProductParameter::clear_bias_filler() { + if (bias_filler_ != nullptr) bias_filler_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::FillerParameter& InnerProductParameter::_internal_bias_filler() const { + const ::opencv_caffe::FillerParameter* p = bias_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& InnerProductParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.bias_filler) + return _internal_bias_filler(); +} +inline void InnerProductParameter::unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_); + } + bias_filler_ = bias_filler; + if (bias_filler) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.InnerProductParameter.bias_filler) +} +inline ::opencv_caffe::FillerParameter* InnerProductParameter::release_bias_filler() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* InnerProductParameter::unsafe_arena_release_bias_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.InnerProductParameter.bias_filler) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* InnerProductParameter::_internal_mutable_bias_filler() { + _has_bits_[0] |= 0x00000002u; + if (bias_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + bias_filler_ = p; + } + return bias_filler_; +} +inline ::opencv_caffe::FillerParameter* InnerProductParameter::mutable_bias_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.InnerProductParameter.bias_filler) + return _msg; +} +inline void InnerProductParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bias_filler_; + } + if (bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(bias_filler); + if (message_arena != submessage_arena) { + bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bias_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + bias_filler_ = bias_filler; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.InnerProductParameter.bias_filler) +} + +// optional int32 axis = 5 [default = 1]; +inline bool InnerProductParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool InnerProductParameter::has_axis() const { + return _internal_has_axis(); +} +inline void InnerProductParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000020u; +} +inline int32_t InnerProductParameter::_internal_axis() const { + return axis_; +} +inline int32_t InnerProductParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.axis) + return _internal_axis(); +} +inline void InnerProductParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000020u; + axis_ = value; +} +inline void InnerProductParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.axis) +} + +// optional bool transpose = 6 [default = false]; +inline bool InnerProductParameter::_internal_has_transpose() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool InnerProductParameter::has_transpose() const { + return _internal_has_transpose(); +} +inline void InnerProductParameter::clear_transpose() { + transpose_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool InnerProductParameter::_internal_transpose() const { + return transpose_; +} +inline bool InnerProductParameter::transpose() const { + // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.transpose) + return _internal_transpose(); +} +inline void InnerProductParameter::_internal_set_transpose(bool value) { + _has_bits_[0] |= 0x00000008u; + transpose_ = value; +} +inline void InnerProductParameter::set_transpose(bool value) { + _internal_set_transpose(value); + // @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.transpose) +} + +// ------------------------------------------------------------------- + +// InputParameter + +// repeated .opencv_caffe.BlobShape shape = 1; +inline int InputParameter::_internal_shape_size() const { + return shape_.size(); +} +inline int InputParameter::shape_size() const { + return _internal_shape_size(); +} +inline void InputParameter::clear_shape() { + shape_.Clear(); +} +inline ::opencv_caffe::BlobShape* InputParameter::mutable_shape(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.InputParameter.shape) + return shape_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >* +InputParameter::mutable_shape() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.InputParameter.shape) + return &shape_; +} +inline const ::opencv_caffe::BlobShape& InputParameter::_internal_shape(int index) const { + return shape_.Get(index); +} +inline const ::opencv_caffe::BlobShape& InputParameter::shape(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.InputParameter.shape) + return _internal_shape(index); +} +inline ::opencv_caffe::BlobShape* InputParameter::_internal_add_shape() { + return shape_.Add(); +} +inline ::opencv_caffe::BlobShape* InputParameter::add_shape() { + ::opencv_caffe::BlobShape* _add = _internal_add_shape(); + // @@protoc_insertion_point(field_add:opencv_caffe.InputParameter.shape) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_has_base() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool LogParameter::has_base() const { + return _internal_has_base(); +} +inline void LogParameter::clear_base() { + base_ = -1; + _has_bits_[0] &= ~0x00000002u; +} +inline float LogParameter::_internal_base() const { + return base_; +} +inline float LogParameter::base() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.base) + return _internal_base(); +} +inline void LogParameter::_internal_set_base(float value) { + _has_bits_[0] |= 0x00000002u; + base_ = value; +} +inline void LogParameter::set_base(float value) { + _internal_set_base(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.base) +} + +// optional float scale = 2 [default = 1]; +inline bool LogParameter::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool LogParameter::has_scale() const { + return _internal_has_scale(); +} +inline void LogParameter::clear_scale() { + scale_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline float LogParameter::_internal_scale() const { + return scale_; +} +inline float LogParameter::scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.scale) + return _internal_scale(); +} +inline void LogParameter::_internal_set_scale(float value) { + _has_bits_[0] |= 0x00000004u; + scale_ = value; +} +inline void LogParameter::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.scale) +} + +// optional float shift = 3 [default = 0]; +inline bool LogParameter::_internal_has_shift() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool LogParameter::has_shift() const { + return _internal_has_shift(); +} +inline void LogParameter::clear_shift() { + shift_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float LogParameter::_internal_shift() const { + return shift_; +} +inline float LogParameter::shift() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.shift) + return _internal_shift(); +} +inline void LogParameter::_internal_set_shift(float value) { + _has_bits_[0] |= 0x00000001u; + shift_ = value; +} +inline void LogParameter::set_shift(float value) { + _internal_set_shift(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.shift) +} + +// ------------------------------------------------------------------- + +// LRNParameter + +// optional uint32 local_size = 1 [default = 5]; +inline bool LRNParameter::_internal_has_local_size() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool LRNParameter::has_local_size() const { + return _internal_has_local_size(); +} +inline void LRNParameter::clear_local_size() { + local_size_ = 5u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t LRNParameter::_internal_local_size() const { + return local_size_; +} +inline uint32_t LRNParameter::local_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.local_size) + return _internal_local_size(); +} +inline void LRNParameter::_internal_set_local_size(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + local_size_ = value; +} +inline void LRNParameter::set_local_size(uint32_t value) { + _internal_set_local_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.local_size) +} + +// optional float alpha = 2 [default = 1]; +inline bool LRNParameter::_internal_has_alpha() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool LRNParameter::has_alpha() const { + return _internal_has_alpha(); +} +inline void LRNParameter::clear_alpha() { + alpha_ = 1; + _has_bits_[0] &= ~0x00000008u; +} +inline float LRNParameter::_internal_alpha() const { + return alpha_; +} +inline float LRNParameter::alpha() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.alpha) + return _internal_alpha(); +} +inline void LRNParameter::_internal_set_alpha(float value) { + _has_bits_[0] |= 0x00000008u; + alpha_ = value; +} +inline void LRNParameter::set_alpha(float value) { + _internal_set_alpha(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.alpha) +} + +// optional float beta = 3 [default = 0.75]; +inline bool LRNParameter::_internal_has_beta() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool LRNParameter::has_beta() const { + return _internal_has_beta(); +} +inline void LRNParameter::clear_beta() { + beta_ = 0.75f; + _has_bits_[0] &= ~0x00000010u; +} +inline float LRNParameter::_internal_beta() const { + return beta_; +} +inline float LRNParameter::beta() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.beta) + return _internal_beta(); +} +inline void LRNParameter::_internal_set_beta(float value) { + _has_bits_[0] |= 0x00000010u; + beta_ = value; +} +inline void LRNParameter::set_beta(float value) { + _internal_set_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::_internal_has_norm_region() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool LRNParameter::has_norm_region() const { + return _internal_has_norm_region(); +} +inline void LRNParameter::clear_norm_region() { + norm_region_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::opencv_caffe::LRNParameter_NormRegion LRNParameter::_internal_norm_region() const { + return static_cast< ::opencv_caffe::LRNParameter_NormRegion >(norm_region_); +} +inline ::opencv_caffe::LRNParameter_NormRegion LRNParameter::norm_region() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.norm_region) + return _internal_norm_region(); +} +inline void LRNParameter::_internal_set_norm_region(::opencv_caffe::LRNParameter_NormRegion value) { + assert(::opencv_caffe::LRNParameter_NormRegion_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + norm_region_ = value; +} +inline void LRNParameter::set_norm_region(::opencv_caffe::LRNParameter_NormRegion value) { + _internal_set_norm_region(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.norm_region) +} + +// optional float k = 5 [default = 1]; +inline bool LRNParameter::_internal_has_k() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool LRNParameter::has_k() const { + return _internal_has_k(); +} +inline void LRNParameter::clear_k() { + k_ = 1; + _has_bits_[0] &= ~0x00000020u; +} +inline float LRNParameter::_internal_k() const { + return k_; +} +inline float LRNParameter::k() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.k) + return _internal_k(); +} +inline void LRNParameter::_internal_set_k(float value) { + _has_bits_[0] |= 0x00000020u; + k_ = value; +} +inline void LRNParameter::set_k(float value) { + _internal_set_k(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.k) +} + +// optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; +inline bool LRNParameter::_internal_has_engine() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool LRNParameter::has_engine() const { + return _internal_has_engine(); +} +inline void LRNParameter::clear_engine() { + engine_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::opencv_caffe::LRNParameter_Engine LRNParameter::_internal_engine() const { + return static_cast< ::opencv_caffe::LRNParameter_Engine >(engine_); +} +inline ::opencv_caffe::LRNParameter_Engine LRNParameter::engine() const { + // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.engine) + return _internal_engine(); +} +inline void LRNParameter::_internal_set_engine(::opencv_caffe::LRNParameter_Engine value) { + assert(::opencv_caffe::LRNParameter_Engine_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + engine_ = value; +} +inline void LRNParameter::set_engine(::opencv_caffe::LRNParameter_Engine value) { + _internal_set_engine(value); + // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.engine) +} + +// ------------------------------------------------------------------- + +// MemoryDataParameter + +// optional uint32 batch_size = 1; +inline bool MemoryDataParameter::_internal_has_batch_size() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MemoryDataParameter::has_batch_size() const { + return _internal_has_batch_size(); +} +inline void MemoryDataParameter::clear_batch_size() { + batch_size_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline uint32_t MemoryDataParameter::_internal_batch_size() const { + return batch_size_; +} +inline uint32_t MemoryDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.batch_size) + return _internal_batch_size(); +} +inline void MemoryDataParameter::_internal_set_batch_size(uint32_t value) { + _has_bits_[0] |= 0x00000001u; + batch_size_ = value; +} +inline void MemoryDataParameter::set_batch_size(uint32_t value) { + _internal_set_batch_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.batch_size) +} + +// optional uint32 channels = 2; +inline bool MemoryDataParameter::_internal_has_channels() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool MemoryDataParameter::has_channels() const { + return _internal_has_channels(); +} +inline void MemoryDataParameter::clear_channels() { + channels_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t MemoryDataParameter::_internal_channels() const { + return channels_; +} +inline uint32_t MemoryDataParameter::channels() const { + // @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.channels) + return _internal_channels(); +} +inline void MemoryDataParameter::_internal_set_channels(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + channels_ = value; +} +inline void MemoryDataParameter::set_channels(uint32_t value) { + _internal_set_channels(value); + // @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.channels) +} + +// optional uint32 height = 3; +inline bool MemoryDataParameter::_internal_has_height() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool MemoryDataParameter::has_height() const { + return _internal_has_height(); +} +inline void MemoryDataParameter::clear_height() { + height_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t MemoryDataParameter::_internal_height() const { + return height_; +} +inline uint32_t MemoryDataParameter::height() const { + // @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.height) + return _internal_height(); +} +inline void MemoryDataParameter::_internal_set_height(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + height_ = value; +} +inline void MemoryDataParameter::set_height(uint32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.height) +} + +// optional uint32 width = 4; +inline bool MemoryDataParameter::_internal_has_width() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool MemoryDataParameter::has_width() const { + return _internal_has_width(); +} +inline void MemoryDataParameter::clear_width() { + width_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline uint32_t MemoryDataParameter::_internal_width() const { + return width_; +} +inline uint32_t MemoryDataParameter::width() const { + // @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.width) + return _internal_width(); +} +inline void MemoryDataParameter::_internal_set_width(uint32_t value) { + _has_bits_[0] |= 0x00000008u; + width_ = value; +} +inline void MemoryDataParameter::set_width(uint32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.width) +} + +// ------------------------------------------------------------------- + +// MVNParameter + +// optional bool normalize_variance = 1 [default = true]; +inline bool MVNParameter::_internal_has_normalize_variance() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool MVNParameter::has_normalize_variance() const { + return _internal_has_normalize_variance(); +} +inline void MVNParameter::clear_normalize_variance() { + normalize_variance_ = true; + _has_bits_[0] &= ~0x00000002u; +} +inline bool MVNParameter::_internal_normalize_variance() const { + return normalize_variance_; +} +inline bool MVNParameter::normalize_variance() const { + // @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.normalize_variance) + return _internal_normalize_variance(); +} +inline void MVNParameter::_internal_set_normalize_variance(bool value) { + _has_bits_[0] |= 0x00000002u; + normalize_variance_ = value; +} +inline void MVNParameter::set_normalize_variance(bool value) { + _internal_set_normalize_variance(value); + // @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.normalize_variance) +} + +// optional bool across_channels = 2 [default = false]; +inline bool MVNParameter::_internal_has_across_channels() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MVNParameter::has_across_channels() const { + return _internal_has_across_channels(); +} +inline void MVNParameter::clear_across_channels() { + across_channels_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool MVNParameter::_internal_across_channels() const { + return across_channels_; +} +inline bool MVNParameter::across_channels() const { + // @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.across_channels) + return _internal_across_channels(); +} +inline void MVNParameter::_internal_set_across_channels(bool value) { + _has_bits_[0] |= 0x00000001u; + across_channels_ = value; +} +inline void MVNParameter::set_across_channels(bool value) { + _internal_set_across_channels(value); + // @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.across_channels) +} + +// optional float eps = 3 [default = 1e-09]; +inline bool MVNParameter::_internal_has_eps() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool MVNParameter::has_eps() const { + return _internal_has_eps(); +} +inline void MVNParameter::clear_eps() { + eps_ = 1e-09f; + _has_bits_[0] &= ~0x00000004u; +} +inline float MVNParameter::_internal_eps() const { + return eps_; +} +inline float MVNParameter::eps() const { + // @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.eps) + return _internal_eps(); +} +inline void MVNParameter::_internal_set_eps(float value) { + _has_bits_[0] |= 0x00000004u; + eps_ = value; +} +inline void MVNParameter::set_eps(float value) { + _internal_set_eps(value); + // @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.eps) +} + +// ------------------------------------------------------------------- + +// ParameterParameter + +// optional .opencv_caffe.BlobShape shape = 1; +inline bool ParameterParameter::_internal_has_shape() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || shape_ != nullptr); + return value; +} +inline bool ParameterParameter::has_shape() const { + return _internal_has_shape(); +} +inline void ParameterParameter::clear_shape() { + if (shape_ != nullptr) shape_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::BlobShape& ParameterParameter::_internal_shape() const { + const ::opencv_caffe::BlobShape* p = shape_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_BlobShape_default_instance_); +} +inline const ::opencv_caffe::BlobShape& ParameterParameter::shape() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ParameterParameter.shape) + return _internal_shape(); +} +inline void ParameterParameter::unsafe_arena_set_allocated_shape( + ::opencv_caffe::BlobShape* shape) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_); + } + shape_ = shape; + if (shape) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ParameterParameter.shape) +} +inline ::opencv_caffe::BlobShape* ParameterParameter::release_shape() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::BlobShape* temp = shape_; + shape_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::BlobShape* ParameterParameter::unsafe_arena_release_shape() { + // @@protoc_insertion_point(field_release:opencv_caffe.ParameterParameter.shape) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::BlobShape* temp = shape_; + shape_ = nullptr; + return temp; +} +inline ::opencv_caffe::BlobShape* ParameterParameter::_internal_mutable_shape() { + _has_bits_[0] |= 0x00000001u; + if (shape_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::BlobShape>(GetArenaForAllocation()); + shape_ = p; + } + return shape_; +} +inline ::opencv_caffe::BlobShape* ParameterParameter::mutable_shape() { + ::opencv_caffe::BlobShape* _msg = _internal_mutable_shape(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ParameterParameter.shape) + return _msg; +} +inline void ParameterParameter::set_allocated_shape(::opencv_caffe::BlobShape* shape) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete shape_; + } + if (shape) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::BlobShape>::GetOwningArena(shape); + if (message_arena != submessage_arena) { + shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, shape, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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::_internal_has_pool() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PoolingParameter::has_pool() const { + return _internal_has_pool(); +} +inline void PoolingParameter::clear_pool() { + pool_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::opencv_caffe::PoolingParameter_PoolMethod PoolingParameter::_internal_pool() const { + return static_cast< ::opencv_caffe::PoolingParameter_PoolMethod >(pool_); +} +inline ::opencv_caffe::PoolingParameter_PoolMethod PoolingParameter::pool() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pool) + return _internal_pool(); +} +inline void PoolingParameter::_internal_set_pool(::opencv_caffe::PoolingParameter_PoolMethod value) { + assert(::opencv_caffe::PoolingParameter_PoolMethod_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + pool_ = value; +} +inline void PoolingParameter::set_pool(::opencv_caffe::PoolingParameter_PoolMethod value) { + _internal_set_pool(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pool) +} + +// optional uint32 pad = 4 [default = 0]; +inline bool PoolingParameter::_internal_has_pad() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PoolingParameter::has_pad() const { + return _internal_has_pad(); +} +inline void PoolingParameter::clear_pad() { + pad_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t PoolingParameter::_internal_pad() const { + return pad_; +} +inline uint32_t PoolingParameter::pad() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad) + return _internal_pad(); +} +inline void PoolingParameter::_internal_set_pad(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + pad_ = value; +} +inline void PoolingParameter::set_pad(uint32_t value) { + _internal_set_pad(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad) +} + +// optional uint32 pad_h = 9 [default = 0]; +inline bool PoolingParameter::_internal_has_pad_h() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool PoolingParameter::has_pad_h() const { + return _internal_has_pad_h(); +} +inline void PoolingParameter::clear_pad_h() { + pad_h_ = 0u; + _has_bits_[0] &= ~0x00000080u; +} +inline uint32_t PoolingParameter::_internal_pad_h() const { + return pad_h_; +} +inline uint32_t PoolingParameter::pad_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad_h) + return _internal_pad_h(); +} +inline void PoolingParameter::_internal_set_pad_h(uint32_t value) { + _has_bits_[0] |= 0x00000080u; + pad_h_ = value; +} +inline void PoolingParameter::set_pad_h(uint32_t value) { + _internal_set_pad_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad_h) +} + +// optional uint32 pad_w = 10 [default = 0]; +inline bool PoolingParameter::_internal_has_pad_w() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool PoolingParameter::has_pad_w() const { + return _internal_has_pad_w(); +} +inline void PoolingParameter::clear_pad_w() { + pad_w_ = 0u; + _has_bits_[0] &= ~0x00000100u; +} +inline uint32_t PoolingParameter::_internal_pad_w() const { + return pad_w_; +} +inline uint32_t PoolingParameter::pad_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad_w) + return _internal_pad_w(); +} +inline void PoolingParameter::_internal_set_pad_w(uint32_t value) { + _has_bits_[0] |= 0x00000100u; + pad_w_ = value; +} +inline void PoolingParameter::set_pad_w(uint32_t value) { + _internal_set_pad_w(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad_w) +} + +// optional uint32 kernel_size = 2; +inline bool PoolingParameter::_internal_has_kernel_size() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PoolingParameter::has_kernel_size() const { + return _internal_has_kernel_size(); +} +inline void PoolingParameter::clear_kernel_size() { + kernel_size_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t PoolingParameter::_internal_kernel_size() const { + return kernel_size_; +} +inline uint32_t PoolingParameter::kernel_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_size) + return _internal_kernel_size(); +} +inline void PoolingParameter::_internal_set_kernel_size(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + kernel_size_ = value; +} +inline void PoolingParameter::set_kernel_size(uint32_t value) { + _internal_set_kernel_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_size) +} + +// optional uint32 kernel_h = 5; +inline bool PoolingParameter::_internal_has_kernel_h() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PoolingParameter::has_kernel_h() const { + return _internal_has_kernel_h(); +} +inline void PoolingParameter::clear_kernel_h() { + kernel_h_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline uint32_t PoolingParameter::_internal_kernel_h() const { + return kernel_h_; +} +inline uint32_t PoolingParameter::kernel_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_h) + return _internal_kernel_h(); +} +inline void PoolingParameter::_internal_set_kernel_h(uint32_t value) { + _has_bits_[0] |= 0x00000008u; + kernel_h_ = value; +} +inline void PoolingParameter::set_kernel_h(uint32_t value) { + _internal_set_kernel_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_h) +} + +// optional uint32 kernel_w = 6; +inline bool PoolingParameter::_internal_has_kernel_w() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool PoolingParameter::has_kernel_w() const { + return _internal_has_kernel_w(); +} +inline void PoolingParameter::clear_kernel_w() { + kernel_w_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline uint32_t PoolingParameter::_internal_kernel_w() const { + return kernel_w_; +} +inline uint32_t PoolingParameter::kernel_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_w) + return _internal_kernel_w(); +} +inline void PoolingParameter::_internal_set_kernel_w(uint32_t value) { + _has_bits_[0] |= 0x00000010u; + kernel_w_ = value; +} +inline void PoolingParameter::set_kernel_w(uint32_t value) { + _internal_set_kernel_w(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_w) +} + +// optional uint32 stride = 3 [default = 1]; +inline bool PoolingParameter::_internal_has_stride() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool PoolingParameter::has_stride() const { + return _internal_has_stride(); +} +inline void PoolingParameter::clear_stride() { + stride_ = 1u; + _has_bits_[0] &= ~0x00000800u; +} +inline uint32_t PoolingParameter::_internal_stride() const { + return stride_; +} +inline uint32_t PoolingParameter::stride() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride) + return _internal_stride(); +} +inline void PoolingParameter::_internal_set_stride(uint32_t value) { + _has_bits_[0] |= 0x00000800u; + stride_ = value; +} +inline void PoolingParameter::set_stride(uint32_t value) { + _internal_set_stride(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.stride) +} + +// optional uint32 stride_h = 7; +inline bool PoolingParameter::_internal_has_stride_h() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool PoolingParameter::has_stride_h() const { + return _internal_has_stride_h(); +} +inline void PoolingParameter::clear_stride_h() { + stride_h_ = 0u; + _has_bits_[0] &= ~0x00000020u; +} +inline uint32_t PoolingParameter::_internal_stride_h() const { + return stride_h_; +} +inline uint32_t PoolingParameter::stride_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride_h) + return _internal_stride_h(); +} +inline void PoolingParameter::_internal_set_stride_h(uint32_t value) { + _has_bits_[0] |= 0x00000020u; + stride_h_ = value; +} +inline void PoolingParameter::set_stride_h(uint32_t value) { + _internal_set_stride_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.stride_h) +} + +// optional uint32 stride_w = 8; +inline bool PoolingParameter::_internal_has_stride_w() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool PoolingParameter::has_stride_w() const { + return _internal_has_stride_w(); +} +inline void PoolingParameter::clear_stride_w() { + stride_w_ = 0u; + _has_bits_[0] &= ~0x00000040u; +} +inline uint32_t PoolingParameter::_internal_stride_w() const { + return stride_w_; +} +inline uint32_t PoolingParameter::stride_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride_w) + return _internal_stride_w(); +} +inline void PoolingParameter::_internal_set_stride_w(uint32_t value) { + _has_bits_[0] |= 0x00000040u; + stride_w_ = value; +} +inline void PoolingParameter::set_stride_w(uint32_t value) { + _internal_set_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::_internal_has_engine() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool PoolingParameter::has_engine() const { + return _internal_has_engine(); +} +inline void PoolingParameter::clear_engine() { + engine_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline ::opencv_caffe::PoolingParameter_Engine PoolingParameter::_internal_engine() const { + return static_cast< ::opencv_caffe::PoolingParameter_Engine >(engine_); +} +inline ::opencv_caffe::PoolingParameter_Engine PoolingParameter::engine() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.engine) + return _internal_engine(); +} +inline void PoolingParameter::_internal_set_engine(::opencv_caffe::PoolingParameter_Engine value) { + assert(::opencv_caffe::PoolingParameter_Engine_IsValid(value)); + _has_bits_[0] |= 0x00000200u; + engine_ = value; +} +inline void PoolingParameter::set_engine(::opencv_caffe::PoolingParameter_Engine value) { + _internal_set_engine(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.engine) +} + +// optional bool global_pooling = 12 [default = false]; +inline bool PoolingParameter::_internal_has_global_pooling() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool PoolingParameter::has_global_pooling() const { + return _internal_has_global_pooling(); +} +inline void PoolingParameter::clear_global_pooling() { + global_pooling_ = false; + _has_bits_[0] &= ~0x00000400u; +} +inline bool PoolingParameter::_internal_global_pooling() const { + return global_pooling_; +} +inline bool PoolingParameter::global_pooling() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.global_pooling) + return _internal_global_pooling(); +} +inline void PoolingParameter::_internal_set_global_pooling(bool value) { + _has_bits_[0] |= 0x00000400u; + global_pooling_ = value; +} +inline void PoolingParameter::set_global_pooling(bool value) { + _internal_set_global_pooling(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.global_pooling) +} + +// optional bool ceil_mode = 13 [default = true]; +inline bool PoolingParameter::_internal_has_ceil_mode() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool PoolingParameter::has_ceil_mode() const { + return _internal_has_ceil_mode(); +} +inline void PoolingParameter::clear_ceil_mode() { + ceil_mode_ = true; + _has_bits_[0] &= ~0x00001000u; +} +inline bool PoolingParameter::_internal_ceil_mode() const { + return ceil_mode_; +} +inline bool PoolingParameter::ceil_mode() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.ceil_mode) + return _internal_ceil_mode(); +} +inline void PoolingParameter::_internal_set_ceil_mode(bool value) { + _has_bits_[0] |= 0x00001000u; + ceil_mode_ = value; +} +inline void PoolingParameter::set_ceil_mode(bool value) { + _internal_set_ceil_mode(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.ceil_mode) +} + +// ------------------------------------------------------------------- + +// PowerParameter + +// optional float power = 1 [default = 1]; +inline bool PowerParameter::_internal_has_power() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PowerParameter::has_power() const { + return _internal_has_power(); +} +inline void PowerParameter::clear_power() { + power_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline float PowerParameter::_internal_power() const { + return power_; +} +inline float PowerParameter::power() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.power) + return _internal_power(); +} +inline void PowerParameter::_internal_set_power(float value) { + _has_bits_[0] |= 0x00000002u; + power_ = value; +} +inline void PowerParameter::set_power(float value) { + _internal_set_power(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.power) +} + +// optional float scale = 2 [default = 1]; +inline bool PowerParameter::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PowerParameter::has_scale() const { + return _internal_has_scale(); +} +inline void PowerParameter::clear_scale() { + scale_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline float PowerParameter::_internal_scale() const { + return scale_; +} +inline float PowerParameter::scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.scale) + return _internal_scale(); +} +inline void PowerParameter::_internal_set_scale(float value) { + _has_bits_[0] |= 0x00000004u; + scale_ = value; +} +inline void PowerParameter::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.scale) +} + +// optional float shift = 3 [default = 0]; +inline bool PowerParameter::_internal_has_shift() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PowerParameter::has_shift() const { + return _internal_has_shift(); +} +inline void PowerParameter::clear_shift() { + shift_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float PowerParameter::_internal_shift() const { + return shift_; +} +inline float PowerParameter::shift() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.shift) + return _internal_shift(); +} +inline void PowerParameter::_internal_set_shift(float value) { + _has_bits_[0] |= 0x00000001u; + shift_ = value; +} +inline void PowerParameter::set_shift(float value) { + _internal_set_shift(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.shift) +} + +// ------------------------------------------------------------------- + +// PythonParameter + +// optional string module = 1; +inline bool PythonParameter::_internal_has_module() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PythonParameter::has_module() const { + return _internal_has_module(); +} +inline void PythonParameter::clear_module() { + module_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PythonParameter::module() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.module) + return _internal_module(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PythonParameter::set_module(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + module_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.module) +} +inline std::string* PythonParameter::mutable_module() { + std::string* _s = _internal_mutable_module(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.module) + return _s; +} +inline const std::string& PythonParameter::_internal_module() const { + return module_.Get(); +} +inline void PythonParameter::_internal_set_module(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + module_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* PythonParameter::_internal_mutable_module() { + _has_bits_[0] |= 0x00000001u; + return module_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* PythonParameter::release_module() { + // @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.module) + if (!_internal_has_module()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = module_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (module_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PythonParameter::set_allocated_module(std::string* module) { + if (module != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + module_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), module, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (module_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.module) +} + +// optional string layer = 2; +inline bool PythonParameter::_internal_has_layer() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PythonParameter::has_layer() const { + return _internal_has_layer(); +} +inline void PythonParameter::clear_layer() { + layer_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PythonParameter::layer() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.layer) + return _internal_layer(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PythonParameter::set_layer(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + layer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.layer) +} +inline std::string* PythonParameter::mutable_layer() { + std::string* _s = _internal_mutable_layer(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.layer) + return _s; +} +inline const std::string& PythonParameter::_internal_layer() const { + return layer_.Get(); +} +inline void PythonParameter::_internal_set_layer(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + layer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* PythonParameter::_internal_mutable_layer() { + _has_bits_[0] |= 0x00000002u; + return layer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* PythonParameter::release_layer() { + // @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.layer) + if (!_internal_has_layer()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = layer_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (layer_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + layer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PythonParameter::set_allocated_layer(std::string* layer) { + if (layer != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + layer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), layer, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (layer_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + layer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.layer) +} + +// optional string param_str = 3 [default = ""]; +inline bool PythonParameter::_internal_has_param_str() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PythonParameter::has_param_str() const { + return _internal_has_param_str(); +} +inline void PythonParameter::clear_param_str() { + param_str_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& PythonParameter::param_str() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.param_str) + return _internal_param_str(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PythonParameter::set_param_str(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + param_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.param_str) +} +inline std::string* PythonParameter::mutable_param_str() { + std::string* _s = _internal_mutable_param_str(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.param_str) + return _s; +} +inline const std::string& PythonParameter::_internal_param_str() const { + return param_str_.Get(); +} +inline void PythonParameter::_internal_set_param_str(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + param_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* PythonParameter::_internal_mutable_param_str() { + _has_bits_[0] |= 0x00000004u; + return param_str_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* PythonParameter::release_param_str() { + // @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.param_str) + if (!_internal_has_param_str()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = param_str_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (param_str_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + param_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PythonParameter::set_allocated_param_str(std::string* param_str) { + if (param_str != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + param_str_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), param_str, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (param_str_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + param_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.param_str) +} + +// optional bool share_in_parallel = 4 [default = false]; +inline bool PythonParameter::_internal_has_share_in_parallel() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PythonParameter::has_share_in_parallel() const { + return _internal_has_share_in_parallel(); +} +inline void PythonParameter::clear_share_in_parallel() { + share_in_parallel_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool PythonParameter::_internal_share_in_parallel() const { + return share_in_parallel_; +} +inline bool PythonParameter::share_in_parallel() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.share_in_parallel) + return _internal_share_in_parallel(); +} +inline void PythonParameter::_internal_set_share_in_parallel(bool value) { + _has_bits_[0] |= 0x00000008u; + share_in_parallel_ = value; +} +inline void PythonParameter::set_share_in_parallel(bool value) { + _internal_set_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::_internal_has_num_output() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool RecurrentParameter::has_num_output() const { + return _internal_has_num_output(); +} +inline void RecurrentParameter::clear_num_output() { + num_output_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t RecurrentParameter::_internal_num_output() const { + return num_output_; +} +inline uint32_t RecurrentParameter::num_output() const { + // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.num_output) + return _internal_num_output(); +} +inline void RecurrentParameter::_internal_set_num_output(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + num_output_ = value; +} +inline void RecurrentParameter::set_num_output(uint32_t value) { + _internal_set_num_output(value); + // @@protoc_insertion_point(field_set:opencv_caffe.RecurrentParameter.num_output) +} + +// optional .opencv_caffe.FillerParameter weight_filler = 2; +inline bool RecurrentParameter::_internal_has_weight_filler() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || weight_filler_ != nullptr); + return value; +} +inline bool RecurrentParameter::has_weight_filler() const { + return _internal_has_weight_filler(); +} +inline void RecurrentParameter::clear_weight_filler() { + if (weight_filler_ != nullptr) weight_filler_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::FillerParameter& RecurrentParameter::_internal_weight_filler() const { + const ::opencv_caffe::FillerParameter* p = weight_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& RecurrentParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.weight_filler) + return _internal_weight_filler(); +} +inline void RecurrentParameter::unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_); + } + weight_filler_ = weight_filler; + if (weight_filler) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.RecurrentParameter.weight_filler) +} +inline ::opencv_caffe::FillerParameter* RecurrentParameter::release_weight_filler() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* RecurrentParameter::unsafe_arena_release_weight_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.RecurrentParameter.weight_filler) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* RecurrentParameter::_internal_mutable_weight_filler() { + _has_bits_[0] |= 0x00000001u; + if (weight_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + weight_filler_ = p; + } + return weight_filler_; +} +inline ::opencv_caffe::FillerParameter* RecurrentParameter::mutable_weight_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.RecurrentParameter.weight_filler) + return _msg; +} +inline void RecurrentParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete weight_filler_; + } + if (weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(weight_filler); + if (message_arena != submessage_arena) { + weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, weight_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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::_internal_has_bias_filler() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || bias_filler_ != nullptr); + return value; +} +inline bool RecurrentParameter::has_bias_filler() const { + return _internal_has_bias_filler(); +} +inline void RecurrentParameter::clear_bias_filler() { + if (bias_filler_ != nullptr) bias_filler_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::FillerParameter& RecurrentParameter::_internal_bias_filler() const { + const ::opencv_caffe::FillerParameter* p = bias_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& RecurrentParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.bias_filler) + return _internal_bias_filler(); +} +inline void RecurrentParameter::unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_); + } + bias_filler_ = bias_filler; + if (bias_filler) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.RecurrentParameter.bias_filler) +} +inline ::opencv_caffe::FillerParameter* RecurrentParameter::release_bias_filler() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* RecurrentParameter::unsafe_arena_release_bias_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.RecurrentParameter.bias_filler) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* RecurrentParameter::_internal_mutable_bias_filler() { + _has_bits_[0] |= 0x00000002u; + if (bias_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + bias_filler_ = p; + } + return bias_filler_; +} +inline ::opencv_caffe::FillerParameter* RecurrentParameter::mutable_bias_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.RecurrentParameter.bias_filler) + return _msg; +} +inline void RecurrentParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bias_filler_; + } + if (bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(bias_filler); + if (message_arena != submessage_arena) { + bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bias_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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::_internal_has_debug_info() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool RecurrentParameter::has_debug_info() const { + return _internal_has_debug_info(); +} +inline void RecurrentParameter::clear_debug_info() { + debug_info_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool RecurrentParameter::_internal_debug_info() const { + return debug_info_; +} +inline bool RecurrentParameter::debug_info() const { + // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.debug_info) + return _internal_debug_info(); +} +inline void RecurrentParameter::_internal_set_debug_info(bool value) { + _has_bits_[0] |= 0x00000008u; + debug_info_ = value; +} +inline void RecurrentParameter::set_debug_info(bool value) { + _internal_set_debug_info(value); + // @@protoc_insertion_point(field_set:opencv_caffe.RecurrentParameter.debug_info) +} + +// optional bool expose_hidden = 5 [default = false]; +inline bool RecurrentParameter::_internal_has_expose_hidden() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool RecurrentParameter::has_expose_hidden() const { + return _internal_has_expose_hidden(); +} +inline void RecurrentParameter::clear_expose_hidden() { + expose_hidden_ = false; + _has_bits_[0] &= ~0x00000010u; +} +inline bool RecurrentParameter::_internal_expose_hidden() const { + return expose_hidden_; +} +inline bool RecurrentParameter::expose_hidden() const { + // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.expose_hidden) + return _internal_expose_hidden(); +} +inline void RecurrentParameter::_internal_set_expose_hidden(bool value) { + _has_bits_[0] |= 0x00000010u; + expose_hidden_ = value; +} +inline void RecurrentParameter::set_expose_hidden(bool value) { + _internal_set_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::_internal_has_operation() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ReductionParameter::has_operation() const { + return _internal_has_operation(); +} +inline void ReductionParameter::clear_operation() { + operation_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline ::opencv_caffe::ReductionParameter_ReductionOp ReductionParameter::_internal_operation() const { + return static_cast< ::opencv_caffe::ReductionParameter_ReductionOp >(operation_); +} +inline ::opencv_caffe::ReductionParameter_ReductionOp ReductionParameter::operation() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.operation) + return _internal_operation(); +} +inline void ReductionParameter::_internal_set_operation(::opencv_caffe::ReductionParameter_ReductionOp value) { + assert(::opencv_caffe::ReductionParameter_ReductionOp_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + operation_ = value; +} +inline void ReductionParameter::set_operation(::opencv_caffe::ReductionParameter_ReductionOp value) { + _internal_set_operation(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.operation) +} + +// optional int32 axis = 2 [default = 0]; +inline bool ReductionParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ReductionParameter::has_axis() const { + return _internal_has_axis(); +} +inline void ReductionParameter::clear_axis() { + axis_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t ReductionParameter::_internal_axis() const { + return axis_; +} +inline int32_t ReductionParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.axis) + return _internal_axis(); +} +inline void ReductionParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000001u; + axis_ = value; +} +inline void ReductionParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.axis) +} + +// optional float coeff = 3 [default = 1]; +inline bool ReductionParameter::_internal_has_coeff() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ReductionParameter::has_coeff() const { + return _internal_has_coeff(); +} +inline void ReductionParameter::clear_coeff() { + coeff_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline float ReductionParameter::_internal_coeff() const { + return coeff_; +} +inline float ReductionParameter::coeff() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.coeff) + return _internal_coeff(); +} +inline void ReductionParameter::_internal_set_coeff(float value) { + _has_bits_[0] |= 0x00000004u; + coeff_ = value; +} +inline void ReductionParameter::set_coeff(float value) { + _internal_set_coeff(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.coeff) +} + +// ------------------------------------------------------------------- + +// ReLUParameter + +// optional float negative_slope = 1 [default = 0]; +inline bool ReLUParameter::_internal_has_negative_slope() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ReLUParameter::has_negative_slope() const { + return _internal_has_negative_slope(); +} +inline void ReLUParameter::clear_negative_slope() { + negative_slope_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float ReLUParameter::_internal_negative_slope() const { + return negative_slope_; +} +inline float ReLUParameter::negative_slope() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ReLUParameter.negative_slope) + return _internal_negative_slope(); +} +inline void ReLUParameter::_internal_set_negative_slope(float value) { + _has_bits_[0] |= 0x00000001u; + negative_slope_ = value; +} +inline void ReLUParameter::set_negative_slope(float value) { + _internal_set_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::_internal_has_engine() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ReLUParameter::has_engine() const { + return _internal_has_engine(); +} +inline void ReLUParameter::clear_engine() { + engine_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::opencv_caffe::ReLUParameter_Engine ReLUParameter::_internal_engine() const { + return static_cast< ::opencv_caffe::ReLUParameter_Engine >(engine_); +} +inline ::opencv_caffe::ReLUParameter_Engine ReLUParameter::engine() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ReLUParameter.engine) + return _internal_engine(); +} +inline void ReLUParameter::_internal_set_engine(::opencv_caffe::ReLUParameter_Engine value) { + assert(::opencv_caffe::ReLUParameter_Engine_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + engine_ = value; +} +inline void ReLUParameter::set_engine(::opencv_caffe::ReLUParameter_Engine value) { + _internal_set_engine(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ReLUParameter.engine) +} + +// ------------------------------------------------------------------- + +// ReshapeParameter + +// optional .opencv_caffe.BlobShape shape = 1; +inline bool ReshapeParameter::_internal_has_shape() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || shape_ != nullptr); + return value; +} +inline bool ReshapeParameter::has_shape() const { + return _internal_has_shape(); +} +inline void ReshapeParameter::clear_shape() { + if (shape_ != nullptr) shape_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::BlobShape& ReshapeParameter::_internal_shape() const { + const ::opencv_caffe::BlobShape* p = shape_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_BlobShape_default_instance_); +} +inline const ::opencv_caffe::BlobShape& ReshapeParameter::shape() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.shape) + return _internal_shape(); +} +inline void ReshapeParameter::unsafe_arena_set_allocated_shape( + ::opencv_caffe::BlobShape* shape) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_); + } + shape_ = shape; + if (shape) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ReshapeParameter.shape) +} +inline ::opencv_caffe::BlobShape* ReshapeParameter::release_shape() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::BlobShape* temp = shape_; + shape_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::BlobShape* ReshapeParameter::unsafe_arena_release_shape() { + // @@protoc_insertion_point(field_release:opencv_caffe.ReshapeParameter.shape) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::BlobShape* temp = shape_; + shape_ = nullptr; + return temp; +} +inline ::opencv_caffe::BlobShape* ReshapeParameter::_internal_mutable_shape() { + _has_bits_[0] |= 0x00000001u; + if (shape_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::BlobShape>(GetArenaForAllocation()); + shape_ = p; + } + return shape_; +} +inline ::opencv_caffe::BlobShape* ReshapeParameter::mutable_shape() { + ::opencv_caffe::BlobShape* _msg = _internal_mutable_shape(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ReshapeParameter.shape) + return _msg; +} +inline void ReshapeParameter::set_allocated_shape(::opencv_caffe::BlobShape* shape) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete shape_; + } + if (shape) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::BlobShape>::GetOwningArena(shape); + if (message_arena != submessage_arena) { + shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, shape, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + shape_ = shape; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ReshapeParameter.shape) +} + +// optional int32 axis = 2 [default = 0]; +inline bool ReshapeParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ReshapeParameter::has_axis() const { + return _internal_has_axis(); +} +inline void ReshapeParameter::clear_axis() { + axis_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t ReshapeParameter::_internal_axis() const { + return axis_; +} +inline int32_t ReshapeParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.axis) + return _internal_axis(); +} +inline void ReshapeParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000002u; + axis_ = value; +} +inline void ReshapeParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ReshapeParameter.axis) +} + +// optional int32 num_axes = 3 [default = -1]; +inline bool ReshapeParameter::_internal_has_num_axes() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ReshapeParameter::has_num_axes() const { + return _internal_has_num_axes(); +} +inline void ReshapeParameter::clear_num_axes() { + num_axes_ = -1; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t ReshapeParameter::_internal_num_axes() const { + return num_axes_; +} +inline int32_t ReshapeParameter::num_axes() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.num_axes) + return _internal_num_axes(); +} +inline void ReshapeParameter::_internal_set_num_axes(int32_t value) { + _has_bits_[0] |= 0x00000004u; + num_axes_ = value; +} +inline void ReshapeParameter::set_num_axes(int32_t value) { + _internal_set_num_axes(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ReshapeParameter.num_axes) +} + +// ------------------------------------------------------------------- + +// ScaleParameter + +// optional int32 axis = 1 [default = 1]; +inline bool ScaleParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ScaleParameter::has_axis() const { + return _internal_has_axis(); +} +inline void ScaleParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000008u; +} +inline int32_t ScaleParameter::_internal_axis() const { + return axis_; +} +inline int32_t ScaleParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.axis) + return _internal_axis(); +} +inline void ScaleParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000008u; + axis_ = value; +} +inline void ScaleParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.axis) +} + +// optional int32 num_axes = 2 [default = 1]; +inline bool ScaleParameter::_internal_has_num_axes() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ScaleParameter::has_num_axes() const { + return _internal_has_num_axes(); +} +inline void ScaleParameter::clear_num_axes() { + num_axes_ = 1; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t ScaleParameter::_internal_num_axes() const { + return num_axes_; +} +inline int32_t ScaleParameter::num_axes() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.num_axes) + return _internal_num_axes(); +} +inline void ScaleParameter::_internal_set_num_axes(int32_t value) { + _has_bits_[0] |= 0x00000010u; + num_axes_ = value; +} +inline void ScaleParameter::set_num_axes(int32_t value) { + _internal_set_num_axes(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.num_axes) +} + +// optional .opencv_caffe.FillerParameter filler = 3; +inline bool ScaleParameter::_internal_has_filler() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || filler_ != nullptr); + return value; +} +inline bool ScaleParameter::has_filler() const { + return _internal_has_filler(); +} +inline void ScaleParameter::clear_filler() { + if (filler_ != nullptr) filler_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::FillerParameter& ScaleParameter::_internal_filler() const { + const ::opencv_caffe::FillerParameter* p = filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& ScaleParameter::filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.filler) + return _internal_filler(); +} +inline void ScaleParameter::unsafe_arena_set_allocated_filler( + ::opencv_caffe::FillerParameter* filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filler_); + } + filler_ = filler; + if (filler) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ScaleParameter.filler) +} +inline ::opencv_caffe::FillerParameter* ScaleParameter::release_filler() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = filler_; + filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* ScaleParameter::unsafe_arena_release_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.ScaleParameter.filler) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = filler_; + filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* ScaleParameter::_internal_mutable_filler() { + _has_bits_[0] |= 0x00000001u; + if (filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + filler_ = p; + } + return filler_; +} +inline ::opencv_caffe::FillerParameter* ScaleParameter::mutable_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ScaleParameter.filler) + return _msg; +} +inline void ScaleParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete filler_; + } + if (filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(filler); + if (message_arena != submessage_arena) { + filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, filler, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + filler_ = filler; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ScaleParameter.filler) +} + +// optional bool bias_term = 4 [default = false]; +inline bool ScaleParameter::_internal_has_bias_term() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ScaleParameter::has_bias_term() const { + return _internal_has_bias_term(); +} +inline void ScaleParameter::clear_bias_term() { + bias_term_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool ScaleParameter::_internal_bias_term() const { + return bias_term_; +} +inline bool ScaleParameter::bias_term() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.bias_term) + return _internal_bias_term(); +} +inline void ScaleParameter::_internal_set_bias_term(bool value) { + _has_bits_[0] |= 0x00000004u; + bias_term_ = value; +} +inline void ScaleParameter::set_bias_term(bool value) { + _internal_set_bias_term(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.bias_term) +} + +// optional .opencv_caffe.FillerParameter bias_filler = 5; +inline bool ScaleParameter::_internal_has_bias_filler() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || bias_filler_ != nullptr); + return value; +} +inline bool ScaleParameter::has_bias_filler() const { + return _internal_has_bias_filler(); +} +inline void ScaleParameter::clear_bias_filler() { + if (bias_filler_ != nullptr) bias_filler_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::FillerParameter& ScaleParameter::_internal_bias_filler() const { + const ::opencv_caffe::FillerParameter* p = bias_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& ScaleParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.bias_filler) + return _internal_bias_filler(); +} +inline void ScaleParameter::unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_); + } + bias_filler_ = bias_filler; + if (bias_filler) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ScaleParameter.bias_filler) +} +inline ::opencv_caffe::FillerParameter* ScaleParameter::release_bias_filler() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* ScaleParameter::unsafe_arena_release_bias_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.ScaleParameter.bias_filler) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* ScaleParameter::_internal_mutable_bias_filler() { + _has_bits_[0] |= 0x00000002u; + if (bias_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + bias_filler_ = p; + } + return bias_filler_; +} +inline ::opencv_caffe::FillerParameter* ScaleParameter::mutable_bias_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.ScaleParameter.bias_filler) + return _msg; +} +inline void ScaleParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bias_filler_; + } + if (bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(bias_filler); + if (message_arena != submessage_arena) { + bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bias_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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::_internal_has_engine() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SigmoidParameter::has_engine() const { + return _internal_has_engine(); +} +inline void SigmoidParameter::clear_engine() { + engine_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::opencv_caffe::SigmoidParameter_Engine SigmoidParameter::_internal_engine() const { + return static_cast< ::opencv_caffe::SigmoidParameter_Engine >(engine_); +} +inline ::opencv_caffe::SigmoidParameter_Engine SigmoidParameter::engine() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SigmoidParameter.engine) + return _internal_engine(); +} +inline void SigmoidParameter::_internal_set_engine(::opencv_caffe::SigmoidParameter_Engine value) { + assert(::opencv_caffe::SigmoidParameter_Engine_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + engine_ = value; +} +inline void SigmoidParameter::set_engine(::opencv_caffe::SigmoidParameter_Engine value) { + _internal_set_engine(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SigmoidParameter.engine) +} + +// ------------------------------------------------------------------- + +// SliceParameter + +// optional int32 axis = 3 [default = 1]; +inline bool SliceParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SliceParameter::has_axis() const { + return _internal_has_axis(); +} +inline void SliceParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t SliceParameter::_internal_axis() const { + return axis_; +} +inline int32_t SliceParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.axis) + return _internal_axis(); +} +inline void SliceParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000002u; + axis_ = value; +} +inline void SliceParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SliceParameter.axis) +} + +// repeated uint32 slice_point = 2; +inline int SliceParameter::_internal_slice_point_size() const { + return slice_point_.size(); +} +inline int SliceParameter::slice_point_size() const { + return _internal_slice_point_size(); +} +inline void SliceParameter::clear_slice_point() { + slice_point_.Clear(); +} +inline uint32_t SliceParameter::_internal_slice_point(int index) const { + return slice_point_.Get(index); +} +inline uint32_t SliceParameter::slice_point(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.slice_point) + return _internal_slice_point(index); +} +inline void SliceParameter::set_slice_point(int index, uint32_t value) { + slice_point_.Set(index, value); + // @@protoc_insertion_point(field_set:opencv_caffe.SliceParameter.slice_point) +} +inline void SliceParameter::_internal_add_slice_point(uint32_t value) { + slice_point_.Add(value); +} +inline void SliceParameter::add_slice_point(uint32_t value) { + _internal_add_slice_point(value); + // @@protoc_insertion_point(field_add:opencv_caffe.SliceParameter.slice_point) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +SliceParameter::_internal_slice_point() const { + return slice_point_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +SliceParameter::slice_point() const { + // @@protoc_insertion_point(field_list:opencv_caffe.SliceParameter.slice_point) + return _internal_slice_point(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +SliceParameter::_internal_mutable_slice_point() { + return &slice_point_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +SliceParameter::mutable_slice_point() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SliceParameter.slice_point) + return _internal_mutable_slice_point(); +} + +// optional uint32 slice_dim = 1 [default = 1]; +inline bool SliceParameter::_internal_has_slice_dim() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SliceParameter::has_slice_dim() const { + return _internal_has_slice_dim(); +} +inline void SliceParameter::clear_slice_dim() { + slice_dim_ = 1u; + _has_bits_[0] &= ~0x00000001u; +} +inline uint32_t SliceParameter::_internal_slice_dim() const { + return slice_dim_; +} +inline uint32_t SliceParameter::slice_dim() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.slice_dim) + return _internal_slice_dim(); +} +inline void SliceParameter::_internal_set_slice_dim(uint32_t value) { + _has_bits_[0] |= 0x00000001u; + slice_dim_ = value; +} +inline void SliceParameter::set_slice_dim(uint32_t value) { + _internal_set_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::_internal_has_engine() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SoftmaxParameter::has_engine() const { + return _internal_has_engine(); +} +inline void SoftmaxParameter::clear_engine() { + engine_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::opencv_caffe::SoftmaxParameter_Engine SoftmaxParameter::_internal_engine() const { + return static_cast< ::opencv_caffe::SoftmaxParameter_Engine >(engine_); +} +inline ::opencv_caffe::SoftmaxParameter_Engine SoftmaxParameter::engine() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SoftmaxParameter.engine) + return _internal_engine(); +} +inline void SoftmaxParameter::_internal_set_engine(::opencv_caffe::SoftmaxParameter_Engine value) { + assert(::opencv_caffe::SoftmaxParameter_Engine_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + engine_ = value; +} +inline void SoftmaxParameter::set_engine(::opencv_caffe::SoftmaxParameter_Engine value) { + _internal_set_engine(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SoftmaxParameter.engine) +} + +// optional int32 axis = 2 [default = 1]; +inline bool SoftmaxParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SoftmaxParameter::has_axis() const { + return _internal_has_axis(); +} +inline void SoftmaxParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t SoftmaxParameter::_internal_axis() const { + return axis_; +} +inline int32_t SoftmaxParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SoftmaxParameter.axis) + return _internal_axis(); +} +inline void SoftmaxParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000002u; + axis_ = value; +} +inline void SoftmaxParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SoftmaxParameter.axis) +} + +// ------------------------------------------------------------------- + +// TanHParameter + +// optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; +inline bool TanHParameter::_internal_has_engine() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TanHParameter::has_engine() const { + return _internal_has_engine(); +} +inline void TanHParameter::clear_engine() { + engine_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::opencv_caffe::TanHParameter_Engine TanHParameter::_internal_engine() const { + return static_cast< ::opencv_caffe::TanHParameter_Engine >(engine_); +} +inline ::opencv_caffe::TanHParameter_Engine TanHParameter::engine() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TanHParameter.engine) + return _internal_engine(); +} +inline void TanHParameter::_internal_set_engine(::opencv_caffe::TanHParameter_Engine value) { + assert(::opencv_caffe::TanHParameter_Engine_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + engine_ = value; +} +inline void TanHParameter::set_engine(::opencv_caffe::TanHParameter_Engine value) { + _internal_set_engine(value); + // @@protoc_insertion_point(field_set:opencv_caffe.TanHParameter.engine) +} + +// ------------------------------------------------------------------- + +// TileParameter + +// optional int32 axis = 1 [default = 1]; +inline bool TileParameter::_internal_has_axis() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TileParameter::has_axis() const { + return _internal_has_axis(); +} +inline void TileParameter::clear_axis() { + axis_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t TileParameter::_internal_axis() const { + return axis_; +} +inline int32_t TileParameter::axis() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TileParameter.axis) + return _internal_axis(); +} +inline void TileParameter::_internal_set_axis(int32_t value) { + _has_bits_[0] |= 0x00000002u; + axis_ = value; +} +inline void TileParameter::set_axis(int32_t value) { + _internal_set_axis(value); + // @@protoc_insertion_point(field_set:opencv_caffe.TileParameter.axis) +} + +// optional int32 tiles = 2; +inline bool TileParameter::_internal_has_tiles() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TileParameter::has_tiles() const { + return _internal_has_tiles(); +} +inline void TileParameter::clear_tiles() { + tiles_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t TileParameter::_internal_tiles() const { + return tiles_; +} +inline int32_t TileParameter::tiles() const { + // @@protoc_insertion_point(field_get:opencv_caffe.TileParameter.tiles) + return _internal_tiles(); +} +inline void TileParameter::_internal_set_tiles(int32_t value) { + _has_bits_[0] |= 0x00000001u; + tiles_ = value; +} +inline void TileParameter::set_tiles(int32_t value) { + _internal_set_tiles(value); + // @@protoc_insertion_point(field_set:opencv_caffe.TileParameter.tiles) +} + +// ------------------------------------------------------------------- + +// ThresholdParameter + +// optional float threshold = 1 [default = 0]; +inline bool ThresholdParameter::_internal_has_threshold() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ThresholdParameter::has_threshold() const { + return _internal_has_threshold(); +} +inline void ThresholdParameter::clear_threshold() { + threshold_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float ThresholdParameter::_internal_threshold() const { + return threshold_; +} +inline float ThresholdParameter::threshold() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ThresholdParameter.threshold) + return _internal_threshold(); +} +inline void ThresholdParameter::_internal_set_threshold(float value) { + _has_bits_[0] |= 0x00000001u; + threshold_ = value; +} +inline void ThresholdParameter::set_threshold(float value) { + _internal_set_threshold(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ThresholdParameter.threshold) +} + +// ------------------------------------------------------------------- + +// WindowDataParameter + +// optional string source = 1; +inline bool WindowDataParameter::_internal_has_source() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool WindowDataParameter::has_source() const { + return _internal_has_source(); +} +inline void WindowDataParameter::clear_source() { + source_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& WindowDataParameter::source() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.source) + return _internal_source(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WindowDataParameter::set_source(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.source) +} +inline std::string* WindowDataParameter::mutable_source() { + std::string* _s = _internal_mutable_source(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.source) + return _s; +} +inline const std::string& WindowDataParameter::_internal_source() const { + return source_.Get(); +} +inline void WindowDataParameter::_internal_set_source(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* WindowDataParameter::_internal_mutable_source() { + _has_bits_[0] |= 0x00000001u; + return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* WindowDataParameter::release_source() { + // @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.source) + if (!_internal_has_source()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WindowDataParameter::set_allocated_source(std::string* source) { + if (source != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.source) +} + +// optional float scale = 2 [default = 1]; +inline bool WindowDataParameter::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool WindowDataParameter::has_scale() const { + return _internal_has_scale(); +} +inline void WindowDataParameter::clear_scale() { + scale_ = 1; + _has_bits_[0] &= ~0x00000200u; +} +inline float WindowDataParameter::_internal_scale() const { + return scale_; +} +inline float WindowDataParameter::scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.scale) + return _internal_scale(); +} +inline void WindowDataParameter::_internal_set_scale(float value) { + _has_bits_[0] |= 0x00000200u; + scale_ = value; +} +inline void WindowDataParameter::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.scale) +} + +// optional string mean_file = 3; +inline bool WindowDataParameter::_internal_has_mean_file() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool WindowDataParameter::has_mean_file() const { + return _internal_has_mean_file(); +} +inline void WindowDataParameter::clear_mean_file() { + mean_file_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& WindowDataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.mean_file) + return _internal_mean_file(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WindowDataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.mean_file) +} +inline std::string* WindowDataParameter::mutable_mean_file() { + std::string* _s = _internal_mutable_mean_file(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.mean_file) + return _s; +} +inline const std::string& WindowDataParameter::_internal_mean_file() const { + return mean_file_.Get(); +} +inline void WindowDataParameter::_internal_set_mean_file(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* WindowDataParameter::_internal_mutable_mean_file() { + _has_bits_[0] |= 0x00000002u; + return mean_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* WindowDataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.mean_file) + if (!_internal_has_mean_file()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = mean_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WindowDataParameter::set_allocated_mean_file(std::string* mean_file) { + if (mean_file != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + mean_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mean_file, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.mean_file) +} + +// optional uint32 batch_size = 4; +inline bool WindowDataParameter::_internal_has_batch_size() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool WindowDataParameter::has_batch_size() const { + return _internal_has_batch_size(); +} +inline void WindowDataParameter::clear_batch_size() { + batch_size_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline uint32_t WindowDataParameter::_internal_batch_size() const { + return batch_size_; +} +inline uint32_t WindowDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.batch_size) + return _internal_batch_size(); +} +inline void WindowDataParameter::_internal_set_batch_size(uint32_t value) { + _has_bits_[0] |= 0x00000010u; + batch_size_ = value; +} +inline void WindowDataParameter::set_batch_size(uint32_t value) { + _internal_set_batch_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.batch_size) +} + +// optional uint32 crop_size = 5 [default = 0]; +inline bool WindowDataParameter::_internal_has_crop_size() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool WindowDataParameter::has_crop_size() const { + return _internal_has_crop_size(); +} +inline void WindowDataParameter::clear_crop_size() { + crop_size_ = 0u; + _has_bits_[0] &= ~0x00000020u; +} +inline uint32_t WindowDataParameter::_internal_crop_size() const { + return crop_size_; +} +inline uint32_t WindowDataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.crop_size) + return _internal_crop_size(); +} +inline void WindowDataParameter::_internal_set_crop_size(uint32_t value) { + _has_bits_[0] |= 0x00000020u; + crop_size_ = value; +} +inline void WindowDataParameter::set_crop_size(uint32_t value) { + _internal_set_crop_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +inline bool WindowDataParameter::_internal_has_mirror() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool WindowDataParameter::has_mirror() const { + return _internal_has_mirror(); +} +inline void WindowDataParameter::clear_mirror() { + mirror_ = false; + _has_bits_[0] &= ~0x00000040u; +} +inline bool WindowDataParameter::_internal_mirror() const { + return mirror_; +} +inline bool WindowDataParameter::mirror() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.mirror) + return _internal_mirror(); +} +inline void WindowDataParameter::_internal_set_mirror(bool value) { + _has_bits_[0] |= 0x00000040u; + mirror_ = value; +} +inline void WindowDataParameter::set_mirror(bool value) { + _internal_set_mirror(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.mirror) +} + +// optional float fg_threshold = 7 [default = 0.5]; +inline bool WindowDataParameter::_internal_has_fg_threshold() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool WindowDataParameter::has_fg_threshold() const { + return _internal_has_fg_threshold(); +} +inline void WindowDataParameter::clear_fg_threshold() { + fg_threshold_ = 0.5f; + _has_bits_[0] &= ~0x00000400u; +} +inline float WindowDataParameter::_internal_fg_threshold() const { + return fg_threshold_; +} +inline float WindowDataParameter::fg_threshold() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.fg_threshold) + return _internal_fg_threshold(); +} +inline void WindowDataParameter::_internal_set_fg_threshold(float value) { + _has_bits_[0] |= 0x00000400u; + fg_threshold_ = value; +} +inline void WindowDataParameter::set_fg_threshold(float value) { + _internal_set_fg_threshold(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.fg_threshold) +} + +// optional float bg_threshold = 8 [default = 0.5]; +inline bool WindowDataParameter::_internal_has_bg_threshold() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool WindowDataParameter::has_bg_threshold() const { + return _internal_has_bg_threshold(); +} +inline void WindowDataParameter::clear_bg_threshold() { + bg_threshold_ = 0.5f; + _has_bits_[0] &= ~0x00000800u; +} +inline float WindowDataParameter::_internal_bg_threshold() const { + return bg_threshold_; +} +inline float WindowDataParameter::bg_threshold() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.bg_threshold) + return _internal_bg_threshold(); +} +inline void WindowDataParameter::_internal_set_bg_threshold(float value) { + _has_bits_[0] |= 0x00000800u; + bg_threshold_ = value; +} +inline void WindowDataParameter::set_bg_threshold(float value) { + _internal_set_bg_threshold(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.bg_threshold) +} + +// optional float fg_fraction = 9 [default = 0.25]; +inline bool WindowDataParameter::_internal_has_fg_fraction() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool WindowDataParameter::has_fg_fraction() const { + return _internal_has_fg_fraction(); +} +inline void WindowDataParameter::clear_fg_fraction() { + fg_fraction_ = 0.25f; + _has_bits_[0] &= ~0x00001000u; +} +inline float WindowDataParameter::_internal_fg_fraction() const { + return fg_fraction_; +} +inline float WindowDataParameter::fg_fraction() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.fg_fraction) + return _internal_fg_fraction(); +} +inline void WindowDataParameter::_internal_set_fg_fraction(float value) { + _has_bits_[0] |= 0x00001000u; + fg_fraction_ = value; +} +inline void WindowDataParameter::set_fg_fraction(float value) { + _internal_set_fg_fraction(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.fg_fraction) +} + +// optional uint32 context_pad = 10 [default = 0]; +inline bool WindowDataParameter::_internal_has_context_pad() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool WindowDataParameter::has_context_pad() const { + return _internal_has_context_pad(); +} +inline void WindowDataParameter::clear_context_pad() { + context_pad_ = 0u; + _has_bits_[0] &= ~0x00000100u; +} +inline uint32_t WindowDataParameter::_internal_context_pad() const { + return context_pad_; +} +inline uint32_t WindowDataParameter::context_pad() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.context_pad) + return _internal_context_pad(); +} +inline void WindowDataParameter::_internal_set_context_pad(uint32_t value) { + _has_bits_[0] |= 0x00000100u; + context_pad_ = value; +} +inline void WindowDataParameter::set_context_pad(uint32_t value) { + _internal_set_context_pad(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.context_pad) +} + +// optional string crop_mode = 11 [default = "warp"]; +inline bool WindowDataParameter::_internal_has_crop_mode() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool WindowDataParameter::has_crop_mode() const { + return _internal_has_crop_mode(); +} +inline void WindowDataParameter::clear_crop_mode() { + crop_mode_.ClearToDefault(::opencv_caffe::WindowDataParameter::_i_give_permission_to_break_this_code_default_crop_mode_, GetArenaForAllocation()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& WindowDataParameter::crop_mode() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.crop_mode) + if (crop_mode_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_crop_mode_.get(); + return _internal_crop_mode(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WindowDataParameter::set_crop_mode(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.crop_mode) +} +inline std::string* WindowDataParameter::mutable_crop_mode() { + std::string* _s = _internal_mutable_crop_mode(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.crop_mode) + return _s; +} +inline const std::string& WindowDataParameter::_internal_crop_mode() const { + return crop_mode_.Get(); +} +inline void WindowDataParameter::_internal_set_crop_mode(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* WindowDataParameter::_internal_mutable_crop_mode() { + _has_bits_[0] |= 0x00000004u; + return crop_mode_.Mutable(::opencv_caffe::WindowDataParameter::_i_give_permission_to_break_this_code_default_crop_mode_, GetArenaForAllocation()); +} +inline std::string* WindowDataParameter::release_crop_mode() { + // @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.crop_mode) + if (!_internal_has_crop_mode()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = crop_mode_.ReleaseNonDefault(nullptr, GetArenaForAllocation()); + return p; +} +inline void WindowDataParameter::set_allocated_crop_mode(std::string* crop_mode) { + if (crop_mode != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + crop_mode_.SetAllocated(nullptr, crop_mode, + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.crop_mode) +} + +// optional bool cache_images = 12 [default = false]; +inline bool WindowDataParameter::_internal_has_cache_images() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool WindowDataParameter::has_cache_images() const { + return _internal_has_cache_images(); +} +inline void WindowDataParameter::clear_cache_images() { + cache_images_ = false; + _has_bits_[0] &= ~0x00000080u; +} +inline bool WindowDataParameter::_internal_cache_images() const { + return cache_images_; +} +inline bool WindowDataParameter::cache_images() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.cache_images) + return _internal_cache_images(); +} +inline void WindowDataParameter::_internal_set_cache_images(bool value) { + _has_bits_[0] |= 0x00000080u; + cache_images_ = value; +} +inline void WindowDataParameter::set_cache_images(bool value) { + _internal_set_cache_images(value); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.cache_images) +} + +// optional string root_folder = 13 [default = ""]; +inline bool WindowDataParameter::_internal_has_root_folder() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool WindowDataParameter::has_root_folder() const { + return _internal_has_root_folder(); +} +inline void WindowDataParameter::clear_root_folder() { + root_folder_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& WindowDataParameter::root_folder() const { + // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.root_folder) + return _internal_root_folder(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WindowDataParameter::set_root_folder(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000008u; + root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.root_folder) +} +inline std::string* WindowDataParameter::mutable_root_folder() { + std::string* _s = _internal_mutable_root_folder(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.root_folder) + return _s; +} +inline const std::string& WindowDataParameter::_internal_root_folder() const { + return root_folder_.Get(); +} +inline void WindowDataParameter::_internal_set_root_folder(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* WindowDataParameter::_internal_mutable_root_folder() { + _has_bits_[0] |= 0x00000008u; + return root_folder_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* WindowDataParameter::release_root_folder() { + // @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.root_folder) + if (!_internal_has_root_folder()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto* p = root_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (root_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WindowDataParameter::set_allocated_root_folder(std::string* root_folder) { + if (root_folder != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + root_folder_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), root_folder, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (root_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.root_folder) +} + +// ------------------------------------------------------------------- + +// SPPParameter + +// optional uint32 pyramid_height = 1; +inline bool SPPParameter::_internal_has_pyramid_height() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SPPParameter::has_pyramid_height() const { + return _internal_has_pyramid_height(); +} +inline void SPPParameter::clear_pyramid_height() { + pyramid_height_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline uint32_t SPPParameter::_internal_pyramid_height() const { + return pyramid_height_; +} +inline uint32_t SPPParameter::pyramid_height() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.pyramid_height) + return _internal_pyramid_height(); +} +inline void SPPParameter::_internal_set_pyramid_height(uint32_t value) { + _has_bits_[0] |= 0x00000001u; + pyramid_height_ = value; +} +inline void SPPParameter::set_pyramid_height(uint32_t value) { + _internal_set_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::_internal_has_pool() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SPPParameter::has_pool() const { + return _internal_has_pool(); +} +inline void SPPParameter::clear_pool() { + pool_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::opencv_caffe::SPPParameter_PoolMethod SPPParameter::_internal_pool() const { + return static_cast< ::opencv_caffe::SPPParameter_PoolMethod >(pool_); +} +inline ::opencv_caffe::SPPParameter_PoolMethod SPPParameter::pool() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.pool) + return _internal_pool(); +} +inline void SPPParameter::_internal_set_pool(::opencv_caffe::SPPParameter_PoolMethod value) { + assert(::opencv_caffe::SPPParameter_PoolMethod_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + pool_ = value; +} +inline void SPPParameter::set_pool(::opencv_caffe::SPPParameter_PoolMethod value) { + _internal_set_pool(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SPPParameter.pool) +} + +// optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; +inline bool SPPParameter::_internal_has_engine() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SPPParameter::has_engine() const { + return _internal_has_engine(); +} +inline void SPPParameter::clear_engine() { + engine_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline ::opencv_caffe::SPPParameter_Engine SPPParameter::_internal_engine() const { + return static_cast< ::opencv_caffe::SPPParameter_Engine >(engine_); +} +inline ::opencv_caffe::SPPParameter_Engine SPPParameter::engine() const { + // @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.engine) + return _internal_engine(); +} +inline void SPPParameter::_internal_set_engine(::opencv_caffe::SPPParameter_Engine value) { + assert(::opencv_caffe::SPPParameter_Engine_IsValid(value)); + _has_bits_[0] |= 0x00000004u; + engine_ = value; +} +inline void SPPParameter::set_engine(::opencv_caffe::SPPParameter_Engine value) { + _internal_set_engine(value); + // @@protoc_insertion_point(field_set:opencv_caffe.SPPParameter.engine) +} + +// ------------------------------------------------------------------- + +// V1LayerParameter + +// repeated string bottom = 2; +inline int V1LayerParameter::_internal_bottom_size() const { + return bottom_.size(); +} +inline int V1LayerParameter::bottom_size() const { + return _internal_bottom_size(); +} +inline void V1LayerParameter::clear_bottom() { + bottom_.Clear(); +} +inline std::string* V1LayerParameter::add_bottom() { + std::string* _s = _internal_add_bottom(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.bottom) + return _s; +} +inline const std::string& V1LayerParameter::_internal_bottom(int index) const { + return bottom_.Get(index); +} +inline const std::string& V1LayerParameter::bottom(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.bottom) + return _internal_bottom(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) { + bottom_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.bottom) +} +inline void V1LayerParameter::set_bottom(int index, std::string&& value) { + bottom_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.bottom) +} +inline void V1LayerParameter::set_bottom(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.bottom) +} +inline std::string* V1LayerParameter::_internal_add_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) +} +inline void V1LayerParameter::add_bottom(std::string&& value) { + bottom_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.bottom) +} +inline void V1LayerParameter::add_bottom(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.bottom) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +V1LayerParameter::bottom() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.bottom) + return bottom_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +V1LayerParameter::mutable_bottom() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.bottom) + return &bottom_; +} + +// repeated string top = 3; +inline int V1LayerParameter::_internal_top_size() const { + return top_.size(); +} +inline int V1LayerParameter::top_size() const { + return _internal_top_size(); +} +inline void V1LayerParameter::clear_top() { + top_.Clear(); +} +inline std::string* V1LayerParameter::add_top() { + std::string* _s = _internal_add_top(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.top) + return _s; +} +inline const std::string& V1LayerParameter::_internal_top(int index) const { + return top_.Get(index); +} +inline const std::string& V1LayerParameter::top(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.top) + return _internal_top(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) { + top_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.top) +} +inline void V1LayerParameter::set_top(int index, std::string&& value) { + top_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.top) +} +inline void V1LayerParameter::set_top(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.top) +} +inline std::string* V1LayerParameter::_internal_add_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) +} +inline void V1LayerParameter::add_top(std::string&& value) { + top_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.top) +} +inline void V1LayerParameter::add_top(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.top) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +V1LayerParameter::top() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.top) + return top_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +V1LayerParameter::mutable_top() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.top) + return &top_; +} + +// optional string name = 4; +inline bool V1LayerParameter::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool V1LayerParameter::has_name() const { + return _internal_has_name(); +} +inline void V1LayerParameter::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& V1LayerParameter::name() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void V1LayerParameter::set_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.name) +} +inline std::string* V1LayerParameter::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.name) + return _s; +} +inline const std::string& V1LayerParameter::_internal_name() const { + return name_.Get(); +} +inline void V1LayerParameter::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* V1LayerParameter::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* V1LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void V1LayerParameter::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.name) +} + +// repeated .opencv_caffe.NetStateRule include = 32; +inline int V1LayerParameter::_internal_include_size() const { + return include_.size(); +} +inline int V1LayerParameter::include_size() const { + return _internal_include_size(); +} +inline void V1LayerParameter::clear_include() { + include_.Clear(); +} +inline ::opencv_caffe::NetStateRule* V1LayerParameter::mutable_include(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.include) + return include_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >* +V1LayerParameter::mutable_include() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.include) + return &include_; +} +inline const ::opencv_caffe::NetStateRule& V1LayerParameter::_internal_include(int index) const { + return include_.Get(index); +} +inline const ::opencv_caffe::NetStateRule& V1LayerParameter::include(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.include) + return _internal_include(index); +} +inline ::opencv_caffe::NetStateRule* V1LayerParameter::_internal_add_include() { + return include_.Add(); +} +inline ::opencv_caffe::NetStateRule* V1LayerParameter::add_include() { + ::opencv_caffe::NetStateRule* _add = _internal_add_include(); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.include) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_exclude_size() const { + return exclude_.size(); +} +inline int V1LayerParameter::exclude_size() const { + return _internal_exclude_size(); +} +inline void V1LayerParameter::clear_exclude() { + exclude_.Clear(); +} +inline ::opencv_caffe::NetStateRule* V1LayerParameter::mutable_exclude(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.exclude) + return exclude_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >* +V1LayerParameter::mutable_exclude() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.exclude) + return &exclude_; +} +inline const ::opencv_caffe::NetStateRule& V1LayerParameter::_internal_exclude(int index) const { + return exclude_.Get(index); +} +inline const ::opencv_caffe::NetStateRule& V1LayerParameter::exclude(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.exclude) + return _internal_exclude(index); +} +inline ::opencv_caffe::NetStateRule* V1LayerParameter::_internal_add_exclude() { + return exclude_.Add(); +} +inline ::opencv_caffe::NetStateRule* V1LayerParameter::add_exclude() { + ::opencv_caffe::NetStateRule* _add = _internal_add_exclude(); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.exclude) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_has_type() const { + bool value = (_has_bits_[1] & 0x00000001u) != 0; + return value; +} +inline bool V1LayerParameter::has_type() const { + return _internal_has_type(); +} +inline void V1LayerParameter::clear_type() { + type_ = 0; + _has_bits_[1] &= ~0x00000001u; +} +inline ::opencv_caffe::V1LayerParameter_LayerType V1LayerParameter::_internal_type() const { + return static_cast< ::opencv_caffe::V1LayerParameter_LayerType >(type_); +} +inline ::opencv_caffe::V1LayerParameter_LayerType V1LayerParameter::type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.type) + return _internal_type(); +} +inline void V1LayerParameter::_internal_set_type(::opencv_caffe::V1LayerParameter_LayerType value) { + assert(::opencv_caffe::V1LayerParameter_LayerType_IsValid(value)); + _has_bits_[1] |= 0x00000001u; + type_ = value; +} +inline void V1LayerParameter::set_type(::opencv_caffe::V1LayerParameter_LayerType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.type) +} + +// repeated .opencv_caffe.BlobProto blobs = 6; +inline int V1LayerParameter::_internal_blobs_size() const { + return blobs_.size(); +} +inline int V1LayerParameter::blobs_size() const { + return _internal_blobs_size(); +} +inline void V1LayerParameter::clear_blobs() { + blobs_.Clear(); +} +inline ::opencv_caffe::BlobProto* V1LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.blobs) + return blobs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* +V1LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blobs) + return &blobs_; +} +inline const ::opencv_caffe::BlobProto& V1LayerParameter::_internal_blobs(int index) const { + return blobs_.Get(index); +} +inline const ::opencv_caffe::BlobProto& V1LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blobs) + return _internal_blobs(index); +} +inline ::opencv_caffe::BlobProto* V1LayerParameter::_internal_add_blobs() { + return blobs_.Add(); +} +inline ::opencv_caffe::BlobProto* V1LayerParameter::add_blobs() { + ::opencv_caffe::BlobProto* _add = _internal_add_blobs(); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blobs) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_param_size() const { + return param_.size(); +} +inline int V1LayerParameter::param_size() const { + return _internal_param_size(); +} +inline void V1LayerParameter::clear_param() { + param_.Clear(); +} +inline std::string* V1LayerParameter::add_param() { + std::string* _s = _internal_add_param(); + // @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.param) + return _s; +} +inline const std::string& V1LayerParameter::_internal_param(int index) const { + return param_.Get(index); +} +inline const std::string& V1LayerParameter::param(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.param) + return _internal_param(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) { + param_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.param) +} +inline void V1LayerParameter::set_param(int index, std::string&& value) { + param_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.param) +} +inline void V1LayerParameter::set_param(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.param) +} +inline std::string* V1LayerParameter::_internal_add_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) +} +inline void V1LayerParameter::add_param(std::string&& value) { + param_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.param) +} +inline void V1LayerParameter::add_param(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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(value), size); + // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.param) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +V1LayerParameter::param() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.param) + return param_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +V1LayerParameter::mutable_param() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.param) + return ¶m_; +} + +// repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; +inline int V1LayerParameter::_internal_blob_share_mode_size() const { + return blob_share_mode_.size(); +} +inline int V1LayerParameter::blob_share_mode_size() const { + return _internal_blob_share_mode_size(); +} +inline void V1LayerParameter::clear_blob_share_mode() { + blob_share_mode_.Clear(); +} +inline ::opencv_caffe::V1LayerParameter_DimCheckMode V1LayerParameter::_internal_blob_share_mode(int index) const { + return static_cast< ::opencv_caffe::V1LayerParameter_DimCheckMode >(blob_share_mode_.Get(index)); +} +inline ::opencv_caffe::V1LayerParameter_DimCheckMode V1LayerParameter::blob_share_mode(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blob_share_mode) + return _internal_blob_share_mode(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::_internal_add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value) { + assert(::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid(value)); + blob_share_mode_.Add(value); +} +inline void V1LayerParameter::add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value) { + _internal_add_blob_share_mode(value); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blob_share_mode) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& +V1LayerParameter::blob_share_mode() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.blob_share_mode) + return blob_share_mode_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +V1LayerParameter::_internal_mutable_blob_share_mode() { + return &blob_share_mode_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +V1LayerParameter::mutable_blob_share_mode() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blob_share_mode) + return _internal_mutable_blob_share_mode(); +} + +// repeated float blobs_lr = 7; +inline int V1LayerParameter::_internal_blobs_lr_size() const { + return blobs_lr_.size(); +} +inline int V1LayerParameter::blobs_lr_size() const { + return _internal_blobs_lr_size(); +} +inline void V1LayerParameter::clear_blobs_lr() { + blobs_lr_.Clear(); +} +inline float V1LayerParameter::_internal_blobs_lr(int index) const { + return blobs_lr_.Get(index); +} +inline float V1LayerParameter::blobs_lr(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blobs_lr) + return _internal_blobs_lr(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::_internal_add_blobs_lr(float value) { + blobs_lr_.Add(value); +} +inline void V1LayerParameter::add_blobs_lr(float value) { + _internal_add_blobs_lr(value); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blobs_lr) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V1LayerParameter::_internal_blobs_lr() const { + return blobs_lr_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V1LayerParameter::blobs_lr() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.blobs_lr) + return _internal_blobs_lr(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V1LayerParameter::_internal_mutable_blobs_lr() { + return &blobs_lr_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V1LayerParameter::mutable_blobs_lr() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blobs_lr) + return _internal_mutable_blobs_lr(); +} + +// repeated float weight_decay = 8; +inline int V1LayerParameter::_internal_weight_decay_size() const { + return weight_decay_.size(); +} +inline int V1LayerParameter::weight_decay_size() const { + return _internal_weight_decay_size(); +} +inline void V1LayerParameter::clear_weight_decay() { + weight_decay_.Clear(); +} +inline float V1LayerParameter::_internal_weight_decay(int index) const { + return weight_decay_.Get(index); +} +inline float V1LayerParameter::weight_decay(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.weight_decay) + return _internal_weight_decay(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::_internal_add_weight_decay(float value) { + weight_decay_.Add(value); +} +inline void V1LayerParameter::add_weight_decay(float value) { + _internal_add_weight_decay(value); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.weight_decay) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V1LayerParameter::_internal_weight_decay() const { + return weight_decay_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V1LayerParameter::weight_decay() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.weight_decay) + return _internal_weight_decay(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V1LayerParameter::_internal_mutable_weight_decay() { + return &weight_decay_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V1LayerParameter::mutable_weight_decay() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.weight_decay) + return _internal_mutable_weight_decay(); +} + +// repeated float loss_weight = 35; +inline int V1LayerParameter::_internal_loss_weight_size() const { + return loss_weight_.size(); +} +inline int V1LayerParameter::loss_weight_size() const { + return _internal_loss_weight_size(); +} +inline void V1LayerParameter::clear_loss_weight() { + loss_weight_.Clear(); +} +inline float V1LayerParameter::_internal_loss_weight(int index) const { + return loss_weight_.Get(index); +} +inline float V1LayerParameter::loss_weight(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.loss_weight) + return _internal_loss_weight(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::_internal_add_loss_weight(float value) { + loss_weight_.Add(value); +} +inline void V1LayerParameter::add_loss_weight(float value) { + _internal_add_loss_weight(value); + // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.loss_weight) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V1LayerParameter::_internal_loss_weight() const { + return loss_weight_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V1LayerParameter::loss_weight() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.loss_weight) + return _internal_loss_weight(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V1LayerParameter::_internal_mutable_loss_weight() { + return &loss_weight_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V1LayerParameter::mutable_loss_weight() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.loss_weight) + return _internal_mutable_loss_weight(); +} + +// optional .opencv_caffe.AccuracyParameter accuracy_param = 27; +inline bool V1LayerParameter::_internal_has_accuracy_param() const { + bool value = (_has_bits_[0] & 0x00100000u) != 0; + PROTOBUF_ASSUME(!value || accuracy_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_accuracy_param() const { + return _internal_has_accuracy_param(); +} +inline void V1LayerParameter::clear_accuracy_param() { + if (accuracy_param_ != nullptr) accuracy_param_->Clear(); + _has_bits_[0] &= ~0x00100000u; +} +inline const ::opencv_caffe::AccuracyParameter& V1LayerParameter::_internal_accuracy_param() const { + const ::opencv_caffe::AccuracyParameter* p = accuracy_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_AccuracyParameter_default_instance_); +} +inline const ::opencv_caffe::AccuracyParameter& V1LayerParameter::accuracy_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.accuracy_param) + return _internal_accuracy_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_accuracy_param( + ::opencv_caffe::AccuracyParameter* accuracy_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(accuracy_param_); + } + accuracy_param_ = accuracy_param; + if (accuracy_param) { + _has_bits_[0] |= 0x00100000u; + } else { + _has_bits_[0] &= ~0x00100000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.accuracy_param) +} +inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::release_accuracy_param() { + _has_bits_[0] &= ~0x00100000u; + ::opencv_caffe::AccuracyParameter* temp = accuracy_param_; + accuracy_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::unsafe_arena_release_accuracy_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.accuracy_param) + _has_bits_[0] &= ~0x00100000u; + ::opencv_caffe::AccuracyParameter* temp = accuracy_param_; + accuracy_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::_internal_mutable_accuracy_param() { + _has_bits_[0] |= 0x00100000u; + if (accuracy_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::AccuracyParameter>(GetArenaForAllocation()); + accuracy_param_ = p; + } + return accuracy_param_; +} +inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::mutable_accuracy_param() { + ::opencv_caffe::AccuracyParameter* _msg = _internal_mutable_accuracy_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.accuracy_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete accuracy_param_; + } + if (accuracy_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::AccuracyParameter>::GetOwningArena(accuracy_param); + if (message_arena != submessage_arena) { + accuracy_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, accuracy_param, submessage_arena); + } + _has_bits_[0] |= 0x00100000u; + } else { + _has_bits_[0] &= ~0x00100000u; + } + 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::_internal_has_argmax_param() const { + bool value = (_has_bits_[0] & 0x00010000u) != 0; + PROTOBUF_ASSUME(!value || argmax_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_argmax_param() const { + return _internal_has_argmax_param(); +} +inline void V1LayerParameter::clear_argmax_param() { + if (argmax_param_ != nullptr) argmax_param_->Clear(); + _has_bits_[0] &= ~0x00010000u; +} +inline const ::opencv_caffe::ArgMaxParameter& V1LayerParameter::_internal_argmax_param() const { + const ::opencv_caffe::ArgMaxParameter* p = argmax_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ArgMaxParameter_default_instance_); +} +inline const ::opencv_caffe::ArgMaxParameter& V1LayerParameter::argmax_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.argmax_param) + return _internal_argmax_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_argmax_param( + ::opencv_caffe::ArgMaxParameter* argmax_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(argmax_param_); + } + argmax_param_ = argmax_param; + if (argmax_param) { + _has_bits_[0] |= 0x00010000u; + } else { + _has_bits_[0] &= ~0x00010000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.argmax_param) +} +inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::release_argmax_param() { + _has_bits_[0] &= ~0x00010000u; + ::opencv_caffe::ArgMaxParameter* temp = argmax_param_; + argmax_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::unsafe_arena_release_argmax_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.argmax_param) + _has_bits_[0] &= ~0x00010000u; + ::opencv_caffe::ArgMaxParameter* temp = argmax_param_; + argmax_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::_internal_mutable_argmax_param() { + _has_bits_[0] |= 0x00010000u; + if (argmax_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ArgMaxParameter>(GetArenaForAllocation()); + argmax_param_ = p; + } + return argmax_param_; +} +inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::mutable_argmax_param() { + ::opencv_caffe::ArgMaxParameter* _msg = _internal_mutable_argmax_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.argmax_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete argmax_param_; + } + if (argmax_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ArgMaxParameter>::GetOwningArena(argmax_param); + if (message_arena != submessage_arena) { + argmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, argmax_param, submessage_arena); + } + _has_bits_[0] |= 0x00010000u; + } else { + _has_bits_[0] &= ~0x00010000u; + } + 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::_internal_has_concat_param() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || concat_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_concat_param() const { + return _internal_has_concat_param(); +} +inline void V1LayerParameter::clear_concat_param() { + if (concat_param_ != nullptr) concat_param_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::opencv_caffe::ConcatParameter& V1LayerParameter::_internal_concat_param() const { + const ::opencv_caffe::ConcatParameter* p = concat_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ConcatParameter_default_instance_); +} +inline const ::opencv_caffe::ConcatParameter& V1LayerParameter::concat_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.concat_param) + return _internal_concat_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_concat_param( + ::opencv_caffe::ConcatParameter* concat_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(concat_param_); + } + concat_param_ = concat_param; + if (concat_param) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.concat_param) +} +inline ::opencv_caffe::ConcatParameter* V1LayerParameter::release_concat_param() { + _has_bits_[0] &= ~0x00000004u; + ::opencv_caffe::ConcatParameter* temp = concat_param_; + concat_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ConcatParameter* V1LayerParameter::unsafe_arena_release_concat_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.concat_param) + _has_bits_[0] &= ~0x00000004u; + ::opencv_caffe::ConcatParameter* temp = concat_param_; + concat_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ConcatParameter* V1LayerParameter::_internal_mutable_concat_param() { + _has_bits_[0] |= 0x00000004u; + if (concat_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ConcatParameter>(GetArenaForAllocation()); + concat_param_ = p; + } + return concat_param_; +} +inline ::opencv_caffe::ConcatParameter* V1LayerParameter::mutable_concat_param() { + ::opencv_caffe::ConcatParameter* _msg = _internal_mutable_concat_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.concat_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete concat_param_; + } + if (concat_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ConcatParameter>::GetOwningArena(concat_param); + if (message_arena != submessage_arena) { + concat_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, concat_param, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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::_internal_has_contrastive_loss_param() const { + bool value = (_has_bits_[0] & 0x20000000u) != 0; + PROTOBUF_ASSUME(!value || contrastive_loss_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_contrastive_loss_param() const { + return _internal_has_contrastive_loss_param(); +} +inline void V1LayerParameter::clear_contrastive_loss_param() { + if (contrastive_loss_param_ != nullptr) contrastive_loss_param_->Clear(); + _has_bits_[0] &= ~0x20000000u; +} +inline const ::opencv_caffe::ContrastiveLossParameter& V1LayerParameter::_internal_contrastive_loss_param() const { + const ::opencv_caffe::ContrastiveLossParameter* p = contrastive_loss_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ContrastiveLossParameter_default_instance_); +} +inline const ::opencv_caffe::ContrastiveLossParameter& V1LayerParameter::contrastive_loss_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.contrastive_loss_param) + return _internal_contrastive_loss_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_contrastive_loss_param( + ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(contrastive_loss_param_); + } + contrastive_loss_param_ = contrastive_loss_param; + if (contrastive_loss_param) { + _has_bits_[0] |= 0x20000000u; + } else { + _has_bits_[0] &= ~0x20000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.contrastive_loss_param) +} +inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::release_contrastive_loss_param() { + _has_bits_[0] &= ~0x20000000u; + ::opencv_caffe::ContrastiveLossParameter* temp = contrastive_loss_param_; + contrastive_loss_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::unsafe_arena_release_contrastive_loss_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.contrastive_loss_param) + _has_bits_[0] &= ~0x20000000u; + ::opencv_caffe::ContrastiveLossParameter* temp = contrastive_loss_param_; + contrastive_loss_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::_internal_mutable_contrastive_loss_param() { + _has_bits_[0] |= 0x20000000u; + if (contrastive_loss_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ContrastiveLossParameter>(GetArenaForAllocation()); + contrastive_loss_param_ = p; + } + return contrastive_loss_param_; +} +inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::mutable_contrastive_loss_param() { + ::opencv_caffe::ContrastiveLossParameter* _msg = _internal_mutable_contrastive_loss_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.contrastive_loss_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete contrastive_loss_param_; + } + if (contrastive_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ContrastiveLossParameter>::GetOwningArena(contrastive_loss_param); + if (message_arena != submessage_arena) { + contrastive_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contrastive_loss_param, submessage_arena); + } + _has_bits_[0] |= 0x20000000u; + } else { + _has_bits_[0] &= ~0x20000000u; + } + 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::_internal_has_convolution_param() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || convolution_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_convolution_param() const { + return _internal_has_convolution_param(); +} +inline void V1LayerParameter::clear_convolution_param() { + if (convolution_param_ != nullptr) convolution_param_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::opencv_caffe::ConvolutionParameter& V1LayerParameter::_internal_convolution_param() const { + const ::opencv_caffe::ConvolutionParameter* p = convolution_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ConvolutionParameter_default_instance_); +} +inline const ::opencv_caffe::ConvolutionParameter& V1LayerParameter::convolution_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.convolution_param) + return _internal_convolution_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_convolution_param( + ::opencv_caffe::ConvolutionParameter* convolution_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(convolution_param_); + } + convolution_param_ = convolution_param; + if (convolution_param) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.convolution_param) +} +inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::release_convolution_param() { + _has_bits_[0] &= ~0x00000008u; + ::opencv_caffe::ConvolutionParameter* temp = convolution_param_; + convolution_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::unsafe_arena_release_convolution_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.convolution_param) + _has_bits_[0] &= ~0x00000008u; + ::opencv_caffe::ConvolutionParameter* temp = convolution_param_; + convolution_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::_internal_mutable_convolution_param() { + _has_bits_[0] |= 0x00000008u; + if (convolution_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ConvolutionParameter>(GetArenaForAllocation()); + convolution_param_ = p; + } + return convolution_param_; +} +inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::mutable_convolution_param() { + ::opencv_caffe::ConvolutionParameter* _msg = _internal_mutable_convolution_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.convolution_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete convolution_param_; + } + if (convolution_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ConvolutionParameter>::GetOwningArena(convolution_param); + if (message_arena != submessage_arena) { + convolution_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, convolution_param, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + 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::_internal_has_data_param() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || data_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_data_param() const { + return _internal_has_data_param(); +} +inline void V1LayerParameter::clear_data_param() { + if (data_param_ != nullptr) data_param_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::opencv_caffe::DataParameter& V1LayerParameter::_internal_data_param() const { + const ::opencv_caffe::DataParameter* p = data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_DataParameter_default_instance_); +} +inline const ::opencv_caffe::DataParameter& V1LayerParameter::data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.data_param) + return _internal_data_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_data_param( + ::opencv_caffe::DataParameter* data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(data_param_); + } + data_param_ = data_param; + if (data_param) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.data_param) +} +inline ::opencv_caffe::DataParameter* V1LayerParameter::release_data_param() { + _has_bits_[0] &= ~0x00000010u; + ::opencv_caffe::DataParameter* temp = data_param_; + data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::DataParameter* V1LayerParameter::unsafe_arena_release_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.data_param) + _has_bits_[0] &= ~0x00000010u; + ::opencv_caffe::DataParameter* temp = data_param_; + data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::DataParameter* V1LayerParameter::_internal_mutable_data_param() { + _has_bits_[0] |= 0x00000010u; + if (data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::DataParameter>(GetArenaForAllocation()); + data_param_ = p; + } + return data_param_; +} +inline ::opencv_caffe::DataParameter* V1LayerParameter::mutable_data_param() { + ::opencv_caffe::DataParameter* _msg = _internal_mutable_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.data_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_data_param(::opencv_caffe::DataParameter* data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete data_param_; + } + if (data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::DataParameter>::GetOwningArena(data_param); + if (message_arena != submessage_arena) { + data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, data_param, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + 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::_internal_has_dropout_param() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || dropout_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_dropout_param() const { + return _internal_has_dropout_param(); +} +inline void V1LayerParameter::clear_dropout_param() { + if (dropout_param_ != nullptr) dropout_param_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::opencv_caffe::DropoutParameter& V1LayerParameter::_internal_dropout_param() const { + const ::opencv_caffe::DropoutParameter* p = dropout_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_DropoutParameter_default_instance_); +} +inline const ::opencv_caffe::DropoutParameter& V1LayerParameter::dropout_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.dropout_param) + return _internal_dropout_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_dropout_param( + ::opencv_caffe::DropoutParameter* dropout_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dropout_param_); + } + dropout_param_ = dropout_param; + if (dropout_param) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.dropout_param) +} +inline ::opencv_caffe::DropoutParameter* V1LayerParameter::release_dropout_param() { + _has_bits_[0] &= ~0x00000020u; + ::opencv_caffe::DropoutParameter* temp = dropout_param_; + dropout_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::DropoutParameter* V1LayerParameter::unsafe_arena_release_dropout_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.dropout_param) + _has_bits_[0] &= ~0x00000020u; + ::opencv_caffe::DropoutParameter* temp = dropout_param_; + dropout_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::DropoutParameter* V1LayerParameter::_internal_mutable_dropout_param() { + _has_bits_[0] |= 0x00000020u; + if (dropout_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::DropoutParameter>(GetArenaForAllocation()); + dropout_param_ = p; + } + return dropout_param_; +} +inline ::opencv_caffe::DropoutParameter* V1LayerParameter::mutable_dropout_param() { + ::opencv_caffe::DropoutParameter* _msg = _internal_mutable_dropout_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.dropout_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete dropout_param_; + } + if (dropout_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::DropoutParameter>::GetOwningArena(dropout_param); + if (message_arena != submessage_arena) { + dropout_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, dropout_param, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + 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::_internal_has_dummy_data_param() const { + bool value = (_has_bits_[0] & 0x00080000u) != 0; + PROTOBUF_ASSUME(!value || dummy_data_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_dummy_data_param() const { + return _internal_has_dummy_data_param(); +} +inline void V1LayerParameter::clear_dummy_data_param() { + if (dummy_data_param_ != nullptr) dummy_data_param_->Clear(); + _has_bits_[0] &= ~0x00080000u; +} +inline const ::opencv_caffe::DummyDataParameter& V1LayerParameter::_internal_dummy_data_param() const { + const ::opencv_caffe::DummyDataParameter* p = dummy_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_DummyDataParameter_default_instance_); +} +inline const ::opencv_caffe::DummyDataParameter& V1LayerParameter::dummy_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.dummy_data_param) + return _internal_dummy_data_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_dummy_data_param( + ::opencv_caffe::DummyDataParameter* dummy_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dummy_data_param_); + } + dummy_data_param_ = dummy_data_param; + if (dummy_data_param) { + _has_bits_[0] |= 0x00080000u; + } else { + _has_bits_[0] &= ~0x00080000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.dummy_data_param) +} +inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::release_dummy_data_param() { + _has_bits_[0] &= ~0x00080000u; + ::opencv_caffe::DummyDataParameter* temp = dummy_data_param_; + dummy_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::unsafe_arena_release_dummy_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.dummy_data_param) + _has_bits_[0] &= ~0x00080000u; + ::opencv_caffe::DummyDataParameter* temp = dummy_data_param_; + dummy_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::_internal_mutable_dummy_data_param() { + _has_bits_[0] |= 0x00080000u; + if (dummy_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::DummyDataParameter>(GetArenaForAllocation()); + dummy_data_param_ = p; + } + return dummy_data_param_; +} +inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::mutable_dummy_data_param() { + ::opencv_caffe::DummyDataParameter* _msg = _internal_mutable_dummy_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.dummy_data_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete dummy_data_param_; + } + if (dummy_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::DummyDataParameter>::GetOwningArena(dummy_data_param); + if (message_arena != submessage_arena) { + dummy_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, dummy_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00080000u; + } else { + _has_bits_[0] &= ~0x00080000u; + } + 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::_internal_has_eltwise_param() const { + bool value = (_has_bits_[0] & 0x00020000u) != 0; + PROTOBUF_ASSUME(!value || eltwise_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_eltwise_param() const { + return _internal_has_eltwise_param(); +} +inline void V1LayerParameter::clear_eltwise_param() { + if (eltwise_param_ != nullptr) eltwise_param_->Clear(); + _has_bits_[0] &= ~0x00020000u; +} +inline const ::opencv_caffe::EltwiseParameter& V1LayerParameter::_internal_eltwise_param() const { + const ::opencv_caffe::EltwiseParameter* p = eltwise_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_EltwiseParameter_default_instance_); +} +inline const ::opencv_caffe::EltwiseParameter& V1LayerParameter::eltwise_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.eltwise_param) + return _internal_eltwise_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_eltwise_param( + ::opencv_caffe::EltwiseParameter* eltwise_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(eltwise_param_); + } + eltwise_param_ = eltwise_param; + if (eltwise_param) { + _has_bits_[0] |= 0x00020000u; + } else { + _has_bits_[0] &= ~0x00020000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.eltwise_param) +} +inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::release_eltwise_param() { + _has_bits_[0] &= ~0x00020000u; + ::opencv_caffe::EltwiseParameter* temp = eltwise_param_; + eltwise_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::unsafe_arena_release_eltwise_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.eltwise_param) + _has_bits_[0] &= ~0x00020000u; + ::opencv_caffe::EltwiseParameter* temp = eltwise_param_; + eltwise_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::_internal_mutable_eltwise_param() { + _has_bits_[0] |= 0x00020000u; + if (eltwise_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::EltwiseParameter>(GetArenaForAllocation()); + eltwise_param_ = p; + } + return eltwise_param_; +} +inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::mutable_eltwise_param() { + ::opencv_caffe::EltwiseParameter* _msg = _internal_mutable_eltwise_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.eltwise_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete eltwise_param_; + } + if (eltwise_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::EltwiseParameter>::GetOwningArena(eltwise_param); + if (message_arena != submessage_arena) { + eltwise_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, eltwise_param, submessage_arena); + } + _has_bits_[0] |= 0x00020000u; + } else { + _has_bits_[0] &= ~0x00020000u; + } + 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::_internal_has_exp_param() const { + bool value = (_has_bits_[0] & 0x40000000u) != 0; + PROTOBUF_ASSUME(!value || exp_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_exp_param() const { + return _internal_has_exp_param(); +} +inline void V1LayerParameter::clear_exp_param() { + if (exp_param_ != nullptr) exp_param_->Clear(); + _has_bits_[0] &= ~0x40000000u; +} +inline const ::opencv_caffe::ExpParameter& V1LayerParameter::_internal_exp_param() const { + const ::opencv_caffe::ExpParameter* p = exp_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ExpParameter_default_instance_); +} +inline const ::opencv_caffe::ExpParameter& V1LayerParameter::exp_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.exp_param) + return _internal_exp_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_exp_param( + ::opencv_caffe::ExpParameter* exp_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(exp_param_); + } + exp_param_ = exp_param; + if (exp_param) { + _has_bits_[0] |= 0x40000000u; + } else { + _has_bits_[0] &= ~0x40000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.exp_param) +} +inline ::opencv_caffe::ExpParameter* V1LayerParameter::release_exp_param() { + _has_bits_[0] &= ~0x40000000u; + ::opencv_caffe::ExpParameter* temp = exp_param_; + exp_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ExpParameter* V1LayerParameter::unsafe_arena_release_exp_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.exp_param) + _has_bits_[0] &= ~0x40000000u; + ::opencv_caffe::ExpParameter* temp = exp_param_; + exp_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ExpParameter* V1LayerParameter::_internal_mutable_exp_param() { + _has_bits_[0] |= 0x40000000u; + if (exp_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ExpParameter>(GetArenaForAllocation()); + exp_param_ = p; + } + return exp_param_; +} +inline ::opencv_caffe::ExpParameter* V1LayerParameter::mutable_exp_param() { + ::opencv_caffe::ExpParameter* _msg = _internal_mutable_exp_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.exp_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete exp_param_; + } + if (exp_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ExpParameter>::GetOwningArena(exp_param); + if (message_arena != submessage_arena) { + exp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, exp_param, submessage_arena); + } + _has_bits_[0] |= 0x40000000u; + } else { + _has_bits_[0] &= ~0x40000000u; + } + 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::_internal_has_hdf5_data_param() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || hdf5_data_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_hdf5_data_param() const { + return _internal_has_hdf5_data_param(); +} +inline void V1LayerParameter::clear_hdf5_data_param() { + if (hdf5_data_param_ != nullptr) hdf5_data_param_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::opencv_caffe::HDF5DataParameter& V1LayerParameter::_internal_hdf5_data_param() const { + const ::opencv_caffe::HDF5DataParameter* p = hdf5_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_HDF5DataParameter_default_instance_); +} +inline const ::opencv_caffe::HDF5DataParameter& V1LayerParameter::hdf5_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hdf5_data_param) + return _internal_hdf5_data_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_hdf5_data_param( + ::opencv_caffe::HDF5DataParameter* hdf5_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_data_param_); + } + hdf5_data_param_ = hdf5_data_param; + if (hdf5_data_param) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.hdf5_data_param) +} +inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::release_hdf5_data_param() { + _has_bits_[0] &= ~0x00000040u; + ::opencv_caffe::HDF5DataParameter* temp = hdf5_data_param_; + hdf5_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::unsafe_arena_release_hdf5_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hdf5_data_param) + _has_bits_[0] &= ~0x00000040u; + ::opencv_caffe::HDF5DataParameter* temp = hdf5_data_param_; + hdf5_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::_internal_mutable_hdf5_data_param() { + _has_bits_[0] |= 0x00000040u; + if (hdf5_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::HDF5DataParameter>(GetArenaForAllocation()); + hdf5_data_param_ = p; + } + return hdf5_data_param_; +} +inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::mutable_hdf5_data_param() { + ::opencv_caffe::HDF5DataParameter* _msg = _internal_mutable_hdf5_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hdf5_data_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete hdf5_data_param_; + } + if (hdf5_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::HDF5DataParameter>::GetOwningArena(hdf5_data_param); + if (message_arena != submessage_arena) { + hdf5_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hdf5_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + 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::_internal_has_hdf5_output_param() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || hdf5_output_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_hdf5_output_param() const { + return _internal_has_hdf5_output_param(); +} +inline void V1LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != nullptr) hdf5_output_param_->Clear(); + _has_bits_[0] &= ~0x00000080u; +} +inline const ::opencv_caffe::HDF5OutputParameter& V1LayerParameter::_internal_hdf5_output_param() const { + const ::opencv_caffe::HDF5OutputParameter* p = hdf5_output_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_HDF5OutputParameter_default_instance_); +} +inline const ::opencv_caffe::HDF5OutputParameter& V1LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hdf5_output_param) + return _internal_hdf5_output_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_hdf5_output_param( + ::opencv_caffe::HDF5OutputParameter* hdf5_output_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_output_param_); + } + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.hdf5_output_param) +} +inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::release_hdf5_output_param() { + _has_bits_[0] &= ~0x00000080u; + ::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::unsafe_arena_release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hdf5_output_param) + _has_bits_[0] &= ~0x00000080u; + ::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::_internal_mutable_hdf5_output_param() { + _has_bits_[0] |= 0x00000080u; + if (hdf5_output_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::HDF5OutputParameter>(GetArenaForAllocation()); + hdf5_output_param_ = p; + } + return hdf5_output_param_; +} +inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::mutable_hdf5_output_param() { + ::opencv_caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hdf5_output_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete hdf5_output_param_; + } + if (hdf5_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::HDF5OutputParameter>::GetOwningArena(hdf5_output_param); + if (message_arena != submessage_arena) { + hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hdf5_output_param, submessage_arena); + } + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + 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::_internal_has_hinge_loss_param() const { + bool value = (_has_bits_[0] & 0x00200000u) != 0; + PROTOBUF_ASSUME(!value || hinge_loss_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_hinge_loss_param() const { + return _internal_has_hinge_loss_param(); +} +inline void V1LayerParameter::clear_hinge_loss_param() { + if (hinge_loss_param_ != nullptr) hinge_loss_param_->Clear(); + _has_bits_[0] &= ~0x00200000u; +} +inline const ::opencv_caffe::HingeLossParameter& V1LayerParameter::_internal_hinge_loss_param() const { + const ::opencv_caffe::HingeLossParameter* p = hinge_loss_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_HingeLossParameter_default_instance_); +} +inline const ::opencv_caffe::HingeLossParameter& V1LayerParameter::hinge_loss_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hinge_loss_param) + return _internal_hinge_loss_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_hinge_loss_param( + ::opencv_caffe::HingeLossParameter* hinge_loss_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hinge_loss_param_); + } + hinge_loss_param_ = hinge_loss_param; + if (hinge_loss_param) { + _has_bits_[0] |= 0x00200000u; + } else { + _has_bits_[0] &= ~0x00200000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.hinge_loss_param) +} +inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::release_hinge_loss_param() { + _has_bits_[0] &= ~0x00200000u; + ::opencv_caffe::HingeLossParameter* temp = hinge_loss_param_; + hinge_loss_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::unsafe_arena_release_hinge_loss_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hinge_loss_param) + _has_bits_[0] &= ~0x00200000u; + ::opencv_caffe::HingeLossParameter* temp = hinge_loss_param_; + hinge_loss_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::_internal_mutable_hinge_loss_param() { + _has_bits_[0] |= 0x00200000u; + if (hinge_loss_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::HingeLossParameter>(GetArenaForAllocation()); + hinge_loss_param_ = p; + } + return hinge_loss_param_; +} +inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::mutable_hinge_loss_param() { + ::opencv_caffe::HingeLossParameter* _msg = _internal_mutable_hinge_loss_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hinge_loss_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete hinge_loss_param_; + } + if (hinge_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::HingeLossParameter>::GetOwningArena(hinge_loss_param); + if (message_arena != submessage_arena) { + hinge_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hinge_loss_param, submessage_arena); + } + _has_bits_[0] |= 0x00200000u; + } else { + _has_bits_[0] &= ~0x00200000u; + } + 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::_internal_has_image_data_param() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || image_data_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_image_data_param() const { + return _internal_has_image_data_param(); +} +inline void V1LayerParameter::clear_image_data_param() { + if (image_data_param_ != nullptr) image_data_param_->Clear(); + _has_bits_[0] &= ~0x00000100u; +} +inline const ::opencv_caffe::ImageDataParameter& V1LayerParameter::_internal_image_data_param() const { + const ::opencv_caffe::ImageDataParameter* p = image_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ImageDataParameter_default_instance_); +} +inline const ::opencv_caffe::ImageDataParameter& V1LayerParameter::image_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.image_data_param) + return _internal_image_data_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_image_data_param( + ::opencv_caffe::ImageDataParameter* image_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(image_data_param_); + } + image_data_param_ = image_data_param; + if (image_data_param) { + _has_bits_[0] |= 0x00000100u; + } else { + _has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.image_data_param) +} +inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::release_image_data_param() { + _has_bits_[0] &= ~0x00000100u; + ::opencv_caffe::ImageDataParameter* temp = image_data_param_; + image_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::unsafe_arena_release_image_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.image_data_param) + _has_bits_[0] &= ~0x00000100u; + ::opencv_caffe::ImageDataParameter* temp = image_data_param_; + image_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::_internal_mutable_image_data_param() { + _has_bits_[0] |= 0x00000100u; + if (image_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ImageDataParameter>(GetArenaForAllocation()); + image_data_param_ = p; + } + return image_data_param_; +} +inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::mutable_image_data_param() { + ::opencv_caffe::ImageDataParameter* _msg = _internal_mutable_image_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.image_data_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete image_data_param_; + } + if (image_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ImageDataParameter>::GetOwningArena(image_data_param); + if (message_arena != submessage_arena) { + image_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, image_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00000100u; + } else { + _has_bits_[0] &= ~0x00000100u; + } + 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::_internal_has_infogain_loss_param() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || infogain_loss_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_infogain_loss_param() const { + return _internal_has_infogain_loss_param(); +} +inline void V1LayerParameter::clear_infogain_loss_param() { + if (infogain_loss_param_ != nullptr) infogain_loss_param_->Clear(); + _has_bits_[0] &= ~0x00000200u; +} +inline const ::opencv_caffe::InfogainLossParameter& V1LayerParameter::_internal_infogain_loss_param() const { + const ::opencv_caffe::InfogainLossParameter* p = infogain_loss_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_InfogainLossParameter_default_instance_); +} +inline const ::opencv_caffe::InfogainLossParameter& V1LayerParameter::infogain_loss_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.infogain_loss_param) + return _internal_infogain_loss_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_infogain_loss_param( + ::opencv_caffe::InfogainLossParameter* infogain_loss_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(infogain_loss_param_); + } + infogain_loss_param_ = infogain_loss_param; + if (infogain_loss_param) { + _has_bits_[0] |= 0x00000200u; + } else { + _has_bits_[0] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.infogain_loss_param) +} +inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::release_infogain_loss_param() { + _has_bits_[0] &= ~0x00000200u; + ::opencv_caffe::InfogainLossParameter* temp = infogain_loss_param_; + infogain_loss_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::unsafe_arena_release_infogain_loss_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.infogain_loss_param) + _has_bits_[0] &= ~0x00000200u; + ::opencv_caffe::InfogainLossParameter* temp = infogain_loss_param_; + infogain_loss_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::_internal_mutable_infogain_loss_param() { + _has_bits_[0] |= 0x00000200u; + if (infogain_loss_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::InfogainLossParameter>(GetArenaForAllocation()); + infogain_loss_param_ = p; + } + return infogain_loss_param_; +} +inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::mutable_infogain_loss_param() { + ::opencv_caffe::InfogainLossParameter* _msg = _internal_mutable_infogain_loss_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.infogain_loss_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete infogain_loss_param_; + } + if (infogain_loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::InfogainLossParameter>::GetOwningArena(infogain_loss_param); + if (message_arena != submessage_arena) { + infogain_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, infogain_loss_param, submessage_arena); + } + _has_bits_[0] |= 0x00000200u; + } else { + _has_bits_[0] &= ~0x00000200u; + } + 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::_internal_has_inner_product_param() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || inner_product_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_inner_product_param() const { + return _internal_has_inner_product_param(); +} +inline void V1LayerParameter::clear_inner_product_param() { + if (inner_product_param_ != nullptr) inner_product_param_->Clear(); + _has_bits_[0] &= ~0x00000400u; +} +inline const ::opencv_caffe::InnerProductParameter& V1LayerParameter::_internal_inner_product_param() const { + const ::opencv_caffe::InnerProductParameter* p = inner_product_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_InnerProductParameter_default_instance_); +} +inline const ::opencv_caffe::InnerProductParameter& V1LayerParameter::inner_product_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.inner_product_param) + return _internal_inner_product_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_inner_product_param( + ::opencv_caffe::InnerProductParameter* inner_product_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(inner_product_param_); + } + inner_product_param_ = inner_product_param; + if (inner_product_param) { + _has_bits_[0] |= 0x00000400u; + } else { + _has_bits_[0] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.inner_product_param) +} +inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::release_inner_product_param() { + _has_bits_[0] &= ~0x00000400u; + ::opencv_caffe::InnerProductParameter* temp = inner_product_param_; + inner_product_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::unsafe_arena_release_inner_product_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.inner_product_param) + _has_bits_[0] &= ~0x00000400u; + ::opencv_caffe::InnerProductParameter* temp = inner_product_param_; + inner_product_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::_internal_mutable_inner_product_param() { + _has_bits_[0] |= 0x00000400u; + if (inner_product_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::InnerProductParameter>(GetArenaForAllocation()); + inner_product_param_ = p; + } + return inner_product_param_; +} +inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::mutable_inner_product_param() { + ::opencv_caffe::InnerProductParameter* _msg = _internal_mutable_inner_product_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.inner_product_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete inner_product_param_; + } + if (inner_product_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::InnerProductParameter>::GetOwningArena(inner_product_param); + if (message_arena != submessage_arena) { + inner_product_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, inner_product_param, submessage_arena); + } + _has_bits_[0] |= 0x00000400u; + } else { + _has_bits_[0] &= ~0x00000400u; + } + 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::_internal_has_lrn_param() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || lrn_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_lrn_param() const { + return _internal_has_lrn_param(); +} +inline void V1LayerParameter::clear_lrn_param() { + if (lrn_param_ != nullptr) lrn_param_->Clear(); + _has_bits_[0] &= ~0x00000800u; +} +inline const ::opencv_caffe::LRNParameter& V1LayerParameter::_internal_lrn_param() const { + const ::opencv_caffe::LRNParameter* p = lrn_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_LRNParameter_default_instance_); +} +inline const ::opencv_caffe::LRNParameter& V1LayerParameter::lrn_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.lrn_param) + return _internal_lrn_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_lrn_param( + ::opencv_caffe::LRNParameter* lrn_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lrn_param_); + } + lrn_param_ = lrn_param; + if (lrn_param) { + _has_bits_[0] |= 0x00000800u; + } else { + _has_bits_[0] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.lrn_param) +} +inline ::opencv_caffe::LRNParameter* V1LayerParameter::release_lrn_param() { + _has_bits_[0] &= ~0x00000800u; + ::opencv_caffe::LRNParameter* temp = lrn_param_; + lrn_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::LRNParameter* V1LayerParameter::unsafe_arena_release_lrn_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.lrn_param) + _has_bits_[0] &= ~0x00000800u; + ::opencv_caffe::LRNParameter* temp = lrn_param_; + lrn_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::LRNParameter* V1LayerParameter::_internal_mutable_lrn_param() { + _has_bits_[0] |= 0x00000800u; + if (lrn_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::LRNParameter>(GetArenaForAllocation()); + lrn_param_ = p; + } + return lrn_param_; +} +inline ::opencv_caffe::LRNParameter* V1LayerParameter::mutable_lrn_param() { + ::opencv_caffe::LRNParameter* _msg = _internal_mutable_lrn_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.lrn_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete lrn_param_; + } + if (lrn_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::LRNParameter>::GetOwningArena(lrn_param); + if (message_arena != submessage_arena) { + lrn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, lrn_param, submessage_arena); + } + _has_bits_[0] |= 0x00000800u; + } else { + _has_bits_[0] &= ~0x00000800u; + } + 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::_internal_has_memory_data_param() const { + bool value = (_has_bits_[0] & 0x00008000u) != 0; + PROTOBUF_ASSUME(!value || memory_data_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_memory_data_param() const { + return _internal_has_memory_data_param(); +} +inline void V1LayerParameter::clear_memory_data_param() { + if (memory_data_param_ != nullptr) memory_data_param_->Clear(); + _has_bits_[0] &= ~0x00008000u; +} +inline const ::opencv_caffe::MemoryDataParameter& V1LayerParameter::_internal_memory_data_param() const { + const ::opencv_caffe::MemoryDataParameter* p = memory_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_MemoryDataParameter_default_instance_); +} +inline const ::opencv_caffe::MemoryDataParameter& V1LayerParameter::memory_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.memory_data_param) + return _internal_memory_data_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_memory_data_param( + ::opencv_caffe::MemoryDataParameter* memory_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(memory_data_param_); + } + memory_data_param_ = memory_data_param; + if (memory_data_param) { + _has_bits_[0] |= 0x00008000u; + } else { + _has_bits_[0] &= ~0x00008000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.memory_data_param) +} +inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::release_memory_data_param() { + _has_bits_[0] &= ~0x00008000u; + ::opencv_caffe::MemoryDataParameter* temp = memory_data_param_; + memory_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::unsafe_arena_release_memory_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.memory_data_param) + _has_bits_[0] &= ~0x00008000u; + ::opencv_caffe::MemoryDataParameter* temp = memory_data_param_; + memory_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::_internal_mutable_memory_data_param() { + _has_bits_[0] |= 0x00008000u; + if (memory_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::MemoryDataParameter>(GetArenaForAllocation()); + memory_data_param_ = p; + } + return memory_data_param_; +} +inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::mutable_memory_data_param() { + ::opencv_caffe::MemoryDataParameter* _msg = _internal_mutable_memory_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.memory_data_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete memory_data_param_; + } + if (memory_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::MemoryDataParameter>::GetOwningArena(memory_data_param); + if (message_arena != submessage_arena) { + memory_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, memory_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00008000u; + } else { + _has_bits_[0] &= ~0x00008000u; + } + 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::_internal_has_mvn_param() const { + bool value = (_has_bits_[0] & 0x01000000u) != 0; + PROTOBUF_ASSUME(!value || mvn_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_mvn_param() const { + return _internal_has_mvn_param(); +} +inline void V1LayerParameter::clear_mvn_param() { + if (mvn_param_ != nullptr) mvn_param_->Clear(); + _has_bits_[0] &= ~0x01000000u; +} +inline const ::opencv_caffe::MVNParameter& V1LayerParameter::_internal_mvn_param() const { + const ::opencv_caffe::MVNParameter* p = mvn_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_MVNParameter_default_instance_); +} +inline const ::opencv_caffe::MVNParameter& V1LayerParameter::mvn_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.mvn_param) + return _internal_mvn_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_mvn_param( + ::opencv_caffe::MVNParameter* mvn_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mvn_param_); + } + mvn_param_ = mvn_param; + if (mvn_param) { + _has_bits_[0] |= 0x01000000u; + } else { + _has_bits_[0] &= ~0x01000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.mvn_param) +} +inline ::opencv_caffe::MVNParameter* V1LayerParameter::release_mvn_param() { + _has_bits_[0] &= ~0x01000000u; + ::opencv_caffe::MVNParameter* temp = mvn_param_; + mvn_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::MVNParameter* V1LayerParameter::unsafe_arena_release_mvn_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.mvn_param) + _has_bits_[0] &= ~0x01000000u; + ::opencv_caffe::MVNParameter* temp = mvn_param_; + mvn_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::MVNParameter* V1LayerParameter::_internal_mutable_mvn_param() { + _has_bits_[0] |= 0x01000000u; + if (mvn_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::MVNParameter>(GetArenaForAllocation()); + mvn_param_ = p; + } + return mvn_param_; +} +inline ::opencv_caffe::MVNParameter* V1LayerParameter::mutable_mvn_param() { + ::opencv_caffe::MVNParameter* _msg = _internal_mutable_mvn_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.mvn_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete mvn_param_; + } + if (mvn_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::MVNParameter>::GetOwningArena(mvn_param); + if (message_arena != submessage_arena) { + mvn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, mvn_param, submessage_arena); + } + _has_bits_[0] |= 0x01000000u; + } else { + _has_bits_[0] &= ~0x01000000u; + } + 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::_internal_has_pooling_param() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || pooling_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_pooling_param() const { + return _internal_has_pooling_param(); +} +inline void V1LayerParameter::clear_pooling_param() { + if (pooling_param_ != nullptr) pooling_param_->Clear(); + _has_bits_[0] &= ~0x00001000u; +} +inline const ::opencv_caffe::PoolingParameter& V1LayerParameter::_internal_pooling_param() const { + const ::opencv_caffe::PoolingParameter* p = pooling_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PoolingParameter_default_instance_); +} +inline const ::opencv_caffe::PoolingParameter& V1LayerParameter::pooling_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.pooling_param) + return _internal_pooling_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_pooling_param( + ::opencv_caffe::PoolingParameter* pooling_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pooling_param_); + } + pooling_param_ = pooling_param; + if (pooling_param) { + _has_bits_[0] |= 0x00001000u; + } else { + _has_bits_[0] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.pooling_param) +} +inline ::opencv_caffe::PoolingParameter* V1LayerParameter::release_pooling_param() { + _has_bits_[0] &= ~0x00001000u; + ::opencv_caffe::PoolingParameter* temp = pooling_param_; + pooling_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PoolingParameter* V1LayerParameter::unsafe_arena_release_pooling_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.pooling_param) + _has_bits_[0] &= ~0x00001000u; + ::opencv_caffe::PoolingParameter* temp = pooling_param_; + pooling_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PoolingParameter* V1LayerParameter::_internal_mutable_pooling_param() { + _has_bits_[0] |= 0x00001000u; + if (pooling_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PoolingParameter>(GetArenaForAllocation()); + pooling_param_ = p; + } + return pooling_param_; +} +inline ::opencv_caffe::PoolingParameter* V1LayerParameter::mutable_pooling_param() { + ::opencv_caffe::PoolingParameter* _msg = _internal_mutable_pooling_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.pooling_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete pooling_param_; + } + if (pooling_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PoolingParameter>::GetOwningArena(pooling_param); + if (message_arena != submessage_arena) { + pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pooling_param, submessage_arena); + } + _has_bits_[0] |= 0x00001000u; + } else { + _has_bits_[0] &= ~0x00001000u; + } + 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::_internal_has_power_param() const { + bool value = (_has_bits_[0] & 0x00004000u) != 0; + PROTOBUF_ASSUME(!value || power_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_power_param() const { + return _internal_has_power_param(); +} +inline void V1LayerParameter::clear_power_param() { + if (power_param_ != nullptr) power_param_->Clear(); + _has_bits_[0] &= ~0x00004000u; +} +inline const ::opencv_caffe::PowerParameter& V1LayerParameter::_internal_power_param() const { + const ::opencv_caffe::PowerParameter* p = power_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_PowerParameter_default_instance_); +} +inline const ::opencv_caffe::PowerParameter& V1LayerParameter::power_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.power_param) + return _internal_power_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_power_param( + ::opencv_caffe::PowerParameter* power_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(power_param_); + } + power_param_ = power_param; + if (power_param) { + _has_bits_[0] |= 0x00004000u; + } else { + _has_bits_[0] &= ~0x00004000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.power_param) +} +inline ::opencv_caffe::PowerParameter* V1LayerParameter::release_power_param() { + _has_bits_[0] &= ~0x00004000u; + ::opencv_caffe::PowerParameter* temp = power_param_; + power_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::PowerParameter* V1LayerParameter::unsafe_arena_release_power_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.power_param) + _has_bits_[0] &= ~0x00004000u; + ::opencv_caffe::PowerParameter* temp = power_param_; + power_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::PowerParameter* V1LayerParameter::_internal_mutable_power_param() { + _has_bits_[0] |= 0x00004000u; + if (power_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::PowerParameter>(GetArenaForAllocation()); + power_param_ = p; + } + return power_param_; +} +inline ::opencv_caffe::PowerParameter* V1LayerParameter::mutable_power_param() { + ::opencv_caffe::PowerParameter* _msg = _internal_mutable_power_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.power_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_power_param(::opencv_caffe::PowerParameter* power_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete power_param_; + } + if (power_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::PowerParameter>::GetOwningArena(power_param); + if (message_arena != submessage_arena) { + power_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, power_param, submessage_arena); + } + _has_bits_[0] |= 0x00004000u; + } else { + _has_bits_[0] &= ~0x00004000u; + } + 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::_internal_has_relu_param() const { + bool value = (_has_bits_[0] & 0x00400000u) != 0; + PROTOBUF_ASSUME(!value || relu_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_relu_param() const { + return _internal_has_relu_param(); +} +inline void V1LayerParameter::clear_relu_param() { + if (relu_param_ != nullptr) relu_param_->Clear(); + _has_bits_[0] &= ~0x00400000u; +} +inline const ::opencv_caffe::ReLUParameter& V1LayerParameter::_internal_relu_param() const { + const ::opencv_caffe::ReLUParameter* p = relu_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ReLUParameter_default_instance_); +} +inline const ::opencv_caffe::ReLUParameter& V1LayerParameter::relu_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.relu_param) + return _internal_relu_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_relu_param( + ::opencv_caffe::ReLUParameter* relu_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relu_param_); + } + relu_param_ = relu_param; + if (relu_param) { + _has_bits_[0] |= 0x00400000u; + } else { + _has_bits_[0] &= ~0x00400000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.relu_param) +} +inline ::opencv_caffe::ReLUParameter* V1LayerParameter::release_relu_param() { + _has_bits_[0] &= ~0x00400000u; + ::opencv_caffe::ReLUParameter* temp = relu_param_; + relu_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ReLUParameter* V1LayerParameter::unsafe_arena_release_relu_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.relu_param) + _has_bits_[0] &= ~0x00400000u; + ::opencv_caffe::ReLUParameter* temp = relu_param_; + relu_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ReLUParameter* V1LayerParameter::_internal_mutable_relu_param() { + _has_bits_[0] |= 0x00400000u; + if (relu_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ReLUParameter>(GetArenaForAllocation()); + relu_param_ = p; + } + return relu_param_; +} +inline ::opencv_caffe::ReLUParameter* V1LayerParameter::mutable_relu_param() { + ::opencv_caffe::ReLUParameter* _msg = _internal_mutable_relu_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.relu_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete relu_param_; + } + if (relu_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ReLUParameter>::GetOwningArena(relu_param); + if (message_arena != submessage_arena) { + relu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, relu_param, submessage_arena); + } + _has_bits_[0] |= 0x00400000u; + } else { + _has_bits_[0] &= ~0x00400000u; + } + 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::_internal_has_sigmoid_param() const { + bool value = (_has_bits_[0] & 0x08000000u) != 0; + PROTOBUF_ASSUME(!value || sigmoid_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_sigmoid_param() const { + return _internal_has_sigmoid_param(); +} +inline void V1LayerParameter::clear_sigmoid_param() { + if (sigmoid_param_ != nullptr) sigmoid_param_->Clear(); + _has_bits_[0] &= ~0x08000000u; +} +inline const ::opencv_caffe::SigmoidParameter& V1LayerParameter::_internal_sigmoid_param() const { + const ::opencv_caffe::SigmoidParameter* p = sigmoid_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_SigmoidParameter_default_instance_); +} +inline const ::opencv_caffe::SigmoidParameter& V1LayerParameter::sigmoid_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.sigmoid_param) + return _internal_sigmoid_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_sigmoid_param( + ::opencv_caffe::SigmoidParameter* sigmoid_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sigmoid_param_); + } + sigmoid_param_ = sigmoid_param; + if (sigmoid_param) { + _has_bits_[0] |= 0x08000000u; + } else { + _has_bits_[0] &= ~0x08000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.sigmoid_param) +} +inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::release_sigmoid_param() { + _has_bits_[0] &= ~0x08000000u; + ::opencv_caffe::SigmoidParameter* temp = sigmoid_param_; + sigmoid_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::unsafe_arena_release_sigmoid_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.sigmoid_param) + _has_bits_[0] &= ~0x08000000u; + ::opencv_caffe::SigmoidParameter* temp = sigmoid_param_; + sigmoid_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::_internal_mutable_sigmoid_param() { + _has_bits_[0] |= 0x08000000u; + if (sigmoid_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::SigmoidParameter>(GetArenaForAllocation()); + sigmoid_param_ = p; + } + return sigmoid_param_; +} +inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::mutable_sigmoid_param() { + ::opencv_caffe::SigmoidParameter* _msg = _internal_mutable_sigmoid_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.sigmoid_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete sigmoid_param_; + } + if (sigmoid_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::SigmoidParameter>::GetOwningArena(sigmoid_param); + if (message_arena != submessage_arena) { + sigmoid_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, sigmoid_param, submessage_arena); + } + _has_bits_[0] |= 0x08000000u; + } else { + _has_bits_[0] &= ~0x08000000u; + } + 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::_internal_has_softmax_param() const { + bool value = (_has_bits_[0] & 0x10000000u) != 0; + PROTOBUF_ASSUME(!value || softmax_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_softmax_param() const { + return _internal_has_softmax_param(); +} +inline void V1LayerParameter::clear_softmax_param() { + if (softmax_param_ != nullptr) softmax_param_->Clear(); + _has_bits_[0] &= ~0x10000000u; +} +inline const ::opencv_caffe::SoftmaxParameter& V1LayerParameter::_internal_softmax_param() const { + const ::opencv_caffe::SoftmaxParameter* p = softmax_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_SoftmaxParameter_default_instance_); +} +inline const ::opencv_caffe::SoftmaxParameter& V1LayerParameter::softmax_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.softmax_param) + return _internal_softmax_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_softmax_param( + ::opencv_caffe::SoftmaxParameter* softmax_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(softmax_param_); + } + softmax_param_ = softmax_param; + if (softmax_param) { + _has_bits_[0] |= 0x10000000u; + } else { + _has_bits_[0] &= ~0x10000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.softmax_param) +} +inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::release_softmax_param() { + _has_bits_[0] &= ~0x10000000u; + ::opencv_caffe::SoftmaxParameter* temp = softmax_param_; + softmax_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::unsafe_arena_release_softmax_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.softmax_param) + _has_bits_[0] &= ~0x10000000u; + ::opencv_caffe::SoftmaxParameter* temp = softmax_param_; + softmax_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::_internal_mutable_softmax_param() { + _has_bits_[0] |= 0x10000000u; + if (softmax_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::SoftmaxParameter>(GetArenaForAllocation()); + softmax_param_ = p; + } + return softmax_param_; +} +inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::mutable_softmax_param() { + ::opencv_caffe::SoftmaxParameter* _msg = _internal_mutable_softmax_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.softmax_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete softmax_param_; + } + if (softmax_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::SoftmaxParameter>::GetOwningArena(softmax_param); + if (message_arena != submessage_arena) { + softmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, softmax_param, submessage_arena); + } + _has_bits_[0] |= 0x10000000u; + } else { + _has_bits_[0] &= ~0x10000000u; + } + 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::_internal_has_slice_param() const { + bool value = (_has_bits_[0] & 0x00800000u) != 0; + PROTOBUF_ASSUME(!value || slice_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_slice_param() const { + return _internal_has_slice_param(); +} +inline void V1LayerParameter::clear_slice_param() { + if (slice_param_ != nullptr) slice_param_->Clear(); + _has_bits_[0] &= ~0x00800000u; +} +inline const ::opencv_caffe::SliceParameter& V1LayerParameter::_internal_slice_param() const { + const ::opencv_caffe::SliceParameter* p = slice_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_SliceParameter_default_instance_); +} +inline const ::opencv_caffe::SliceParameter& V1LayerParameter::slice_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.slice_param) + return _internal_slice_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_slice_param( + ::opencv_caffe::SliceParameter* slice_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(slice_param_); + } + slice_param_ = slice_param; + if (slice_param) { + _has_bits_[0] |= 0x00800000u; + } else { + _has_bits_[0] &= ~0x00800000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.slice_param) +} +inline ::opencv_caffe::SliceParameter* V1LayerParameter::release_slice_param() { + _has_bits_[0] &= ~0x00800000u; + ::opencv_caffe::SliceParameter* temp = slice_param_; + slice_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::SliceParameter* V1LayerParameter::unsafe_arena_release_slice_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.slice_param) + _has_bits_[0] &= ~0x00800000u; + ::opencv_caffe::SliceParameter* temp = slice_param_; + slice_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::SliceParameter* V1LayerParameter::_internal_mutable_slice_param() { + _has_bits_[0] |= 0x00800000u; + if (slice_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::SliceParameter>(GetArenaForAllocation()); + slice_param_ = p; + } + return slice_param_; +} +inline ::opencv_caffe::SliceParameter* V1LayerParameter::mutable_slice_param() { + ::opencv_caffe::SliceParameter* _msg = _internal_mutable_slice_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.slice_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete slice_param_; + } + if (slice_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::SliceParameter>::GetOwningArena(slice_param); + if (message_arena != submessage_arena) { + slice_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, slice_param, submessage_arena); + } + _has_bits_[0] |= 0x00800000u; + } else { + _has_bits_[0] &= ~0x00800000u; + } + 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::_internal_has_tanh_param() const { + bool value = (_has_bits_[0] & 0x04000000u) != 0; + PROTOBUF_ASSUME(!value || tanh_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_tanh_param() const { + return _internal_has_tanh_param(); +} +inline void V1LayerParameter::clear_tanh_param() { + if (tanh_param_ != nullptr) tanh_param_->Clear(); + _has_bits_[0] &= ~0x04000000u; +} +inline const ::opencv_caffe::TanHParameter& V1LayerParameter::_internal_tanh_param() const { + const ::opencv_caffe::TanHParameter* p = tanh_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_TanHParameter_default_instance_); +} +inline const ::opencv_caffe::TanHParameter& V1LayerParameter::tanh_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.tanh_param) + return _internal_tanh_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_tanh_param( + ::opencv_caffe::TanHParameter* tanh_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tanh_param_); + } + tanh_param_ = tanh_param; + if (tanh_param) { + _has_bits_[0] |= 0x04000000u; + } else { + _has_bits_[0] &= ~0x04000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.tanh_param) +} +inline ::opencv_caffe::TanHParameter* V1LayerParameter::release_tanh_param() { + _has_bits_[0] &= ~0x04000000u; + ::opencv_caffe::TanHParameter* temp = tanh_param_; + tanh_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::TanHParameter* V1LayerParameter::unsafe_arena_release_tanh_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.tanh_param) + _has_bits_[0] &= ~0x04000000u; + ::opencv_caffe::TanHParameter* temp = tanh_param_; + tanh_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::TanHParameter* V1LayerParameter::_internal_mutable_tanh_param() { + _has_bits_[0] |= 0x04000000u; + if (tanh_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::TanHParameter>(GetArenaForAllocation()); + tanh_param_ = p; + } + return tanh_param_; +} +inline ::opencv_caffe::TanHParameter* V1LayerParameter::mutable_tanh_param() { + ::opencv_caffe::TanHParameter* _msg = _internal_mutable_tanh_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.tanh_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete tanh_param_; + } + if (tanh_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::TanHParameter>::GetOwningArena(tanh_param); + if (message_arena != submessage_arena) { + tanh_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, tanh_param, submessage_arena); + } + _has_bits_[0] |= 0x04000000u; + } else { + _has_bits_[0] &= ~0x04000000u; + } + 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::_internal_has_threshold_param() const { + bool value = (_has_bits_[0] & 0x00040000u) != 0; + PROTOBUF_ASSUME(!value || threshold_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_threshold_param() const { + return _internal_has_threshold_param(); +} +inline void V1LayerParameter::clear_threshold_param() { + if (threshold_param_ != nullptr) threshold_param_->Clear(); + _has_bits_[0] &= ~0x00040000u; +} +inline const ::opencv_caffe::ThresholdParameter& V1LayerParameter::_internal_threshold_param() const { + const ::opencv_caffe::ThresholdParameter* p = threshold_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_ThresholdParameter_default_instance_); +} +inline const ::opencv_caffe::ThresholdParameter& V1LayerParameter::threshold_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.threshold_param) + return _internal_threshold_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_threshold_param( + ::opencv_caffe::ThresholdParameter* threshold_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(threshold_param_); + } + threshold_param_ = threshold_param; + if (threshold_param) { + _has_bits_[0] |= 0x00040000u; + } else { + _has_bits_[0] &= ~0x00040000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.threshold_param) +} +inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::release_threshold_param() { + _has_bits_[0] &= ~0x00040000u; + ::opencv_caffe::ThresholdParameter* temp = threshold_param_; + threshold_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::unsafe_arena_release_threshold_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.threshold_param) + _has_bits_[0] &= ~0x00040000u; + ::opencv_caffe::ThresholdParameter* temp = threshold_param_; + threshold_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::_internal_mutable_threshold_param() { + _has_bits_[0] |= 0x00040000u; + if (threshold_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::ThresholdParameter>(GetArenaForAllocation()); + threshold_param_ = p; + } + return threshold_param_; +} +inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::mutable_threshold_param() { + ::opencv_caffe::ThresholdParameter* _msg = _internal_mutable_threshold_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.threshold_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete threshold_param_; + } + if (threshold_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::ThresholdParameter>::GetOwningArena(threshold_param); + if (message_arena != submessage_arena) { + threshold_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, threshold_param, submessage_arena); + } + _has_bits_[0] |= 0x00040000u; + } else { + _has_bits_[0] &= ~0x00040000u; + } + 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::_internal_has_window_data_param() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || window_data_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_window_data_param() const { + return _internal_has_window_data_param(); +} +inline void V1LayerParameter::clear_window_data_param() { + if (window_data_param_ != nullptr) window_data_param_->Clear(); + _has_bits_[0] &= ~0x00002000u; +} +inline const ::opencv_caffe::WindowDataParameter& V1LayerParameter::_internal_window_data_param() const { + const ::opencv_caffe::WindowDataParameter* p = window_data_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_WindowDataParameter_default_instance_); +} +inline const ::opencv_caffe::WindowDataParameter& V1LayerParameter::window_data_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.window_data_param) + return _internal_window_data_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_window_data_param( + ::opencv_caffe::WindowDataParameter* window_data_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(window_data_param_); + } + window_data_param_ = window_data_param; + if (window_data_param) { + _has_bits_[0] |= 0x00002000u; + } else { + _has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.window_data_param) +} +inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::release_window_data_param() { + _has_bits_[0] &= ~0x00002000u; + ::opencv_caffe::WindowDataParameter* temp = window_data_param_; + window_data_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::unsafe_arena_release_window_data_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.window_data_param) + _has_bits_[0] &= ~0x00002000u; + ::opencv_caffe::WindowDataParameter* temp = window_data_param_; + window_data_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::_internal_mutable_window_data_param() { + _has_bits_[0] |= 0x00002000u; + if (window_data_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::WindowDataParameter>(GetArenaForAllocation()); + window_data_param_ = p; + } + return window_data_param_; +} +inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::mutable_window_data_param() { + ::opencv_caffe::WindowDataParameter* _msg = _internal_mutable_window_data_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.window_data_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete window_data_param_; + } + if (window_data_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::WindowDataParameter>::GetOwningArena(window_data_param); + if (message_arena != submessage_arena) { + window_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, window_data_param, submessage_arena); + } + _has_bits_[0] |= 0x00002000u; + } else { + _has_bits_[0] &= ~0x00002000u; + } + 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::_internal_has_transform_param() const { + bool value = (_has_bits_[0] & 0x02000000u) != 0; + PROTOBUF_ASSUME(!value || transform_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_transform_param() const { + return _internal_has_transform_param(); +} +inline void V1LayerParameter::clear_transform_param() { + if (transform_param_ != nullptr) transform_param_->Clear(); + _has_bits_[0] &= ~0x02000000u; +} +inline const ::opencv_caffe::TransformationParameter& V1LayerParameter::_internal_transform_param() const { + const ::opencv_caffe::TransformationParameter* p = transform_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_TransformationParameter_default_instance_); +} +inline const ::opencv_caffe::TransformationParameter& V1LayerParameter::transform_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.transform_param) + return _internal_transform_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_transform_param( + ::opencv_caffe::TransformationParameter* transform_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(transform_param_); + } + transform_param_ = transform_param; + if (transform_param) { + _has_bits_[0] |= 0x02000000u; + } else { + _has_bits_[0] &= ~0x02000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.transform_param) +} +inline ::opencv_caffe::TransformationParameter* V1LayerParameter::release_transform_param() { + _has_bits_[0] &= ~0x02000000u; + ::opencv_caffe::TransformationParameter* temp = transform_param_; + transform_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::TransformationParameter* V1LayerParameter::unsafe_arena_release_transform_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.transform_param) + _has_bits_[0] &= ~0x02000000u; + ::opencv_caffe::TransformationParameter* temp = transform_param_; + transform_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::TransformationParameter* V1LayerParameter::_internal_mutable_transform_param() { + _has_bits_[0] |= 0x02000000u; + if (transform_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::TransformationParameter>(GetArenaForAllocation()); + transform_param_ = p; + } + return transform_param_; +} +inline ::opencv_caffe::TransformationParameter* V1LayerParameter::mutable_transform_param() { + ::opencv_caffe::TransformationParameter* _msg = _internal_mutable_transform_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.transform_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete transform_param_; + } + if (transform_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::TransformationParameter>::GetOwningArena(transform_param); + if (message_arena != submessage_arena) { + transform_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, transform_param, submessage_arena); + } + _has_bits_[0] |= 0x02000000u; + } else { + _has_bits_[0] &= ~0x02000000u; + } + 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::_internal_has_loss_param() const { + bool value = (_has_bits_[0] & 0x80000000u) != 0; + PROTOBUF_ASSUME(!value || loss_param_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_loss_param() const { + return _internal_has_loss_param(); +} +inline void V1LayerParameter::clear_loss_param() { + if (loss_param_ != nullptr) loss_param_->Clear(); + _has_bits_[0] &= ~0x80000000u; +} +inline const ::opencv_caffe::LossParameter& V1LayerParameter::_internal_loss_param() const { + const ::opencv_caffe::LossParameter* p = loss_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_LossParameter_default_instance_); +} +inline const ::opencv_caffe::LossParameter& V1LayerParameter::loss_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.loss_param) + return _internal_loss_param(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_loss_param( + ::opencv_caffe::LossParameter* loss_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(loss_param_); + } + loss_param_ = loss_param; + if (loss_param) { + _has_bits_[0] |= 0x80000000u; + } else { + _has_bits_[0] &= ~0x80000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.loss_param) +} +inline ::opencv_caffe::LossParameter* V1LayerParameter::release_loss_param() { + _has_bits_[0] &= ~0x80000000u; + ::opencv_caffe::LossParameter* temp = loss_param_; + loss_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::LossParameter* V1LayerParameter::unsafe_arena_release_loss_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.loss_param) + _has_bits_[0] &= ~0x80000000u; + ::opencv_caffe::LossParameter* temp = loss_param_; + loss_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::LossParameter* V1LayerParameter::_internal_mutable_loss_param() { + _has_bits_[0] |= 0x80000000u; + if (loss_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::LossParameter>(GetArenaForAllocation()); + loss_param_ = p; + } + return loss_param_; +} +inline ::opencv_caffe::LossParameter* V1LayerParameter::mutable_loss_param() { + ::opencv_caffe::LossParameter* _msg = _internal_mutable_loss_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.loss_param) + return _msg; +} +inline void V1LayerParameter::set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete loss_param_; + } + if (loss_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::LossParameter>::GetOwningArena(loss_param); + if (message_arena != submessage_arena) { + loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, loss_param, submessage_arena); + } + _has_bits_[0] |= 0x80000000u; + } else { + _has_bits_[0] &= ~0x80000000u; + } + loss_param_ = loss_param; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.loss_param) +} + +// optional .opencv_caffe.V0LayerParameter layer = 1; +inline bool V1LayerParameter::_internal_has_layer() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || layer_ != nullptr); + return value; +} +inline bool V1LayerParameter::has_layer() const { + return _internal_has_layer(); +} +inline void V1LayerParameter::clear_layer() { + if (layer_ != nullptr) layer_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::opencv_caffe::V0LayerParameter& V1LayerParameter::_internal_layer() const { + const ::opencv_caffe::V0LayerParameter* p = layer_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_V0LayerParameter_default_instance_); +} +inline const ::opencv_caffe::V0LayerParameter& V1LayerParameter::layer() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.layer) + return _internal_layer(); +} +inline void V1LayerParameter::unsafe_arena_set_allocated_layer( + ::opencv_caffe::V0LayerParameter* layer) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(layer_); + } + layer_ = layer; + if (layer) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.layer) +} +inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::release_layer() { + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::V0LayerParameter* temp = layer_; + layer_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::unsafe_arena_release_layer() { + // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.layer) + _has_bits_[0] &= ~0x00000002u; + ::opencv_caffe::V0LayerParameter* temp = layer_; + layer_ = nullptr; + return temp; +} +inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::_internal_mutable_layer() { + _has_bits_[0] |= 0x00000002u; + if (layer_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::V0LayerParameter>(GetArenaForAllocation()); + layer_ = p; + } + return layer_; +} +inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::mutable_layer() { + ::opencv_caffe::V0LayerParameter* _msg = _internal_mutable_layer(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.layer) + return _msg; +} +inline void V1LayerParameter::set_allocated_layer(::opencv_caffe::V0LayerParameter* layer) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete layer_; + } + if (layer) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::V0LayerParameter>::GetOwningArena(layer); + if (message_arena != submessage_arena) { + layer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, layer, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + layer_ = layer; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.layer) +} + +// ------------------------------------------------------------------- + +// V0LayerParameter + +// optional string name = 1; +inline bool V0LayerParameter::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool V0LayerParameter::has_name() const { + return _internal_has_name(); +} +inline void V0LayerParameter::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& V0LayerParameter::name() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void V0LayerParameter::set_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.name) +} +inline std::string* V0LayerParameter::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.name) + return _s; +} +inline const std::string& V0LayerParameter::_internal_name() const { + return name_.Get(); +} +inline void V0LayerParameter::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void V0LayerParameter::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.name) +} + +// optional string type = 2; +inline bool V0LayerParameter::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool V0LayerParameter::has_type() const { + return _internal_has_type(); +} +inline void V0LayerParameter::clear_type() { + type_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& V0LayerParameter::type() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void V0LayerParameter::set_type(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.type) +} +inline std::string* V0LayerParameter::mutable_type() { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.type) + return _s; +} +inline const std::string& V0LayerParameter::_internal_type() const { + return type_.Get(); +} +inline void V0LayerParameter::_internal_set_type(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::_internal_mutable_type() { + _has_bits_[0] |= 0x00000002u; + return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::release_type() { + // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.type) + if (!_internal_has_type()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void V0LayerParameter::set_allocated_type(std::string* type) { + if (type != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.type) +} + +// optional uint32 num_output = 3; +inline bool V0LayerParameter::_internal_has_num_output() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool V0LayerParameter::has_num_output() const { + return _internal_has_num_output(); +} +inline void V0LayerParameter::clear_num_output() { + num_output_ = 0u; + _has_bits_[0] &= ~0x00000100u; +} +inline uint32_t V0LayerParameter::_internal_num_output() const { + return num_output_; +} +inline uint32_t V0LayerParameter::num_output() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.num_output) + return _internal_num_output(); +} +inline void V0LayerParameter::_internal_set_num_output(uint32_t value) { + _has_bits_[0] |= 0x00000100u; + num_output_ = value; +} +inline void V0LayerParameter::set_num_output(uint32_t value) { + _internal_set_num_output(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.num_output) +} + +// optional bool biasterm = 4 [default = true]; +inline bool V0LayerParameter::_internal_has_biasterm() const { + bool value = (_has_bits_[0] & 0x00800000u) != 0; + return value; +} +inline bool V0LayerParameter::has_biasterm() const { + return _internal_has_biasterm(); +} +inline void V0LayerParameter::clear_biasterm() { + biasterm_ = true; + _has_bits_[0] &= ~0x00800000u; +} +inline bool V0LayerParameter::_internal_biasterm() const { + return biasterm_; +} +inline bool V0LayerParameter::biasterm() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.biasterm) + return _internal_biasterm(); +} +inline void V0LayerParameter::_internal_set_biasterm(bool value) { + _has_bits_[0] |= 0x00800000u; + biasterm_ = value; +} +inline void V0LayerParameter::set_biasterm(bool value) { + _internal_set_biasterm(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.biasterm) +} + +// optional .opencv_caffe.FillerParameter weight_filler = 5; +inline bool V0LayerParameter::_internal_has_weight_filler() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || weight_filler_ != nullptr); + return value; +} +inline bool V0LayerParameter::has_weight_filler() const { + return _internal_has_weight_filler(); +} +inline void V0LayerParameter::clear_weight_filler() { + if (weight_filler_ != nullptr) weight_filler_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::opencv_caffe::FillerParameter& V0LayerParameter::_internal_weight_filler() const { + const ::opencv_caffe::FillerParameter* p = weight_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& V0LayerParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.weight_filler) + return _internal_weight_filler(); +} +inline void V0LayerParameter::unsafe_arena_set_allocated_weight_filler( + ::opencv_caffe::FillerParameter* weight_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_); + } + weight_filler_ = weight_filler; + if (weight_filler) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V0LayerParameter.weight_filler) +} +inline ::opencv_caffe::FillerParameter* V0LayerParameter::release_weight_filler() { + _has_bits_[0] &= ~0x00000020u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* V0LayerParameter::unsafe_arena_release_weight_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.weight_filler) + _has_bits_[0] &= ~0x00000020u; + ::opencv_caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* V0LayerParameter::_internal_mutable_weight_filler() { + _has_bits_[0] |= 0x00000020u; + if (weight_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + weight_filler_ = p; + } + return weight_filler_; +} +inline ::opencv_caffe::FillerParameter* V0LayerParameter::mutable_weight_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.weight_filler) + return _msg; +} +inline void V0LayerParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete weight_filler_; + } + if (weight_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(weight_filler); + if (message_arena != submessage_arena) { + weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, weight_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + 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::_internal_has_bias_filler() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || bias_filler_ != nullptr); + return value; +} +inline bool V0LayerParameter::has_bias_filler() const { + return _internal_has_bias_filler(); +} +inline void V0LayerParameter::clear_bias_filler() { + if (bias_filler_ != nullptr) bias_filler_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::opencv_caffe::FillerParameter& V0LayerParameter::_internal_bias_filler() const { + const ::opencv_caffe::FillerParameter* p = bias_filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& V0LayerParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.bias_filler) + return _internal_bias_filler(); +} +inline void V0LayerParameter::unsafe_arena_set_allocated_bias_filler( + ::opencv_caffe::FillerParameter* bias_filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_); + } + bias_filler_ = bias_filler; + if (bias_filler) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V0LayerParameter.bias_filler) +} +inline ::opencv_caffe::FillerParameter* V0LayerParameter::release_bias_filler() { + _has_bits_[0] &= ~0x00000040u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* V0LayerParameter::unsafe_arena_release_bias_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.bias_filler) + _has_bits_[0] &= ~0x00000040u; + ::opencv_caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* V0LayerParameter::_internal_mutable_bias_filler() { + _has_bits_[0] |= 0x00000040u; + if (bias_filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + bias_filler_ = p; + } + return bias_filler_; +} +inline ::opencv_caffe::FillerParameter* V0LayerParameter::mutable_bias_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.bias_filler) + return _msg; +} +inline void V0LayerParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bias_filler_; + } + if (bias_filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(bias_filler); + if (message_arena != submessage_arena) { + bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bias_filler, submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + bias_filler_ = bias_filler; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.bias_filler) +} + +// optional uint32 pad = 7 [default = 0]; +inline bool V0LayerParameter::_internal_has_pad() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool V0LayerParameter::has_pad() const { + return _internal_has_pad(); +} +inline void V0LayerParameter::clear_pad() { + pad_ = 0u; + _has_bits_[0] &= ~0x00000200u; +} +inline uint32_t V0LayerParameter::_internal_pad() const { + return pad_; +} +inline uint32_t V0LayerParameter::pad() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.pad) + return _internal_pad(); +} +inline void V0LayerParameter::_internal_set_pad(uint32_t value) { + _has_bits_[0] |= 0x00000200u; + pad_ = value; +} +inline void V0LayerParameter::set_pad(uint32_t value) { + _internal_set_pad(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.pad) +} + +// optional uint32 kernelsize = 8; +inline bool V0LayerParameter::_internal_has_kernelsize() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool V0LayerParameter::has_kernelsize() const { + return _internal_has_kernelsize(); +} +inline void V0LayerParameter::clear_kernelsize() { + kernelsize_ = 0u; + _has_bits_[0] &= ~0x00000400u; +} +inline uint32_t V0LayerParameter::_internal_kernelsize() const { + return kernelsize_; +} +inline uint32_t V0LayerParameter::kernelsize() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.kernelsize) + return _internal_kernelsize(); +} +inline void V0LayerParameter::_internal_set_kernelsize(uint32_t value) { + _has_bits_[0] |= 0x00000400u; + kernelsize_ = value; +} +inline void V0LayerParameter::set_kernelsize(uint32_t value) { + _internal_set_kernelsize(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.kernelsize) +} + +// optional uint32 group = 9 [default = 1]; +inline bool V0LayerParameter::_internal_has_group() const { + bool value = (_has_bits_[0] & 0x01000000u) != 0; + return value; +} +inline bool V0LayerParameter::has_group() const { + return _internal_has_group(); +} +inline void V0LayerParameter::clear_group() { + group_ = 1u; + _has_bits_[0] &= ~0x01000000u; +} +inline uint32_t V0LayerParameter::_internal_group() const { + return group_; +} +inline uint32_t V0LayerParameter::group() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.group) + return _internal_group(); +} +inline void V0LayerParameter::_internal_set_group(uint32_t value) { + _has_bits_[0] |= 0x01000000u; + group_ = value; +} +inline void V0LayerParameter::set_group(uint32_t value) { + _internal_set_group(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.group) +} + +// optional uint32 stride = 10 [default = 1]; +inline bool V0LayerParameter::_internal_has_stride() const { + bool value = (_has_bits_[0] & 0x02000000u) != 0; + return value; +} +inline bool V0LayerParameter::has_stride() const { + return _internal_has_stride(); +} +inline void V0LayerParameter::clear_stride() { + stride_ = 1u; + _has_bits_[0] &= ~0x02000000u; +} +inline uint32_t V0LayerParameter::_internal_stride() const { + return stride_; +} +inline uint32_t V0LayerParameter::stride() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.stride) + return _internal_stride(); +} +inline void V0LayerParameter::_internal_set_stride(uint32_t value) { + _has_bits_[0] |= 0x02000000u; + stride_ = value; +} +inline void V0LayerParameter::set_stride(uint32_t value) { + _internal_set_stride(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.stride) +} + +// optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; +inline bool V0LayerParameter::_internal_has_pool() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool V0LayerParameter::has_pool() const { + return _internal_has_pool(); +} +inline void V0LayerParameter::clear_pool() { + pool_ = 0; + _has_bits_[0] &= ~0x00000800u; +} +inline ::opencv_caffe::V0LayerParameter_PoolMethod V0LayerParameter::_internal_pool() const { + return static_cast< ::opencv_caffe::V0LayerParameter_PoolMethod >(pool_); +} +inline ::opencv_caffe::V0LayerParameter_PoolMethod V0LayerParameter::pool() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.pool) + return _internal_pool(); +} +inline void V0LayerParameter::_internal_set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value) { + assert(::opencv_caffe::V0LayerParameter_PoolMethod_IsValid(value)); + _has_bits_[0] |= 0x00000800u; + pool_ = value; +} +inline void V0LayerParameter::set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value) { + _internal_set_pool(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.pool) +} + +// optional float dropout_ratio = 12 [default = 0.5]; +inline bool V0LayerParameter::_internal_has_dropout_ratio() const { + bool value = (_has_bits_[0] & 0x04000000u) != 0; + return value; +} +inline bool V0LayerParameter::has_dropout_ratio() const { + return _internal_has_dropout_ratio(); +} +inline void V0LayerParameter::clear_dropout_ratio() { + dropout_ratio_ = 0.5f; + _has_bits_[0] &= ~0x04000000u; +} +inline float V0LayerParameter::_internal_dropout_ratio() const { + return dropout_ratio_; +} +inline float V0LayerParameter::dropout_ratio() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.dropout_ratio) + return _internal_dropout_ratio(); +} +inline void V0LayerParameter::_internal_set_dropout_ratio(float value) { + _has_bits_[0] |= 0x04000000u; + dropout_ratio_ = value; +} +inline void V0LayerParameter::set_dropout_ratio(float value) { + _internal_set_dropout_ratio(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.dropout_ratio) +} + +// optional uint32 local_size = 13 [default = 5]; +inline bool V0LayerParameter::_internal_has_local_size() const { + bool value = (_has_bits_[0] & 0x08000000u) != 0; + return value; +} +inline bool V0LayerParameter::has_local_size() const { + return _internal_has_local_size(); +} +inline void V0LayerParameter::clear_local_size() { + local_size_ = 5u; + _has_bits_[0] &= ~0x08000000u; +} +inline uint32_t V0LayerParameter::_internal_local_size() const { + return local_size_; +} +inline uint32_t V0LayerParameter::local_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.local_size) + return _internal_local_size(); +} +inline void V0LayerParameter::_internal_set_local_size(uint32_t value) { + _has_bits_[0] |= 0x08000000u; + local_size_ = value; +} +inline void V0LayerParameter::set_local_size(uint32_t value) { + _internal_set_local_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.local_size) +} + +// optional float alpha = 14 [default = 1]; +inline bool V0LayerParameter::_internal_has_alpha() const { + bool value = (_has_bits_[0] & 0x10000000u) != 0; + return value; +} +inline bool V0LayerParameter::has_alpha() const { + return _internal_has_alpha(); +} +inline void V0LayerParameter::clear_alpha() { + alpha_ = 1; + _has_bits_[0] &= ~0x10000000u; +} +inline float V0LayerParameter::_internal_alpha() const { + return alpha_; +} +inline float V0LayerParameter::alpha() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.alpha) + return _internal_alpha(); +} +inline void V0LayerParameter::_internal_set_alpha(float value) { + _has_bits_[0] |= 0x10000000u; + alpha_ = value; +} +inline void V0LayerParameter::set_alpha(float value) { + _internal_set_alpha(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.alpha) +} + +// optional float beta = 15 [default = 0.75]; +inline bool V0LayerParameter::_internal_has_beta() const { + bool value = (_has_bits_[0] & 0x20000000u) != 0; + return value; +} +inline bool V0LayerParameter::has_beta() const { + return _internal_has_beta(); +} +inline void V0LayerParameter::clear_beta() { + beta_ = 0.75f; + _has_bits_[0] &= ~0x20000000u; +} +inline float V0LayerParameter::_internal_beta() const { + return beta_; +} +inline float V0LayerParameter::beta() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.beta) + return _internal_beta(); +} +inline void V0LayerParameter::_internal_set_beta(float value) { + _has_bits_[0] |= 0x20000000u; + beta_ = value; +} +inline void V0LayerParameter::set_beta(float value) { + _internal_set_beta(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.beta) +} + +// optional float k = 22 [default = 1]; +inline bool V0LayerParameter::_internal_has_k() const { + bool value = (_has_bits_[0] & 0x80000000u) != 0; + return value; +} +inline bool V0LayerParameter::has_k() const { + return _internal_has_k(); +} +inline void V0LayerParameter::clear_k() { + k_ = 1; + _has_bits_[0] &= ~0x80000000u; +} +inline float V0LayerParameter::_internal_k() const { + return k_; +} +inline float V0LayerParameter::k() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.k) + return _internal_k(); +} +inline void V0LayerParameter::_internal_set_k(float value) { + _has_bits_[0] |= 0x80000000u; + k_ = value; +} +inline void V0LayerParameter::set_k(float value) { + _internal_set_k(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.k) +} + +// optional string source = 16; +inline bool V0LayerParameter::_internal_has_source() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool V0LayerParameter::has_source() const { + return _internal_has_source(); +} +inline void V0LayerParameter::clear_source() { + source_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& V0LayerParameter::source() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.source) + return _internal_source(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void V0LayerParameter::set_source(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.source) +} +inline std::string* V0LayerParameter::mutable_source() { + std::string* _s = _internal_mutable_source(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.source) + return _s; +} +inline const std::string& V0LayerParameter::_internal_source() const { + return source_.Get(); +} +inline void V0LayerParameter::_internal_set_source(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::_internal_mutable_source() { + _has_bits_[0] |= 0x00000004u; + return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::release_source() { + // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.source) + if (!_internal_has_source()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void V0LayerParameter::set_allocated_source(std::string* source) { + if (source != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.source) +} + +// optional float scale = 17 [default = 1]; +inline bool V0LayerParameter::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x40000000u) != 0; + return value; +} +inline bool V0LayerParameter::has_scale() const { + return _internal_has_scale(); +} +inline void V0LayerParameter::clear_scale() { + scale_ = 1; + _has_bits_[0] &= ~0x40000000u; +} +inline float V0LayerParameter::_internal_scale() const { + return scale_; +} +inline float V0LayerParameter::scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.scale) + return _internal_scale(); +} +inline void V0LayerParameter::_internal_set_scale(float value) { + _has_bits_[0] |= 0x40000000u; + scale_ = value; +} +inline void V0LayerParameter::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.scale) +} + +// optional string meanfile = 18; +inline bool V0LayerParameter::_internal_has_meanfile() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool V0LayerParameter::has_meanfile() const { + return _internal_has_meanfile(); +} +inline void V0LayerParameter::clear_meanfile() { + meanfile_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& V0LayerParameter::meanfile() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.meanfile) + return _internal_meanfile(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void V0LayerParameter::set_meanfile(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000008u; + meanfile_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.meanfile) +} +inline std::string* V0LayerParameter::mutable_meanfile() { + std::string* _s = _internal_mutable_meanfile(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.meanfile) + return _s; +} +inline const std::string& V0LayerParameter::_internal_meanfile() const { + return meanfile_.Get(); +} +inline void V0LayerParameter::_internal_set_meanfile(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + meanfile_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::_internal_mutable_meanfile() { + _has_bits_[0] |= 0x00000008u; + return meanfile_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::release_meanfile() { + // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.meanfile) + if (!_internal_has_meanfile()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto* p = meanfile_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (meanfile_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + meanfile_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void V0LayerParameter::set_allocated_meanfile(std::string* meanfile) { + if (meanfile != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + meanfile_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), meanfile, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (meanfile_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + meanfile_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.meanfile) +} + +// optional uint32 batchsize = 19; +inline bool V0LayerParameter::_internal_has_batchsize() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool V0LayerParameter::has_batchsize() const { + return _internal_has_batchsize(); +} +inline void V0LayerParameter::clear_batchsize() { + batchsize_ = 0u; + _has_bits_[0] &= ~0x00001000u; +} +inline uint32_t V0LayerParameter::_internal_batchsize() const { + return batchsize_; +} +inline uint32_t V0LayerParameter::batchsize() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.batchsize) + return _internal_batchsize(); +} +inline void V0LayerParameter::_internal_set_batchsize(uint32_t value) { + _has_bits_[0] |= 0x00001000u; + batchsize_ = value; +} +inline void V0LayerParameter::set_batchsize(uint32_t value) { + _internal_set_batchsize(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.batchsize) +} + +// optional uint32 cropsize = 20 [default = 0]; +inline bool V0LayerParameter::_internal_has_cropsize() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool V0LayerParameter::has_cropsize() const { + return _internal_has_cropsize(); +} +inline void V0LayerParameter::clear_cropsize() { + cropsize_ = 0u; + _has_bits_[0] &= ~0x00002000u; +} +inline uint32_t V0LayerParameter::_internal_cropsize() const { + return cropsize_; +} +inline uint32_t V0LayerParameter::cropsize() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.cropsize) + return _internal_cropsize(); +} +inline void V0LayerParameter::_internal_set_cropsize(uint32_t value) { + _has_bits_[0] |= 0x00002000u; + cropsize_ = value; +} +inline void V0LayerParameter::set_cropsize(uint32_t value) { + _internal_set_cropsize(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.cropsize) +} + +// optional bool mirror = 21 [default = false]; +inline bool V0LayerParameter::_internal_has_mirror() const { + bool value = (_has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool V0LayerParameter::has_mirror() const { + return _internal_has_mirror(); +} +inline void V0LayerParameter::clear_mirror() { + mirror_ = false; + _has_bits_[0] &= ~0x00008000u; +} +inline bool V0LayerParameter::_internal_mirror() const { + return mirror_; +} +inline bool V0LayerParameter::mirror() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.mirror) + return _internal_mirror(); +} +inline void V0LayerParameter::_internal_set_mirror(bool value) { + _has_bits_[0] |= 0x00008000u; + mirror_ = value; +} +inline void V0LayerParameter::set_mirror(bool value) { + _internal_set_mirror(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.mirror) +} + +// repeated .opencv_caffe.BlobProto blobs = 50; +inline int V0LayerParameter::_internal_blobs_size() const { + return blobs_.size(); +} +inline int V0LayerParameter::blobs_size() const { + return _internal_blobs_size(); +} +inline void V0LayerParameter::clear_blobs() { + blobs_.Clear(); +} +inline ::opencv_caffe::BlobProto* V0LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.blobs) + return blobs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >* +V0LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.blobs) + return &blobs_; +} +inline const ::opencv_caffe::BlobProto& V0LayerParameter::_internal_blobs(int index) const { + return blobs_.Get(index); +} +inline const ::opencv_caffe::BlobProto& V0LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.blobs) + return _internal_blobs(index); +} +inline ::opencv_caffe::BlobProto* V0LayerParameter::_internal_add_blobs() { + return blobs_.Add(); +} +inline ::opencv_caffe::BlobProto* V0LayerParameter::add_blobs() { + ::opencv_caffe::BlobProto* _add = _internal_add_blobs(); + // @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.blobs) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_blobs_lr_size() const { + return blobs_lr_.size(); +} +inline int V0LayerParameter::blobs_lr_size() const { + return _internal_blobs_lr_size(); +} +inline void V0LayerParameter::clear_blobs_lr() { + blobs_lr_.Clear(); +} +inline float V0LayerParameter::_internal_blobs_lr(int index) const { + return blobs_lr_.Get(index); +} +inline float V0LayerParameter::blobs_lr(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.blobs_lr) + return _internal_blobs_lr(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::_internal_add_blobs_lr(float value) { + blobs_lr_.Add(value); +} +inline void V0LayerParameter::add_blobs_lr(float value) { + _internal_add_blobs_lr(value); + // @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.blobs_lr) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V0LayerParameter::_internal_blobs_lr() const { + return blobs_lr_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V0LayerParameter::blobs_lr() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V0LayerParameter.blobs_lr) + return _internal_blobs_lr(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V0LayerParameter::_internal_mutable_blobs_lr() { + return &blobs_lr_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V0LayerParameter::mutable_blobs_lr() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.blobs_lr) + return _internal_mutable_blobs_lr(); +} + +// repeated float weight_decay = 52; +inline int V0LayerParameter::_internal_weight_decay_size() const { + return weight_decay_.size(); +} +inline int V0LayerParameter::weight_decay_size() const { + return _internal_weight_decay_size(); +} +inline void V0LayerParameter::clear_weight_decay() { + weight_decay_.Clear(); +} +inline float V0LayerParameter::_internal_weight_decay(int index) const { + return weight_decay_.Get(index); +} +inline float V0LayerParameter::weight_decay(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.weight_decay) + return _internal_weight_decay(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::_internal_add_weight_decay(float value) { + weight_decay_.Add(value); +} +inline void V0LayerParameter::add_weight_decay(float value) { + _internal_add_weight_decay(value); + // @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.weight_decay) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V0LayerParameter::_internal_weight_decay() const { + return weight_decay_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +V0LayerParameter::weight_decay() const { + // @@protoc_insertion_point(field_list:opencv_caffe.V0LayerParameter.weight_decay) + return _internal_weight_decay(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V0LayerParameter::_internal_mutable_weight_decay() { + return &weight_decay_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +V0LayerParameter::mutable_weight_decay() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.weight_decay) + return _internal_mutable_weight_decay(); +} + +// optional uint32 rand_skip = 53 [default = 0]; +inline bool V0LayerParameter::_internal_has_rand_skip() const { + bool value = (_has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool V0LayerParameter::has_rand_skip() const { + return _internal_has_rand_skip(); +} +inline void V0LayerParameter::clear_rand_skip() { + rand_skip_ = 0u; + _has_bits_[0] &= ~0x00020000u; +} +inline uint32_t V0LayerParameter::_internal_rand_skip() const { + return rand_skip_; +} +inline uint32_t V0LayerParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.rand_skip) + return _internal_rand_skip(); +} +inline void V0LayerParameter::_internal_set_rand_skip(uint32_t value) { + _has_bits_[0] |= 0x00020000u; + rand_skip_ = value; +} +inline void V0LayerParameter::set_rand_skip(uint32_t value) { + _internal_set_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::_internal_has_det_fg_threshold() const { + bool value = (_has_bits_[1] & 0x00000001u) != 0; + return value; +} +inline bool V0LayerParameter::has_det_fg_threshold() const { + return _internal_has_det_fg_threshold(); +} +inline void V0LayerParameter::clear_det_fg_threshold() { + det_fg_threshold_ = 0.5f; + _has_bits_[1] &= ~0x00000001u; +} +inline float V0LayerParameter::_internal_det_fg_threshold() const { + return det_fg_threshold_; +} +inline float V0LayerParameter::det_fg_threshold() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_fg_threshold) + return _internal_det_fg_threshold(); +} +inline void V0LayerParameter::_internal_set_det_fg_threshold(float value) { + _has_bits_[1] |= 0x00000001u; + det_fg_threshold_ = value; +} +inline void V0LayerParameter::set_det_fg_threshold(float value) { + _internal_set_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::_internal_has_det_bg_threshold() const { + bool value = (_has_bits_[1] & 0x00000002u) != 0; + return value; +} +inline bool V0LayerParameter::has_det_bg_threshold() const { + return _internal_has_det_bg_threshold(); +} +inline void V0LayerParameter::clear_det_bg_threshold() { + det_bg_threshold_ = 0.5f; + _has_bits_[1] &= ~0x00000002u; +} +inline float V0LayerParameter::_internal_det_bg_threshold() const { + return det_bg_threshold_; +} +inline float V0LayerParameter::det_bg_threshold() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_bg_threshold) + return _internal_det_bg_threshold(); +} +inline void V0LayerParameter::_internal_set_det_bg_threshold(float value) { + _has_bits_[1] |= 0x00000002u; + det_bg_threshold_ = value; +} +inline void V0LayerParameter::set_det_bg_threshold(float value) { + _internal_set_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::_internal_has_det_fg_fraction() const { + bool value = (_has_bits_[1] & 0x00000004u) != 0; + return value; +} +inline bool V0LayerParameter::has_det_fg_fraction() const { + return _internal_has_det_fg_fraction(); +} +inline void V0LayerParameter::clear_det_fg_fraction() { + det_fg_fraction_ = 0.25f; + _has_bits_[1] &= ~0x00000004u; +} +inline float V0LayerParameter::_internal_det_fg_fraction() const { + return det_fg_fraction_; +} +inline float V0LayerParameter::det_fg_fraction() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_fg_fraction) + return _internal_det_fg_fraction(); +} +inline void V0LayerParameter::_internal_set_det_fg_fraction(float value) { + _has_bits_[1] |= 0x00000004u; + det_fg_fraction_ = value; +} +inline void V0LayerParameter::set_det_fg_fraction(float value) { + _internal_set_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::_internal_has_det_context_pad() const { + bool value = (_has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool V0LayerParameter::has_det_context_pad() const { + return _internal_has_det_context_pad(); +} +inline void V0LayerParameter::clear_det_context_pad() { + det_context_pad_ = 0u; + _has_bits_[0] &= ~0x00040000u; +} +inline uint32_t V0LayerParameter::_internal_det_context_pad() const { + return det_context_pad_; +} +inline uint32_t V0LayerParameter::det_context_pad() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_context_pad) + return _internal_det_context_pad(); +} +inline void V0LayerParameter::_internal_set_det_context_pad(uint32_t value) { + _has_bits_[0] |= 0x00040000u; + det_context_pad_ = value; +} +inline void V0LayerParameter::set_det_context_pad(uint32_t value) { + _internal_set_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::_internal_has_det_crop_mode() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool V0LayerParameter::has_det_crop_mode() const { + return _internal_has_det_crop_mode(); +} +inline void V0LayerParameter::clear_det_crop_mode() { + det_crop_mode_.ClearToDefault(::opencv_caffe::V0LayerParameter::_i_give_permission_to_break_this_code_default_det_crop_mode_, GetArenaForAllocation()); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& V0LayerParameter::det_crop_mode() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_crop_mode) + if (det_crop_mode_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_det_crop_mode_.get(); + return _internal_det_crop_mode(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void V0LayerParameter::set_det_crop_mode(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000010u; + det_crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_crop_mode) +} +inline std::string* V0LayerParameter::mutable_det_crop_mode() { + std::string* _s = _internal_mutable_det_crop_mode(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.det_crop_mode) + return _s; +} +inline const std::string& V0LayerParameter::_internal_det_crop_mode() const { + return det_crop_mode_.Get(); +} +inline void V0LayerParameter::_internal_set_det_crop_mode(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + det_crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::_internal_mutable_det_crop_mode() { + _has_bits_[0] |= 0x00000010u; + return det_crop_mode_.Mutable(::opencv_caffe::V0LayerParameter::_i_give_permission_to_break_this_code_default_det_crop_mode_, GetArenaForAllocation()); +} +inline std::string* V0LayerParameter::release_det_crop_mode() { + // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.det_crop_mode) + if (!_internal_has_det_crop_mode()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + auto* p = det_crop_mode_.ReleaseNonDefault(nullptr, GetArenaForAllocation()); + return p; +} +inline void V0LayerParameter::set_allocated_det_crop_mode(std::string* det_crop_mode) { + if (det_crop_mode != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + det_crop_mode_.SetAllocated(nullptr, det_crop_mode, + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.det_crop_mode) +} + +// optional int32 new_num = 60 [default = 0]; +inline bool V0LayerParameter::_internal_has_new_num() const { + bool value = (_has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool V0LayerParameter::has_new_num() const { + return _internal_has_new_num(); +} +inline void V0LayerParameter::clear_new_num() { + new_num_ = 0; + _has_bits_[0] &= ~0x00080000u; +} +inline int32_t V0LayerParameter::_internal_new_num() const { + return new_num_; +} +inline int32_t V0LayerParameter::new_num() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_num) + return _internal_new_num(); +} +inline void V0LayerParameter::_internal_set_new_num(int32_t value) { + _has_bits_[0] |= 0x00080000u; + new_num_ = value; +} +inline void V0LayerParameter::set_new_num(int32_t value) { + _internal_set_new_num(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_num) +} + +// optional int32 new_channels = 61 [default = 0]; +inline bool V0LayerParameter::_internal_has_new_channels() const { + bool value = (_has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool V0LayerParameter::has_new_channels() const { + return _internal_has_new_channels(); +} +inline void V0LayerParameter::clear_new_channels() { + new_channels_ = 0; + _has_bits_[0] &= ~0x00100000u; +} +inline int32_t V0LayerParameter::_internal_new_channels() const { + return new_channels_; +} +inline int32_t V0LayerParameter::new_channels() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_channels) + return _internal_new_channels(); +} +inline void V0LayerParameter::_internal_set_new_channels(int32_t value) { + _has_bits_[0] |= 0x00100000u; + new_channels_ = value; +} +inline void V0LayerParameter::set_new_channels(int32_t value) { + _internal_set_new_channels(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_channels) +} + +// optional int32 new_height = 62 [default = 0]; +inline bool V0LayerParameter::_internal_has_new_height() const { + bool value = (_has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool V0LayerParameter::has_new_height() const { + return _internal_has_new_height(); +} +inline void V0LayerParameter::clear_new_height() { + new_height_ = 0; + _has_bits_[0] &= ~0x00200000u; +} +inline int32_t V0LayerParameter::_internal_new_height() const { + return new_height_; +} +inline int32_t V0LayerParameter::new_height() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_height) + return _internal_new_height(); +} +inline void V0LayerParameter::_internal_set_new_height(int32_t value) { + _has_bits_[0] |= 0x00200000u; + new_height_ = value; +} +inline void V0LayerParameter::set_new_height(int32_t value) { + _internal_set_new_height(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_height) +} + +// optional int32 new_width = 63 [default = 0]; +inline bool V0LayerParameter::_internal_has_new_width() const { + bool value = (_has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool V0LayerParameter::has_new_width() const { + return _internal_has_new_width(); +} +inline void V0LayerParameter::clear_new_width() { + new_width_ = 0; + _has_bits_[0] &= ~0x00004000u; +} +inline int32_t V0LayerParameter::_internal_new_width() const { + return new_width_; +} +inline int32_t V0LayerParameter::new_width() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_width) + return _internal_new_width(); +} +inline void V0LayerParameter::_internal_set_new_width(int32_t value) { + _has_bits_[0] |= 0x00004000u; + new_width_ = value; +} +inline void V0LayerParameter::set_new_width(int32_t value) { + _internal_set_new_width(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_width) +} + +// optional bool shuffle_images = 64 [default = false]; +inline bool V0LayerParameter::_internal_has_shuffle_images() const { + bool value = (_has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool V0LayerParameter::has_shuffle_images() const { + return _internal_has_shuffle_images(); +} +inline void V0LayerParameter::clear_shuffle_images() { + shuffle_images_ = false; + _has_bits_[0] &= ~0x00010000u; +} +inline bool V0LayerParameter::_internal_shuffle_images() const { + return shuffle_images_; +} +inline bool V0LayerParameter::shuffle_images() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.shuffle_images) + return _internal_shuffle_images(); +} +inline void V0LayerParameter::_internal_set_shuffle_images(bool value) { + _has_bits_[0] |= 0x00010000u; + shuffle_images_ = value; +} +inline void V0LayerParameter::set_shuffle_images(bool value) { + _internal_set_shuffle_images(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.shuffle_images) +} + +// optional uint32 concat_dim = 65 [default = 1]; +inline bool V0LayerParameter::_internal_has_concat_dim() const { + bool value = (_has_bits_[0] & 0x00400000u) != 0; + return value; +} +inline bool V0LayerParameter::has_concat_dim() const { + return _internal_has_concat_dim(); +} +inline void V0LayerParameter::clear_concat_dim() { + concat_dim_ = 1u; + _has_bits_[0] &= ~0x00400000u; +} +inline uint32_t V0LayerParameter::_internal_concat_dim() const { + return concat_dim_; +} +inline uint32_t V0LayerParameter::concat_dim() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.concat_dim) + return _internal_concat_dim(); +} +inline void V0LayerParameter::_internal_set_concat_dim(uint32_t value) { + _has_bits_[0] |= 0x00400000u; + concat_dim_ = value; +} +inline void V0LayerParameter::set_concat_dim(uint32_t value) { + _internal_set_concat_dim(value); + // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.concat_dim) +} + +// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001; +inline bool V0LayerParameter::_internal_has_hdf5_output_param() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || hdf5_output_param_ != nullptr); + return value; +} +inline bool V0LayerParameter::has_hdf5_output_param() const { + return _internal_has_hdf5_output_param(); +} +inline void V0LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != nullptr) hdf5_output_param_->Clear(); + _has_bits_[0] &= ~0x00000080u; +} +inline const ::opencv_caffe::HDF5OutputParameter& V0LayerParameter::_internal_hdf5_output_param() const { + const ::opencv_caffe::HDF5OutputParameter* p = hdf5_output_param_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_HDF5OutputParameter_default_instance_); +} +inline const ::opencv_caffe::HDF5OutputParameter& V0LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.hdf5_output_param) + return _internal_hdf5_output_param(); +} +inline void V0LayerParameter::unsafe_arena_set_allocated_hdf5_output_param( + ::opencv_caffe::HDF5OutputParameter* hdf5_output_param) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_output_param_); + } + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V0LayerParameter.hdf5_output_param) +} +inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::release_hdf5_output_param() { + _has_bits_[0] &= ~0x00000080u; + ::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::unsafe_arena_release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.hdf5_output_param) + _has_bits_[0] &= ~0x00000080u; + ::opencv_caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = nullptr; + return temp; +} +inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::_internal_mutable_hdf5_output_param() { + _has_bits_[0] |= 0x00000080u; + if (hdf5_output_param_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::HDF5OutputParameter>(GetArenaForAllocation()); + hdf5_output_param_ = p; + } + return hdf5_output_param_; +} +inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::mutable_hdf5_output_param() { + ::opencv_caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.hdf5_output_param) + return _msg; +} +inline void V0LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete hdf5_output_param_; + } + if (hdf5_output_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::HDF5OutputParameter>::GetOwningArena(hdf5_output_param); + if (message_arena != submessage_arena) { + hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hdf5_output_param, submessage_arena); + } + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + 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::_internal_has_filler() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || filler_ != nullptr); + return value; +} +inline bool PReLUParameter::has_filler() const { + return _internal_has_filler(); +} +inline void PReLUParameter::clear_filler() { + if (filler_ != nullptr) filler_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::opencv_caffe::FillerParameter& PReLUParameter::_internal_filler() const { + const ::opencv_caffe::FillerParameter* p = filler_; + return p != nullptr ? *p : reinterpret_cast( + ::opencv_caffe::_FillerParameter_default_instance_); +} +inline const ::opencv_caffe::FillerParameter& PReLUParameter::filler() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PReLUParameter.filler) + return _internal_filler(); +} +inline void PReLUParameter::unsafe_arena_set_allocated_filler( + ::opencv_caffe::FillerParameter* filler) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filler_); + } + filler_ = filler; + if (filler) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.PReLUParameter.filler) +} +inline ::opencv_caffe::FillerParameter* PReLUParameter::release_filler() { + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = filler_; + filler_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::opencv_caffe::FillerParameter* PReLUParameter::unsafe_arena_release_filler() { + // @@protoc_insertion_point(field_release:opencv_caffe.PReLUParameter.filler) + _has_bits_[0] &= ~0x00000001u; + ::opencv_caffe::FillerParameter* temp = filler_; + filler_ = nullptr; + return temp; +} +inline ::opencv_caffe::FillerParameter* PReLUParameter::_internal_mutable_filler() { + _has_bits_[0] |= 0x00000001u; + if (filler_ == nullptr) { + auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation()); + filler_ = p; + } + return filler_; +} +inline ::opencv_caffe::FillerParameter* PReLUParameter::mutable_filler() { + ::opencv_caffe::FillerParameter* _msg = _internal_mutable_filler(); + // @@protoc_insertion_point(field_mutable:opencv_caffe.PReLUParameter.filler) + return _msg; +} +inline void PReLUParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete filler_; + } + if (filler) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_caffe::FillerParameter>::GetOwningArena(filler); + if (message_arena != submessage_arena) { + filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, filler, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + filler_ = filler; + // @@protoc_insertion_point(field_set_allocated:opencv_caffe.PReLUParameter.filler) +} + +// optional bool channel_shared = 2 [default = false]; +inline bool PReLUParameter::_internal_has_channel_shared() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PReLUParameter::has_channel_shared() const { + return _internal_has_channel_shared(); +} +inline void PReLUParameter::clear_channel_shared() { + channel_shared_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool PReLUParameter::_internal_channel_shared() const { + return channel_shared_; +} +inline bool PReLUParameter::channel_shared() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PReLUParameter.channel_shared) + return _internal_channel_shared(); +} +inline void PReLUParameter::_internal_set_channel_shared(bool value) { + _has_bits_[0] |= 0x00000002u; + channel_shared_ = value; +} +inline void PReLUParameter::set_channel_shared(bool value) { + _internal_set_channel_shared(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PReLUParameter.channel_shared) +} + +// ------------------------------------------------------------------- + +// NormalizedBBox + +// optional float xmin = 1; +inline bool NormalizedBBox::_internal_has_xmin() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NormalizedBBox::has_xmin() const { + return _internal_has_xmin(); +} +inline void NormalizedBBox::clear_xmin() { + xmin_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float NormalizedBBox::_internal_xmin() const { + return xmin_; +} +inline float NormalizedBBox::xmin() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.xmin) + return _internal_xmin(); +} +inline void NormalizedBBox::_internal_set_xmin(float value) { + _has_bits_[0] |= 0x00000001u; + xmin_ = value; +} +inline void NormalizedBBox::set_xmin(float value) { + _internal_set_xmin(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.xmin) +} + +// optional float ymin = 2; +inline bool NormalizedBBox::_internal_has_ymin() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool NormalizedBBox::has_ymin() const { + return _internal_has_ymin(); +} +inline void NormalizedBBox::clear_ymin() { + ymin_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float NormalizedBBox::_internal_ymin() const { + return ymin_; +} +inline float NormalizedBBox::ymin() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.ymin) + return _internal_ymin(); +} +inline void NormalizedBBox::_internal_set_ymin(float value) { + _has_bits_[0] |= 0x00000002u; + ymin_ = value; +} +inline void NormalizedBBox::set_ymin(float value) { + _internal_set_ymin(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.ymin) +} + +// optional float xmax = 3; +inline bool NormalizedBBox::_internal_has_xmax() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool NormalizedBBox::has_xmax() const { + return _internal_has_xmax(); +} +inline void NormalizedBBox::clear_xmax() { + xmax_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline float NormalizedBBox::_internal_xmax() const { + return xmax_; +} +inline float NormalizedBBox::xmax() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.xmax) + return _internal_xmax(); +} +inline void NormalizedBBox::_internal_set_xmax(float value) { + _has_bits_[0] |= 0x00000004u; + xmax_ = value; +} +inline void NormalizedBBox::set_xmax(float value) { + _internal_set_xmax(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.xmax) +} + +// optional float ymax = 4; +inline bool NormalizedBBox::_internal_has_ymax() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool NormalizedBBox::has_ymax() const { + return _internal_has_ymax(); +} +inline void NormalizedBBox::clear_ymax() { + ymax_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline float NormalizedBBox::_internal_ymax() const { + return ymax_; +} +inline float NormalizedBBox::ymax() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.ymax) + return _internal_ymax(); +} +inline void NormalizedBBox::_internal_set_ymax(float value) { + _has_bits_[0] |= 0x00000008u; + ymax_ = value; +} +inline void NormalizedBBox::set_ymax(float value) { + _internal_set_ymax(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.ymax) +} + +// optional int32 label = 5; +inline bool NormalizedBBox::_internal_has_label() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool NormalizedBBox::has_label() const { + return _internal_has_label(); +} +inline void NormalizedBBox::clear_label() { + label_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t NormalizedBBox::_internal_label() const { + return label_; +} +inline int32_t NormalizedBBox::label() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.label) + return _internal_label(); +} +inline void NormalizedBBox::_internal_set_label(int32_t value) { + _has_bits_[0] |= 0x00000010u; + label_ = value; +} +inline void NormalizedBBox::set_label(int32_t value) { + _internal_set_label(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.label) +} + +// optional bool difficult = 6; +inline bool NormalizedBBox::_internal_has_difficult() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool NormalizedBBox::has_difficult() const { + return _internal_has_difficult(); +} +inline void NormalizedBBox::clear_difficult() { + difficult_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool NormalizedBBox::_internal_difficult() const { + return difficult_; +} +inline bool NormalizedBBox::difficult() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.difficult) + return _internal_difficult(); +} +inline void NormalizedBBox::_internal_set_difficult(bool value) { + _has_bits_[0] |= 0x00000020u; + difficult_ = value; +} +inline void NormalizedBBox::set_difficult(bool value) { + _internal_set_difficult(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.difficult) +} + +// optional float score = 7; +inline bool NormalizedBBox::_internal_has_score() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool NormalizedBBox::has_score() const { + return _internal_has_score(); +} +inline void NormalizedBBox::clear_score() { + score_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline float NormalizedBBox::_internal_score() const { + return score_; +} +inline float NormalizedBBox::score() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.score) + return _internal_score(); +} +inline void NormalizedBBox::_internal_set_score(float value) { + _has_bits_[0] |= 0x00000040u; + score_ = value; +} +inline void NormalizedBBox::set_score(float value) { + _internal_set_score(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.score) +} + +// optional float size = 8; +inline bool NormalizedBBox::_internal_has_size() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool NormalizedBBox::has_size() const { + return _internal_has_size(); +} +inline void NormalizedBBox::clear_size() { + size_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline float NormalizedBBox::_internal_size() const { + return size_; +} +inline float NormalizedBBox::size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.size) + return _internal_size(); +} +inline void NormalizedBBox::_internal_set_size(float value) { + _has_bits_[0] |= 0x00000080u; + size_ = value; +} +inline void NormalizedBBox::set_size(float value) { + _internal_set_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.size) +} + +// ------------------------------------------------------------------- + +// ROIPoolingParameter + +// optional uint32 pooled_h = 1 [default = 0]; +inline bool ROIPoolingParameter::_internal_has_pooled_h() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ROIPoolingParameter::has_pooled_h() const { + return _internal_has_pooled_h(); +} +inline void ROIPoolingParameter::clear_pooled_h() { + pooled_h_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline uint32_t ROIPoolingParameter::_internal_pooled_h() const { + return pooled_h_; +} +inline uint32_t ROIPoolingParameter::pooled_h() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.pooled_h) + return _internal_pooled_h(); +} +inline void ROIPoolingParameter::_internal_set_pooled_h(uint32_t value) { + _has_bits_[0] |= 0x00000001u; + pooled_h_ = value; +} +inline void ROIPoolingParameter::set_pooled_h(uint32_t value) { + _internal_set_pooled_h(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.pooled_h) +} + +// optional uint32 pooled_w = 2 [default = 0]; +inline bool ROIPoolingParameter::_internal_has_pooled_w() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ROIPoolingParameter::has_pooled_w() const { + return _internal_has_pooled_w(); +} +inline void ROIPoolingParameter::clear_pooled_w() { + pooled_w_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t ROIPoolingParameter::_internal_pooled_w() const { + return pooled_w_; +} +inline uint32_t ROIPoolingParameter::pooled_w() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.pooled_w) + return _internal_pooled_w(); +} +inline void ROIPoolingParameter::_internal_set_pooled_w(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + pooled_w_ = value; +} +inline void ROIPoolingParameter::set_pooled_w(uint32_t value) { + _internal_set_pooled_w(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.pooled_w) +} + +// optional float spatial_scale = 3 [default = 1]; +inline bool ROIPoolingParameter::_internal_has_spatial_scale() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ROIPoolingParameter::has_spatial_scale() const { + return _internal_has_spatial_scale(); +} +inline void ROIPoolingParameter::clear_spatial_scale() { + spatial_scale_ = 1; + _has_bits_[0] &= ~0x00000004u; +} +inline float ROIPoolingParameter::_internal_spatial_scale() const { + return spatial_scale_; +} +inline float ROIPoolingParameter::spatial_scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.spatial_scale) + return _internal_spatial_scale(); +} +inline void ROIPoolingParameter::_internal_set_spatial_scale(float value) { + _has_bits_[0] |= 0x00000004u; + spatial_scale_ = value; +} +inline void ROIPoolingParameter::set_spatial_scale(float value) { + _internal_set_spatial_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.spatial_scale) +} + +// ------------------------------------------------------------------- + +// ProposalParameter + +// optional uint32 feat_stride = 1 [default = 16]; +inline bool ProposalParameter::_internal_has_feat_stride() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ProposalParameter::has_feat_stride() const { + return _internal_has_feat_stride(); +} +inline void ProposalParameter::clear_feat_stride() { + feat_stride_ = 16u; + _has_bits_[0] &= ~0x00000001u; +} +inline uint32_t ProposalParameter::_internal_feat_stride() const { + return feat_stride_; +} +inline uint32_t ProposalParameter::feat_stride() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.feat_stride) + return _internal_feat_stride(); +} +inline void ProposalParameter::_internal_set_feat_stride(uint32_t value) { + _has_bits_[0] |= 0x00000001u; + feat_stride_ = value; +} +inline void ProposalParameter::set_feat_stride(uint32_t value) { + _internal_set_feat_stride(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.feat_stride) +} + +// optional uint32 base_size = 2 [default = 16]; +inline bool ProposalParameter::_internal_has_base_size() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ProposalParameter::has_base_size() const { + return _internal_has_base_size(); +} +inline void ProposalParameter::clear_base_size() { + base_size_ = 16u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t ProposalParameter::_internal_base_size() const { + return base_size_; +} +inline uint32_t ProposalParameter::base_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.base_size) + return _internal_base_size(); +} +inline void ProposalParameter::_internal_set_base_size(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + base_size_ = value; +} +inline void ProposalParameter::set_base_size(uint32_t value) { + _internal_set_base_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.base_size) +} + +// optional uint32 min_size = 3 [default = 16]; +inline bool ProposalParameter::_internal_has_min_size() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ProposalParameter::has_min_size() const { + return _internal_has_min_size(); +} +inline void ProposalParameter::clear_min_size() { + min_size_ = 16u; + _has_bits_[0] &= ~0x00000004u; +} +inline uint32_t ProposalParameter::_internal_min_size() const { + return min_size_; +} +inline uint32_t ProposalParameter::min_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.min_size) + return _internal_min_size(); +} +inline void ProposalParameter::_internal_set_min_size(uint32_t value) { + _has_bits_[0] |= 0x00000004u; + min_size_ = value; +} +inline void ProposalParameter::set_min_size(uint32_t value) { + _internal_set_min_size(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.min_size) +} + +// repeated float ratio = 4; +inline int ProposalParameter::_internal_ratio_size() const { + return ratio_.size(); +} +inline int ProposalParameter::ratio_size() const { + return _internal_ratio_size(); +} +inline void ProposalParameter::clear_ratio() { + ratio_.Clear(); +} +inline float ProposalParameter::_internal_ratio(int index) const { + return ratio_.Get(index); +} +inline float ProposalParameter::ratio(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.ratio) + return _internal_ratio(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::_internal_add_ratio(float value) { + ratio_.Add(value); +} +inline void ProposalParameter::add_ratio(float value) { + _internal_add_ratio(value); + // @@protoc_insertion_point(field_add:opencv_caffe.ProposalParameter.ratio) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +ProposalParameter::_internal_ratio() const { + return ratio_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +ProposalParameter::ratio() const { + // @@protoc_insertion_point(field_list:opencv_caffe.ProposalParameter.ratio) + return _internal_ratio(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +ProposalParameter::_internal_mutable_ratio() { + return &ratio_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +ProposalParameter::mutable_ratio() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ProposalParameter.ratio) + return _internal_mutable_ratio(); +} + +// repeated float scale = 5; +inline int ProposalParameter::_internal_scale_size() const { + return scale_.size(); +} +inline int ProposalParameter::scale_size() const { + return _internal_scale_size(); +} +inline void ProposalParameter::clear_scale() { + scale_.Clear(); +} +inline float ProposalParameter::_internal_scale(int index) const { + return scale_.Get(index); +} +inline float ProposalParameter::scale(int index) const { + // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.scale) + return _internal_scale(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::_internal_add_scale(float value) { + scale_.Add(value); +} +inline void ProposalParameter::add_scale(float value) { + _internal_add_scale(value); + // @@protoc_insertion_point(field_add:opencv_caffe.ProposalParameter.scale) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +ProposalParameter::_internal_scale() const { + return scale_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +ProposalParameter::scale() const { + // @@protoc_insertion_point(field_list:opencv_caffe.ProposalParameter.scale) + return _internal_scale(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +ProposalParameter::_internal_mutable_scale() { + return &scale_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +ProposalParameter::mutable_scale() { + // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ProposalParameter.scale) + return _internal_mutable_scale(); +} + +// optional uint32 pre_nms_topn = 6 [default = 6000]; +inline bool ProposalParameter::_internal_has_pre_nms_topn() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ProposalParameter::has_pre_nms_topn() const { + return _internal_has_pre_nms_topn(); +} +inline void ProposalParameter::clear_pre_nms_topn() { + pre_nms_topn_ = 6000u; + _has_bits_[0] &= ~0x00000008u; +} +inline uint32_t ProposalParameter::_internal_pre_nms_topn() const { + return pre_nms_topn_; +} +inline uint32_t ProposalParameter::pre_nms_topn() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.pre_nms_topn) + return _internal_pre_nms_topn(); +} +inline void ProposalParameter::_internal_set_pre_nms_topn(uint32_t value) { + _has_bits_[0] |= 0x00000008u; + pre_nms_topn_ = value; +} +inline void ProposalParameter::set_pre_nms_topn(uint32_t value) { + _internal_set_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::_internal_has_post_nms_topn() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ProposalParameter::has_post_nms_topn() const { + return _internal_has_post_nms_topn(); +} +inline void ProposalParameter::clear_post_nms_topn() { + post_nms_topn_ = 300u; + _has_bits_[0] &= ~0x00000010u; +} +inline uint32_t ProposalParameter::_internal_post_nms_topn() const { + return post_nms_topn_; +} +inline uint32_t ProposalParameter::post_nms_topn() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.post_nms_topn) + return _internal_post_nms_topn(); +} +inline void ProposalParameter::_internal_set_post_nms_topn(uint32_t value) { + _has_bits_[0] |= 0x00000010u; + post_nms_topn_ = value; +} +inline void ProposalParameter::set_post_nms_topn(uint32_t value) { + _internal_set_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::_internal_has_nms_thresh() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ProposalParameter::has_nms_thresh() const { + return _internal_has_nms_thresh(); +} +inline void ProposalParameter::clear_nms_thresh() { + nms_thresh_ = 0.7f; + _has_bits_[0] &= ~0x00000020u; +} +inline float ProposalParameter::_internal_nms_thresh() const { + return nms_thresh_; +} +inline float ProposalParameter::nms_thresh() const { + // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.nms_thresh) + return _internal_nms_thresh(); +} +inline void ProposalParameter::_internal_set_nms_thresh(float value) { + _has_bits_[0] |= 0x00000020u; + nms_thresh_ = value; +} +inline void ProposalParameter::set_nms_thresh(float value) { + _internal_set_nms_thresh(value); + // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.nms_thresh) +} + +// ------------------------------------------------------------------- + +// PSROIPoolingParameter + +// required float spatial_scale = 1; +inline bool PSROIPoolingParameter::_internal_has_spatial_scale() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PSROIPoolingParameter::has_spatial_scale() const { + return _internal_has_spatial_scale(); +} +inline void PSROIPoolingParameter::clear_spatial_scale() { + spatial_scale_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float PSROIPoolingParameter::_internal_spatial_scale() const { + return spatial_scale_; +} +inline float PSROIPoolingParameter::spatial_scale() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.spatial_scale) + return _internal_spatial_scale(); +} +inline void PSROIPoolingParameter::_internal_set_spatial_scale(float value) { + _has_bits_[0] |= 0x00000001u; + spatial_scale_ = value; +} +inline void PSROIPoolingParameter::set_spatial_scale(float value) { + _internal_set_spatial_scale(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PSROIPoolingParameter.spatial_scale) +} + +// required int32 output_dim = 2; +inline bool PSROIPoolingParameter::_internal_has_output_dim() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PSROIPoolingParameter::has_output_dim() const { + return _internal_has_output_dim(); +} +inline void PSROIPoolingParameter::clear_output_dim() { + output_dim_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t PSROIPoolingParameter::_internal_output_dim() const { + return output_dim_; +} +inline int32_t PSROIPoolingParameter::output_dim() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.output_dim) + return _internal_output_dim(); +} +inline void PSROIPoolingParameter::_internal_set_output_dim(int32_t value) { + _has_bits_[0] |= 0x00000002u; + output_dim_ = value; +} +inline void PSROIPoolingParameter::set_output_dim(int32_t value) { + _internal_set_output_dim(value); + // @@protoc_insertion_point(field_set:opencv_caffe.PSROIPoolingParameter.output_dim) +} + +// required int32 group_size = 3; +inline bool PSROIPoolingParameter::_internal_has_group_size() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PSROIPoolingParameter::has_group_size() const { + return _internal_has_group_size(); +} +inline void PSROIPoolingParameter::clear_group_size() { + group_size_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t PSROIPoolingParameter::_internal_group_size() const { + return group_size_; +} +inline int32_t PSROIPoolingParameter::group_size() const { + // @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.group_size) + return _internal_group_size(); +} +inline void PSROIPoolingParameter::_internal_set_group_size(int32_t value) { + _has_bits_[0] |= 0x00000004u; + group_size_ = value; +} +inline void PSROIPoolingParameter::set_group_size(int32_t value) { + _internal_set_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 + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::opencv_caffe::PriorBoxParameter_CodeType> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::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> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::Type>() { + return ::opencv_caffe::Type_descriptor(); +} +template <> struct is_proto_enum< ::opencv_caffe::Phase> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::Phase>() { + return ::opencv_caffe::Phase_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_opencv_2dcaffe_2eproto diff --git a/modules/dnnlegacy/src/caffe/caffe_importer.cpp b/modules/dnnlegacy/src/caffe/caffe_importer.cpp new file mode 100644 index 00000000000..02ad0d6151c --- /dev/null +++ b/modules/dnnlegacy/src/caffe/caffe_importer.cpp @@ -0,0 +1,619 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" + +#ifdef HAVE_PROTOBUF +#include +#include +#include +#include +#include +#include +#include +#include +#include "caffe_io.hpp" +#endif +#include +#include +#include + +namespace cv { +namespace dnnlegacy { + +#ifdef HAVE_PROTOBUF +using ::google::protobuf::RepeatedFieldRef; +using ::google::protobuf::Message; +using ::google::protobuf::Descriptor; +using ::google::protobuf::FieldDescriptor; +using ::google::protobuf::Reflection; + +using namespace dnn; + +namespace +{ + +template +static cv::String toString(const T &v) +{ + std::ostringstream ss; + ss << v; + return ss.str(); +} + +static inline +MatShape parseBlobShape(const caffe::BlobShape& _input_shape) +{ + MatShape shape; + for (int i = 0; i < _input_shape.dim_size(); i++) + { + shape.push_back((int)_input_shape.dim(i)); + } + return shape; +} + +class CaffeImporter +{ + FPDenormalsIgnoreHintScope fp_denormals_ignore_scope; + + caffe::NetParameter net; + caffe::NetParameter netBinary; + +public: + + CaffeImporter(const char *prototxt, const char *caffeModel) + { + CV_TRACE_FUNCTION(); + + ReadNetParamsFromTextFileOrDie(prototxt, &net); + + if (caffeModel && caffeModel[0]) + ReadNetParamsFromBinaryFileOrDie(caffeModel, &netBinary); + } + + CaffeImporter(const char *dataProto, size_t lenProto, + const char *dataModel, size_t lenModel) + { + CV_TRACE_FUNCTION(); + + ReadNetParamsFromTextBufferOrDie(dataProto, lenProto, &net); + + if (dataModel != NULL && lenModel > 0) + ReadNetParamsFromBinaryBufferOrDie(dataModel, lenModel, &netBinary); + } + + void extractCustomParams(const google::protobuf::UnknownFieldSet& unknownFields, cv::dnn::LayerParams ¶ms) + { + const int numFields = unknownFields.field_count(); + for (int i = 0; i < numFields; ++i) + { + const google::protobuf::UnknownField& field = unknownFields.field(i); + CV_Assert(field.type() == google::protobuf::UnknownField::TYPE_GROUP); + CV_CheckGE(field.group().field_count(), 2, "UnknownField should have at least 2 items: name and value"); + std::string fieldName = field.group().field(0).length_delimited(); + std::string fieldValue = field.group().field(1).length_delimited(); + params.set(fieldName, fieldValue); + } + } + + void addParam(const Message &msg, const FieldDescriptor *field, cv::dnn::LayerParams ¶ms) + { + const Reflection *refl = msg.GetReflection(); + int type = field->cpp_type(); + bool isRepeated = field->is_repeated(); + const std::string &name = field->name(); + + #define SET_UP_FILED(getter, arrayConstr, gtype) \ + if (isRepeated) { \ + const RepeatedFieldRef v = refl->GetRepeatedFieldRef(msg, field); \ + params.set(name, DictValue::arrayConstr(v.begin(), (int)v.size())); \ + } \ + else { \ + params.set(name, refl->getter(msg, field)); \ + } + + switch (type) + { + case FieldDescriptor::CPPTYPE_INT32: + SET_UP_FILED(GetInt32, arrayInt, ::google::protobuf::int32); + break; + case FieldDescriptor::CPPTYPE_UINT32: + SET_UP_FILED(GetUInt32, arrayInt, ::google::protobuf::uint32); + break; + case FieldDescriptor::CPPTYPE_INT64: + SET_UP_FILED(GetInt32, arrayInt, ::google::protobuf::int64); + break; + case FieldDescriptor::CPPTYPE_UINT64: + SET_UP_FILED(GetUInt32, arrayInt, ::google::protobuf::uint64); + break; + case FieldDescriptor::CPPTYPE_BOOL: + SET_UP_FILED(GetBool, arrayInt, bool); + break; + case FieldDescriptor::CPPTYPE_DOUBLE: + SET_UP_FILED(GetDouble, arrayReal, double); + break; + case FieldDescriptor::CPPTYPE_FLOAT: + SET_UP_FILED(GetFloat, arrayReal, float); + break; + case FieldDescriptor::CPPTYPE_STRING: + if (isRepeated) { + const RepeatedFieldRef v = refl->GetRepeatedFieldRef(msg, field); + params.set(name, DictValue::arrayString(v.begin(), (int)v.size())); + } + else { + params.set(name, refl->GetString(msg, field)); + } + break; + case FieldDescriptor::CPPTYPE_ENUM: + if (isRepeated) { + int size = refl->FieldSize(msg, field); + std::vector buf(size); + for (int i = 0; i < size; i++) + buf[i] = refl->GetRepeatedEnum(msg, field, i)->name(); + params.set(name, DictValue::arrayString(buf.begin(), size)); + } + else { + params.set(name, refl->GetEnum(msg, field)->name()); + } + break; + default: + CV_Error(Error::StsError, "Unknown type \"" + String(field->type_name()) + "\" in prototxt"); + } + } + + inline static bool ends_with_param(const std::string &str) + { + static const std::string _param("_param"); + return (str.size() >= _param.size()) && str.compare(str.size() - _param.size(), _param.size(), _param) == 0; + } + + void extractLayerParams(const Message &msg, cv::dnn::LayerParams ¶ms, bool isInternal = false) + { + const Descriptor *msgDesc = msg.GetDescriptor(); + const Reflection *msgRefl = msg.GetReflection(); + + for (int fieldId = 0; fieldId < msgDesc->field_count(); fieldId++) + { + const FieldDescriptor *fd = msgDesc->field(fieldId); + + if (!isInternal && !ends_with_param(fd->name())) + continue; + + const google::protobuf::UnknownFieldSet& unknownFields = msgRefl->GetUnknownFields(msg); + bool hasData = fd->is_required() || + (fd->is_optional() && msgRefl->HasField(msg, fd)) || + (fd->is_repeated() && msgRefl->FieldSize(msg, fd) > 0) || + !unknownFields.empty(); + if (!hasData) + continue; + + extractCustomParams(unknownFields, params); + if (fd->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) + { + if (fd->is_repeated()) //Extract only first item! + extractLayerParams(msgRefl->GetRepeatedMessage(msg, fd, 0), params, true); + else + extractLayerParams(msgRefl->GetMessage(msg, fd), params, true); + } + else + { + addParam(msg, fd, params); + } + } + } + + void blobShapeFromProto(const caffe::BlobProto &pbBlob, MatShape& shape) + { + shape.clear(); + if (pbBlob.has_num() || pbBlob.has_channels() || pbBlob.has_height() || pbBlob.has_width()) + { + shape.push_back(pbBlob.num()); + shape.push_back(pbBlob.channels()); + shape.push_back(pbBlob.height()); + shape.push_back(pbBlob.width()); + } + else if (pbBlob.has_shape()) + { + shape = parseBlobShape(pbBlob.shape()); + } + else + shape.resize(1, 1); // Is a scalar. + } + + void blobFromProto(const caffe::BlobProto &pbBlob, cv::Mat &dstBlob) + { + MatShape shape; + blobShapeFromProto(pbBlob, shape); + + dstBlob.create((int)shape.size(), &shape[0], CV_32F); + if (pbBlob.data_size()) + { + // Single precision floats. + CV_Assert(pbBlob.data_size() == (int)dstBlob.total()); + + CV_DbgAssert(pbBlob.GetDescriptor()->FindFieldByLowercaseName("data")->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT); + Mat(dstBlob.dims, &dstBlob.size[0], CV_32F, (void*)pbBlob.data().data()).copyTo(dstBlob); + } + else + { + CV_Assert(pbBlob.has_raw_data()); + const std::string& raw_data = pbBlob.raw_data(); + if (pbBlob.raw_data_type() == caffe::FLOAT16) + { + // Half precision floats. + CV_Assert(raw_data.size() / 2 == (int)dstBlob.total()); + + Mat halfs((int)shape.size(), &shape[0], CV_16FC1, (void*)raw_data.c_str()); + halfs.convertTo(dstBlob, CV_32F); + } + else if (pbBlob.raw_data_type() == caffe::FLOAT) + { + CV_Assert(raw_data.size() / 4 == (int)dstBlob.total()); + Mat((int)shape.size(), &shape[0], CV_32FC1, (void*)raw_data.c_str()).copyTo(dstBlob); + } + else + CV_Error(Error::StsNotImplemented, "Unexpected blob data type"); + } + } + + void extractBinaryLayerParams(const caffe::LayerParameter& layer, LayerParams& layerParams) + { + const std::string &name = layer.name(); + + int li; + for (li = 0; li != netBinary.layer_size(); li++) + { + const caffe::LayerParameter& binLayer = netBinary.layer(li); + // Break if the layer name is the same and the blobs are not cleared + if (binLayer.name() == name && binLayer.blobs_size() != 0) + break; + } + + if (li == netBinary.layer_size()) + return; + + caffe::LayerParameter* binLayer = netBinary.mutable_layer(li); + const int numBlobs = binLayer->blobs_size(); + std::vector blobs(numBlobs); + binLayer->mutable_blobs()->ExtractSubrange(0, numBlobs, blobs.data()); + layerParams.blobs.resize(numBlobs); + for (int bi = 0; bi < numBlobs; bi++) + { + blobFromProto(*blobs[bi], layerParams.blobs[bi]); + delete blobs[bi]; + } + } + + struct BlobNote + { + BlobNote(const std::string &_name, int _layerId, int _outNum) : + name(_name), layerId(_layerId), outNum(_outNum) {} + + std::string name; + int layerId, outNum; + }; + + std::vector addedBlobs; + std::map layerCounter; + + void populateNet(Net dstNet) + { + CV_TRACE_FUNCTION(); + + int layersSize = net.layer_size(); + layerCounter.clear(); + addedBlobs.clear(); + addedBlobs.reserve(layersSize + 1); + + //setup input layer names + std::vector netInputs(net.input_size()); + std::vector inp_shapes; + { + int net_input_size = net.input_size(); + for (int inNum = 0; inNum < net_input_size; inNum++) + { + addedBlobs.push_back(BlobNote(net.input(inNum), 0, inNum)); + netInputs[inNum] = net.input(inNum); + } + + if (net.input_dim_size() > 0) // deprecated in Caffe proto + { + int net_input_dim_size = net.input_dim_size(); + CV_Check(net_input_dim_size, net_input_dim_size % 4 == 0, ""); + CV_CheckEQ(net_input_dim_size, net_input_size * 4, ""); + for (int inp_id = 0; inp_id < net_input_size; inp_id++) + { + int dim = inp_id * 4; + MatShape shape(4); + shape[0] = net.input_dim(dim); + shape[1] = net.input_dim(dim+1); + shape[2] = net.input_dim(dim+2); + shape[3] = net.input_dim(dim+3); + inp_shapes.push_back(shape); + } + } + else if (net.input_shape_size() > 0) // deprecated in Caffe proto + { + int net_input_shape_size = net.input_shape_size(); + CV_CheckEQ(net_input_shape_size, net_input_size, ""); + for (int inp_id = 0; inp_id < net_input_shape_size; inp_id++) + { + MatShape shape = parseBlobShape(net.input_shape(inp_id)); + inp_shapes.push_back(shape); + } + } + else + { + for (int inp_id = 0; inp_id < net_input_size; inp_id++) + { + MatShape shape; // empty + inp_shapes.push_back(shape); + } + } + } + + for (int li = 0; li < layersSize; li++) + { + const caffe::LayerParameter &layer = net.layer(li); + String name = layer.name(); + String type = layer.type(); + LayerParams layerParams; + + extractLayerParams(layer, layerParams); + extractBinaryLayerParams(layer, layerParams); + + int repetitions = layerCounter[name]++; + if (repetitions) + name += String("_") + toString(repetitions); + + if (type == "Input") + { + for (int outNum = 0; outNum < layer.top_size(); outNum++) + { + addOutput(layer, 0, outNum); + addedBlobs.back().outNum = netInputs.size(); + netInputs.push_back(addedBlobs.back().name); + } + if (layer.has_input_param()) + { + const caffe::InputParameter &inputParameter = layer.input_param(); + int input_shape_size = inputParameter.shape_size(); + CV_CheckEQ(input_shape_size, layer.top_size(), ""); + for (int inp_id = 0; inp_id < input_shape_size; inp_id++) + { + MatShape shape = parseBlobShape(inputParameter.shape(inp_id)); + inp_shapes.push_back(shape); + } + } + continue; + } + else if (type == "BatchNorm") + { + if (!layerParams.get("use_global_stats", true)) + { + CV_Assert_N(layer.bottom_size() == 1, layer.top_size() == 1); + + LayerParams mvnParams; + mvnParams.set("eps", layerParams.get("eps", 1e-5)); + std::string mvnName = name + "/mvn"; + + int repetitions = layerCounter[mvnName]++; + if (repetitions) + mvnName += String("_") + toString(repetitions); + + int mvnId = dstNet.addLayer(mvnName, "MVN", mvnParams); + addInput(layer.bottom(0), mvnId, 0, dstNet); + addOutput(layer, mvnId, 0); + net.mutable_layer(li)->set_bottom(0, layer.top(0)); + layerParams.blobs[0].setTo(0); // mean + layerParams.blobs[1].setTo(1); // std + } + } + else if (type == "Axpy") + { + CV_Assert_N(layer.bottom_size() == 3, layer.top_size() == 1); + + std::string scaleName = name + "/scale"; + int repetitions = layerCounter[scaleName]++; + if (repetitions) { + scaleName += String("_") + toString(repetitions); + } + + LayerParams scaleParams; + scaleParams.set("axis", 1); + scaleParams.set("has_bias", false); + int scaleId = dstNet.addLayer(scaleName, "Scale", scaleParams); + addInput(layer.bottom(2), scaleId, 0, dstNet); + addInput(layer.bottom(0), scaleId, 1, dstNet); + addOutput(layer, scaleId, 0); + net.mutable_layer(li)->set_bottom(0, layer.top(0)); + net.mutable_layer(li)->mutable_bottom()->RemoveLast(); + type = "Eltwise"; + } + else if (type == "Resample") + { + CV_Assert(layer.bottom_size() == 1 || layer.bottom_size() == 2); + type = "Resize"; + String interp = toLowerCase(layerParams.get("type")); + layerParams.set("interpolation", interp == "linear" ? "bilinear" : interp); + + if (layerParams.has("factor")) + { + float factor = layerParams.get("factor"); + CV_Assert(layer.bottom_size() != 2 || factor == 1.0); + layerParams.set("zoom_factor", factor); + + if ((interp == "linear" && factor != 1.0) || + (interp == "nearest" && factor < 1.0)) + CV_Error(Error::StsNotImplemented, "Unsupported Resample mode"); + } + } + else if ("Convolution" == type) + { + CV_Assert(layer.bottom_size() == layer.top_size()); + for (int i = 0; i < layer.bottom_size(); i++) + { + int conv_id = dstNet.addLayer(layer.top(i), type, layerParams); + addInput(layer.bottom(i), conv_id, 0, dstNet); + addedBlobs.push_back(BlobNote(layer.top(i), conv_id, 0)); + } + continue; + } + else if ("ConvolutionDepthwise" == type) + { + type = "Convolution"; + } + else if (type == "Softmax"){ + // set default axis to 1 + if(!layerParams.has("axis")) + layerParams.set("axis", 1); + } + + int id = dstNet.addLayer(name, type, layerParams); + + for (int inNum = 0; inNum < layer.bottom_size(); inNum++) + addInput(layer.bottom(inNum), id, inNum, dstNet); + + for (int outNum = 0; outNum < layer.top_size(); outNum++) + addOutput(layer, id, outNum); + } + dstNet.setInputsNames(netInputs); + + if (inp_shapes.size() > 0) + { + CV_CheckEQ(inp_shapes.size(), netInputs.size(), ""); + for (int inp_id = 0; inp_id < inp_shapes.size(); inp_id++) + dstNet.setInputShape(netInputs[inp_id], inp_shapes[inp_id]); + } + + addedBlobs.clear(); + } + + void addOutput(const caffe::LayerParameter &layer, int layerId, int outNum) + { + const std::string &name = layer.top(outNum); + + bool haveDups = false; + for (int idx = (int)addedBlobs.size() - 1; idx >= 0; idx--) + { + if (addedBlobs[idx].name == name) + { + haveDups = true; + break; + } + } + + if (haveDups) + { + bool isInplace = layer.bottom_size() > outNum && layer.bottom(outNum) == name; + if (!isInplace) + CV_Error(Error::StsBadArg, "Duplicate blobs produced by multiple sources"); + } + + addedBlobs.push_back(BlobNote(name, layerId, outNum)); + } + + void addInput(const std::string &name, int layerId, int inNum, Net &dstNet) + { + int idx; + for (idx = (int)addedBlobs.size() - 1; idx >= 0; idx--) + { + if (addedBlobs[idx].name == name) + break; + } + + if (idx < 0) + { + CV_Error(Error::StsObjectNotFound, "Can't find output blob \"" + name + "\""); + } + + dstNet.connect(addedBlobs[idx].layerId, addedBlobs[idx].outNum, layerId, inNum); + } +}; + +} + +Net readNetFromCaffe(const String &prototxt, const String &caffeModel /*= String()*/) +{ + CaffeImporter caffeImporter(prototxt.c_str(), caffeModel.c_str()); + Net net; + caffeImporter.populateNet(net); + return net; +} + +Net readNetFromCaffe(const char *bufferProto, size_t lenProto, + const char *bufferModel, size_t lenModel) +{ + CaffeImporter caffeImporter(bufferProto, lenProto, bufferModel, lenModel); + Net net; + caffeImporter.populateNet(net); + return net; +} + +Net readNetFromCaffe(const std::vector& bufferProto, const std::vector& bufferModel) +{ + const char* bufferProtoPtr = reinterpret_cast(&bufferProto[0]); + const char* bufferModelPtr = bufferModel.empty() ? NULL : + reinterpret_cast(&bufferModel[0]); + return readNetFromCaffe(bufferProtoPtr, bufferProto.size(), + bufferModelPtr, bufferModel.size()); +} + +#else // HAVE_PROTOBUF + +#define DNN_PROTOBUF_UNSUPPORTED() CV_Error(Error::StsError, "DNN/Caffe: Build OpenCV with Protobuf to import Caffe models") + +Net readNetFromCaffe(const String &, const String &) { + DNN_PROTOBUF_UNSUPPORTED(); +} + +Net readNetFromCaffe(const char *, size_t, const char *, size_t) { + DNN_PROTOBUF_UNSUPPORTED(); +} + +Net readNetFromCaffe(const std::vector&, const std::vector&) { + DNN_PROTOBUF_UNSUPPORTED(); +} + +#endif // HAVE_PROTOBUF + + +}} // namespace diff --git a/modules/dnnlegacy/src/caffe/caffe_io.cpp b/modules/dnnlegacy/src/caffe/caffe_io.cpp new file mode 100644 index 00000000000..cdb8c751c6d --- /dev/null +++ b/modules/dnnlegacy/src/caffe/caffe_io.cpp @@ -0,0 +1,1254 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +/*M/////////////////////////////////////////////////////////////////////////////////////// +//COPYRIGHT +// +//All contributions by the University of California: +//Copyright (c) 2014, The Regents of the University of California (Regents) +//All rights reserved. +// +//All other contributions: +//Copyright (c) 2014, the respective contributors +//All rights reserved. +// +//Caffe uses a shared copyright model: each contributor holds copyright over +//their contributions to Caffe. The project versioning records all such +//contribution and copyright details. If a contributor wants to further mark +//their specific copyright on a particular contribution, they should indicate +//their copyright solely in the commit message of the change when it is +//committed. +// +//LICENSE +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions are met: +// +//1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +//2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//CONTRIBUTION AGREEMENT +// +//By contributing to the BVLC/caffe repository through pull-request, comment, +//or otherwise, the contributor releases their content to the +//license and copyright terms herein. +// +//M*/ + + +#ifdef HAVE_PROTOBUF +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + +#include "caffe_io.hpp" + + +#include +#include +#include + +#define CHECK(cond) for(cv::dnnlegacy::GLogWrapper _logger(__FILE__, CV_Func, __LINE__, "CHECK", #cond, cond); _logger.exit(); _logger.check()) _logger.stream() +#define CHECK_EQ(a, b) for(cv::dnnlegacy::GLogWrapper _logger(__FILE__, CV_Func, __LINE__, "CHECK", #a"="#b, ((a) == (b))); _logger.exit(); _logger.check()) _logger.stream() +#define LOG(TYPE) for(cv::dnnlegacy::GLogWrapper _logger(__FILE__, CV_Func, __LINE__, #TYPE); _logger.exit(); _logger.check()) _logger.stream() + +namespace cv +{ + namespace dnnlegacy + { + + class GLogWrapper + { + const char* file, * func, * type, * cond_str; + int line; + bool cond_status, exit_loop; + std::stringstream sstream; + + public: + + GLogWrapper(const char* _file, const char* _func, int _line, + const char* _type, + const char* _cond_str = NULL, bool _cond_status = true + ) : + file(_file), func(_func), type(_type), cond_str(_cond_str), + line(_line), cond_status(_cond_status), exit_loop(true) {} + + std::iostream& stream() + { + return sstream; + } + + bool exit() + { + return exit_loop; + } + + void check() + { + exit_loop = false; + + if (cond_str && !cond_status) + { + cv::error(cv::Error::StsError, "FAILED: " + String(cond_str) + ". " + sstream.str(), func, file, line); + } + else if (!cond_str && strcmp(type, "CHECK")) + { +#ifndef NDEBUG + if (!std::strcmp(type, "INFO")) + std::cout << sstream.str() << std::endl; + else + std::cerr << sstream.str() << std::endl; +#endif + } + } + }; + } +} + + + +namespace cv { +namespace dnnlegacy { + +using std::string; +using std::map; +using namespace caffe; +using namespace ::google::protobuf; +using namespace ::google::protobuf::io; + +// Return true iff the net is not the current version. +bool NetNeedsUpgrade(const NetParameter& net_param); + +// Return true iff any layer contains parameters specified using +// deprecated V0LayerParameter. +bool NetNeedsV0ToV1Upgrade(const NetParameter& net_param); + +// Perform all necessary transformations to upgrade a V0NetParameter into a +// NetParameter (including upgrading padding layers and LayerParameters). +bool UpgradeV0Net(const NetParameter& v0_net_param, NetParameter* net_param); + +// Upgrade NetParameter with padding layers to pad-aware conv layers. +// For any padding layer, remove it and put its pad parameter in any layers +// taking its top blob as input. +// Error if any of these above layers are not-conv layers. +void UpgradeV0PaddingLayers(const NetParameter& param, + NetParameter* param_upgraded_pad); + +// Upgrade a single V0LayerConnection to the V1LayerParameter format. +bool UpgradeV0LayerParameter(V1LayerParameter* v0_layer_connection, + V1LayerParameter* layer_param); + +V1LayerParameter_LayerType UpgradeV0LayerType(const string& type); + +// Return true iff any layer contains deprecated data transformation parameters. +bool NetNeedsDataUpgrade(const NetParameter& net_param); + +// Perform all necessary transformations to upgrade old transformation fields +// into a TransformationParameter. +void UpgradeNetDataTransformation(NetParameter* net_param); + +// Return true iff the Net contains any layers specified as V1LayerParameters. +bool NetNeedsV1ToV2Upgrade(const NetParameter& net_param); + +// Perform all necessary transformations to upgrade a NetParameter with +// deprecated V1LayerParameters. +bool UpgradeV1Net(NetParameter* net_param); + +bool UpgradeV1LayerParameter(V1LayerParameter* v1_layer_param, + LayerParameter* layer_param); + +const char* UpgradeV1LayerType(const V1LayerParameter_LayerType type); + +bool NetNeedsBatchNormUpgrade(const NetParameter& net_param); + +void UpgradeNetBatchNorm(NetParameter* net_param); + +// Check for deprecations and upgrade the NetParameter as needed. +bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param); + + +bool NetNeedsUpgrade(const NetParameter& net_param) { + return NetNeedsV0ToV1Upgrade(net_param) || NetNeedsV1ToV2Upgrade(net_param) || + NetNeedsBatchNormUpgrade(net_param); +} + +bool NetNeedsV0ToV1Upgrade(const NetParameter& net_param) { + for (int i = 0; i < net_param.layers_size(); ++i) { + if (net_param.layers(i).has_layer()) { + return true; + } + } + return false; +} + +bool NetNeedsV1ToV2Upgrade(const NetParameter& net_param) { + return net_param.layers_size() > 0; +} + +bool UpgradeV0Net(const NetParameter& v0_net_param_padding_layers, + NetParameter* net_param) { + // First upgrade padding layers to padded conv layers. + NetParameter v0_net_param; + UpgradeV0PaddingLayers(v0_net_param_padding_layers, &v0_net_param); + // Now upgrade layer parameters. + bool is_fully_compatible = true; + net_param->Clear(); + if (v0_net_param.has_name()) { + net_param->set_name(v0_net_param.name()); + } + for (int i = 0; i < v0_net_param.layers_size(); ++i) { + is_fully_compatible &= UpgradeV0LayerParameter(v0_net_param.mutable_layers(i), + net_param->add_layers()); + } + for (int i = 0; i < v0_net_param.input_size(); ++i) { + net_param->add_input(v0_net_param.input(i)); + } + for (int i = 0; i < v0_net_param.input_dim_size(); ++i) { + net_param->add_input_dim(v0_net_param.input_dim(i)); + } + if (v0_net_param.has_force_backward()) { + net_param->set_force_backward(v0_net_param.force_backward()); + } + return is_fully_compatible; +} + +void UpgradeV0PaddingLayers(const NetParameter& param, + NetParameter* param_upgraded_pad) { + // Copy everything other than the layers from the original param. + param_upgraded_pad->Clear(); + param_upgraded_pad->CopyFrom(param); + param_upgraded_pad->clear_layers(); + // Figure out which layer each bottom blob comes from. + map blob_name_to_last_top_idx; + for (int i = 0; i < param.input_size(); ++i) { + const string& blob_name = param.input(i); + blob_name_to_last_top_idx[blob_name] = -1; + } + for (int i = 0; i < param.layers_size(); ++i) { + const V1LayerParameter& layer_connection = param.layers(i); + const V0LayerParameter& layer_param = layer_connection.layer(); + // Add the layer to the new net, unless it's a padding layer. + if (layer_param.type() != "padding") { + param_upgraded_pad->add_layers()->CopyFrom(layer_connection); + } + for (int j = 0; j < layer_connection.bottom_size(); ++j) { + const string& blob_name = layer_connection.bottom(j); + if (blob_name_to_last_top_idx.find(blob_name) == + blob_name_to_last_top_idx.end()) { + LOG(FATAL) << "Unknown blob input " << blob_name << " to layer " << j; + } + const int top_idx = blob_name_to_last_top_idx[blob_name]; + if (top_idx == -1) { + continue; + } + const V1LayerParameter& source_layer = param.layers(top_idx); + if (source_layer.layer().type() == "padding") { + // This layer has a padding layer as input -- check that it is a conv + // layer or a pooling layer and takes only one input. Also check that + // the padding layer input has only one input and one output. Other + // cases have undefined behavior in Caffe. + CHECK((layer_param.type() == "conv") || (layer_param.type() == "pool")) + << "Padding layer input to " + "non-convolutional / non-pooling layer type " + << layer_param.type(); + CHECK_EQ(layer_connection.bottom_size(), 1) + << "Conv Layer takes a single blob as input."; + CHECK_EQ(source_layer.bottom_size(), 1) + << "Padding Layer takes a single blob as input."; + CHECK_EQ(source_layer.top_size(), 1) + << "Padding Layer produces a single blob as output."; + int layer_index = param_upgraded_pad->layers_size() - 1; + param_upgraded_pad->mutable_layers(layer_index)->mutable_layer() + ->set_pad(source_layer.layer().pad()); + param_upgraded_pad->mutable_layers(layer_index) + ->set_bottom(j, source_layer.bottom(0)); + } + } + for (int j = 0; j < layer_connection.top_size(); ++j) { + const string& blob_name = layer_connection.top(j); + blob_name_to_last_top_idx[blob_name] = i; + } + } +} + +bool UpgradeV0LayerParameter(V1LayerParameter* v0_layer_connection_, + V1LayerParameter* layer_param) { + CV_Assert(v0_layer_connection_ != NULL); + const V1LayerParameter& v0_layer_connection = *v0_layer_connection_; + bool is_fully_compatible = true; + layer_param->Clear(); + for (int i = 0; i < v0_layer_connection.bottom_size(); ++i) { + layer_param->add_bottom(v0_layer_connection.bottom(i)); + } + for (int i = 0; i < v0_layer_connection.top_size(); ++i) { + layer_param->add_top(v0_layer_connection.top(i)); + } + if (v0_layer_connection.has_layer()) { + const V0LayerParameter& v0_layer_param = v0_layer_connection.layer(); + if (v0_layer_param.has_name()) { + layer_param->set_name(v0_layer_param.name()); + } + const string& type = v0_layer_param.type(); + if (v0_layer_param.has_type()) { + layer_param->set_type(UpgradeV0LayerType(type)); + } + layer_param->mutable_blobs()->Swap(v0_layer_connection_->mutable_blobs()); + for (int i = 0; i < v0_layer_param.blobs_lr_size(); ++i) { + layer_param->add_blobs_lr(v0_layer_param.blobs_lr(i)); + } + for (int i = 0; i < v0_layer_param.weight_decay_size(); ++i) { + layer_param->add_weight_decay(v0_layer_param.weight_decay(i)); + } + if (v0_layer_param.has_num_output()) { + if (type == "conv") { + layer_param->mutable_convolution_param()->set_num_output( + v0_layer_param.num_output()); + } else if (type == "innerproduct") { + layer_param->mutable_inner_product_param()->set_num_output( + v0_layer_param.num_output()); + } else { + LOG(ERROR) << "Unknown parameter num_output for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_biasterm()) { + if (type == "conv") { + layer_param->mutable_convolution_param()->set_bias_term( + v0_layer_param.biasterm()); + } else if (type == "innerproduct") { + layer_param->mutable_inner_product_param()->set_bias_term( + v0_layer_param.biasterm()); + } else { + LOG(ERROR) << "Unknown parameter biasterm for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_weight_filler()) { + if (type == "conv") { + layer_param->mutable_convolution_param()-> + mutable_weight_filler()->CopyFrom(v0_layer_param.weight_filler()); + } else if (type == "innerproduct") { + layer_param->mutable_inner_product_param()-> + mutable_weight_filler()->CopyFrom(v0_layer_param.weight_filler()); + } else { + LOG(ERROR) << "Unknown parameter weight_filler for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_bias_filler()) { + if (type == "conv") { + layer_param->mutable_convolution_param()-> + mutable_bias_filler()->CopyFrom(v0_layer_param.bias_filler()); + } else if (type == "innerproduct") { + layer_param->mutable_inner_product_param()-> + mutable_bias_filler()->CopyFrom(v0_layer_param.bias_filler()); + } else { + LOG(ERROR) << "Unknown parameter bias_filler for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_pad()) { + if (type == "conv") { + layer_param->mutable_convolution_param()->add_pad(v0_layer_param.pad()); + } else if (type == "pool") { + layer_param->mutable_pooling_param()->set_pad(v0_layer_param.pad()); + } else { + LOG(ERROR) << "Unknown parameter pad for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_kernelsize()) { + if (type == "conv") { + layer_param->mutable_convolution_param()->add_kernel_size( + v0_layer_param.kernelsize()); + } else if (type == "pool") { + layer_param->mutable_pooling_param()->set_kernel_size( + v0_layer_param.kernelsize()); + } else { + LOG(ERROR) << "Unknown parameter kernelsize for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_group()) { + if (type == "conv") { + layer_param->mutable_convolution_param()->set_group( + v0_layer_param.group()); + } else { + LOG(ERROR) << "Unknown parameter group for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_stride()) { + if (type == "conv") { + layer_param->mutable_convolution_param()->add_stride( + v0_layer_param.stride()); + } else if (type == "pool") { + layer_param->mutable_pooling_param()->set_stride( + v0_layer_param.stride()); + } else { + LOG(ERROR) << "Unknown parameter stride for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_pool()) { + if (type == "pool") { + V0LayerParameter_PoolMethod pool = v0_layer_param.pool(); + switch (pool) { + case V0LayerParameter_PoolMethod_MAX: + layer_param->mutable_pooling_param()->set_pool( + PoolingParameter_PoolMethod_MAX); + break; + case V0LayerParameter_PoolMethod_AVE: + layer_param->mutable_pooling_param()->set_pool( + PoolingParameter_PoolMethod_AVE); + break; + case V0LayerParameter_PoolMethod_STOCHASTIC: + layer_param->mutable_pooling_param()->set_pool( + PoolingParameter_PoolMethod_STOCHASTIC); + break; + default: + LOG(ERROR) << "Unknown pool method " << (int)pool; + is_fully_compatible = false; + } + } else { + LOG(ERROR) << "Unknown parameter pool for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_dropout_ratio()) { + if (type == "dropout") { + layer_param->mutable_dropout_param()->set_dropout_ratio( + v0_layer_param.dropout_ratio()); + } else { + LOG(ERROR) << "Unknown parameter dropout_ratio for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_local_size()) { + if (type == "lrn") { + layer_param->mutable_lrn_param()->set_local_size( + v0_layer_param.local_size()); + } else { + LOG(ERROR) << "Unknown parameter local_size for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_alpha()) { + if (type == "lrn") { + layer_param->mutable_lrn_param()->set_alpha(v0_layer_param.alpha()); + } else { + LOG(ERROR) << "Unknown parameter alpha for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_beta()) { + if (type == "lrn") { + layer_param->mutable_lrn_param()->set_beta(v0_layer_param.beta()); + } else { + LOG(ERROR) << "Unknown parameter beta for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_k()) { + if (type == "lrn") { + layer_param->mutable_lrn_param()->set_k(v0_layer_param.k()); + } else { + LOG(ERROR) << "Unknown parameter k for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_source()) { + if (type == "data") { + layer_param->mutable_data_param()->set_source(v0_layer_param.source()); + } else if (type == "hdf5_data") { + layer_param->mutable_hdf5_data_param()->set_source( + v0_layer_param.source()); + } else if (type == "images") { + layer_param->mutable_image_data_param()->set_source( + v0_layer_param.source()); + } else if (type == "window_data") { + layer_param->mutable_window_data_param()->set_source( + v0_layer_param.source()); + } else if (type == "infogain_loss") { + layer_param->mutable_infogain_loss_param()->set_source( + v0_layer_param.source()); + } else { + LOG(ERROR) << "Unknown parameter source for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_scale()) { + layer_param->mutable_transform_param()-> + set_scale(v0_layer_param.scale()); + } + if (v0_layer_param.has_meanfile()) { + layer_param->mutable_transform_param()-> + set_mean_file(v0_layer_param.meanfile()); + } + if (v0_layer_param.has_batchsize()) { + if (type == "data") { + layer_param->mutable_data_param()->set_batch_size( + v0_layer_param.batchsize()); + } else if (type == "hdf5_data") { + layer_param->mutable_hdf5_data_param()->set_batch_size( + v0_layer_param.batchsize()); + } else if (type == "images") { + layer_param->mutable_image_data_param()->set_batch_size( + v0_layer_param.batchsize()); + } else if (type == "window_data") { + layer_param->mutable_window_data_param()->set_batch_size( + v0_layer_param.batchsize()); + } else { + LOG(ERROR) << "Unknown parameter batchsize for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_cropsize()) { + layer_param->mutable_transform_param()-> + set_crop_size(v0_layer_param.cropsize()); + } + if (v0_layer_param.has_mirror()) { + layer_param->mutable_transform_param()-> + set_mirror(v0_layer_param.mirror()); + } + if (v0_layer_param.has_rand_skip()) { + if (type == "data") { + layer_param->mutable_data_param()->set_rand_skip( + v0_layer_param.rand_skip()); + } else if (type == "images") { + layer_param->mutable_image_data_param()->set_rand_skip( + v0_layer_param.rand_skip()); + } else { + LOG(ERROR) << "Unknown parameter rand_skip for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_shuffle_images()) { + if (type == "images") { + layer_param->mutable_image_data_param()->set_shuffle( + v0_layer_param.shuffle_images()); + } else { + LOG(ERROR) << "Unknown parameter shuffle for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_new_height()) { + if (type == "images") { + layer_param->mutable_image_data_param()->set_new_height( + v0_layer_param.new_height()); + } else { + LOG(ERROR) << "Unknown parameter new_height for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_new_width()) { + if (type == "images") { + layer_param->mutable_image_data_param()->set_new_width( + v0_layer_param.new_width()); + } else { + LOG(ERROR) << "Unknown parameter new_width for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_concat_dim()) { + if (type == "concat") { + layer_param->mutable_concat_param()->set_concat_dim( + v0_layer_param.concat_dim()); + } else { + LOG(ERROR) << "Unknown parameter concat_dim for layer type " << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_det_fg_threshold()) { + if (type == "window_data") { + layer_param->mutable_window_data_param()->set_fg_threshold( + v0_layer_param.det_fg_threshold()); + } else { + LOG(ERROR) << "Unknown parameter det_fg_threshold for layer type " + << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_det_bg_threshold()) { + if (type == "window_data") { + layer_param->mutable_window_data_param()->set_bg_threshold( + v0_layer_param.det_bg_threshold()); + } else { + LOG(ERROR) << "Unknown parameter det_bg_threshold for layer type " + << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_det_fg_fraction()) { + if (type == "window_data") { + layer_param->mutable_window_data_param()->set_fg_fraction( + v0_layer_param.det_fg_fraction()); + } else { + LOG(ERROR) << "Unknown parameter det_fg_fraction for layer type " + << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_det_context_pad()) { + if (type == "window_data") { + layer_param->mutable_window_data_param()->set_context_pad( + v0_layer_param.det_context_pad()); + } else { + LOG(ERROR) << "Unknown parameter det_context_pad for layer type " + << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_det_crop_mode()) { + if (type == "window_data") { + layer_param->mutable_window_data_param()->set_crop_mode( + v0_layer_param.det_crop_mode()); + } else { + LOG(ERROR) << "Unknown parameter det_crop_mode for layer type " + << type; + is_fully_compatible = false; + } + } + if (v0_layer_param.has_hdf5_output_param()) { + if (type == "hdf5_output") { + layer_param->mutable_hdf5_output_param()->CopyFrom( + v0_layer_param.hdf5_output_param()); + } else { + LOG(ERROR) << "Unknown parameter hdf5_output_param for layer type " + << type; + is_fully_compatible = false; + } + } + } + return is_fully_compatible; +} + +V1LayerParameter_LayerType UpgradeV0LayerType(const string& type) { + if (type == "accuracy") { + return V1LayerParameter_LayerType_ACCURACY; + } else if (type == "bnll") { + return V1LayerParameter_LayerType_BNLL; + } else if (type == "concat") { + return V1LayerParameter_LayerType_CONCAT; + } else if (type == "conv") { + return V1LayerParameter_LayerType_CONVOLUTION; + } else if (type == "data") { + return V1LayerParameter_LayerType_DATA; + } else if (type == "dropout") { + return V1LayerParameter_LayerType_DROPOUT; + } else if (type == "euclidean_loss") { + return V1LayerParameter_LayerType_EUCLIDEAN_LOSS; + } else if (type == "flatten") { + return V1LayerParameter_LayerType_FLATTEN; + } else if (type == "hdf5_data") { + return V1LayerParameter_LayerType_HDF5_DATA; + } else if (type == "hdf5_output") { + return V1LayerParameter_LayerType_HDF5_OUTPUT; + } else if (type == "im2col") { + return V1LayerParameter_LayerType_IM2COL; + } else if (type == "images") { + return V1LayerParameter_LayerType_IMAGE_DATA; + } else if (type == "infogain_loss") { + return V1LayerParameter_LayerType_INFOGAIN_LOSS; + } else if (type == "innerproduct") { + return V1LayerParameter_LayerType_INNER_PRODUCT; + } else if (type == "lrn") { + return V1LayerParameter_LayerType_LRN; + } else if (type == "multinomial_logistic_loss") { + return V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS; + } else if (type == "pool") { + return V1LayerParameter_LayerType_POOLING; + } else if (type == "relu") { + return V1LayerParameter_LayerType_RELU; + } else if (type == "sigmoid") { + return V1LayerParameter_LayerType_SIGMOID; + } else if (type == "softmax") { + return V1LayerParameter_LayerType_SOFTMAX; + } else if (type == "softmax_loss") { + return V1LayerParameter_LayerType_SOFTMAX_LOSS; + } else if (type == "split") { + return V1LayerParameter_LayerType_SPLIT; + } else if (type == "tanh") { + return V1LayerParameter_LayerType_TANH; + } else if (type == "window_data") { + return V1LayerParameter_LayerType_WINDOW_DATA; + } else { + LOG(FATAL) << "Unknown layer name: " << type; + return V1LayerParameter_LayerType_NONE; + } +} + +bool NetNeedsDataUpgrade(const NetParameter& net_param) { + for (int i = 0; i < net_param.layers_size(); ++i) { + if (net_param.layers(i).type() == V1LayerParameter_LayerType_DATA) { + DataParameter layer_param = net_param.layers(i).data_param(); + if (layer_param.has_scale()) { return true; } + if (layer_param.has_mean_file()) { return true; } + if (layer_param.has_crop_size()) { return true; } + if (layer_param.has_mirror()) { return true; } + } + if (net_param.layers(i).type() == V1LayerParameter_LayerType_IMAGE_DATA) { + ImageDataParameter layer_param = net_param.layers(i).image_data_param(); + if (layer_param.has_scale()) { return true; } + if (layer_param.has_mean_file()) { return true; } + if (layer_param.has_crop_size()) { return true; } + if (layer_param.has_mirror()) { return true; } + } + if (net_param.layers(i).type() == V1LayerParameter_LayerType_WINDOW_DATA) { + WindowDataParameter layer_param = net_param.layers(i).window_data_param(); + if (layer_param.has_scale()) { return true; } + if (layer_param.has_mean_file()) { return true; } + if (layer_param.has_crop_size()) { return true; } + if (layer_param.has_mirror()) { return true; } + } + } + return false; +} + +#define CONVERT_LAYER_TRANSFORM_PARAM(TYPE, Name, param_name) \ + do { \ + if (net_param->layers(i).type() == V1LayerParameter_LayerType_##TYPE) { \ + Name##Parameter* layer_param = \ + net_param->mutable_layers(i)->mutable_##param_name##_param(); \ + TransformationParameter* transform_param = \ + net_param->mutable_layers(i)->mutable_transform_param(); \ + if (layer_param->has_scale()) { \ + transform_param->set_scale(layer_param->scale()); \ + layer_param->clear_scale(); \ + } \ + if (layer_param->has_mean_file()) { \ + transform_param->set_mean_file(layer_param->mean_file()); \ + layer_param->clear_mean_file(); \ + } \ + if (layer_param->has_crop_size()) { \ + transform_param->set_crop_size(layer_param->crop_size()); \ + layer_param->clear_crop_size(); \ + } \ + if (layer_param->has_mirror()) { \ + transform_param->set_mirror(layer_param->mirror()); \ + layer_param->clear_mirror(); \ + } \ + } \ + } while (0) + +void UpgradeNetDataTransformation(NetParameter* net_param) { + for (int i = 0; i < net_param->layers_size(); ++i) { + CONVERT_LAYER_TRANSFORM_PARAM(DATA, Data, data); + CONVERT_LAYER_TRANSFORM_PARAM(IMAGE_DATA, ImageData, image_data); + CONVERT_LAYER_TRANSFORM_PARAM(WINDOW_DATA, WindowData, window_data); + } +} + +bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param) { + bool success = true; + if (NetNeedsV0ToV1Upgrade(*param)) { + // NetParameter was specified using the old style (V0LayerParameter); try to + // upgrade it. + LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " + << "V0LayerParameter: " << param_file; + NetParameter original_param(*param); + if (!UpgradeV0Net(original_param, param)) { + success = false; + LOG(ERROR) << "Warning: had one or more problems upgrading " + << "V0NetParameter to NetParameter (see above); continuing anyway."; + } else { + LOG(INFO) << "Successfully upgraded file specified using deprecated " + << "V0LayerParameter"; + } + LOG(ERROR) << "Note that future Caffe releases will not support " + << "V0NetParameter; use ./build/tools/upgrade_net_proto_text for " + << "prototxt and ./build/tools/upgrade_net_proto_binary for model " + << "weights upgrade this and any other net protos to the new format."; + } + // NetParameter uses old style data transformation fields; try to upgrade it. + if (NetNeedsDataUpgrade(*param)) { + LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " + << "transformation parameters: " << param_file; + UpgradeNetDataTransformation(param); + LOG(INFO) << "Successfully upgraded file specified using deprecated " + << "data transformation parameters."; + LOG(ERROR) << "Note that future Caffe releases will only support " + << "transform_param messages for transformation fields."; + } + if (NetNeedsV1ToV2Upgrade(*param)) { + LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " + << "V1LayerParameter: " << param_file; + if (!UpgradeV1Net(param)) { + success = false; + LOG(ERROR) << "Warning: had one or more problems upgrading " + << "V1LayerParameter (see above); continuing anyway."; + } else { + LOG(INFO) << "Successfully upgraded file specified using deprecated " + << "V1LayerParameter"; + } + } + // NetParameter uses old style batch norm layers; try to upgrade it. + if (NetNeedsBatchNormUpgrade(*param)) { + LOG(INFO) << "Attempting to upgrade batch norm layers using deprecated " + << "params: " << param_file; + UpgradeNetBatchNorm(param); + LOG(INFO) << "Successfully upgraded batch norm layers using deprecated " + << "params."; + } + return success; +} + +bool UpgradeV1Net(NetParameter* net_param) { + // V1LayerParameter layers -> LayerParameter layer + CV_Assert(net_param != NULL); + bool is_fully_compatible = true; + if (net_param->layer_size() > 0) { + LOG(ERROR) << "Input NetParameter to be upgraded already specifies 'layer' " + << "fields; these will be ignored for the upgrade."; + is_fully_compatible = false; + } + net_param->clear_layer(); + for (int i = 0; i < net_param->layers_size(); ++i) { + if (!UpgradeV1LayerParameter(net_param->mutable_layers(i), + net_param->add_layer())) { + LOG(ERROR) << "Upgrade of input layer " << i << " failed."; + is_fully_compatible = false; + } + } + net_param->clear_layers(); + return is_fully_compatible; +} + +bool NetNeedsBatchNormUpgrade(const NetParameter& net_param) { + for (int i = 0; i < net_param.layer_size(); ++i) { + // Check if BatchNorm layers declare three parameters, as required by + // the previous BatchNorm layer definition. + if (net_param.layer(i).type() == "BatchNorm" + && net_param.layer(i).param_size() == 3) { + return true; + } + } + return false; +} + +void UpgradeNetBatchNorm(NetParameter* net_param) { + for (int i = 0; i < net_param->layer_size(); ++i) { + // Check if BatchNorm layers declare three parameters, as required by + // the previous BatchNorm layer definition. + if (net_param->layer(i).type() == "BatchNorm" + && net_param->layer(i).param_size() == 3) { + net_param->mutable_layer(i)->clear_param(); + } + } +} + +bool UpgradeV1LayerParameter(V1LayerParameter* v1_layer_param_, + LayerParameter* layer_param) { + CV_Assert(v1_layer_param_ != NULL); + const V1LayerParameter& v1_layer_param = *v1_layer_param_; + layer_param->Clear(); + bool is_fully_compatible = true; + for (int i = 0; i < v1_layer_param.bottom_size(); ++i) { + layer_param->add_bottom(v1_layer_param.bottom(i)); + } + for (int i = 0; i < v1_layer_param.top_size(); ++i) { + layer_param->add_top(v1_layer_param.top(i)); + } + if (v1_layer_param.has_name()) { + layer_param->set_name(v1_layer_param.name()); + } + for (int i = 0; i < v1_layer_param.include_size(); ++i) { + layer_param->add_include()->CopyFrom(v1_layer_param.include(i)); + } + for (int i = 0; i < v1_layer_param.exclude_size(); ++i) { + layer_param->add_exclude()->CopyFrom(v1_layer_param.exclude(i)); + } + if (v1_layer_param.has_type()) { + layer_param->set_type(UpgradeV1LayerType(v1_layer_param.type())); + } + layer_param->mutable_blobs()->Swap(v1_layer_param_->mutable_blobs()); + for (int i = 0; i < v1_layer_param.param_size(); ++i) { + while (layer_param->param_size() <= i) { layer_param->add_param(); } + layer_param->mutable_param(i)->set_name(v1_layer_param.param(i)); + } + ParamSpec_DimCheckMode mode = ParamSpec_DimCheckMode_STRICT; + for (int i = 0; i < v1_layer_param.blob_share_mode_size(); ++i) { + while (layer_param->param_size() <= i) { layer_param->add_param(); } + switch (v1_layer_param.blob_share_mode(i)) { + case V1LayerParameter_DimCheckMode_STRICT: + mode = ParamSpec_DimCheckMode_STRICT; + break; + case V1LayerParameter_DimCheckMode_PERMISSIVE: + mode = ParamSpec_DimCheckMode_PERMISSIVE; + break; + default: + LOG(FATAL) << "Unknown blob_share_mode: " + << (int)v1_layer_param.blob_share_mode(i); + CV_Error_(Error::StsError, ("Unknown blob_share_mode: %d", (int)v1_layer_param.blob_share_mode(i))); + } + layer_param->mutable_param(i)->set_share_mode(mode); + } + for (int i = 0; i < v1_layer_param.blobs_lr_size(); ++i) { + while (layer_param->param_size() <= i) { layer_param->add_param(); } + layer_param->mutable_param(i)->set_lr_mult(v1_layer_param.blobs_lr(i)); + } + for (int i = 0; i < v1_layer_param.weight_decay_size(); ++i) { + while (layer_param->param_size() <= i) { layer_param->add_param(); } + layer_param->mutable_param(i)->set_decay_mult( + v1_layer_param.weight_decay(i)); + } + for (int i = 0; i < v1_layer_param.loss_weight_size(); ++i) { + layer_param->add_loss_weight(v1_layer_param.loss_weight(i)); + } + if (v1_layer_param.has_accuracy_param()) { + layer_param->mutable_accuracy_param()->CopyFrom( + v1_layer_param.accuracy_param()); + } + if (v1_layer_param.has_argmax_param()) { + layer_param->mutable_argmax_param()->CopyFrom( + v1_layer_param.argmax_param()); + } + if (v1_layer_param.has_concat_param()) { + layer_param->mutable_concat_param()->CopyFrom( + v1_layer_param.concat_param()); + } + if (v1_layer_param.has_contrastive_loss_param()) { + layer_param->mutable_contrastive_loss_param()->CopyFrom( + v1_layer_param.contrastive_loss_param()); + } + if (v1_layer_param.has_convolution_param()) { + layer_param->mutable_convolution_param()->CopyFrom( + v1_layer_param.convolution_param()); + } + if (v1_layer_param.has_data_param()) { + layer_param->mutable_data_param()->CopyFrom( + v1_layer_param.data_param()); + } + if (v1_layer_param.has_dropout_param()) { + layer_param->mutable_dropout_param()->CopyFrom( + v1_layer_param.dropout_param()); + } + if (v1_layer_param.has_dummy_data_param()) { + layer_param->mutable_dummy_data_param()->CopyFrom( + v1_layer_param.dummy_data_param()); + } + if (v1_layer_param.has_eltwise_param()) { + layer_param->mutable_eltwise_param()->CopyFrom( + v1_layer_param.eltwise_param()); + } + if (v1_layer_param.has_exp_param()) { + layer_param->mutable_exp_param()->CopyFrom( + v1_layer_param.exp_param()); + } + if (v1_layer_param.has_hdf5_data_param()) { + layer_param->mutable_hdf5_data_param()->CopyFrom( + v1_layer_param.hdf5_data_param()); + } + if (v1_layer_param.has_hdf5_output_param()) { + layer_param->mutable_hdf5_output_param()->CopyFrom( + v1_layer_param.hdf5_output_param()); + } + if (v1_layer_param.has_hinge_loss_param()) { + layer_param->mutable_hinge_loss_param()->CopyFrom( + v1_layer_param.hinge_loss_param()); + } + if (v1_layer_param.has_image_data_param()) { + layer_param->mutable_image_data_param()->CopyFrom( + v1_layer_param.image_data_param()); + } + if (v1_layer_param.has_infogain_loss_param()) { + layer_param->mutable_infogain_loss_param()->CopyFrom( + v1_layer_param.infogain_loss_param()); + } + if (v1_layer_param.has_inner_product_param()) { + layer_param->mutable_inner_product_param()->CopyFrom( + v1_layer_param.inner_product_param()); + } + if (v1_layer_param.has_lrn_param()) { + layer_param->mutable_lrn_param()->CopyFrom( + v1_layer_param.lrn_param()); + } + if (v1_layer_param.has_memory_data_param()) { + layer_param->mutable_memory_data_param()->CopyFrom( + v1_layer_param.memory_data_param()); + } + if (v1_layer_param.has_mvn_param()) { + layer_param->mutable_mvn_param()->CopyFrom( + v1_layer_param.mvn_param()); + } + if (v1_layer_param.has_pooling_param()) { + layer_param->mutable_pooling_param()->CopyFrom( + v1_layer_param.pooling_param()); + } + if (v1_layer_param.has_power_param()) { + layer_param->mutable_power_param()->CopyFrom( + v1_layer_param.power_param()); + } + if (v1_layer_param.has_relu_param()) { + layer_param->mutable_relu_param()->CopyFrom( + v1_layer_param.relu_param()); + } + if (v1_layer_param.has_sigmoid_param()) { + layer_param->mutable_sigmoid_param()->CopyFrom( + v1_layer_param.sigmoid_param()); + } + if (v1_layer_param.has_softmax_param()) { + layer_param->mutable_softmax_param()->CopyFrom( + v1_layer_param.softmax_param()); + } + if (v1_layer_param.has_slice_param()) { + layer_param->mutable_slice_param()->CopyFrom( + v1_layer_param.slice_param()); + } + if (v1_layer_param.has_tanh_param()) { + layer_param->mutable_tanh_param()->CopyFrom( + v1_layer_param.tanh_param()); + } + if (v1_layer_param.has_threshold_param()) { + layer_param->mutable_threshold_param()->CopyFrom( + v1_layer_param.threshold_param()); + } + if (v1_layer_param.has_window_data_param()) { + layer_param->mutable_window_data_param()->CopyFrom( + v1_layer_param.window_data_param()); + } + if (v1_layer_param.has_transform_param()) { + layer_param->mutable_transform_param()->CopyFrom( + v1_layer_param.transform_param()); + } + if (v1_layer_param.has_loss_param()) { + layer_param->mutable_loss_param()->CopyFrom( + v1_layer_param.loss_param()); + } + if (v1_layer_param.has_layer()) { + LOG(ERROR) << "Input NetParameter has V0 layer -- ignoring."; + is_fully_compatible = false; + } + return is_fully_compatible; +} + +const char* UpgradeV1LayerType(const V1LayerParameter_LayerType type) { + switch (type) { + case V1LayerParameter_LayerType_NONE: + return ""; + case V1LayerParameter_LayerType_ABSVAL: + return "AbsVal"; + case V1LayerParameter_LayerType_ACCURACY: + return "Accuracy"; + case V1LayerParameter_LayerType_ARGMAX: + return "ArgMax"; + case V1LayerParameter_LayerType_BNLL: + return "BNLL"; + case V1LayerParameter_LayerType_CONCAT: + return "Concat"; + case V1LayerParameter_LayerType_CONTRASTIVE_LOSS: + return "ContrastiveLoss"; + case V1LayerParameter_LayerType_CONVOLUTION: + return "Convolution"; + case V1LayerParameter_LayerType_DECONVOLUTION: + return "Deconvolution"; + case V1LayerParameter_LayerType_DATA: + return "Data"; + case V1LayerParameter_LayerType_DROPOUT: + return "Dropout"; + case V1LayerParameter_LayerType_DUMMY_DATA: + return "DummyData"; + case V1LayerParameter_LayerType_EUCLIDEAN_LOSS: + return "EuclideanLoss"; + case V1LayerParameter_LayerType_ELTWISE: + return "Eltwise"; + case V1LayerParameter_LayerType_EXP: + return "Exp"; + case V1LayerParameter_LayerType_FLATTEN: + return "Flatten"; + case V1LayerParameter_LayerType_HDF5_DATA: + return "HDF5Data"; + case V1LayerParameter_LayerType_HDF5_OUTPUT: + return "HDF5Output"; + case V1LayerParameter_LayerType_HINGE_LOSS: + return "HingeLoss"; + case V1LayerParameter_LayerType_IM2COL: + return "Im2col"; + case V1LayerParameter_LayerType_IMAGE_DATA: + return "ImageData"; + case V1LayerParameter_LayerType_INFOGAIN_LOSS: + return "InfogainLoss"; + case V1LayerParameter_LayerType_INNER_PRODUCT: + return "InnerProduct"; + case V1LayerParameter_LayerType_LRN: + return "LRN"; + case V1LayerParameter_LayerType_MEMORY_DATA: + return "MemoryData"; + case V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS: + return "MultinomialLogisticLoss"; + case V1LayerParameter_LayerType_MVN: + return "MVN"; + case V1LayerParameter_LayerType_POOLING: + return "Pooling"; + case V1LayerParameter_LayerType_POWER: + return "Power"; + case V1LayerParameter_LayerType_RELU: + return "ReLU"; + case V1LayerParameter_LayerType_SIGMOID: + return "Sigmoid"; + case V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS: + return "SigmoidCrossEntropyLoss"; + case V1LayerParameter_LayerType_SILENCE: + return "Silence"; + case V1LayerParameter_LayerType_SOFTMAX: + return "Softmax"; + case V1LayerParameter_LayerType_SOFTMAX_LOSS: + return "SoftmaxWithLoss"; + case V1LayerParameter_LayerType_SPLIT: + return "Split"; + case V1LayerParameter_LayerType_SLICE: + return "Slice"; + case V1LayerParameter_LayerType_TANH: + return "TanH"; + case V1LayerParameter_LayerType_WINDOW_DATA: + return "WindowData"; + case V1LayerParameter_LayerType_THRESHOLD: + return "Threshold"; + default: + LOG(FATAL) << "Unknown V1LayerParameter layer type: " << (int)type; + return ""; + } +} + +static const int kProtoReadBytesLimit = INT_MAX; // Max size of 2 GB minus 1 byte. + +bool ReadProtoFromBinary(ZeroCopyInputStream* input, Message *proto) { + CodedInputStream coded_input(input); +#if GOOGLE_PROTOBUF_VERSION >= 3006000 + coded_input.SetTotalBytesLimit(kProtoReadBytesLimit); +#else + coded_input.SetTotalBytesLimit(kProtoReadBytesLimit, 536870912); +#endif + + return proto->ParseFromCodedStream(&coded_input); +} + +bool ReadProtoFromTextFile(const char* filename, Message* proto) { + std::ifstream fs(filename, std::ifstream::in); + CHECK(fs.is_open()) << "Can't open \"" << filename << "\""; + IstreamInputStream input(&fs); + google::protobuf::TextFormat::Parser parser; +#ifndef OPENCV_DNN_EXTERNAL_PROTOBUF + parser.AllowUnknownField(true); + parser.SetRecursionLimit(1000); +#endif + return parser.Parse(&input, proto); +} + +bool ReadProtoFromBinaryFile(const char* filename, Message* proto) { + std::ifstream fs(filename, std::ifstream::in | std::ifstream::binary); + CHECK(fs.is_open()) << "Can't open \"" << filename << "\""; + IstreamInputStream raw_input(&fs); + + return ReadProtoFromBinary(&raw_input, proto); +} + +bool ReadProtoFromTextBuffer(const char* data, size_t len, Message* proto) { + ArrayInputStream input(data, len); + google::protobuf::TextFormat::Parser parser; +#ifndef OPENCV_DNN_EXTERNAL_PROTOBUF + parser.AllowUnknownField(true); + parser.SetRecursionLimit(1000); +#endif + return parser.Parse(&input, proto); +} + + +bool ReadProtoFromBinaryBuffer(const char* data, size_t len, Message* proto) { + ArrayInputStream raw_input(data, len); + return ReadProtoFromBinary(&raw_input, proto); +} + +void ReadNetParamsFromTextFileOrDie(const char* param_file, + NetParameter* param) { + CHECK(ReadProtoFromTextFile(param_file, param)) + << "Failed to parse NetParameter file: " << param_file; + UpgradeNetAsNeeded(param_file, param); +} + +void ReadNetParamsFromTextBufferOrDie(const char* data, size_t len, + NetParameter* param) { + CHECK(ReadProtoFromTextBuffer(data, len, param)) + << "Failed to parse NetParameter buffer"; + UpgradeNetAsNeeded("memory buffer", param); +} + +void ReadNetParamsFromBinaryFileOrDie(const char* param_file, + NetParameter* param) { + CHECK(ReadProtoFromBinaryFile(param_file, param)) + << "Failed to parse NetParameter file: " << param_file; + UpgradeNetAsNeeded(param_file, param); +} + +void ReadNetParamsFromBinaryBufferOrDie(const char* data, size_t len, + NetParameter* param) { + CHECK(ReadProtoFromBinaryBuffer(data, len, param)) + << "Failed to parse NetParameter buffer"; + UpgradeNetAsNeeded("memory buffer", param); +} + +} +} +#endif diff --git a/modules/dnnlegacy/src/caffe/caffe_io.hpp b/modules/dnnlegacy/src/caffe/caffe_io.hpp new file mode 100644 index 00000000000..8b86c4c42d0 --- /dev/null +++ b/modules/dnnlegacy/src/caffe/caffe_io.hpp @@ -0,0 +1,129 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +/*M/////////////////////////////////////////////////////////////////////////////////////// +//COPYRIGHT +// +//All contributions by the University of California: +//Copyright (c) 2014, The Regents of the University of California (Regents) +//All rights reserved. +// +//All other contributions: +//Copyright (c) 2014, the respective contributors +//All rights reserved. +// +//Caffe uses a shared copyright model: each contributor holds copyright over +//their contributions to Caffe. The project versioning records all such +//contribution and copyright details. If a contributor wants to further mark +//their specific copyright on a particular contribution, they should indicate +//their copyright solely in the commit message of the change when it is +//committed. +// +//LICENSE +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions are met: +// +//1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +//2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//CONTRIBUTION AGREEMENT +// +//By contributing to the BVLC/caffe repository through pull-request, comment, +//or otherwise, the contributor releases their content to the +//license and copyright terms herein. +// +//M*/ + +#ifndef __OPENCV_DNN_CAFFE_IO_HPP__ +#define __OPENCV_DNN_CAFFE_IO_HPP__ +#ifdef HAVE_PROTOBUF + +#if defined(__GNUC__) && __GNUC__ >= 5 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wsuggest-override" +#endif +#include "opencv-caffe.pb.h" +#if defined(__GNUC__) && __GNUC__ >= 5 +#pragma GCC diagnostic pop +#endif + +namespace caffe { using namespace opencv_caffe; } // avoid massive renames from caffe proto package + +namespace cv { +namespace dnnlegacy { + +// Read parameters from a file into a NetParameter proto message. +void ReadNetParamsFromTextFileOrDie(const char* param_file, + caffe::NetParameter* param); +void ReadNetParamsFromBinaryFileOrDie(const char* param_file, + caffe::NetParameter* param); + +// Read parameters from a memory buffer into a NetParammeter proto message. +void ReadNetParamsFromBinaryBufferOrDie(const char* data, size_t len, + caffe::NetParameter* param); +void ReadNetParamsFromTextBufferOrDie(const char* data, size_t len, + caffe::NetParameter* param); + +// Utility functions used internally by Caffe and TensorFlow loaders +bool ReadProtoFromTextFile(const char* filename, ::google::protobuf::Message* proto); +bool ReadProtoFromBinaryFile(const char* filename, ::google::protobuf::Message* proto); +bool ReadProtoFromTextBuffer(const char* data, size_t len, ::google::protobuf::Message* proto); +bool ReadProtoFromBinaryBuffer(const char* data, size_t len, ::google::protobuf::Message* proto); + +} +} +#endif +#endif diff --git a/modules/dnnlegacy/src/caffe/caffe_shrinker.cpp b/modules/dnnlegacy/src/caffe/caffe_shrinker.cpp new file mode 100644 index 00000000000..0957ff1016d --- /dev/null +++ b/modules/dnnlegacy/src/caffe/caffe_shrinker.cpp @@ -0,0 +1,77 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../precomp.hpp" + +#ifdef HAVE_PROTOBUF +#include +#include "caffe_io.hpp" +#endif + +namespace cv { namespace dnnlegacy { +#ifdef HAVE_PROTOBUF + + +void shrinkCaffeModel(const String& src, const String& dst, const std::vector& layersTypes) +{ + CV_TRACE_FUNCTION(); + + std::vector types(layersTypes); + if (types.empty()) + { + types.push_back("Convolution"); + types.push_back("InnerProduct"); + } + + caffe::NetParameter net; + ReadNetParamsFromBinaryFileOrDie(src.c_str(), &net); + + for (int i = 0; i < net.layer_size(); ++i) + { + caffe::LayerParameter* lp = net.mutable_layer(i); + if (std::find(types.begin(), types.end(), lp->type()) == types.end()) + { + continue; + } + for (int j = 0; j < lp->blobs_size(); ++j) + { + caffe::BlobProto* blob = lp->mutable_blobs(j); + CV_Assert(blob->data_size() != 0); // float32 array. + + Mat floats(1, blob->data_size(), CV_32FC1, (void*)blob->data().data()); + Mat halfs(1, blob->data_size(), CV_16FC1); + floats.convertTo(halfs, CV_16F); // Convert to float16. + + blob->clear_data(); // Clear float32 data. + + // Set float16 data. + blob->set_raw_data(halfs.data, halfs.total() * halfs.elemSize()); + blob->set_raw_data_type(caffe::FLOAT16); + } + } +#if GOOGLE_PROTOBUF_VERSION < 3005000 + size_t msgSize = saturate_cast(net.ByteSize()); +#else + size_t msgSize = net.ByteSizeLong(); +#endif + std::vector output(msgSize); + net.SerializeWithCachedSizesToArray(&output[0]); + + std::ofstream ofs(dst.c_str(), std::ios::binary); + ofs.write((const char*)&output[0], msgSize); + ofs.close(); +} + +#else + +void shrinkCaffeModel(const String& src, const String& dst, const std::vector& types) +{ + CV_Error(cv::Error::StsNotImplemented, "libprotobuf required to import data from Caffe models"); +} + +#endif // HAVE_PROTOBUF +}} // namespace diff --git a/modules/dnnlegacy/src/caffe/opencv-caffe.proto b/modules/dnnlegacy/src/caffe/opencv-caffe.proto new file mode 100644 index 00000000000..d540591f823 --- /dev/null +++ b/modules/dnnlegacy/src/caffe/opencv-caffe.proto @@ -0,0 +1,1649 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +//COPYRIGHT +// +//All contributions by the University of California: +//Copyright (c) 2014, The Regents of the University of California (Regents) +//All rights reserved. +// +//All other contributions: +//Copyright (c) 2014, the respective contributors +//All rights reserved. +// +//Caffe uses a shared copyright model: each contributor holds copyright over +//their contributions to Caffe. The project versioning records all such +//contribution and copyright details. If a contributor wants to further mark +//their specific copyright on a particular contribution, they should indicate +//their copyright solely in the commit message of the change when it is +//committed. +// +//LICENSE +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions are met: +// +//1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +//2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//CONTRIBUTION AGREEMENT +// +//By contributing to the BVLC/caffe repository through pull-request, comment, +//or otherwise, the contributor releases their content to the +//license and copyright terms herein. +// +//M*/ + +syntax = "proto2"; + +package opencv_caffe; + +// NVIDIA's Caffe feature is used to store fp16 weights, https://github.com/NVIDIA/caffe: +// Math and storage types +enum Type { + DOUBLE = 0; + FLOAT = 1; + FLOAT16 = 2; + INT = 3; // math not supported + UINT = 4; // math not supported +} + +// Specifies the shape (dimensions) of a Blob. +message BlobShape { + repeated int64 dim = 1 [packed = true]; +} + +message BlobProto { + optional BlobShape shape = 7; + repeated float data = 5 [packed = true]; + repeated float diff = 6 [packed = true]; + repeated double double_data = 8 [packed = true]; + repeated double double_diff = 9 [packed = true]; + + // NVIDIA's Caffe fields begin. + optional Type raw_data_type = 10; + optional bytes raw_data = 12 [packed = false]; + // NVIDIA's Caffe fields end. + + // 4D dimensions -- deprecated. Use "shape" instead. + optional int32 num = 1 [default = 0]; + optional int32 channels = 2 [default = 0]; + optional int32 height = 3 [default = 0]; + optional int32 width = 4 [default = 0]; +} + +// The BlobProtoVector is simply a way to pass multiple blobproto instances +// around. +message BlobProtoVector { + repeated BlobProto blobs = 1; +} + +message PermuteParameter { + // The new orders of the axes of data. Notice it should be with + // in the same range as the input data, and it starts from 0. + // Do not provide repeated order. + repeated uint32 order = 1; +} + +// Message that stores parameters used by NormalizeBBoxLayer +message NormalizeBBoxParameter { + optional bool across_spatial = 1 [default = true]; + // Initial value of scale. Default is 1.0 for all + optional FillerParameter scale_filler = 2; + // Whether or not scale parameters are shared across channels. + optional bool channel_shared = 3 [default = true]; + // Epsilon for not dividing by zero while normalizing variance + optional float eps = 4 [default = 1e-10]; +} + +// Message that store parameters used by PriorBoxLayer +message PriorBoxParameter { + // Encode/decode type. + enum CodeType { + CORNER = 1; + CENTER_SIZE = 2; + } + // Minimum box size (in pixels). Required! + repeated float min_size = 1; + // Maximum box size (in pixels). Required! + repeated float max_size = 2; + // Various of aspect ratios. Duplicate ratios will be ignored. + // If none is provided, we use default ratio 1. + repeated float aspect_ratio = 3; + // If true, will flip each aspect ratio. + // For example, if there is aspect ratio "r", + // we will generate aspect ratio "1.0/r" as well. + optional bool flip = 4 [default = true]; + // If true, will clip the prior so that it is within [0, 1] + optional bool clip = 5 [default = true]; + // Variance for adjusting the prior bboxes. + repeated float variance = 6; + // By default, we calculate img_height, img_width, step_x, step_y based on + // bottom[0] (feat) and bottom[1] (img). Unless these values are explicitly + // provided. + // Explicitly provide the img_size. + optional uint32 img_size = 7; + // Either img_size or img_h/img_w should be specified; not both. + optional uint32 img_h = 8; + optional uint32 img_w = 9; + // Explicitly provide the step size. + optional float step = 10; + // Either step or step_h/step_w should be specified; not both. + optional float step_h = 11; + optional float step_w = 12; + // Offset to the top left corner of each cell. + optional float offset = 13 [default = 0.5]; + // Offset to the top corner of each cell. + repeated float offset_h = 14; + // Offset to the left corner of each cell. + repeated float offset_w = 15; + // Priox boxes width (in pixels). + repeated float width = 16; + // Priox boxes height (in pixels). + repeated float height = 17; +} + +// Message that store parameters used by DetectionOutputLayer +message DetectionOutputParameter { + // Number of classes to be predicted. Required! + optional uint32 num_classes = 1; + // If true, bounding box are shared among different classes. + optional bool share_location = 2 [default = true]; + // Background label id. If there is no background class, + // set it as -1. + optional int32 background_label_id = 3 [default = 0]; + // Parameters used for non maximum suppression. + optional NonMaximumSuppressionParameter nms_param = 4; + // Parameters used for saving detection results. + optional SaveOutputParameter save_output_param = 5; + // Type of coding method for bbox. + optional PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + // If true, variance is encoded in target; otherwise we need to adjust the + // predicted offset accordingly. + optional bool variance_encoded_in_target = 8 [default = false]; + // Number of total bboxes to be kept per image after nms step. + // -1 means keeping all bboxes after nms step. + optional int32 keep_top_k = 7 [default = -1]; + // Only consider detections whose confidences are larger than a threshold. + // If not provided, consider all boxes. + optional float confidence_threshold = 9; + // If prior boxes are normalized to [0, 1] or not. + optional bool normalized_bbox = 10 [default = true]; + // OpenCV custom parameter + optional bool clip = 1000 [default = false]; +} + +message Datum { + optional int32 channels = 1; + optional int32 height = 2; + optional int32 width = 3; + // the actual image data, in bytes + optional bytes data = 4; + optional int32 label = 5; + // Optionally, the datum could also hold float data. + repeated float float_data = 6; + // If true data contains an encoded image that need to be decoded + optional bool encoded = 7 [default = false]; +} + +message FillerParameter { + // The filler type. + optional string type = 1 [default = 'constant']; + optional float value = 2 [default = 0]; // the value in constant filler + optional float min = 3 [default = 0]; // the min value in uniform filler + optional float max = 4 [default = 1]; // the max value in uniform filler + optional float mean = 5 [default = 0]; // the mean value in Gaussian filler + optional float std = 6 [default = 1]; // the std value in Gaussian filler + // The expected number of non-zero output weights for a given input in + // Gaussian filler -- the default -1 means don't perform sparsification. + optional int32 sparse = 7 [default = -1]; + // Normalize the filler variance by fan_in, fan_out, or their average. + // Applies to 'xavier' and 'msra' fillers. + enum VarianceNorm { + FAN_IN = 0; + FAN_OUT = 1; + AVERAGE = 2; + } + optional VarianceNorm variance_norm = 8 [default = FAN_IN]; +} + +message NetParameter { + optional string name = 1; // consider giving the network a name + // DEPRECATED. See InputParameter. The input blobs to the network. + repeated string input = 3; + // DEPRECATED. See InputParameter. The shape of the input blobs. + repeated BlobShape input_shape = 8; + + // 4D input dimensions -- deprecated. Use "input_shape" instead. + // If specified, for each input blob there should be four + // values specifying the num, channels, height and width of the input blob. + // Thus, there should be a total of (4 * #input) numbers. + repeated int32 input_dim = 4; + + // Whether the network will force every layer to carry out backward operation. + // If set False, then whether to carry out backward is determined + // automatically according to the net structure and learning rates. + optional bool force_backward = 5 [default = false]; + // The current "state" of the network, including the phase, level, and stage. + // Some layers may be included/excluded depending on this state and the states + // specified in the layers' include and exclude fields. + optional NetState state = 6; + + // Print debugging information about results while running Net::Forward, + // Net::Backward, and Net::Update. + optional bool debug_info = 7 [default = false]; + + // The layers that make up the net. Each of their configurations, including + // connectivity and behavior, is specified as a LayerParameter. + repeated LayerParameter layer = 100; // ID 100 so layers are printed last. + + // DEPRECATED: use 'layer' instead. + repeated V1LayerParameter layers = 2; +} + +// NOTE +// Update the next available ID when you add a new SolverParameter field. +// +// SolverParameter next available ID: 41 (last added: type) +message SolverParameter { + ////////////////////////////////////////////////////////////////////////////// + // Specifying the train and test networks + // + // Exactly one train net must be specified using one of the following fields: + // train_net_param, train_net, net_param, net + // One or more test nets may be specified using any of the following fields: + // test_net_param, test_net, net_param, net + // If more than one test net field is specified (e.g., both net and + // test_net are specified), they will be evaluated in the field order given + // above: (1) test_net_param, (2) test_net, (3) net_param/net. + // A test_iter must be specified for each test_net. + // A test_level and/or a test_stage may also be specified for each test_net. + ////////////////////////////////////////////////////////////////////////////// + + // Proto filename for the train net, possibly combined with one or more + // test nets. + optional string net = 24; + // Inline train net param, possibly combined with one or more test nets. + optional NetParameter net_param = 25; + + optional string train_net = 1; // Proto filename for the train net. + repeated string test_net = 2; // Proto filenames for the test nets. + optional NetParameter train_net_param = 21; // Inline train net params. + repeated NetParameter test_net_param = 22; // Inline test net params. + + // The states for the train/test nets. Must be unspecified or + // specified once per net. + // + // By default, all states will have solver = true; + // train_state will have phase = TRAIN, + // and all test_state's will have phase = TEST. + // Other defaults are set according to the NetState defaults. + optional NetState train_state = 26; + repeated NetState test_state = 27; + + // The number of iterations for each test net. + repeated int32 test_iter = 3; + + // The number of iterations between two testing phases. + optional int32 test_interval = 4 [default = 0]; + optional bool test_compute_loss = 19 [default = false]; + // If true, run an initial test pass before the first iteration, + // ensuring memory availability and printing the starting value of the loss. + optional bool test_initialization = 32 [default = true]; + optional float base_lr = 5; // The base learning rate + // the number of iterations between displaying info. If display = 0, no info + // will be displayed. + optional int32 display = 6; + // Display the loss averaged over the last average_loss iterations + optional int32 average_loss = 33 [default = 1]; + optional int32 max_iter = 7; // the maximum number of iterations + // accumulate gradients over `iter_size` x `batch_size` instances + optional int32 iter_size = 36 [default = 1]; + + // The learning rate decay policy. The currently implemented learning rate + // policies are as follows: + // - fixed: always return base_lr. + // - step: return base_lr * gamma ^ (floor(iter / step)) + // - exp: return base_lr * gamma ^ iter + // - inv: return base_lr * (1 + gamma * iter) ^ (- power) + // - multistep: similar to step but it allows non uniform steps defined by + // stepvalue + // - poly: the effective learning rate follows a polynomial decay, to be + // zero by the max_iter. return base_lr (1 - iter/max_iter) ^ (power) + // - sigmoid: the effective learning rate follows a sigmod decay + // return base_lr ( 1/(1 + exp(-gamma * (iter - stepsize)))) + // + // where base_lr, max_iter, gamma, step, stepvalue and power are defined + // in the solver parameter protocol buffer, and iter is the current iteration. + optional string lr_policy = 8; + optional float gamma = 9; // The parameter to compute the learning rate. + optional float power = 10; // The parameter to compute the learning rate. + optional float momentum = 11; // The momentum value. + optional float weight_decay = 12; // The weight decay. + // regularization types supported: L1 and L2 + // controlled by weight_decay + optional string regularization_type = 29 [default = "L2"]; + // the stepsize for learning rate policy "step" + optional int32 stepsize = 13; + // the stepsize for learning rate policy "multistep" + repeated int32 stepvalue = 34; + + // Set clip_gradients to >= 0 to clip parameter gradients to that L2 norm, + // whenever their actual L2 norm is larger. + optional float clip_gradients = 35 [default = -1]; + + optional int32 snapshot = 14 [default = 0]; // The snapshot interval + optional string snapshot_prefix = 15; // The prefix for the snapshot. + // whether to snapshot diff in the results or not. Snapshotting diff will help + // debugging but the final protocol buffer size will be much larger. + optional bool snapshot_diff = 16 [default = false]; + enum SnapshotFormat { + HDF5 = 0; + BINARYPROTO = 1; + } + optional SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + // the mode solver will use: 0 for CPU and 1 for GPU. Use GPU in default. + enum SolverMode { + CPU = 0; + GPU = 1; + } + optional SolverMode solver_mode = 17 [default = GPU]; + // the device_id will that be used in GPU mode. Use device_id = 0 in default. + optional int32 device_id = 18 [default = 0]; + // If non-negative, the seed with which the Solver will initialize the Caffe + // random number generator -- useful for reproducible results. Otherwise, + // (and by default) initialize using a seed derived from the system clock. + optional int64 random_seed = 20 [default = -1]; + + // type of the solver + optional string type = 40 [default = "SGD"]; + + // numerical stability for RMSProp, AdaGrad and AdaDelta and Adam + optional float delta = 31 [default = 1e-8]; + // parameters for the Adam solver + optional float momentum2 = 39 [default = 0.999]; + + // RMSProp decay value + // MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t) + optional float rms_decay = 38 [default = 0.99]; + + // If true, print information about the state of the net that may help with + // debugging learning problems. + optional bool debug_info = 23 [default = false]; + + // If false, don't save a snapshot after training finishes. + optional bool snapshot_after_train = 28 [default = true]; + + // DEPRECATED: old solver enum types, use string instead + enum SolverType { + SGD = 0; + NESTEROV = 1; + ADAGRAD = 2; + RMSPROP = 3; + ADADELTA = 4; + ADAM = 5; + } + // DEPRECATED: use type instead of solver_type + optional SolverType solver_type = 30 [default = SGD]; +} + +// A message that stores the solver snapshots +message SolverState { + optional int32 iter = 1; // The current iteration + optional string learned_net = 2; // The file that stores the learned net. + repeated BlobProto history = 3; // The history for sgd solvers + optional int32 current_step = 4 [default = 0]; // The current step for learning rate +} + +enum Phase { + TRAIN = 0; + TEST = 1; +} + +message NetState { + optional Phase phase = 1 [default = TEST]; + optional int32 level = 2 [default = 0]; + repeated string stage = 3; +} + +message NetStateRule { + // Set phase to require the NetState have a particular phase (TRAIN or TEST) + // to meet this rule. + optional Phase phase = 1; + + // Set the minimum and/or maximum levels in which the layer should be used. + // Leave undefined to meet the rule regardless of level. + optional int32 min_level = 2; + optional int32 max_level = 3; + + // Customizable sets of stages to include or exclude. + // The net must have ALL of the specified stages and NONE of the specified + // "not_stage"s to meet the rule. + // (Use multiple NetStateRules to specify conjunctions of stages.) + repeated string stage = 4; + repeated string not_stage = 5; +} + +// Specifies training parameters (multipliers on global learning constants, +// and the name and other settings used for weight sharing). +message ParamSpec { + // The names of the parameter blobs -- useful for sharing parameters among + // layers, but never required otherwise. To share a parameter between two + // layers, give it a (non-empty) name. + optional string name = 1; + + // Whether to require shared weights to have the same shape, or just the same + // count -- defaults to STRICT if unspecified. + optional DimCheckMode share_mode = 2; + enum DimCheckMode { + // STRICT (default) requires that num, channels, height, width each match. + STRICT = 0; + // PERMISSIVE requires only the count (num*channels*height*width) to match. + PERMISSIVE = 1; + } + + // The multiplier on the global learning rate for this parameter. + optional float lr_mult = 3 [default = 1.0]; + + // The multiplier on the global weight decay for this parameter. + optional float decay_mult = 4 [default = 1.0]; +} + +// NOTE +// Update the next available ID when you add a new LayerParameter field. +// +// LayerParameter next available layer-specific ID: 147 (last added: recurrent_param) +message LayerParameter { + optional string name = 1; // the layer name + optional string type = 2; // the layer type + repeated string bottom = 3; // the name of each bottom blob + repeated string top = 4; // the name of each top blob + + // The train / test phase for computation. + optional Phase phase = 10; + + // The amount of weight to assign each top blob in the objective. + // Each layer assigns a default value, usually of either 0 or 1, + // to each top blob. + repeated float loss_weight = 5; + + // Specifies training parameters (multipliers on global learning constants, + // and the name and other settings used for weight sharing). + repeated ParamSpec param = 6; + + // The blobs containing the numeric parameters of the layer. + repeated BlobProto blobs = 7; + + // Specifies whether to backpropagate to each bottom. If unspecified, + // Caffe will automatically infer whether each input needs backpropagation + // to compute parameter gradients. If set to true for some inputs, + // backpropagation to those inputs is forced; if set false for some inputs, + // backpropagation to those inputs is skipped. + // + // The size must be either 0 or equal to the number of bottoms. + repeated bool propagate_down = 11; + + // Rules controlling whether and when a layer is included in the network, + // based on the current NetState. You may specify a non-zero number of rules + // to include OR exclude, but not both. If no include or exclude rules are + // specified, the layer is always included. If the current NetState meets + // ANY (i.e., one or more) of the specified rules, the layer is + // included/excluded. + repeated NetStateRule include = 8; + repeated NetStateRule exclude = 9; + + // Parameters for data pre-processing. + optional TransformationParameter transform_param = 100; + + // Parameters shared by loss layers. + optional LossParameter loss_param = 101; + + // Layer type-specific parameters. + // + // Note: certain layers may have more than one computational engine + // for their implementation. These layers include an Engine type and + // engine parameter for selecting the implementation. + // The default for the engine is set by the ENGINE switch at compile-time. + optional AccuracyParameter accuracy_param = 102; + optional ArgMaxParameter argmax_param = 103; + optional BatchNormParameter batch_norm_param = 139; + optional BiasParameter bias_param = 141; + optional ConcatParameter concat_param = 104; + optional ContrastiveLossParameter contrastive_loss_param = 105; + optional ConvolutionParameter convolution_param = 106; + optional CropParameter crop_param = 144; + optional DataParameter data_param = 107; + optional DetectionOutputParameter detection_output_param = 147; + optional DropoutParameter dropout_param = 108; + optional DummyDataParameter dummy_data_param = 109; + optional EltwiseParameter eltwise_param = 110; + optional ELUParameter elu_param = 140; + optional EmbedParameter embed_param = 137; + optional ExpParameter exp_param = 111; + optional FlattenParameter flatten_param = 135; + optional HDF5DataParameter hdf5_data_param = 112; + optional HDF5OutputParameter hdf5_output_param = 113; + optional HingeLossParameter hinge_loss_param = 114; + optional ImageDataParameter image_data_param = 115; + optional InfogainLossParameter infogain_loss_param = 116; + optional InnerProductParameter inner_product_param = 117; + optional InputParameter input_param = 143; + optional LogParameter log_param = 134; + optional LRNParameter lrn_param = 118; + optional MemoryDataParameter memory_data_param = 119; + optional MVNParameter mvn_param = 120; + optional NormalizeBBoxParameter norm_param = 149; + optional PermuteParameter permute_param = 148; + optional ParameterParameter parameter_param = 145; + optional PoolingParameter pooling_param = 121; + optional PowerParameter power_param = 122; + optional PReLUParameter prelu_param = 131; + optional PriorBoxParameter prior_box_param = 150; + optional ProposalParameter proposal_param = 201; + optional PSROIPoolingParameter psroi_pooling_param = 10002; // https://github.com/daijifeng001/caffe-rfcn + optional PythonParameter python_param = 130; + optional RecurrentParameter recurrent_param = 146; + optional ReductionParameter reduction_param = 136; + optional ReLUParameter relu_param = 123; + optional ReshapeParameter reshape_param = 133; + optional ROIPoolingParameter roi_pooling_param = 8266711; // https://github.com/rbgirshick/caffe-fast-rcnn/tree/fast-rcnn + optional ScaleParameter scale_param = 142; + optional SigmoidParameter sigmoid_param = 124; + optional SoftmaxParameter softmax_param = 125; + optional SPPParameter spp_param = 132; + optional SliceParameter slice_param = 126; + optional TanHParameter tanh_param = 127; + optional ThresholdParameter threshold_param = 128; + optional TileParameter tile_param = 138; + optional WindowDataParameter window_data_param = 129; +} + +// Message that stores parameters used to apply transformation +// to the data layer's data +message TransformationParameter { + // For data pre-processing, we can do simple scaling and subtracting the + // data mean, if provided. Note that the mean subtraction is always carried + // out before scaling. + optional float scale = 1 [default = 1]; + // Specify if we want to randomly mirror data. + optional bool mirror = 2 [default = false]; + // Specify if we would like to randomly crop an image. + optional uint32 crop_size = 3 [default = 0]; + // mean_file and mean_value cannot be specified at the same time + optional string mean_file = 4; + // if specified can be repeated once (would subtract it from all the channels) + // or can be repeated the same number of times as channels + // (would subtract them from the corresponding channel) + repeated float mean_value = 5; + // Force the decoded image to have 3 color channels. + optional bool force_color = 6 [default = false]; + // Force the decoded image to have 1 color channels. + optional bool force_gray = 7 [default = false]; +} + +// Message that stores parameters shared by loss layers +message LossParameter { + // If specified, ignore instances with the given label. + optional int32 ignore_label = 1; + // How to normalize the loss for loss layers that aggregate across batches, + // spatial dimensions, or other dimensions. Currently only implemented in + // SoftmaxWithLoss and SigmoidCrossEntropyLoss layers. + enum NormalizationMode { + // Divide by the number of examples in the batch times spatial dimensions. + // Outputs that receive the ignore label will NOT be ignored in computing + // the normalization factor. + FULL = 0; + // Divide by the total number of output locations that do not take the + // ignore_label. If ignore_label is not set, this behaves like FULL. + VALID = 1; + // Divide by the batch size. + BATCH_SIZE = 2; + // Do not normalize the loss. + NONE = 3; + } + // For historical reasons, the default normalization for + // SigmoidCrossEntropyLoss is BATCH_SIZE and *not* VALID. + optional NormalizationMode normalization = 3 [default = VALID]; + // Deprecated. Ignored if normalization is specified. If normalization + // is not specified, then setting this to false will be equivalent to + // normalization = BATCH_SIZE to be consistent with previous behavior. + optional bool normalize = 2; +} + +// Messages that store parameters used by individual layer types follow, in +// alphabetical order. + +message AccuracyParameter { + // When computing accuracy, count as correct by comparing the true label to + // the top k scoring classes. By default, only compare to the top scoring + // class (i.e. argmax). + optional uint32 top_k = 1 [default = 1]; + + // The "label" axis of the prediction blob, whose argmax corresponds to the + // predicted label -- may be negative to index from the end (e.g., -1 for the + // last axis). For example, if axis == 1 and the predictions are + // (N x C x H x W), the label blob is expected to contain N*H*W ground truth + // labels with integer values in {0, 1, ..., C-1}. + optional int32 axis = 2 [default = 1]; + + // If specified, ignore instances with the given label. + optional int32 ignore_label = 3; +} + +message ArgMaxParameter { + // If true produce pairs (argmax, maxval) + optional bool out_max_val = 1 [default = false]; + optional uint32 top_k = 2 [default = 1]; + // The axis along which to maximise -- may be negative to index from the + // end (e.g., -1 for the last axis). + // By default ArgMaxLayer maximizes over the flattened trailing dimensions + // for each index of the first / num dimension. + optional int32 axis = 3; +} + +message ConcatParameter { + // The axis along which to concatenate -- may be negative to index from the + // end (e.g., -1 for the last axis). Other axes must have the + // same dimension for all the bottom blobs. + // By default, ConcatLayer concatenates blobs along the "channels" axis (1). + optional int32 axis = 2 [default = 1]; + + // DEPRECATED: alias for "axis" -- does not support negative indexing. + optional uint32 concat_dim = 1 [default = 1]; +} + +message BatchNormParameter { + // If false, accumulate global mean/variance values via a moving average. If + // true, use those accumulated values instead of computing mean/variance + // across the batch. + optional bool use_global_stats = 1; + // How much does the moving average decay each iteration? + optional float moving_average_fraction = 2 [default = .999]; + // Small value to add to the variance estimate so that we don't divide by + // zero. + optional float eps = 3 [default = 1e-5]; + // It true, scale and add biases. Source: https://github.com/NVIDIA/caffe/ + optional bool scale_bias = 7 [default = false]; +} + +message BiasParameter { + // The first axis of bottom[0] (the first input Blob) along which to apply + // bottom[1] (the second input Blob). May be negative to index from the end + // (e.g., -1 for the last axis). + // + // For example, if bottom[0] is 4D with shape 100x3x40x60, the output + // top[0] will have the same shape, and bottom[1] may have any of the + // following shapes (for the given value of axis): + // (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60 + // (axis == 1 == -3) 3; 3x40; 3x40x60 + // (axis == 2 == -2) 40; 40x60 + // (axis == 3 == -1) 60 + // Furthermore, bottom[1] may have the empty shape (regardless of the value of + // "axis") -- a scalar bias. + optional int32 axis = 1 [default = 1]; + + // (num_axes is ignored unless just one bottom is given and the bias is + // a learned parameter of the layer. Otherwise, num_axes is determined by the + // number of axes by the second bottom.) + // The number of axes of the input (bottom[0]) covered by the bias + // parameter, or -1 to cover all axes of bottom[0] starting from `axis`. + // Set num_axes := 0, to add a zero-axis Blob: a scalar. + optional int32 num_axes = 2 [default = 1]; + + // (filler is ignored unless just one bottom is given and the bias is + // a learned parameter of the layer.) + // The initialization for the learned bias parameter. + // Default is the zero (0) initialization, resulting in the BiasLayer + // initially performing the identity operation. + optional FillerParameter filler = 3; +} + +message ContrastiveLossParameter { + // margin for dissimilar pair + optional float margin = 1 [default = 1.0]; + // The first implementation of this cost did not exactly match the cost of + // Hadsell et al 2006 -- using (margin - d^2) instead of (margin - d)^2. + // legacy_version = false (the default) uses (margin - d)^2 as proposed in the + // Hadsell paper. New models should probably use this version. + // legacy_version = true uses (margin - d^2). This is kept to support / + // reproduce existing models and results + optional bool legacy_version = 2 [default = false]; +} + +message ConvolutionParameter { + optional uint32 num_output = 1; // The number of outputs for the layer + optional bool bias_term = 2 [default = true]; // whether to have bias terms + + // Pad, kernel size, and stride are all given as a single value for equal + // dimensions in all spatial dimensions, or once per spatial dimension. + repeated uint32 pad = 3; // The padding size; defaults to 0 + repeated uint32 kernel_size = 4; // The kernel size + repeated uint32 stride = 6; // The stride; defaults to 1 + // Factor used to dilate the kernel, (implicitly) zero-filling the resulting + // holes. (Kernel dilation is sometimes referred to by its use in the + // algorithme à trous from Holschneider et al. 1987.) + repeated uint32 dilation = 18; // The dilation; defaults to 1 + + // For 2D convolution only, the *_h and *_w versions may also be used to + // specify both spatial dimensions. + optional uint32 pad_h = 9 [default = 0]; // The padding height (2D only) + optional uint32 pad_w = 10 [default = 0]; // The padding width (2D only) + optional uint32 kernel_h = 11; // The kernel height (2D only) + optional uint32 kernel_w = 12; // The kernel width (2D only) + optional uint32 stride_h = 13; // The stride height (2D only) + optional uint32 stride_w = 14; // The stride width (2D only) + + optional uint32 group = 5 [default = 1]; // The group size for group conv + + optional FillerParameter weight_filler = 7; // The filler for the weight + optional FillerParameter bias_filler = 8; // The filler for the bias + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 15 [default = DEFAULT]; + + // The axis to interpret as "channels" when performing convolution. + // Preceding dimensions are treated as independent inputs; + // succeeding dimensions are treated as "spatial". + // With (N, C, H, W) inputs, and axis == 1 (the default), we perform + // N independent 2D convolutions, sliding C-channel (or (C/g)-channels, for + // groups g>1) filters across the spatial axes (H, W) of the input. + // With (N, C, D, H, W) inputs, and axis == 1, we perform + // N independent 3D convolutions, sliding (C/g)-channels + // filters across the spatial axes (D, H, W) of the input. + optional int32 axis = 16 [default = 1]; + + // Whether to force use of the general ND convolution, even if a specific + // implementation for blobs of the appropriate number of spatial dimensions + // is available. (Currently, there is only a 2D-specific convolution + // implementation; for input blobs with num_axes != 2, this option is + // ignored and the ND implementation will be used.) + optional bool force_nd_im2col = 17 [default = false]; +} + +message CropParameter { + // To crop, elements of the first bottom are selected to fit the dimensions + // of the second, reference bottom. The crop is configured by + // - the crop `axis` to pick the dimensions for cropping + // - the crop `offset` to set the shift for all/each dimension + // to align the cropped bottom with the reference bottom. + // All dimensions up to but excluding `axis` are preserved, while + // the dimensions including and trailing `axis` are cropped. + // If only one `offset` is set, then all dimensions are offset by this amount. + // Otherwise, the number of offsets must equal the number of cropped axes to + // shift the crop in each dimension accordingly. + // Note: standard dimensions are N,C,H,W so the default is a spatial crop, + // and `axis` may be negative to index from the end (e.g., -1 for the last + // axis). + optional int32 axis = 1 [default = 2]; + repeated uint32 offset = 2; +} + +message DataParameter { + enum DB { + LEVELDB = 0; + LMDB = 1; + } + // Specify the data source. + optional string source = 1; + // Specify the batch size. + optional uint32 batch_size = 4; + // The rand_skip variable is for the data layer to skip a few data points + // to avoid all asynchronous sgd clients to start at the same point. The skip + // point would be set as rand_skip * rand(0,1). Note that rand_skip should not + // be larger than the number of keys in the database. + // DEPRECATED. Each solver accesses a different subset of the database. + optional uint32 rand_skip = 7 [default = 0]; + optional DB backend = 8 [default = LEVELDB]; + // DEPRECATED. See TransformationParameter. For data pre-processing, we can do + // simple scaling and subtracting the data mean, if provided. Note that the + // mean subtraction is always carried out before scaling. + optional float scale = 2 [default = 1]; + optional string mean_file = 3; + // DEPRECATED. See TransformationParameter. Specify if we would like to randomly + // crop an image. + optional uint32 crop_size = 5 [default = 0]; + // DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror + // data. + optional bool mirror = 6 [default = false]; + // Force the encoded image to have 3 color channels + optional bool force_encoded_color = 9 [default = false]; + // Prefetch queue (Number of batches to prefetch to host memory, increase if + // data access bandwidth varies). + optional uint32 prefetch = 10 [default = 4]; +} + +message NonMaximumSuppressionParameter { + // Threshold to be used in nms. + optional float nms_threshold = 1 [default = 0.3]; + // Maximum number of results to be kept. + optional int32 top_k = 2; + // Parameter for adaptive nms. + optional float eta = 3 [default = 1.0]; +} + +message SaveOutputParameter { + // Output directory. If not empty, we will save the results. + optional string output_directory = 1; + // Output name prefix. + optional string output_name_prefix = 2; + // Output format. + // VOC - PASCAL VOC output format. + // COCO - MS COCO output format. + optional string output_format = 3; + // If you want to output results, must also provide the following two files. + // Otherwise, we will ignore saving results. + // label map file. + optional string label_map_file = 4; + // A file which contains a list of names and sizes with same order + // of the input DB. The file is in the following format: + // name height width + // ... + optional string name_size_file = 5; + // Number of test images. It can be less than the lines specified in + // name_size_file. For example, when we only want to evaluate on part + // of the test images. + optional uint32 num_test_image = 6; +} + +message DropoutParameter { + optional float dropout_ratio = 1 [default = 0.5]; // dropout ratio + // Faster-RCNN framework's parameter. + // source: https://github.com/rbgirshick/caffe-fast-rcnn/tree/faster-rcnn + optional bool scale_train = 2 [default = true]; // scale train or test phase +} + +// DummyDataLayer fills any number of arbitrarily shaped blobs with random +// (or constant) data generated by "Fillers" (see "message FillerParameter"). +message DummyDataParameter { + // This layer produces N >= 1 top blobs. DummyDataParameter must specify 1 or N + // shape fields, and 0, 1 or N data_fillers. + // + // If 0 data_fillers are specified, ConstantFiller with a value of 0 is used. + // If 1 data_filler is specified, it is applied to all top blobs. If N are + // specified, the ith is applied to the ith top blob. + repeated FillerParameter data_filler = 1; + repeated BlobShape shape = 6; + + // 4D dimensions -- deprecated. Use "shape" instead. + repeated uint32 num = 2; + repeated uint32 channels = 3; + repeated uint32 height = 4; + repeated uint32 width = 5; +} + +message EltwiseParameter { + enum EltwiseOp { + PROD = 0; + SUM = 1; + MAX = 2; + } + optional EltwiseOp operation = 1 [default = SUM]; // element-wise operation + repeated float coeff = 2; // blob-wise coefficient for SUM operation + + // Whether to use an asymptotically slower (for >2 inputs) but stabler method + // of computing the gradient for the PROD operation. (No effect for SUM op.) + optional bool stable_prod_grad = 3 [default = true]; +} + +// Message that stores parameters used by ELULayer +message ELUParameter { + // Described in: + // Clevert, D.-A., Unterthiner, T., & Hochreiter, S. (2015). Fast and Accurate + // Deep Network Learning by Exponential Linear Units (ELUs). arXiv + optional float alpha = 1 [default = 1]; +} + +// Message that stores parameters used by EmbedLayer +message EmbedParameter { + optional uint32 num_output = 1; // The number of outputs for the layer + // The input is given as integers to be interpreted as one-hot + // vector indices with dimension num_input. Hence num_input should be + // 1 greater than the maximum possible input value. + optional uint32 input_dim = 2; + + optional bool bias_term = 3 [default = true]; // Whether to use a bias term + optional FillerParameter weight_filler = 4; // The filler for the weight + optional FillerParameter bias_filler = 5; // The filler for the bias + +} + +// Message that stores parameters used by ExpLayer +message ExpParameter { + // ExpLayer computes outputs y = base ^ (shift + scale * x), for base > 0. + // Or if base is set to the default (-1), base is set to e, + // so y = exp(shift + scale * x). + optional float base = 1 [default = -1.0]; + optional float scale = 2 [default = 1.0]; + optional float shift = 3 [default = 0.0]; +} + +/// Message that stores parameters used by FlattenLayer +message FlattenParameter { + // The first axis to flatten: all preceding axes are retained in the output. + // May be negative to index from the end (e.g., -1 for the last axis). + optional int32 axis = 1 [default = 1]; + + // The last axis to flatten: all following axes are retained in the output. + // May be negative to index from the end (e.g., the default -1 for the last + // axis). + optional int32 end_axis = 2 [default = -1]; +} + +// Message that stores parameters used by HDF5DataLayer +message HDF5DataParameter { + // Specify the data source. + optional string source = 1; + // Specify the batch size. + optional uint32 batch_size = 2; + + // Specify whether to shuffle the data. + // If shuffle == true, the ordering of the HDF5 files is shuffled, + // and the ordering of data within any given HDF5 file is shuffled, + // but data between different files are not interleaved; all of a file's + // data are output (in a random order) before moving onto another file. + optional bool shuffle = 3 [default = false]; +} + +message HDF5OutputParameter { + optional string file_name = 1; +} + +message HingeLossParameter { + enum Norm { + L1 = 1; + L2 = 2; + } + // Specify the Norm to use L1 or L2 + optional Norm norm = 1 [default = L1]; +} + +message ImageDataParameter { + // Specify the data source. + optional string source = 1; + // Specify the batch size. + optional uint32 batch_size = 4 [default = 1]; + // The rand_skip variable is for the data layer to skip a few data points + // to avoid all asynchronous sgd clients to start at the same point. The skip + // point would be set as rand_skip * rand(0,1). Note that rand_skip should not + // be larger than the number of keys in the database. + optional uint32 rand_skip = 7 [default = 0]; + // Whether or not ImageLayer should shuffle the list of files at every epoch. + optional bool shuffle = 8 [default = false]; + // It will also resize images if new_height or new_width are not zero. + optional uint32 new_height = 9 [default = 0]; + optional uint32 new_width = 10 [default = 0]; + // Specify if the images are color or gray + optional bool is_color = 11 [default = true]; + // DEPRECATED. See TransformationParameter. For data pre-processing, we can do + // simple scaling and subtracting the data mean, if provided. Note that the + // mean subtraction is always carried out before scaling. + optional float scale = 2 [default = 1]; + optional string mean_file = 3; + // DEPRECATED. See TransformationParameter. Specify if we would like to randomly + // crop an image. + optional uint32 crop_size = 5 [default = 0]; + // DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror + // data. + optional bool mirror = 6 [default = false]; + optional string root_folder = 12 [default = ""]; +} + +message InfogainLossParameter { + // Specify the infogain matrix source. + optional string source = 1; +} + +message InnerProductParameter { + optional uint32 num_output = 1; // The number of outputs for the layer + optional bool bias_term = 2 [default = true]; // whether to have bias terms + optional FillerParameter weight_filler = 3; // The filler for the weight + optional FillerParameter bias_filler = 4; // The filler for the bias + + // The first axis to be lumped into a single inner product computation; + // all preceding axes are retained in the output. + // May be negative to index from the end (e.g., -1 for the last axis). + optional int32 axis = 5 [default = 1]; + // Specify whether to transpose the weight matrix or not. + // If transpose == true, any operations will be performed on the transpose + // of the weight matrix. The weight matrix itself is not going to be transposed + // but rather the transfer flag of operations will be toggled accordingly. + optional bool transpose = 6 [default = false]; +} + +message InputParameter { + // This layer produces N >= 1 top blob(s) to be assigned manually. + // Define N shapes to set a shape for each top. + // Define 1 shape to set the same shape for every top. + // Define no shape to defer to reshaping manually. + repeated BlobShape shape = 1; +} + +// Message that stores parameters used by LogLayer +message LogParameter { + // LogLayer computes outputs y = log_base(shift + scale * x), for base > 0. + // Or if base is set to the default (-1), base is set to e, + // so y = ln(shift + scale * x) = log_e(shift + scale * x) + optional float base = 1 [default = -1.0]; + optional float scale = 2 [default = 1.0]; + optional float shift = 3 [default = 0.0]; +} + +// Message that stores parameters used by LRNLayer +message LRNParameter { + optional uint32 local_size = 1 [default = 5]; + optional float alpha = 2 [default = 1.]; + optional float beta = 3 [default = 0.75]; + enum NormRegion { + ACROSS_CHANNELS = 0; + WITHIN_CHANNEL = 1; + } + optional NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + optional float k = 5 [default = 1.]; + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 6 [default = DEFAULT]; +} + +message MemoryDataParameter { + optional uint32 batch_size = 1; + optional uint32 channels = 2; + optional uint32 height = 3; + optional uint32 width = 4; +} + +message MVNParameter { + // This parameter can be set to false to normalize mean only + optional bool normalize_variance = 1 [default = true]; + + // This parameter can be set to true to perform DNN-like MVN + optional bool across_channels = 2 [default = false]; + + // Epsilon for not dividing by zero while normalizing variance + optional float eps = 3 [default = 1e-9]; +} + +message ParameterParameter { + optional BlobShape shape = 1; +} + +message PoolingParameter { + enum PoolMethod { + MAX = 0; + AVE = 1; + STOCHASTIC = 2; + } + optional PoolMethod pool = 1 [default = MAX]; // The pooling method + // Pad, kernel size, and stride are all given as a single value for equal + // dimensions in height and width or as Y, X pairs. + optional uint32 pad = 4 [default = 0]; // The padding size (equal in Y, X) + optional uint32 pad_h = 9 [default = 0]; // The padding height + optional uint32 pad_w = 10 [default = 0]; // The padding width + optional uint32 kernel_size = 2; // The kernel size (square) + optional uint32 kernel_h = 5; // The kernel height + optional uint32 kernel_w = 6; // The kernel width + optional uint32 stride = 3 [default = 1]; // The stride (equal in Y, X) + optional uint32 stride_h = 7; // The stride height + optional uint32 stride_w = 8; // The stride width + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 11 [default = DEFAULT]; + // If global_pooling then it will pool over the size of the bottom by doing + // kernel_h = bottom->height and kernel_w = bottom->width + optional bool global_pooling = 12 [default = false]; + // Specify floor/ceil mode + // source: https://github.com/BVLC/caffe/pull/3057 + optional bool ceil_mode = 13 [default = true]; +} + +message PowerParameter { + // PowerLayer computes outputs y = (shift + scale * x) ^ power. + optional float power = 1 [default = 1.0]; + optional float scale = 2 [default = 1.0]; + optional float shift = 3 [default = 0.0]; +} + +message PythonParameter { + optional string module = 1; + optional string layer = 2; + // This value is set to the attribute `param_str` of the `PythonLayer` object + // in Python before calling the `setup()` method. This could be a number, + // string, dictionary in Python dict format, JSON, etc. You may parse this + // string in `setup` method and use it in `forward` and `backward`. + optional string param_str = 3 [default = '']; + // Whether this PythonLayer is shared among worker solvers during data parallelism. + // If true, each worker solver sequentially run forward from this layer. + // This value should be set true if you are using it as a data layer. + optional bool share_in_parallel = 4 [default = false]; +} + +// Message that stores parameters used by RecurrentLayer +message RecurrentParameter { + // The dimension of the output (and usually hidden state) representation -- + // must be explicitly set to non-zero. + optional uint32 num_output = 1 [default = 0]; + + optional FillerParameter weight_filler = 2; // The filler for the weight + optional FillerParameter bias_filler = 3; // The filler for the bias + + // Whether to enable displaying debug_info in the unrolled recurrent net. + optional bool debug_info = 4 [default = false]; + + // Whether to add as additional inputs (bottoms) the initial hidden state + // blobs, and add as additional outputs (tops) the final timestep hidden state + // blobs. The number of additional bottom/top blobs required depends on the + // recurrent architecture -- e.g., 1 for RNNs, 2 for LSTMs. + optional bool expose_hidden = 5 [default = false]; +} + +// Message that stores parameters used by ReductionLayer +message ReductionParameter { + enum ReductionOp { + SUM = 1; + ASUM = 2; + SUMSQ = 3; + MEAN = 4; + } + + optional ReductionOp operation = 1 [default = SUM]; // reduction operation + + // The first axis to reduce to a scalar -- may be negative to index from the + // end (e.g., -1 for the last axis). + // (Currently, only reduction along ALL "tail" axes is supported; reduction + // of axis M through N, where N < num_axes - 1, is unsupported.) + // Suppose we have an n-axis bottom Blob with shape: + // (d0, d1, d2, ..., d(m-1), dm, d(m+1), ..., d(n-1)). + // If axis == m, the output Blob will have shape + // (d0, d1, d2, ..., d(m-1)), + // and the ReductionOp operation is performed (d0 * d1 * d2 * ... * d(m-1)) + // times, each including (dm * d(m+1) * ... * d(n-1)) individual data. + // If axis == 0 (the default), the output Blob always has the empty shape + // (count 1), performing reduction across the entire input -- + // often useful for creating new loss functions. + optional int32 axis = 2 [default = 0]; + + optional float coeff = 3 [default = 1.0]; // coefficient for output +} + +// Message that stores parameters used by ReLULayer +message ReLUParameter { + // Allow non-zero slope for negative inputs to speed up optimization + // Described in: + // Maas, A. L., Hannun, A. Y., & Ng, A. Y. (2013). Rectifier nonlinearities + // improve neural network acoustic models. In ICML Workshop on Deep Learning + // for Audio, Speech, and Language Processing. + optional float negative_slope = 1 [default = 0]; + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 2 [default = DEFAULT]; +} + +message ReshapeParameter { + // Specify the output dimensions. If some of the dimensions are set to 0, + // the corresponding dimension from the bottom layer is used (unchanged). + // Exactly one dimension may be set to -1, in which case its value is + // inferred from the count of the bottom blob and the remaining dimensions. + // For example, suppose we want to reshape a 2D blob "input" with shape 2 x 8: + // + // layer { + // type: "Reshape" bottom: "input" top: "output" + // reshape_param { ... } + // } + // + // If "input" is 2D with shape 2 x 8, then the following reshape_param + // specifications are all equivalent, producing a 3D blob "output" with shape + // 2 x 2 x 4: + // + // reshape_param { shape { dim: 2 dim: 2 dim: 4 } } + // reshape_param { shape { dim: 0 dim: 2 dim: 4 } } + // reshape_param { shape { dim: 0 dim: 2 dim: -1 } } + // reshape_param { shape { dim: 0 dim:-1 dim: 4 } } + // + optional BlobShape shape = 1; + + // axis and num_axes control the portion of the bottom blob's shape that are + // replaced by (included in) the reshape. By default (axis == 0 and + // num_axes == -1), the entire bottom blob shape is included in the reshape, + // and hence the shape field must specify the entire output shape. + // + // axis may be non-zero to retain some portion of the beginning of the input + // shape (and may be negative to index from the end; e.g., -1 to begin the + // reshape after the last axis, including nothing in the reshape, + // -2 to include only the last axis, etc.). + // + // For example, suppose "input" is a 2D blob with shape 2 x 8. + // Then the following ReshapeLayer specifications are all equivalent, + // producing a blob "output" with shape 2 x 2 x 4: + // + // reshape_param { shape { dim: 2 dim: 2 dim: 4 } } + // reshape_param { shape { dim: 2 dim: 4 } axis: 1 } + // reshape_param { shape { dim: 2 dim: 4 } axis: -3 } + // + // num_axes specifies the extent of the reshape. + // If num_axes >= 0 (and axis >= 0), the reshape will be performed only on + // input axes in the range [axis, axis+num_axes]. + // num_axes may also be -1, the default, to include all remaining axes + // (starting from axis). + // + // For example, suppose "input" is a 2D blob with shape 2 x 8. + // Then the following ReshapeLayer specifications are equivalent, + // producing a blob "output" with shape 1 x 2 x 8. + // + // reshape_param { shape { dim: 1 dim: 2 dim: 8 } } + // reshape_param { shape { dim: 1 dim: 2 } num_axes: 1 } + // reshape_param { shape { dim: 1 } num_axes: 0 } + // + // On the other hand, these would produce output blob shape 2 x 1 x 8: + // + // reshape_param { shape { dim: 2 dim: 1 dim: 8 } } + // reshape_param { shape { dim: 1 } axis: 1 num_axes: 0 } + // + optional int32 axis = 2 [default = 0]; + optional int32 num_axes = 3 [default = -1]; +} + +message ScaleParameter { + // The first axis of bottom[0] (the first input Blob) along which to apply + // bottom[1] (the second input Blob). May be negative to index from the end + // (e.g., -1 for the last axis). + // + // For example, if bottom[0] is 4D with shape 100x3x40x60, the output + // top[0] will have the same shape, and bottom[1] may have any of the + // following shapes (for the given value of axis): + // (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60 + // (axis == 1 == -3) 3; 3x40; 3x40x60 + // (axis == 2 == -2) 40; 40x60 + // (axis == 3 == -1) 60 + // Furthermore, bottom[1] may have the empty shape (regardless of the value of + // "axis") -- a scalar multiplier. + optional int32 axis = 1 [default = 1]; + + // (num_axes is ignored unless just one bottom is given and the scale is + // a learned parameter of the layer. Otherwise, num_axes is determined by the + // number of axes by the second bottom.) + // The number of axes of the input (bottom[0]) covered by the scale + // parameter, or -1 to cover all axes of bottom[0] starting from `axis`. + // Set num_axes := 0, to multiply with a zero-axis Blob: a scalar. + optional int32 num_axes = 2 [default = 1]; + + // (filler is ignored unless just one bottom is given and the scale is + // a learned parameter of the layer.) + // The initialization for the learned scale parameter. + // Default is the unit (1) initialization, resulting in the ScaleLayer + // initially performing the identity operation. + optional FillerParameter filler = 3; + + // Whether to also learn a bias (equivalent to a ScaleLayer+BiasLayer, but + // may be more efficient). Initialized with bias_filler (defaults to 0). + optional bool bias_term = 4 [default = false]; + optional FillerParameter bias_filler = 5; +} + +message SigmoidParameter { + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 1 [default = DEFAULT]; +} + +message SliceParameter { + // The axis along which to slice -- may be negative to index from the end + // (e.g., -1 for the last axis). + // By default, SliceLayer concatenates blobs along the "channels" axis (1). + optional int32 axis = 3 [default = 1]; + repeated uint32 slice_point = 2; + + // DEPRECATED: alias for "axis" -- does not support negative indexing. + optional uint32 slice_dim = 1 [default = 1]; +} + +// Message that stores parameters used by SoftmaxLayer, SoftmaxWithLossLayer +message SoftmaxParameter { + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 1 [default = DEFAULT]; + + // The axis along which to perform the softmax -- may be negative to index + // from the end (e.g., -1 for the last axis). + // Any other axes will be evaluated as independent softmaxes. + optional int32 axis = 2 [default = 1]; +} + +message TanHParameter { + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 1 [default = DEFAULT]; +} + +// Message that stores parameters used by TileLayer +message TileParameter { + // The index of the axis to tile. + optional int32 axis = 1 [default = 1]; + + // The number of copies (tiles) of the blob to output. + optional int32 tiles = 2; +} + +// Message that stores parameters used by ThresholdLayer +message ThresholdParameter { + optional float threshold = 1 [default = 0]; // Strictly positive values +} + +message WindowDataParameter { + // Specify the data source. + optional string source = 1; + // For data pre-processing, we can do simple scaling and subtracting the + // data mean, if provided. Note that the mean subtraction is always carried + // out before scaling. + optional float scale = 2 [default = 1]; + optional string mean_file = 3; + // Specify the batch size. + optional uint32 batch_size = 4; + // Specify if we would like to randomly crop an image. + optional uint32 crop_size = 5 [default = 0]; + // Specify if we want to randomly mirror data. + optional bool mirror = 6 [default = false]; + // Foreground (object) overlap threshold + optional float fg_threshold = 7 [default = 0.5]; + // Background (non-object) overlap threshold + optional float bg_threshold = 8 [default = 0.5]; + // Fraction of batch that should be foreground objects + optional float fg_fraction = 9 [default = 0.25]; + // Amount of contextual padding to add around a window + // (used only by the window_data_layer) + optional uint32 context_pad = 10 [default = 0]; + // Mode for cropping out a detection window + // warp: cropped window is warped to a fixed size and aspect ratio + // square: the tightest square around the window is cropped + optional string crop_mode = 11 [default = "warp"]; + // cache_images: will load all images in memory for faster access + optional bool cache_images = 12 [default = false]; + // append root_folder to locate images + optional string root_folder = 13 [default = ""]; +} + +message SPPParameter { + enum PoolMethod { + MAX = 0; + AVE = 1; + STOCHASTIC = 2; + } + optional uint32 pyramid_height = 1; + optional PoolMethod pool = 2 [default = MAX]; // The pooling method + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 6 [default = DEFAULT]; +} + +// DEPRECATED: use LayerParameter. +message V1LayerParameter { + repeated string bottom = 2; + repeated string top = 3; + optional string name = 4; + repeated NetStateRule include = 32; + repeated NetStateRule exclude = 33; + enum LayerType { + NONE = 0; + ABSVAL = 35; + ACCURACY = 1; + ARGMAX = 30; + BNLL = 2; + CONCAT = 3; + CONTRASTIVE_LOSS = 37; + CONVOLUTION = 4; + DATA = 5; + DECONVOLUTION = 39; + DROPOUT = 6; + DUMMY_DATA = 32; + EUCLIDEAN_LOSS = 7; + ELTWISE = 25; + EXP = 38; + FLATTEN = 8; + HDF5_DATA = 9; + HDF5_OUTPUT = 10; + HINGE_LOSS = 28; + IM2COL = 11; + IMAGE_DATA = 12; + INFOGAIN_LOSS = 13; + INNER_PRODUCT = 14; + LRN = 15; + MEMORY_DATA = 29; + MULTINOMIAL_LOGISTIC_LOSS = 16; + MVN = 34; + POOLING = 17; + POWER = 26; + RELU = 18; + SIGMOID = 19; + SIGMOID_CROSS_ENTROPY_LOSS = 27; + SILENCE = 36; + SOFTMAX = 20; + SOFTMAX_LOSS = 21; + SPLIT = 22; + SLICE = 33; + TANH = 23; + WINDOW_DATA = 24; + THRESHOLD = 31; + } + optional LayerType type = 5; + repeated BlobProto blobs = 6; + repeated string param = 1001; + repeated DimCheckMode blob_share_mode = 1002; + enum DimCheckMode { + STRICT = 0; + PERMISSIVE = 1; + } + repeated float blobs_lr = 7; + repeated float weight_decay = 8; + repeated float loss_weight = 35; + optional AccuracyParameter accuracy_param = 27; + optional ArgMaxParameter argmax_param = 23; + optional ConcatParameter concat_param = 9; + optional ContrastiveLossParameter contrastive_loss_param = 40; + optional ConvolutionParameter convolution_param = 10; + optional DataParameter data_param = 11; + optional DropoutParameter dropout_param = 12; + optional DummyDataParameter dummy_data_param = 26; + optional EltwiseParameter eltwise_param = 24; + optional ExpParameter exp_param = 41; + optional HDF5DataParameter hdf5_data_param = 13; + optional HDF5OutputParameter hdf5_output_param = 14; + optional HingeLossParameter hinge_loss_param = 29; + optional ImageDataParameter image_data_param = 15; + optional InfogainLossParameter infogain_loss_param = 16; + optional InnerProductParameter inner_product_param = 17; + optional LRNParameter lrn_param = 18; + optional MemoryDataParameter memory_data_param = 22; + optional MVNParameter mvn_param = 34; + optional PoolingParameter pooling_param = 19; + optional PowerParameter power_param = 21; + optional ReLUParameter relu_param = 30; + optional SigmoidParameter sigmoid_param = 38; + optional SoftmaxParameter softmax_param = 39; + optional SliceParameter slice_param = 31; + optional TanHParameter tanh_param = 37; + optional ThresholdParameter threshold_param = 25; + optional WindowDataParameter window_data_param = 20; + optional TransformationParameter transform_param = 36; + optional LossParameter loss_param = 42; + optional V0LayerParameter layer = 1; +} + +// DEPRECATED: V0LayerParameter is the old way of specifying layer parameters +// in Caffe. We keep this message type around for legacy support. +message V0LayerParameter { + optional string name = 1; // the layer name + optional string type = 2; // the string to specify the layer type + + // Parameters to specify layers with inner products. + optional uint32 num_output = 3; // The number of outputs for the layer + optional bool biasterm = 4 [default = true]; // whether to have bias terms + optional FillerParameter weight_filler = 5; // The filler for the weight + optional FillerParameter bias_filler = 6; // The filler for the bias + + optional uint32 pad = 7 [default = 0]; // The padding size + optional uint32 kernelsize = 8; // The kernel size + optional uint32 group = 9 [default = 1]; // The group size for group conv + optional uint32 stride = 10 [default = 1]; // The stride + enum PoolMethod { + MAX = 0; + AVE = 1; + STOCHASTIC = 2; + } + optional PoolMethod pool = 11 [default = MAX]; // The pooling method + optional float dropout_ratio = 12 [default = 0.5]; // dropout ratio + + optional uint32 local_size = 13 [default = 5]; // for local response norm + optional float alpha = 14 [default = 1.]; // for local response norm + optional float beta = 15 [default = 0.75]; // for local response norm + optional float k = 22 [default = 1.]; + + // For data layers, specify the data source + optional string source = 16; + // For data pre-processing, we can do simple scaling and subtracting the + // data mean, if provided. Note that the mean subtraction is always carried + // out before scaling. + optional float scale = 17 [default = 1]; + optional string meanfile = 18; + // For data layers, specify the batch size. + optional uint32 batchsize = 19; + // For data layers, specify if we would like to randomly crop an image. + optional uint32 cropsize = 20 [default = 0]; + // For data layers, specify if we want to randomly mirror data. + optional bool mirror = 21 [default = false]; + + // The blobs containing the numeric parameters of the layer + repeated BlobProto blobs = 50; + // The ratio that is multiplied on the global learning rate. If you want to + // set the learning ratio for one blob, you need to set it for all blobs. + repeated float blobs_lr = 51; + // The weight decay that is multiplied on the global weight decay. + repeated float weight_decay = 52; + + // The rand_skip variable is for the data layer to skip a few data points + // to avoid all asynchronous sgd clients to start at the same point. The skip + // point would be set as rand_skip * rand(0,1). Note that rand_skip should not + // be larger than the number of keys in the database. + optional uint32 rand_skip = 53 [default = 0]; + + // Fields related to detection (det_*) + // foreground (object) overlap threshold + optional float det_fg_threshold = 54 [default = 0.5]; + // background (non-object) overlap threshold + optional float det_bg_threshold = 55 [default = 0.5]; + // Fraction of batch that should be foreground objects + optional float det_fg_fraction = 56 [default = 0.25]; + + // optional bool OBSOLETE_can_clobber = 57 [default = true]; + + // Amount of contextual padding to add around a window + // (used only by the window_data_layer) + optional uint32 det_context_pad = 58 [default = 0]; + + // Mode for cropping out a detection window + // warp: cropped window is warped to a fixed size and aspect ratio + // square: the tightest square around the window is cropped + optional string det_crop_mode = 59 [default = "warp"]; + + // For ReshapeLayer, one needs to specify the new dimensions. + optional int32 new_num = 60 [default = 0]; + optional int32 new_channels = 61 [default = 0]; + optional int32 new_height = 62 [default = 0]; + optional int32 new_width = 63 [default = 0]; + + // Whether or not ImageLayer should shuffle the list of files at every epoch. + // It will also resize images if new_height or new_width are not zero. + optional bool shuffle_images = 64 [default = false]; + + // For ConcatLayer, one needs to specify the dimension for concatenation, and + // the other dimensions must be the same for all the bottom blobs. + // By default it will concatenate blobs along the channels dimension. + optional uint32 concat_dim = 65 [default = 1]; + + optional HDF5OutputParameter hdf5_output_param = 1001; +} + +message PReLUParameter { + // Parametric ReLU described in K. He et al, Delving Deep into Rectifiers: + // Surpassing Human-Level Performance on ImageNet Classification, 2015. + + // Initial value of a_i. Default is a_i=0.25 for all i. + optional FillerParameter filler = 1; + // Whether or not slope parameters are shared across channels. + optional bool channel_shared = 2 [default = false]; +} + +// The normalized bounding box [0, 1] w.r.t. the input image size. +message NormalizedBBox { + optional float xmin = 1; + optional float ymin = 2; + optional float xmax = 3; + optional float ymax = 4; + optional int32 label = 5; + optional bool difficult = 6; + optional float score = 7; + optional float size = 8; +} + +// origin: https://github.com/rbgirshick/caffe-fast-rcnn/tree/fast-rcnn +// Message that stores parameters used by ROIPoolingLayer +message ROIPoolingParameter { + // Pad, kernel size, and stride are all given as a single value for equal + // dimensions in height and width or as Y, X pairs. + optional uint32 pooled_h = 1 [default = 0]; // The pooled output height + optional uint32 pooled_w = 2 [default = 0]; // The pooled output width + // Multiplicative spatial scale factor to translate ROI coords from their + // input scale to the scale used when pooling + optional float spatial_scale = 3 [default = 1]; +} + +message ProposalParameter { + optional uint32 feat_stride = 1 [default = 16]; + optional uint32 base_size = 2 [default = 16]; + optional uint32 min_size = 3 [default = 16]; + repeated float ratio = 4; + repeated float scale = 5; + optional uint32 pre_nms_topn = 6 [default = 6000]; + optional uint32 post_nms_topn = 7 [default = 300]; + optional float nms_thresh = 8 [default = 0.7]; +} + +// origin: https://github.com/daijifeng001/caffe-rfcn +message PSROIPoolingParameter { + required float spatial_scale = 1; + required int32 output_dim = 2; // output channel number + required int32 group_size = 3; // equal to pooled_size +} diff --git a/modules/dnnlegacy/src/darknet/darknet_importer.cpp b/modules/dnnlegacy/src/darknet/darknet_importer.cpp new file mode 100644 index 00000000000..3dc579a38f9 --- /dev/null +++ b/modules/dnnlegacy/src/darknet/darknet_importer.cpp @@ -0,0 +1,256 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// (3-clause BSD License) +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * Neither the names of the copyright holders nor the names of the contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall copyright holders or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ +#include "../precomp.hpp" + + +#include +#include +#include +#include +#include + +#include "darknet_io.hpp" + +#include + +namespace cv { +namespace dnnlegacy { +using namespace dnn; +namespace +{ + +class DarknetImporter +{ + FPDenormalsIgnoreHintScope fp_denormals_ignore_scope; + + dnnlegacy::darknet::NetParameter net; + +public: + + DarknetImporter() {} + + DarknetImporter(std::istream &cfgStream, std::istream &darknetModelStream) + { + CV_TRACE_FUNCTION(); + + dnnlegacy::ReadNetParamsFromCfgStreamOrDie(cfgStream, &net); + dnnlegacy::ReadNetParamsFromBinaryStreamOrDie(darknetModelStream, &net); + } + + DarknetImporter(std::istream &cfgStream) + { + CV_TRACE_FUNCTION(); + + dnnlegacy::ReadNetParamsFromCfgStreamOrDie(cfgStream, &net); + } + + struct BlobNote + { + BlobNote(const std::string &_name, int _layerId, int _outNum) : + name(_name), layerId(_layerId), outNum(_outNum) {} + + std::string name; + int layerId, outNum; + }; + + std::vector addedBlobs; + std::map layerCounter; + + void populateNet(cv::dnn::Net dstNet) + { + CV_TRACE_FUNCTION(); + + int layersSize = net.layer_size(); + layerCounter.clear(); + addedBlobs.clear(); + addedBlobs.reserve(layersSize + 1); + + //setup input layer names + { + std::vector netInputs(net.input_size()); + for (int inNum = 0; inNum < net.input_size(); inNum++) + { + addedBlobs.push_back(BlobNote(net.input(inNum), 0, inNum)); + netInputs[inNum] = net.input(inNum); + } + dstNet.setInputsNames(netInputs); + } + + for (int li = 0; li < layersSize; li++) + { + const dnnlegacy::darknet::LayerParameter &layer = net.layer(li); + String name = layer.name(); + String type = layer.type(); + cv::dnn::LayerParams layerParams = layer.getLayerParams(); + + int repetitions = layerCounter[name]++; + if (repetitions) + name += cv::format("_%d", repetitions); + + int id = dstNet.addLayer(name, type, layerParams); + + // iterate many bottoms layers (for example for: route -1, -4) + for (int inNum = 0; inNum < layer.bottom_size(); inNum++) + addInput(layer.bottom(inNum), id, inNum, dstNet, layer.name()); + + for (int outNum = 0; outNum < layer.top_size(); outNum++) + addOutput(layer, id, outNum); + } + + addedBlobs.clear(); + } + + void addOutput(const dnnlegacy::darknet::LayerParameter &layer, int layerId, int outNum) + { + const std::string &name = layer.top(outNum); + + bool haveDups = false; + for (int idx = (int)addedBlobs.size() - 1; idx >= 0; idx--) + { + if (addedBlobs[idx].name == name) + { + haveDups = true; + break; + } + } + + if (haveDups) + { + bool isInplace = layer.bottom_size() > outNum && layer.bottom(outNum) == name; + if (!isInplace) + CV_Error(Error::StsBadArg, "Duplicate blobs produced by multiple sources"); + } + + addedBlobs.push_back(BlobNote(name, layerId, outNum)); + } + + void addInput(const std::string &name, int layerId, int inNum, cv::dnn::Net &dstNet, std::string nn) + { + int idx; + for (idx = (int)addedBlobs.size() - 1; idx >= 0; idx--) + { + if (addedBlobs[idx].name == name) + break; + } + + if (idx < 0) + { + CV_Error(Error::StsObjectNotFound, "Can't find output blob \"" + name + "\""); + return; + } + + dstNet.connect(addedBlobs[idx].layerId, addedBlobs[idx].outNum, layerId, inNum); + } +}; + +static Net readNetFromDarknet(std::istream &cfgFile, std::istream &darknetModel) +{ + Net net; + DarknetImporter darknetImporter(cfgFile, darknetModel); + darknetImporter.populateNet(net); + return net; +} + +static Net readNetFromDarknet(std::istream &cfgFile) +{ + Net net; + DarknetImporter darknetImporter(cfgFile); + darknetImporter.populateNet(net); + return net; +} + +} + +Net readNetFromDarknet(const String &cfgFile, const String &darknetModel /*= String()*/) +{ + std::ifstream cfgStream(cfgFile.c_str()); + if (!cfgStream.is_open()) + { + CV_Error(cv::Error::StsParseError, "Failed to open NetParameter file: " + std::string(cfgFile)); + } + if (darknetModel != String()) + { + std::ifstream darknetModelStream(darknetModel.c_str(), std::ios::binary); + if (!darknetModelStream.is_open()) + { + CV_Error(cv::Error::StsParseError, "Failed to parse NetParameter file: " + std::string(darknetModel)); + } + return readNetFromDarknet(cfgStream, darknetModelStream); + } + else + return readNetFromDarknet(cfgStream); +} + +struct BufferStream : public std::streambuf +{ + BufferStream(const char* s, std::size_t n) + { + char* ptr = const_cast(s); + setg(ptr, ptr, ptr + n); + } +}; + +Net readNetFromDarknet(const char *bufferCfg, size_t lenCfg, const char *bufferModel, size_t lenModel) +{ + BufferStream cfgBufferStream(bufferCfg, lenCfg); + std::istream cfgStream(&cfgBufferStream); + if (lenModel) + { + BufferStream weightsBufferStream(bufferModel, lenModel); + std::istream weightsStream(&weightsBufferStream); + return readNetFromDarknet(cfgStream, weightsStream); + } + else + return readNetFromDarknet(cfgStream); +} + +Net readNetFromDarknet(const std::vector& bufferCfg, const std::vector& bufferModel) +{ + const char* bufferCfgPtr = reinterpret_cast(&bufferCfg[0]); + const char* bufferModelPtr = bufferModel.empty() ? NULL : + reinterpret_cast(&bufferModel[0]); + return readNetFromDarknet(bufferCfgPtr, bufferCfg.size(), + bufferModelPtr, bufferModel.size()); +} + +}} // namespace diff --git a/modules/dnnlegacy/src/darknet/darknet_io.cpp b/modules/dnnlegacy/src/darknet/darknet_io.cpp new file mode 100644 index 00000000000..9e6e81e32a9 --- /dev/null +++ b/modules/dnnlegacy/src/darknet/darknet_io.cpp @@ -0,0 +1,1110 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// (3-clause BSD License) +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * Neither the names of the copyright holders nor the names of the contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall copyright holders or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +/*M/////////////////////////////////////////////////////////////////////////////////////// +//MIT License +// +//Copyright (c) 2017 Joseph Redmon +// +//Permission is hereby granted, free of charge, to any person obtaining a copy +//of this software and associated documentation files (the "Software"), to deal +//in the Software without restriction, including without limitation the rights +//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +//copies of the Software, and to permit persons to whom the Software is +//furnished to do so, subject to the following conditions: +// +//The above copyright notice and this permission notice shall be included in all +//copies or substantial portions of the Software. +// +//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +//SOFTWARE. +// +//M*/ + +#include +#include + +#include +#include +#include + +#include "darknet_io.hpp" + +namespace cv { + namespace dnnlegacy { + namespace darknet { + + template + T getParam(const std::map ¶ms, const std::string param_name, T init_val) + { + std::map::const_iterator it = params.find(param_name); + if (it != params.end()) { + std::stringstream ss(it->second); + ss >> init_val; + } + return init_val; + } + + static const std::string kFirstLayerName = "data"; + + class setLayersParams { + + NetParameter *net; + int layer_id; + std::string last_layer; + std::vector fused_layer_names; + + public: + setLayersParams(NetParameter *_net) : + net(_net), layer_id(0), last_layer(kFirstLayerName) + {} + + void setLayerBlobs(int i, std::vector blobs) + { + cv::dnn::LayerParams ¶ms = net->layers[i].layerParams; + params.blobs = blobs; + } + + void setBatchNorm() + { + cv::dnn::LayerParams bn_param; + + bn_param.name = "BatchNorm-name"; + bn_param.type = "BatchNorm"; + bn_param.set("has_weight", true); + bn_param.set("has_bias", true); + bn_param.set("eps", 1E-6); // .000001f in Darknet Yolo + + darknet::LayerParameter lp; + std::string layer_name = cv::format("bn_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = bn_param.type; + lp.layerParams = bn_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + } + + cv::dnn::LayerParams getParamConvolution(int kernel, int pad, + int stride, int filters_num) + { + cv::dnn::LayerParams params; + params.name = "Convolution-name"; + params.type = "Convolution"; + + params.set("kernel_size", kernel); + params.set("pad", pad); + params.set("stride", stride); + + params.set("bias_term", false); // true only if(BatchNorm == false) + params.set("num_output", filters_num); + + return params; + } + + + void setConvolution(int kernel, int pad, int stride, + int filters_num, int channels_num, int groups, int use_batch_normalize) + { + cv::dnn::LayerParams conv_param = + getParamConvolution(kernel, pad, stride, filters_num); + + darknet::LayerParameter lp; + std::string layer_name = cv::format("conv_%d", layer_id); + + // use BIAS in any case + if (!use_batch_normalize) { + conv_param.set("bias_term", true); + } + + conv_param.set("group", groups); + + lp.layer_name = layer_name; + lp.layer_type = conv_param.type; + lp.layerParams = conv_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + + if (use_batch_normalize) + setBatchNorm(); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + cv::dnn::LayerParams getParamFullyConnected(int output) + { + cv::dnn::LayerParams params; + params.name = "FullyConnected-name"; + params.type = "InnerProduct"; + + params.set("bias_term", false); // true only if(BatchNorm == false) + params.set("num_output", output); + + return params; + } + + void setFullyConnected(int output, int use_batch_normalize) + { + cv::dnn::LayerParams fullyconnected_param = + getParamFullyConnected(output); + + darknet::LayerParameter lp; + std::string layer_name = cv::format("fullyConnected_%d", layer_id); + + // use BIAS in any case + if (!use_batch_normalize) { + fullyconnected_param.set("bias_term", true); + } + + lp.layer_name = layer_name; + lp.layer_type = fullyconnected_param.type; + lp.layerParams = fullyconnected_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + + if (use_batch_normalize) + setBatchNorm(); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setActivation(String type) + { + cv::dnn::LayerParams activation_param; + if (type == "relu") + { + activation_param.type = "ReLU"; + } + else if (type == "leaky") + { + activation_param.set("negative_slope", 0.1f); + activation_param.type = "ReLU"; + } + else if (type == "swish" || type == "silu") // swish is an extension of silu. + { + activation_param.type = "Swish"; + } + else if (type == "mish") + { + activation_param.type = "Mish"; + } + else if (type == "logistic") + { + activation_param.type = "Sigmoid"; + } + else if (type == "tanh") + { + activation_param.type = "TanH"; + } + else + { + CV_Error(cv::Error::StsParseError, "Unsupported activation: " + type); + } + + std::string layer_name = cv::format("%s_%d", type.c_str(), layer_id); + + darknet::LayerParameter lp; + lp.layer_name = layer_name; + lp.layer_type = activation_param.type; + lp.layerParams = activation_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + + fused_layer_names.back() = last_layer; + } + + void setMaxpool(int kernel, int pad, int stride) + { + cv::dnn::LayerParams maxpool_param; + maxpool_param.set("pool", "max"); + maxpool_param.set("kernel_size", kernel); + maxpool_param.set("pad_l", floor((float)pad / 2)); + maxpool_param.set("pad_r", ceil((float)pad / 2)); + maxpool_param.set("pad_t", floor((float)pad / 2)); + maxpool_param.set("pad_b", ceil((float)pad / 2)); + maxpool_param.set("ceil_mode", false); + maxpool_param.set("stride", stride); + maxpool_param.name = "Pooling-name"; + maxpool_param.type = "Pooling"; + + darknet::LayerParameter lp; + std::string layer_name = cv::format("pool_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = maxpool_param.type; + lp.layerParams = maxpool_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setAvgpool() + { + cv::dnn::LayerParams avgpool_param; + avgpool_param.set("pool", "ave"); + avgpool_param.set("global_pooling", true); + avgpool_param.name = "Pooling-name"; + avgpool_param.type = "Pooling"; + darknet::LayerParameter lp; + + std::string layer_name = cv::format("avgpool_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = avgpool_param.type; + lp.layerParams = avgpool_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setCrop(int crop_height, int crop_width, int inp_height, int inp_width, bool noadjust) + { + cv::dnn::LayerParams crop_param; + crop_param.name = "CropLayer-name"; + std::vector begin = {0, 0, (inp_height - crop_height) / 2, (inp_width - crop_width) / 2}; + std::vector sizes = {-1, -1, crop_height, crop_width}; + crop_param.set("begin", cv::dnn::DictValue::arrayInt(&begin[0], begin.size())); + crop_param.set("size", cv::dnn::DictValue::arrayInt(&sizes[0], sizes.size())); + crop_param.type = "Slice"; + + darknet::LayerParameter lp; + std::string layer_name = cv::format("crop_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = crop_param.type; + lp.layerParams = crop_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + layer_id++; + + if (!noadjust) + { + cv::dnn::LayerParams params; + params.set("bias_term", true); + params.blobs = { + Mat(1, 1, CV_32F, Scalar(2)), + Mat(1, 1, CV_32F, Scalar(-1)) + }; + + darknet::LayerParameter lp; + std::string layer_name = cv::format("adjust_crop_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = "Scale"; + lp.layerParams = params; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + layer_id++; + } + fused_layer_names.push_back(last_layer); + } + + void setSoftmax() + { + cv::dnn::LayerParams softmax_param; + softmax_param.name = "Softmax-name"; + softmax_param.type = "Softmax"; + // set default axis to 1 + if(!softmax_param.has("axis")) + softmax_param.set("axis", 1); + darknet::LayerParameter lp; + + std::string layer_name = cv::format("softmax_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = softmax_param.type; + lp.layerParams = softmax_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setConcat(int number_of_inputs, int *input_indexes) + { + cv::dnn::LayerParams concat_param; + concat_param.name = "Concat-name"; + concat_param.type = "Concat"; + concat_param.set("axis", 1); // channels are in axis = 1 + + darknet::LayerParameter lp; + + std::string layer_name = cv::format("concat_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = concat_param.type; + lp.layerParams = concat_param; + for (int i = 0; i < number_of_inputs; ++i) + lp.bottom_indexes.push_back(fused_layer_names.at(input_indexes[i])); + + last_layer = layer_name; + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setIdentity(int bottom_index) + { + cv::dnn::LayerParams identity_param; + identity_param.name = "Identity-name"; + identity_param.type = "Identity"; + + darknet::LayerParameter lp; + + std::string layer_name = cv::format("identity_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = identity_param.type; + lp.layerParams = identity_param; + lp.bottom_indexes.push_back(fused_layer_names.at(bottom_index)); + + last_layer = layer_name; + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setSlice(int input_index, int split_size, int group_id) + { + int begin[] = {0, split_size * group_id, 0, 0}; + cv::dnn::DictValue paramBegin = cv::dnn::DictValue::arrayInt(begin, 4); + + int end[] = {INT_MAX, begin[1] + split_size, INT_MAX, INT_MAX}; + cv::dnn::DictValue paramEnd = cv::dnn::DictValue::arrayInt(end, 4); + + darknet::LayerParameter lp; + lp.layer_name = cv::format("slice_%d", layer_id); + lp.layer_type = "Slice"; + lp.layerParams.set("begin", paramBegin); + lp.layerParams.set("end", paramEnd); + + lp.bottom_indexes.push_back(fused_layer_names.at(input_index)); + net->layers.push_back(lp); + + layer_id++; + last_layer = lp.layer_name; + fused_layer_names.push_back(last_layer); + } + + void setReorg(int stride) + { + cv::dnn::LayerParams reorg_params; + reorg_params.name = "Reorg-name"; + reorg_params.type = "Reorg"; + reorg_params.set("reorg_stride", stride); + + darknet::LayerParameter lp; + std::string layer_name = cv::format("reorg_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = reorg_params.type; + lp.layerParams = reorg_params; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setPermute(bool isDarknetLayer = true) + { + cv::dnn::LayerParams permute_params; + permute_params.name = "Permute-name"; + permute_params.type = "Permute"; + int permute[] = { 0, 2, 3, 1 }; + cv::dnn::DictValue paramOrder = cv::dnn::DictValue::arrayInt(permute, 4); + + permute_params.set("order", paramOrder); + + darknet::LayerParameter lp; + std::string layer_name = cv::format("permute_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = permute_params.type; + lp.layerParams = permute_params; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + + if (isDarknetLayer) + { + layer_id++; + fused_layer_names.push_back(last_layer); + } + } + + void setRegion(float thresh, int coords, int classes, int anchors, int classfix, int softmax, int softmax_tree, float *biasData) + { + cv::dnn::LayerParams region_param; + region_param.name = "Region-name"; + region_param.type = "Region"; + + region_param.set("thresh", thresh); + region_param.set("coords", coords); + region_param.set("classes", classes); + region_param.set("anchors", anchors); + region_param.set("classfix", classfix); + region_param.set("softmax_tree", softmax_tree); + region_param.set("softmax", softmax); + + cv::Mat biasData_mat = cv::Mat(1, anchors * 2, CV_32F, biasData).clone(); + region_param.blobs.push_back(biasData_mat); + + darknet::LayerParameter lp; + std::string layer_name = "detection_out"; + lp.layer_name = layer_name; + lp.layer_type = region_param.type; + lp.layerParams = region_param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setYolo(int classes, const std::vector& mask, const std::vector& anchors, float thresh, float nms_threshold, float scale_x_y, int new_coords) + { + cv::dnn::LayerParams region_param; + region_param.name = "Region-name"; + region_param.type = "Region"; + + const int numAnchors = mask.size(); + + region_param.set("classes", classes); + region_param.set("anchors", numAnchors); + region_param.set("logistic", true); + region_param.set("thresh", thresh); + region_param.set("nms_threshold", nms_threshold); + region_param.set("scale_x_y", scale_x_y); + region_param.set("new_coords", new_coords); + + std::vector usedAnchors(numAnchors * 2); + for (int i = 0; i < numAnchors; ++i) + { + usedAnchors[i * 2] = anchors[mask[i] * 2]; + usedAnchors[i * 2 + 1] = anchors[mask[i] * 2 + 1]; + } + + cv::Mat biasData_mat = cv::Mat(1, numAnchors * 2, CV_32F, &usedAnchors[0]).clone(); + region_param.blobs.push_back(biasData_mat); + + darknet::LayerParameter lp; + std::string layer_name = cv::format("yolo_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = region_param.type; + lp.layerParams = region_param; + lp.bottom_indexes.push_back(last_layer); + lp.bottom_indexes.push_back(kFirstLayerName); + last_layer = layer_name; + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setShortcut(int from, float alpha) + { + cv::dnn::LayerParams shortcut_param; + shortcut_param.name = "Shortcut-name"; + shortcut_param.type = "Eltwise"; + + if (alpha != 1) + { + std::vector coeffs(2, 1); + coeffs[0] = alpha; + shortcut_param.set("coeff", cv::dnn::DictValue::arrayReal(&coeffs[0], coeffs.size())); + } + + shortcut_param.set("op", "sum"); + shortcut_param.set("output_channels_mode", "input_0_truncate"); + + darknet::LayerParameter lp; + std::string layer_name = cv::format("shortcut_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = shortcut_param.type; + lp.layerParams = shortcut_param; + lp.bottom_indexes.push_back(last_layer); + lp.bottom_indexes.push_back(fused_layer_names.at(from)); + last_layer = layer_name; + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setScaleChannels(int from) + { + cv::dnn::LayerParams shortcut_param; + shortcut_param.type = "Scale"; + + darknet::LayerParameter lp; + std::string layer_name = cv::format("scale_channels_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = shortcut_param.type; + lp.layerParams = shortcut_param; + lp.bottom_indexes.push_back(fused_layer_names.at(from)); + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setSAM(int from) + { + cv::dnn::LayerParams eltwise_param; + eltwise_param.name = "SAM-name"; + eltwise_param.type = "Eltwise"; + + eltwise_param.set("operation", "prod"); + eltwise_param.set("output_channels_mode", "same"); + + darknet::LayerParameter lp; + std::string layer_name = cv::format("sam_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = eltwise_param.type; + lp.layerParams = eltwise_param; + lp.bottom_indexes.push_back(last_layer); + lp.bottom_indexes.push_back(fused_layer_names.at(from)); + last_layer = layer_name; + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + + void setUpsample(int scaleFactor) + { + cv::dnn::LayerParams param; + param.name = "Upsample-name"; + param.type = "Resize"; + + param.set("zoom_factor", scaleFactor); + param.set("interpolation", "nearest"); + + darknet::LayerParameter lp; + std::string layer_name = cv::format("upsample_%d", layer_id); + lp.layer_name = layer_name; + lp.layer_type = param.type; + lp.layerParams = param; + lp.bottom_indexes.push_back(last_layer); + last_layer = layer_name; + net->layers.push_back(lp); + + layer_id++; + fused_layer_names.push_back(last_layer); + } + }; + + std::string escapeString(const std::string &src) + { + std::string dst; + for (size_t i = 0; i < src.size(); ++i) + if (src[i] > ' ' && src[i] <= 'z') + dst += src[i]; + return dst; + } + + template + std::vector getNumbers(const std::string &src) + { + std::vector dst; + std::stringstream ss(src); + + for (std::string str; std::getline(ss, str, ',');) { + std::stringstream line(str); + T val; + line >> val; + dst.push_back(val); + } + return dst; + } + + bool ReadDarknetFromCfgStream(std::istream &ifile, NetParameter *net) + { + bool read_net = false; + int layers_counter = -1; + for (std::string line; std::getline(ifile, line);) { + line = escapeString(line); + if (line.empty()) continue; + switch (line[0]) { + case '\0': break; + case '#': break; + case ';': break; + case '[': + if (line == "[net]") { + read_net = true; + } + else { + // read section + read_net = false; + ++layers_counter; + const size_t layer_type_size = line.find(']') - 1; + CV_Assert(layer_type_size < line.size()); + std::string layer_type = line.substr(1, layer_type_size); + net->layers_cfg[layers_counter]["layer_type"] = layer_type; + } + break; + default: + // read entry + const size_t separator_index = line.find('='); + CV_Assert(separator_index < line.size()); + if (separator_index != std::string::npos) { + std::string name = line.substr(0, separator_index); + std::string value = line.substr(separator_index + 1, line.size() - (separator_index + 1)); + name = escapeString(name); + value = escapeString(value); + if (name.empty() || value.empty()) continue; + if (read_net) + net->net_cfg[name] = value; + else + net->layers_cfg[layers_counter][name] = value; + } + } + } + + std::string anchors = net->layers_cfg[net->layers_cfg.size() - 1]["anchors"]; + std::vector vec = getNumbers(anchors); + std::map &net_params = net->net_cfg; + net->width = getParam(net_params, "width", 416); + net->height = getParam(net_params, "height", 416); + net->channels = getParam(net_params, "channels", 3); + CV_Assert(net->width > 0 && net->height > 0 && net->channels > 0); + + cv::dnn::MatShape tensor_shape(3); + tensor_shape[0] = net->channels; + tensor_shape[1] = net->height; + tensor_shape[2] = net->width; + net->out_channels_vec.resize(net->layers_cfg.size()); + + layers_counter = -1; + + setLayersParams setParams(net); + + typedef std::map >::iterator it_type; + for (it_type i = net->layers_cfg.begin(); i != net->layers_cfg.end(); ++i) { + ++layers_counter; + std::map &layer_params = i->second; + std::string layer_type = layer_params["layer_type"]; + + if (layer_type == "convolutional") + { + int kernel_size = getParam(layer_params, "size", -1); + int pad = getParam(layer_params, "pad", 0); + int padding = getParam(layer_params, "padding", 0); + int stride = getParam(layer_params, "stride", 1); + int filters = getParam(layer_params, "filters", -1); + int groups = getParam(layer_params, "groups", 1); + bool batch_normalize = getParam(layer_params, "batch_normalize", 0) == 1; + int flipped = getParam(layer_params, "flipped", 0); + if (flipped == 1) + CV_Error(cv::Error::StsNotImplemented, "Transpose the convolutional weights is not implemented"); + + if (pad) + padding = kernel_size / 2; + + // Cannot divide 0 + CV_Assert(stride > 0); + CV_Assert(kernel_size > 0 && filters > 0); + CV_Assert(tensor_shape[0] > 0); + CV_Assert(tensor_shape[0] % groups == 0); + + setParams.setConvolution(kernel_size, padding, stride, filters, tensor_shape[0], + groups, batch_normalize); + + tensor_shape[0] = filters; + tensor_shape[1] = (tensor_shape[1] - kernel_size + 2 * padding) / stride + 1; + tensor_shape[2] = (tensor_shape[2] - kernel_size + 2 * padding) / stride + 1; + } + else if (layer_type == "connected") + { + int output = getParam(layer_params, "output", 1); + bool batch_normalize = getParam(layer_params, "batch_normalize", 0) == 1; + + CV_Assert(output > 0); + + setParams.setFullyConnected(output, batch_normalize); + + if(layers_counter && tensor_shape[1] > 1) + net->out_channels_vec[layers_counter-1] = cv::dnn::total(tensor_shape); + + tensor_shape[0] = output; + tensor_shape[1] = 1; + tensor_shape[2] = 1; + } + else if (layer_type == "maxpool") + { + int kernel_size = getParam(layer_params, "size", 2); + int stride = getParam(layer_params, "stride", 2); + int padding = getParam(layer_params, "padding", kernel_size - 1); + // Cannot divide 0 + CV_Assert(stride > 0); + + setParams.setMaxpool(kernel_size, padding, stride); + + tensor_shape[1] = (tensor_shape[1] - kernel_size + padding) / stride + 1; + tensor_shape[2] = (tensor_shape[2] - kernel_size + padding) / stride + 1; + } + else if (layer_type == "avgpool") + { + setParams.setAvgpool(); + tensor_shape[1] = 1; + tensor_shape[2] = 1; + } + else if (layer_type == "crop") + { + int crop_height = getParam(layer_params, "crop_height", 0); + int crop_width = getParam(layer_params, "crop_width", 0); + bool noadjust = getParam(layer_params, "noadjust", false); + CV_CheckGT(crop_height, 0, ""); + CV_CheckGT(crop_width, 0, ""); + + setParams.setCrop(crop_height, crop_width, tensor_shape[1], tensor_shape[2], noadjust); + + tensor_shape[1] = crop_height; + tensor_shape[2] = crop_width; + } + else if (layer_type == "softmax") + { + int groups = getParam(layer_params, "groups", 1); + if (groups != 1) + CV_Error(Error::StsNotImplemented, "Softmax from Darknet with groups != 1"); + setParams.setSoftmax(); + } + else if (layer_type == "route") + { + std::string bottom_layers = getParam(layer_params, "layers", ""); + CV_Assert(!bottom_layers.empty()); + int groups = getParam(layer_params, "groups", 1); + std::vector layers_vec = getNumbers(bottom_layers); + + tensor_shape[0] = 0; + for (size_t k = 0; k < layers_vec.size(); ++k) { + layers_vec[k] = layers_vec[k] >= 0 ? layers_vec[k] : (layers_vec[k] + layers_counter); + tensor_shape[0] += net->out_channels_vec[layers_vec[k]]; + } + + if (groups > 1) + { + int group_id = getParam(layer_params, "group_id", 0); + tensor_shape[0] /= groups; + int split_size = tensor_shape[0] / layers_vec.size(); + for (size_t k = 0; k < layers_vec.size(); ++k) + setParams.setSlice(layers_vec[k], split_size, group_id); + + if (layers_vec.size() > 1) + { + // layer ids in layers_vec - inputs of Slice layers + // after adding offset to layers_vec: layer ids - outputs of Slice layers + for (size_t k = 0; k < layers_vec.size(); ++k) + layers_vec[k] += layers_vec.size(); + + setParams.setConcat(layers_vec.size(), layers_vec.data()); + } + } + else + { + if (layers_vec.size() == 1) + setParams.setIdentity(layers_vec.at(0)); + else + setParams.setConcat(layers_vec.size(), layers_vec.data()); + } + } + else if (layer_type == "dropout" || layer_type == "cost") + { + setParams.setIdentity(layers_counter-1); + } + else if (layer_type == "reorg") + { + int stride = getParam(layer_params, "stride", 2); + // Cannot divide 0 + CV_Assert(stride > 0); + tensor_shape[0] = tensor_shape[0] * (stride * stride); + tensor_shape[1] = tensor_shape[1] / stride; + tensor_shape[2] = tensor_shape[2] / stride; + + setParams.setReorg(stride); + } + else if (layer_type == "region") + { + float thresh = getParam(layer_params, "thresh", 0.001); + int coords = getParam(layer_params, "coords", 4); + int classes = getParam(layer_params, "classes", -1); + int num_of_anchors = getParam(layer_params, "num", -1); + int classfix = getParam(layer_params, "classfix", 0); + bool softmax = (getParam(layer_params, "softmax", 0) == 1); + bool softmax_tree = (getParam(layer_params, "tree", "").size() > 0); + + std::string anchors_values = getParam(layer_params, "anchors", std::string()); + CV_Assert(!anchors_values.empty()); + std::vector anchors_vec = getNumbers(anchors_values); + + CV_Assert(classes > 0 && num_of_anchors > 0 && (num_of_anchors * 2) == anchors_vec.size()); + + setParams.setPermute(false); + setParams.setRegion(thresh, coords, classes, num_of_anchors, classfix, softmax, softmax_tree, anchors_vec.data()); + } + else if (layer_type == "shortcut") + { + std::string bottom_layer = getParam(layer_params, "from", ""); + float alpha = getParam(layer_params, "alpha", 1); + float beta = getParam(layer_params, "beta", 0); + if (beta != 0) + CV_Error(Error::StsNotImplemented, "Non-zero beta"); + CV_Assert(!bottom_layer.empty()); + int from = std::atoi(bottom_layer.c_str()); + + from = from < 0 ? from + layers_counter : from; + setParams.setShortcut(from, alpha); + } + else if (layer_type == "scale_channels") + { + std::string bottom_layer = getParam(layer_params, "from", ""); + CV_Assert(!bottom_layer.empty()); + int from = std::atoi(bottom_layer.c_str()); + from = from < 0 ? from + layers_counter : from; + setParams.setScaleChannels(from); + } + else if (layer_type == "sam") + { + std::string bottom_layer = getParam(layer_params, "from", ""); + CV_Assert(!bottom_layer.empty()); + int from = std::atoi(bottom_layer.c_str()); + from = from < 0 ? from + layers_counter : from; + setParams.setSAM(from); + } + else if (layer_type == "upsample") + { + int scaleFactor = getParam(layer_params, "stride", 1); + setParams.setUpsample(scaleFactor); + tensor_shape[1] = tensor_shape[1] * scaleFactor; + tensor_shape[2] = tensor_shape[2] * scaleFactor; + } + else if (layer_type == "yolo") + { + int classes = getParam(layer_params, "classes", -1); + int num_of_anchors = getParam(layer_params, "num", -1); + float thresh = getParam(layer_params, "thresh", 0.2); + float nms_threshold = getParam(layer_params, "nms_threshold", 0.0); + float scale_x_y = getParam(layer_params, "scale_x_y", 1.0); + int new_coords = getParam(layer_params, "new_coords", 0); + + std::string anchors_values = getParam(layer_params, "anchors", std::string()); + CV_Assert(!anchors_values.empty()); + std::vector anchors_vec = getNumbers(anchors_values); + + std::string mask_values = getParam(layer_params, "mask", std::string()); + CV_Assert(!mask_values.empty()); + std::vector mask_vec = getNumbers(mask_values); + + CV_Assert(classes > 0 && num_of_anchors > 0 && (num_of_anchors * 2) == anchors_vec.size()); + + setParams.setPermute(false); + setParams.setYolo(classes, mask_vec, anchors_vec, thresh, nms_threshold, scale_x_y, new_coords); + } + else { + CV_Error(cv::Error::StsParseError, "Unknown layer type: " + layer_type); + } + + std::string activation = getParam(layer_params, "activation", "linear"); + if (activation != "linear") + setParams.setActivation(activation); + + net->out_channels_vec[layers_counter] = tensor_shape[0]; + } + + return true; + } + + bool ReadDarknetFromWeightsStream(std::istream &ifile, NetParameter *net) + { + int32_t major_ver, minor_ver, revision; + ifile.read(reinterpret_cast(&major_ver), sizeof(int32_t)); + ifile.read(reinterpret_cast(&minor_ver), sizeof(int32_t)); + ifile.read(reinterpret_cast(&revision), sizeof(int32_t)); + + uint64_t seen; + if ((major_ver * 10 + minor_ver) >= 2) { + ifile.read(reinterpret_cast(&seen), sizeof(uint64_t)); + } + else { + int32_t iseen = 0; + ifile.read(reinterpret_cast(&iseen), sizeof(int32_t)); + seen = iseen; + } + bool transpose = (major_ver > 1000) || (minor_ver > 1000); + if(transpose) + CV_Error(cv::Error::StsNotImplemented, "Transpose the weights (except for convolutional) is not implemented"); + + cv::dnn::MatShape tensor_shape(3); + tensor_shape[0] = net->channels; + tensor_shape[1] = net->height; + tensor_shape[2] = net->width; + int cv_layers_counter = -1; + int darknet_layers_counter = -1; + + setLayersParams setParams(net); + + typedef std::map >::iterator it_type; + for (it_type i = net->layers_cfg.begin(); i != net->layers_cfg.end(); ++i) { + ++darknet_layers_counter; + ++cv_layers_counter; + std::map &layer_params = i->second; + std::string layer_type = layer_params["layer_type"]; + + if (layer_type == "convolutional" || layer_type == "connected") + { + size_t weights_size; + int filters; + bool use_batch_normalize; + cv::Mat weightsBlob; + if(layer_type == "convolutional") + { + int kernel_size = getParam(layer_params, "size", -1); + filters = getParam(layer_params, "filters", -1); + int groups = getParam(layer_params, "groups", 1); + use_batch_normalize = getParam(layer_params, "batch_normalize", 0) == 1; + + CV_Assert(kernel_size > 0 && filters > 0); + CV_Assert(tensor_shape[0] > 0); + CV_Assert(tensor_shape[0] % groups == 0); + + weights_size = filters * (tensor_shape[0] / groups) * kernel_size * kernel_size; + int sizes_weights[] = { filters, tensor_shape[0] / groups, kernel_size, kernel_size }; + weightsBlob.create(4, sizes_weights, CV_32F); + } + else + { + filters = getParam(layer_params, "output", 1); + use_batch_normalize = getParam(layer_params, "batch_normalize", 0) == 1; + + CV_Assert(filters>0); + + weights_size = cv::dnn::total(tensor_shape) * filters; + int sizes_weights[] = { filters, cv::dnn::total(tensor_shape) }; + weightsBlob.create(2, sizes_weights, CV_32F); + } + CV_Assert(weightsBlob.isContinuous()); + + cv::Mat meanData_mat(1, filters, CV_32F); // mean + cv::Mat stdData_mat(1, filters, CV_32F); // variance + cv::Mat weightsData_mat(1, filters, CV_32F);// scale + cv::Mat biasData_mat(1, filters, CV_32F); // bias + + ifile.read(reinterpret_cast(biasData_mat.ptr()), sizeof(float)*filters); + if (use_batch_normalize) { + ifile.read(reinterpret_cast(weightsData_mat.ptr()), sizeof(float)*filters); + ifile.read(reinterpret_cast(meanData_mat.ptr()), sizeof(float)*filters); + ifile.read(reinterpret_cast(stdData_mat.ptr()), sizeof(float)*filters); + } + ifile.read(reinterpret_cast(weightsBlob.ptr()), sizeof(float)*weights_size); + + // set conv/connected weights + std::vector layer_blobs; + layer_blobs.push_back(weightsBlob); + if (!use_batch_normalize) { + // use BIAS in any case + layer_blobs.push_back(biasData_mat); + } + setParams.setLayerBlobs(cv_layers_counter, layer_blobs); + + // set batch normalize (mean, variance, scale, bias) + if (use_batch_normalize) { + ++cv_layers_counter; + std::vector bn_blobs; + bn_blobs.push_back(meanData_mat); + bn_blobs.push_back(stdData_mat); + bn_blobs.push_back(weightsData_mat); + bn_blobs.push_back(biasData_mat); + setParams.setLayerBlobs(cv_layers_counter, bn_blobs); + } + } + if (layer_type == "region" || layer_type == "yolo") + { + ++cv_layers_counter; // For permute. + } + + std::string activation = getParam(layer_params, "activation", "linear"); + if (activation != "linear") + ++cv_layers_counter; // For ReLU, Swish, Mish, Sigmoid, etc + + if(!darknet_layers_counter) + tensor_shape.resize(1); + + tensor_shape[0] = net->out_channels_vec[darknet_layers_counter]; + } + return true; + } + + } + + + void ReadNetParamsFromCfgStreamOrDie(std::istream &ifile, darknet::NetParameter *net) + { + if (!darknet::ReadDarknetFromCfgStream(ifile, net)) { + CV_Error(cv::Error::StsParseError, "Failed to parse NetParameter stream"); + } + } + + void ReadNetParamsFromBinaryStreamOrDie(std::istream &ifile, darknet::NetParameter *net) + { + if (!darknet::ReadDarknetFromWeightsStream(ifile, net)) { + CV_Error(cv::Error::StsParseError, "Failed to parse NetParameter stream"); + } + } + } +} diff --git a/modules/dnnlegacy/src/darknet/darknet_io.hpp b/modules/dnnlegacy/src/darknet/darknet_io.hpp new file mode 100644 index 00000000000..4e524befcb2 --- /dev/null +++ b/modules/dnnlegacy/src/darknet/darknet_io.hpp @@ -0,0 +1,117 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// (3-clause BSD License) +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * Neither the names of the copyright holders nor the names of the contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall copyright holders or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +/*M/////////////////////////////////////////////////////////////////////////////////////// +//MIT License +// +//Copyright (c) 2017 Joseph Redmon +// +//Permission is hereby granted, free of charge, to any person obtaining a copy +//of this software and associated documentation files (the "Software"), to deal +//in the Software without restriction, including without limitation the rights +//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +//copies of the Software, and to permit persons to whom the Software is +//furnished to do so, subject to the following conditions: +// +//The above copyright notice and this permission notice shall be included in all +//copies or substantial portions of the Software. +// +//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +//SOFTWARE. +// +//M*/ + +#ifndef __OPENCV_DNN_DARKNET_IO_HPP__ +#define __OPENCV_DNN_DARKNET_IO_HPP__ + +#include + +namespace cv { + namespace dnnlegacy { + namespace darknet { + + class LayerParameter { + std::string layer_name, layer_type; + std::vector bottom_indexes; + cv::dnn::LayerParams layerParams; + public: + friend class setLayersParams; + cv::dnn::LayerParams getLayerParams() const { return layerParams; } + std::string name() const { return layer_name; } + std::string type() const { return layer_type; } + int bottom_size() const { return bottom_indexes.size(); } + std::string bottom(const int index) const { return bottom_indexes.at(index); } + int top_size() const { return 1; } + std::string top(const int index) const { return layer_name; } + }; + + class NetParameter { + public: + int width, height, channels; + std::vector layers; + std::vector out_channels_vec; + + std::map > layers_cfg; + std::map net_cfg; + + NetParameter() : width(0), height(0), channels(0) {} + + int layer_size() const { return layers.size(); } + + int input_size() const { return 1; } + std::string input(const int index) const { return "data"; } + LayerParameter layer(const int index) const { return layers.at(index); } + }; + } + + // Read parameters from a stream into a NetParameter message. + void ReadNetParamsFromCfgStreamOrDie(std::istream &ifile, darknet::NetParameter *net); + void ReadNetParamsFromBinaryStreamOrDie(std::istream &ifile, darknet::NetParameter *net); + } +} +#endif diff --git a/modules/dnnlegacy/src/precomp.hpp b/modules/dnnlegacy/src/precomp.hpp new file mode 100644 index 00000000000..a761a0252b0 --- /dev/null +++ b/modules/dnnlegacy/src/precomp.hpp @@ -0,0 +1,90 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#if !defined(BUILD_PLUGIN) +#include "cvconfig.h" +#else +#include +#undef __OPENCV_BUILD // allow public API only +#endif + +#include + +#ifndef CV_OCL4DNN +#define CV_OCL4DNN 0 +#endif + +#if CV_OCL4DNN +#ifndef HAVE_OPENCL +#error "Configuration error: re-run CMake from clean build directory" +#endif +#else +#undef HAVE_OPENCL +#endif + +#ifndef CV_CUDA4DNN +#define CV_CUDA4DNN 0 +#endif + +#if CV_CUDA4DNN +#ifndef HAVE_CUDA +#error "Configuration error: re-run CMake from clean build directory" +#endif +#else +#undef HAVE_CUDA +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +//#include "dnn_common.hpp" diff --git a/modules/dnnlegacy/test/npy_blob.cpp b/modules/dnnlegacy/test/npy_blob.cpp new file mode 100644 index 00000000000..a966801af67 --- /dev/null +++ b/modules/dnnlegacy/test/npy_blob.cpp @@ -0,0 +1,94 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "test_precomp.hpp" +#include "npy_blob.hpp" + +namespace cv +{ + +static std::string getType(const std::string& header) +{ + std::string field = "'descr':"; + int idx = header.find(field); + CV_Assert(idx != -1); + + int from = header.find('\'', idx + field.size()) + 1; + int to = header.find('\'', from); + return header.substr(from, to - from); +} + +static std::string getFortranOrder(const std::string& header) +{ + std::string field = "'fortran_order':"; + int idx = header.find(field); + CV_Assert(idx != -1); + + int from = header.find_last_of(' ', idx + field.size()) + 1; + int to = header.find(',', from); + return header.substr(from, to - from); +} + +static std::vector getShape(const std::string& header) +{ + std::string field = "'shape':"; + int idx = header.find(field); + CV_Assert(idx != -1); + + int from = header.find('(', idx + field.size()) + 1; + int to = header.find(')', from); + + std::string shapeStr = header.substr(from, to - from); + if (shapeStr.empty()) + return std::vector(1, 1); + + // Remove all commas. + shapeStr.erase(std::remove(shapeStr.begin(), shapeStr.end(), ','), + shapeStr.end()); + + std::istringstream ss(shapeStr); + int value; + + std::vector shape; + while (ss >> value) + { + shape.push_back(value); + } + return shape; +} + +Mat blobFromNPY(const std::string& path) +{ + std::ifstream ifs(path.c_str(), std::ios::binary); + CV_Assert(ifs.is_open()); + + std::string magic(6, '*'); + ifs.read(&magic[0], magic.size()); + CV_Assert(magic == "\x93NUMPY"); + + ifs.ignore(1); // Skip major version byte. + ifs.ignore(1); // Skip minor version byte. + + unsigned short headerSize; + ifs.read((char*)&headerSize, sizeof(headerSize)); + + std::string header(headerSize, '*'); + ifs.read(&header[0], header.size()); + + // Extract data type. + CV_Assert(getType(header) == " shape = getShape(header); + + Mat blob(shape, CV_32F); + ifs.read((char*)blob.data, blob.total() * blob.elemSize()); + CV_Assert((size_t)ifs.gcount() == blob.total() * blob.elemSize()); + + return blob; +} + +} // namespace cv diff --git a/modules/dnnlegacy/test/npy_blob.hpp b/modules/dnnlegacy/test/npy_blob.hpp new file mode 100644 index 00000000000..13b29df1fbb --- /dev/null +++ b/modules/dnnlegacy/test/npy_blob.hpp @@ -0,0 +1,20 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef __OPENCV_DNNLEGACY_TEST_NPY_BLOB_HPP__ +#define __OPENCV_DNNLEGACY_TEST_NPY_BLOB_HPP__ + +namespace cv +{ + +// Parse serialized NumPy array by np.save(...) +// Based on specification of .npy data format. +Mat blobFromNPY(const std::string& path); + +} + +#endif diff --git a/modules/dnnlegacy/test/test_caffe_importer.cpp b/modules/dnnlegacy/test/test_caffe_importer.cpp new file mode 100644 index 00000000000..e483b233f22 --- /dev/null +++ b/modules/dnnlegacy/test/test_caffe_importer.cpp @@ -0,0 +1,877 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include +#include "test_precomp.hpp" +#include +#include "npy_blob.hpp" +#include + +using namespace cv; + +namespace opencv_test { + namespace { + + template + static std::string _tf(Tstring filename) + { + return cv::samples::findFile(std::string("dnn/") + filename); + } + + class Test_Caffe_nets : public DNNlegacyTestLayer + { + public: + void testFaster(const std::string& proto, const std::string& model, const Mat& ref, + double scoreDiff = 0.0, double iouDiff = 0.0) + { + checkBackend(); + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(cv::samples::findFile("dnn/" + proto), + cv::samples::findFile("dnn/" + model, false)); + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + + if (target == cv::dnn::DNN_TARGET_CPU_FP16) + net.enableWinograd(false); + + Mat img = imread(cv::samples::findFile("dnn/dog416.png")); + resize(img, img, Size(800, 600)); + Mat blob = cv::dnn::blobFromImage(img, 1.0, Size(), Scalar(102.9801, 115.9465, 122.7717), false, false); + Mat imInfo = (Mat_(1, 3) << img.rows, img.cols, 1.6f); + + net.setInput(blob, "data"); + net.setInput(imInfo, "im_info"); + // Output has shape 1x1xNx7 where N - number of detections. + // An every detection is a vector of values [id, classId, confidence, left, top, right, bottom] + Mat out = net.forward(); + scoreDiff = scoreDiff ? scoreDiff : default_l1; + iouDiff = iouDiff ? iouDiff : default_lInf; + opencv_test::normAssertDetections(ref, out, ("model name: " + model).c_str(), 0.8, scoreDiff, iouDiff); + } + }; + + TEST(Test_Caffe, memory_read) + { + const std::string proto = cv::samples::findFile("dnn/bvlc_googlenet.prototxt"); + const std::string model = cv::samples::findFile("dnn/bvlc_googlenet.caffemodel", false); + + std::vector dataProto; + readFileContent(proto, dataProto); + + std::vector dataModel; + readFileContent(model, dataModel); + + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(dataProto.data(), dataProto.size()); + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + ASSERT_FALSE(net.empty()); + + cv::dnn::Net net2 = cv::dnnlegacy::readNetFromCaffe(dataProto.data(), dataProto.size(), + dataModel.data(), dataModel.size()); + ASSERT_FALSE(net2.empty()); + } + + TEST(Test_Caffe, read_gtsrb) + { + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(_tf("gtsrb.prototxt")); + ASSERT_FALSE(net.empty()); + } + + TEST(Test_Caffe, read_googlenet) + { + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(_tf("bvlc_googlenet.prototxt")); + ASSERT_FALSE(net.empty()); + } + + TEST_P(Test_Caffe_nets, Axpy) + { + #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000) + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); + #endif + + std::string proto = _tf("axpy.prototxt"); + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto); + + checkBackend(); + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + + int size[] = {1, 2, 3, 4}; + int scale_size[] = {1, 2, 1, 1}; + Mat scale(4, &scale_size[0], CV_32F); + Mat shift(4, &size[0], CV_32F); + Mat inp(4, &size[0], CV_32F); + randu(scale, -1.0f, 1.0f); + randu(shift, -1.0f, 1.0f); + randu(inp, -1.0f, 1.0f); + + net.setInput(scale, "scale"); + net.setInput(shift, "shift"); + net.setInput(inp, "data"); + + Mat out = net.forward(); + + Mat ref(4, &size[0], inp.type()); + for (int i = 0; i < inp.size[1]; i++) { + for (int h = 0; h < inp.size[2]; h++) { + for (int w = 0; w < inp.size[3]; w++) { + int idx[] = {0, i, h, w}; + int scale_idx[] = {0, i, 0, 0}; + ref.at(idx) = inp.at(idx) * scale.at(scale_idx) + + shift.at(idx); + } + } + } + float l1 = 1e-5, lInf = 1e-4; + if (target ==cv::dnn::DNN_TARGET_OPENCL_FP16 || target ==cv::dnn::DNN_TARGET_CPU_FP16) + { + l1 = 2e-4; + lInf = 1e-3; + } + if (target ==cv::dnn::DNN_TARGET_MYRIAD) + { + l1 = 0.001; + lInf = 0.001; + } + if(target ==cv::dnn::DNN_TARGET_CUDA_FP16) + { + l1 = 0.0002; + lInf = 0.0007; + } + normAssert(ref, out, "", l1, lInf); + } + + typedef testing::TestWithParam > Reproducibility_AlexNet; + TEST_P(Reproducibility_AlexNet, Accuracy) + { + cv::dnn::Target targetId = get<1>(GetParam()); + #if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL) + applyTestTag(CV_TEST_TAG_MEMORY_2GB); + #else + applyTestTag(targetId == cv::dnn::DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB); + #endif + ASSERT_TRUE(ocl::useOpenCL() || targetId == cv::dnn::DNN_TARGET_CPU || targetId == cv::dnn::DNN_TARGET_CPU_FP16); + + bool readFromMemory = get<0>(GetParam()); + cv::dnn::Net net; + { + const std::string proto = cv::samples::findFile("dnn/bvlc_alexnet.prototxt"); + const std::string model = cv::samples::findFile("dnn/bvlc_alexnet.caffemodel", false); + if (readFromMemory) + { + std::vector dataProto; + readFileContent(proto, dataProto); + std::vector dataModel; + readFileContent(model, dataModel); + net = cv::dnnlegacy::readNetFromCaffe(dataProto.data(), dataProto.size(), + dataModel.data(), dataModel.size()); + } + else + net = cv::dnnlegacy::readNetFromCaffe(proto, model); + ASSERT_FALSE(net.empty()); + } + + // Test input layer size + /* CHANGE in getLayerShapes param in OPENCV 5 + * TEST disable + std::vector inLayerShapes; + std::vector outLayerShapes; + net.getLayerShapes(cv::dnn::MatShape(), 0, inLayerShapes, outLayerShapes); + ASSERT_FALSE(inLayerShapes.empty()); + ASSERT_EQ(inLayerShapes[0].size(), 4); + ASSERT_EQ(inLayerShapes[0][0], 1); + ASSERT_EQ(inLayerShapes[0][1], 3); + ASSERT_EQ(inLayerShapes[0][2], 227); + ASSERT_EQ(inLayerShapes[0][3], 227); + */ + const float l1 = 1e-5; + const float lInf = (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 || targetId == cv::dnn::DNN_TARGET_CPU_FP16) ? 4e-3 : 1e-4; + + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + net.setPreferableTarget(targetId); + + if (targetId == cv::dnn::DNN_TARGET_CPU_FP16) + net.enableWinograd(false); + + Mat sample = imread(_tf("grace_hopper_227.png")); + ASSERT_TRUE(!sample.empty()); + + net.setInput(cv::dnn::blobFromImage(sample, 1.0f, Size(227, 227), Scalar(), false), "data"); + Mat out = net.forward("prob"); + Mat ref = blobFromNPY(_tf("caffe_alexnet_prob.npy")); + normAssert(ref, out, "", l1, lInf); + } + + INSTANTIATE_TEST_CASE_P(/**/, Reproducibility_AlexNet, Combine(testing::Bool(), + testing::ValuesIn(getAvailableTargets(cv::dnn::DNN_BACKEND_OPENCV)))); + + TEST(Reproducibility_FCN, Accuracy) + { + applyTestTag(CV_TEST_TAG_LONG, CV_TEST_TAG_DEBUG_VERYLONG, CV_TEST_TAG_MEMORY_2GB); + + cv::dnn::Net net; + { + const std::string proto = cv::samples::findFile("dnn/fcn8s-heavy-pascal.prototxt"); + const std::string model = cv::samples::findFile("dnn/fcn8s-heavy-pascal.caffemodel", false); + net = dnnlegacy::readNetFromCaffe(proto, model); + ASSERT_FALSE(net.empty()); + } + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + + Mat sample = imread(_tf("street.png")); + ASSERT_TRUE(!sample.empty()); + + std::vector layerIds; + std::vector weights, blobs; + /* CHANGE in getMemoryConsumption param in OPENCV 5 + * TEST disable + net.getMemoryConsumption(cv::dnn::shape(1,3,227,227), layerIds, weights, blobs); + */ + net.setInput(cv::dnn::blobFromImage(sample, 1.0f, Size(500, 500), Scalar(), false), "data"); + Mat out = net.forward("score"); + + Mat refData = imread(_tf("caffe_fcn8s_prob.png"), IMREAD_ANYDEPTH); + int shape[] = {1, 21, 500, 500}; + Mat ref(4, shape, CV_32FC1, refData.data); + + normAssert(ref, out); + } + + TEST(Reproducibility_SSD, Accuracy) + { + applyTestTag( + CV_TEST_TAG_MEMORY_512MB, + CV_TEST_TAG_DEBUG_VERYLONG + ); + + cv::dnn::Net net; + { + const std::string proto = cv::samples::findFile("dnn/ssd_vgg16.prototxt"); + const std::string model = cv::samples::findFile("dnn/VGG_ILSVRC2016_SSD_300x300_iter_440000.caffemodel", false); + net = cv::dnnlegacy::readNetFromCaffe(proto, model); + ASSERT_FALSE(net.empty()); + } + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + + Mat sample = imread(_tf("street.png")); + ASSERT_TRUE(!sample.empty()); + + if (sample.channels() == 4) + cvtColor(sample, sample, COLOR_BGRA2BGR); + + Mat in_blob = cv::dnn::blobFromImage(sample, 1.0f, Size(300, 300), Scalar(), false); + net.setInput(in_blob, "data"); + Mat out = net.forward("detection_out"); + + Mat ref = blobFromNPY(_tf("ssd_out.npy")); + normAssertDetections(ref, out, "", 0.06); + } + + typedef testing::TestWithParam > Reproducibility_MobileNet_SSD; + TEST_P(Reproducibility_MobileNet_SSD, Accuracy) + { + const std::string proto = cv::samples::findFile("dnn/MobileNetSSD_deploy_19e3ec3.prototxt", false); + const std::string model = cv::samples::findFile("dnn/MobileNetSSD_deploy_19e3ec3.caffemodel", false); + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto, model); + int backendId = get<0>(GetParam()); + int targetId = get<1>(GetParam()); + + net.setPreferableBackend(backendId); + net.setPreferableTarget(targetId); + + Mat sample = imread(_tf("street.png")); + + Mat inp = cv::dnn::blobFromImage(sample, 1.0f / 127.5, Size(300, 300), Scalar(127.5, 127.5, 127.5), false); + net.setInput(inp); + Mat out = net.forward().clone(); + + ASSERT_EQ(out.size[2], 100); + + float scores_diff = 1e-5, boxes_iou_diff = 1e-4; + if (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 || targetId == cv::dnn::DNN_TARGET_MYRIAD || targetId == cv::dnn::DNN_TARGET_CPU_FP16) + { + scores_diff = 1.5e-2; + boxes_iou_diff = 6.3e-2; + } + else if (targetId == cv::dnn::DNN_TARGET_CUDA_FP16) + { + scores_diff = 0.015; + boxes_iou_diff = 0.07; + } + Mat ref = blobFromNPY(_tf("mobilenet_ssd_caffe_out.npy")); + normAssertDetections(ref, out, "", FLT_MIN, scores_diff, boxes_iou_diff); + + // Check that detections aren't preserved. + inp.setTo(0.0f); + net.setInput(inp); + Mat zerosOut = net.forward(); + zerosOut = zerosOut.reshape(1, zerosOut.total() / 7); + + const int numDetections = zerosOut.rows; + // TODO: fix it + if (targetId != cv::dnn::DNN_TARGET_MYRIAD || + cv::dnn::getInferenceEngineVPUType() != CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + { + ASSERT_NE(numDetections, 0); + for (int i = 0; i < numDetections; ++i) + { + float confidence = zerosOut.ptr(i)[2]; + ASSERT_EQ(confidence, 0); + } + } + + // There is something wrong with Reshape layer in Myriad plugin. + if (backendId == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 + || backendId == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH + ) + { + if (targetId == cv::dnn::DNN_TARGET_MYRIAD || targetId == cv::dnn::DNN_TARGET_OPENCL_FP16) + return; + } + + // Check batching mode. + inp = cv::dnn::blobFromImages(std::vector(2, sample), 1.0f / 127.5, Size(300, 300), Scalar(127.5, 127.5, 127.5), false); + net.setInput(inp); + Mat outBatch = net.forward(); + + // Output blob has a shape 1x1x2Nx7 where N is a number of detection for + // a single sample in batch. The first numbers of detection vectors are batch id. + // For Inference Engine backend there is -1 delimiter which points the end of detections. + const int numRealDetections = ref.size[2]; + EXPECT_EQ(outBatch.size[2], 2 * numDetections); + out = out.reshape(1, numDetections).rowRange(0, numRealDetections); + outBatch = outBatch.reshape(1, 2 * numDetections); + for (int i = 0; i < 2; ++i) + { + Mat pred = outBatch.rowRange(i * numRealDetections, (i + 1) * numRealDetections); + EXPECT_EQ(countNonZero(pred.col(0) != i), 0); + normAssert(pred.colRange(1, 7), out.colRange(1, 7)); + } + } + INSTANTIATE_TEST_CASE_P(/**/, Reproducibility_MobileNet_SSD, dnnBackendsAndTargets()); + + typedef testing::TestWithParam Reproducibility_ResNet50; + TEST_P(Reproducibility_ResNet50, Accuracy) + { + cv::dnn::Target targetId = GetParam(); + applyTestTag(targetId == cv::dnn::DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB); + ASSERT_TRUE(ocl::useOpenCL() || targetId ==cv::dnn::DNN_TARGET_CPU || targetId ==cv::dnn::DNN_TARGET_CPU_FP16); + + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(cv::samples::findFile("dnn/ResNet-50-deploy.prototxt"), + cv::samples::findFile("dnn/ResNet-50-model.caffemodel", false)); + + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + net.setPreferableTarget(targetId); + + if (targetId == cv::dnn::DNN_TARGET_CPU_FP16) + net.enableWinograd(false); + + float l1 = (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 || targetId == cv::dnn::DNN_TARGET_CPU_FP16) ? 3e-5 : 1e-5; + float lInf = (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 || targetId == cv::dnn::DNN_TARGET_CPU_FP16) ? 6e-3 : 1e-4; + + Mat input = cv::dnn::blobFromImage(imread(_tf("googlenet_0.png")), 1.0f, Size(224,224), Scalar(), false); + ASSERT_TRUE(!input.empty()); + + net.setInput(input); + Mat out = net.forward(); + + Mat ref = blobFromNPY(_tf("resnet50_prob.npy")); + normAssert(ref, out, "", l1, lInf); + + if (targetId == cv::dnn::DNN_TARGET_OPENCL || targetId == cv::dnn::DNN_TARGET_OPENCL_FP16) + { + UMat out_umat; + net.forward(out_umat); + normAssert(ref, out_umat, "out_umat", l1, lInf); + + std::vector out_umats; + net.forward(out_umats); + normAssert(ref, out_umats[0], "out_umat_vector", l1, lInf); + } + } + INSTANTIATE_TEST_CASE_P(/**/, Reproducibility_ResNet50, + testing::ValuesIn(getAvailableTargets(cv::dnn::DNN_BACKEND_OPENCV))); + + typedef testing::TestWithParam Reproducibility_SqueezeNet_v1_1; + TEST_P(Reproducibility_SqueezeNet_v1_1, Accuracy) + { + int targetId = GetParam(); + if(targetId == cv::dnn::DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16); + if(targetId == cv::dnn::DNN_TARGET_CPU_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_CPU_FP16); + cv::dnn::Net net= cv::dnnlegacy::readNetFromCaffe(cv::samples::findFile("dnn/squeezenet_v1.1.prototxt"), + cv::samples::findFile("dnn/squeezenet_v1.1.caffemodel", false)); + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + net.setPreferableTarget(targetId); + + Mat input = cv::dnn::blobFromImage(imread(_tf("googlenet_0.png")), 1.0f, Size(227,227), Scalar(), false, true); + ASSERT_TRUE(!input.empty()); + + Mat out; + if (targetId == cv::dnn::DNN_TARGET_OPENCL) + { + // Firstly set a wrong input blob and run the model to receive a wrong output. + // Then set a correct input blob to check CPU->GPU synchronization is working well. + net.setInput(input * 2.0f); + out = net.forward(); + } + net.setInput(input); + out = net.forward(); + + Mat ref = blobFromNPY(_tf("squeezenet_v1.1_prob.npy")); + normAssert(ref, out); + } + INSTANTIATE_TEST_CASE_P(/**/, Reproducibility_SqueezeNet_v1_1, + testing::ValuesIn(getAvailableTargets(cv::dnn::DNN_BACKEND_OPENCV))); + + TEST(Reproducibility_AlexNet_fp16, Accuracy) + { + applyTestTag(CV_TEST_TAG_MEMORY_512MB); + const float l1 = 1e-5; + const float lInf = 3e-3; + + const std::string proto = cv::samples::findFile("dnn/bvlc_alexnet.prototxt"); + const std::string model = cv::samples::findFile("dnn/bvlc_alexnet.caffemodel", false); + + cv::dnnlegacy::shrinkCaffeModel(model, "bvlc_alexnet.caffemodel_fp16"); + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto, "bvlc_alexnet.caffemodel_fp16"); + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + + Mat sample = imread(cv::samples::findFile("dnn/grace_hopper_227.png")); + + net.setInput(cv::dnn::blobFromImage(sample, 1.0f, Size(227, 227), Scalar())); + Mat out = net.forward(); + Mat ref = blobFromNPY(cv::samples::findFile("dnn/caffe_alexnet_prob.npy")); + normAssert(ref, out, "", l1, lInf); + } + + TEST(Reproducibility_GoogLeNet_fp16, Accuracy) + { + const float l1 = 1e-5; + const float lInf = 3e-3; + + const std::string proto = cv::samples::findFile("dnn/bvlc_googlenet.prototxt"); + const std::string model = cv::samples::findFile("dnn/bvlc_googlenet.caffemodel", false); + + shrinkCaffeModel(model, "bvlc_googlenet.caffemodel_fp16"); + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto, "bvlc_googlenet.caffemodel_fp16"); + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + + std::vector inpMats; + inpMats.push_back( imread(_tf("googlenet_0.png")) ); + inpMats.push_back( imread(_tf("googlenet_1.png")) ); + ASSERT_TRUE(!inpMats[0].empty() && !inpMats[1].empty()); + + net.setInput(cv::dnn::blobFromImages(inpMats, 1.0f, Size(), Scalar(), false), "data"); + Mat out = net.forward("prob"); + + Mat ref = blobFromNPY(_tf("googlenet_prob.npy")); + normAssert(out, ref, "", l1, lInf); + } + + // https://github.com/richzhang/colorization + TEST_P(Test_Caffe_nets, Colorization) + { + applyTestTag( + target == cv::dnn::DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB, + CV_TEST_TAG_DEBUG_VERYLONG + ); + checkBackend(); + + Mat inp = blobFromNPY(_tf("colorization_inp.npy")); + Mat ref = blobFromNPY(_tf("colorization_out.npy")); + Mat kernel = blobFromNPY(_tf("colorization_pts_in_hull.npy")); + + const std::string proto = cv::samples::findFile("dnn/colorization_deploy_v2.prototxt", false); + const std::string model = cv::samples::findFile("dnn/colorization_release_v2.caffemodel", false); + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto, model); + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + + // This model has bad accuracy when the FP16 and Winograd are enable at same time. + if (target == cv::dnn::DNN_TARGET_CPU_FP16) + net.enableWinograd(false); + + net.getLayer(net.getLayerId("class8_ab"))->blobs.push_back(kernel); + net.getLayer(net.getLayerId("conv8_313_rh"))->blobs.push_back(Mat(1, 313, CV_32F, 2.606)); + + net.setInput(inp); + Mat out = net.forward(); + + // Reference output values are in range [-29.1, 69.5] + double l1 = 4e-4, lInf = 3e-3; + if (target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_CPU_FP16) + { + l1 = 0.25; + lInf = 5.3; + } + else if (target == cv::dnn::DNN_TARGET_MYRIAD) + { + l1 = (cv::dnn::getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) ? 0.5 : 0.25; + lInf = (cv::dnn::getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) ? 11 : 5.3; + } + else if(target == cv::dnn::DNN_TARGET_CUDA_FP16) + { + l1 = 0.21; + lInf = 4.5; + } + #if defined(INF_ENGINE_RELEASE) + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == cv::dnn::DNN_TARGET_OPENCL_FP16) + { + l1 = 0.3; lInf = 10; + } + #endif + + normAssert(out, ref, "", l1, lInf); + expectNoFallbacksFromIE(net); + } + + TEST_P(Test_Caffe_nets, DenseNet_121) + { + applyTestTag(CV_TEST_TAG_MEMORY_512MB); + checkBackend(); + const std::string proto = cv::samples::findFile("dnn/DenseNet_121.prototxt", false); + const std::string weights = cv::samples::findFile("dnn/DenseNet_121.caffemodel", false); + + Mat inp = imread(_tf("dog416.png")); + cv::dnn::Model model(proto, weights); + model.setInputScale(1.0 / 255).setInputSwapRB(true).setInputCrop(true); + std::vector outs; + Mat ref = blobFromNPY(_tf("densenet_121_output.npy")); + + model.setPreferableBackend(backend); + model.setPreferableTarget(target); + model.predict(inp, outs); + + // Reference is an array of 1000 values from a range [-6.16, 7.9] + float l1 = default_l1, lInf = default_lInf; + if (target == cv::dnn::DNN_TARGET_OPENCL_FP16) + { + #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2019020000) + l1 = 0.05; lInf = 0.3; + #else + l1 = 0.017; lInf = 0.0795; + #endif + } + else if (target == cv::dnn::DNN_TARGET_MYRIAD) + { + l1 = 0.11; lInf = 0.5; + } + else if (target == cv::dnn::DNN_TARGET_CUDA_FP16) + { + l1 = 0.04; lInf = 0.2; + } + else if (target == cv::dnn::DNN_TARGET_CPU_FP16) + { + l1 = 0.06; lInf = 0.3; + } + + normAssert(outs[0], ref, "", l1, lInf); + if (target != cv::dnn::DNN_TARGET_MYRIAD || cv::dnn::getInferenceEngineVPUType() != CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + expectNoFallbacksFromIE(model.getNetwork_()); + } + + TEST(Test_Caffe, multiple_inputs) + { + const std::string proto = cv::samples::findFile("dnn/layers/net_input.prototxt"); + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto); + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + + Mat first_image(10, 11, CV_32FC3); + Mat second_image(10, 11, CV_32FC3); + randu(first_image, -1, 1); + randu(second_image, -1, 1); + + first_image = cv::dnn::blobFromImage(first_image); + second_image = cv::dnn::blobFromImage(second_image); + + Mat first_image_blue_green = cv::dnn::slice(first_image, Range::all(), Range(0, 2), Range::all(), Range::all()); + Mat first_image_red = cv::dnn::slice(first_image, Range::all(), Range(2, 3), Range::all(), Range::all()); + Mat second_image_blue_green = cv::dnn::slice(second_image, Range::all(), Range(0, 2), Range::all(), Range::all()); + Mat second_image_red = cv::dnn::slice(second_image, Range::all(), Range(2, 3), Range::all(), Range::all()); + + net.setInput(first_image_blue_green, "old_style_input_blue_green"); + net.setInput(first_image_red, "different_name_for_red"); + net.setInput(second_image_blue_green, "input_layer_blue_green"); + net.setInput(second_image_red, "old_style_input_red"); + Mat out = net.forward(); + + normAssert(out, first_image + second_image); + } + + TEST(Test_Caffe, shared_weights) + { + const std::string proto = cv::samples::findFile("dnn/layers/shared_weights.prototxt"); + const std::string model = cv::samples::findFile("dnn/layers/shared_weights.caffemodel"); + + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto, model); + + Mat input_1 = (Mat_(2, 2) << 0., 2., 4., 6.); + Mat input_2 = (Mat_(2, 2) << 1., 3., 5., 7.); + + Mat blob_1 = cv::dnn::blobFromImage(input_1); + Mat blob_2 = cv::dnn::blobFromImage(input_2); + + net.setInput(blob_1, "input_1"); + net.setInput(blob_2, "input_2"); + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + + Mat sum = net.forward(); + + EXPECT_EQ(sum.at(0,0), 12.); + EXPECT_EQ(sum.at(0,1), 16.); + } + + typedef testing::TestWithParam > opencv_face_detector; + TEST_P(opencv_face_detector, Accuracy) + { + std::string proto = cv::samples::findFile("dnn/opencv_face_detector.prototxt"); + std::string model = cv::samples::findFile(get<0>(GetParam()), false); + cv::dnn::Target targetId = (cv::dnn::Target)(int)get<1>(GetParam()); + + if (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16); + if (targetId == cv::dnn::DNN_TARGET_CPU_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_CPU_FP16); + + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto, model); + Mat img = imread(cv::samples::findFile("gpu/lbpcascade/er.png")); + Mat blob = cv::dnn::blobFromImage(img, 1.0, Size(), Scalar(104.0, 177.0, 123.0), false, false); + + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + net.setPreferableTarget(targetId); + + net.setInput(blob); + // Output has shape 1x1xNx7 where N - number of detections. + // An every detection is a vector of values [id, classId, confidence, left, top, right, bottom] + Mat out = net.forward(); + Mat ref = (Mat_(6, 7) << 0, 1, 0.99520785, 0.80997437, 0.16379407, 0.87996572, 0.26685631, + 0, 1, 0.9934696, 0.2831718, 0.50738752, 0.345781, 0.5985168, + 0, 1, 0.99096733, 0.13629119, 0.24892329, 0.19756334, 0.3310290, + 0, 1, 0.98977017, 0.23901358, 0.09084064, 0.29902688, 0.1769477, + 0, 1, 0.97203469, 0.67965847, 0.06876482, 0.73999709, 0.1513494, + 0, 1, 0.95097077, 0.51901293, 0.45863652, 0.5777427, 0.5347801); + normAssertDetections(ref, out, "", 0.5, 1e-4, 2e-4); + } + + // False positives bug for large faces: https://github.com/opencv/opencv/issues/15106 + TEST_P(opencv_face_detector, issue_15106) + { + std::string proto = cv::samples::findFile("dnn/opencv_face_detector.prototxt"); + std::string model = cv::samples::findFile(get<0>(GetParam()), false); + cv::dnn::Target targetId = (cv::dnn::Target)(int)get<1>(GetParam()); + + if (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16); + if (targetId == cv::dnn::DNN_TARGET_CPU_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_CPU_FP16); + + cv::dnn::Net net = cv::dnnlegacy::readNetFromCaffe(proto, model); + Mat img = imread(cv::samples::findFile("cv/shared/lena.png")); + img = img.rowRange(img.rows / 4, 3 * img.rows / 4).colRange(img.cols / 4, 3 * img.cols / 4); + Mat blob = cv::dnn::blobFromImage(img, 1.0, Size(300, 300), Scalar(104.0, 177.0, 123.0), false, false); + + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + net.setPreferableTarget(targetId); + + net.setInput(blob); + // Output has shape 1x1xNx7 where N - number of detections. + // An every detection is a vector of values [id, classId, confidence, left, top, right, bottom] + Mat out = net.forward(); + Mat ref = (Mat_(1, 7) << 0, 1, 0.9149431, 0.30424616, 0.26964942, 0.88733053, 0.99815309); + normAssertDetections(ref, out, "", 0.89, 6e-5, 1e-4); + } + INSTANTIATE_TEST_CASE_P(Test_Caffe, opencv_face_detector, + Combine( + Values("dnn/opencv_face_detector.caffemodel", + "dnn/opencv_face_detector_fp16.caffemodel"), + testing::ValuesIn(getAvailableTargets(cv::dnn::DNN_BACKEND_OPENCV)) + ) + ); + + TEST_P(Test_Caffe_nets, FasterRCNN_vgg16) + { + applyTestTag( + #if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL) + CV_TEST_TAG_MEMORY_2GB, // utilizes ~1Gb, but huge blobs may not be allocated on 32-bit systems due memory fragmentation + #else + CV_TEST_TAG_MEMORY_2GB, + #endif + CV_TEST_TAG_LONG, + CV_TEST_TAG_DEBUG_VERYLONG + ); + + #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000) + if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && (target ==cv::dnn::DNN_TARGET_OPENCL || target ==cv::dnn::DNN_TARGET_OPENCL_FP16)) + applyTestTag(target ==cv::dnn::DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16); + + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target ==cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD); + #endif + + #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // IE exception: Ngraph operation Reshape with name rpn_cls_score_reshape has dynamic output shape on 0 port, but CPU plug-in supports only static shape + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target ==cv::dnn::DNN_TARGET_OPENCL || target ==cv::dnn::DNN_TARGET_OPENCL_FP16)) + applyTestTag(target ==cv::dnn::DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, + CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION + ); + // Check 'backward_compatible_check || in_out_elements_equal' failed at core/src/op/reshape.cpp:390: + // While validating node 'v1::Reshape bbox_pred_reshape (bbox_pred[0]:f32{1,84}, Constant_241202[0]:i64{4}) -> (f32{?,?,?,?})' with friendly_name 'bbox_pred_reshape': + // Requested output shape {1,6300,4,1} is incompatible with input shape Shape{1, 84} + if (target ==cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + #endif + + double scoreDiff = 0.0012, iouDiff = 0.03; + #if defined(INF_ENGINE_RELEASE) + if (target ==cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) { + iouDiff = 0.02; + if (target ==cv::dnn::DNN_TARGET_OPENCL || target ==cv::dnn::DNN_TARGET_OPENCL_FP16) { + scoreDiff = 0.04; + iouDiff = 0.06; + } + } + #endif + + static Mat ref = (Mat_(3, 7) << 0, 2, 0.949398, 99.2454, 210.141, 601.205, 462.849, + 0, 7, 0.997022, 481.841, 92.3218, 722.685, 175.953, + 0, 12, 0.993028, 133.221, 189.377, 350.994, 563.166); + testFaster("faster_rcnn_vgg16.prototxt", "VGG16_faster_rcnn_final.caffemodel", ref, scoreDiff, iouDiff); + } + + TEST_P(Test_Caffe_nets, FasterRCNN_zf) + { + applyTestTag( + #if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL) + CV_TEST_TAG_MEMORY_2GB, + #else + (target ==cv::dnn::DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB), + #endif + CV_TEST_TAG_DEBUG_VERYLONG + ); + #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // IE exception: Ngraph operation Reshape with name rpn_cls_score_reshape has dynamic output shape on 0 port, but CPU plug-in supports only static shape + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target ==cv::dnn::DNN_TARGET_OPENCL || target ==cv::dnn::DNN_TARGET_OPENCL_FP16)) + applyTestTag(target ==cv::dnn::DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, + CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION + ); + #endif + + if ((backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || + backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target ==cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD); + if (target ==cv::dnn::DNN_TARGET_CUDA_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA_FP16); + if (target ==cv::dnn::DNN_TARGET_CPU_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_CPU_FP16); + static Mat ref = (Mat_(3, 7) << 0, 2, 0.90121, 120.407, 115.83, 570.586, 528.395, + 0, 7, 0.988779, 469.849, 75.1756, 718.64, 186.762, + 0, 12, 0.967198, 138.588, 206.843, 329.766, 553.176); + + double scoreDiff = 0.003, iouDiff = 0.07; + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) { + scoreDiff = 0.02; + iouDiff = 0.13; + } + + testFaster("faster_rcnn_zf.prototxt", "ZF_faster_rcnn_final.caffemodel", ref, scoreDiff, iouDiff); + } + + TEST_P(Test_Caffe_nets, RFCN) + { + applyTestTag( + (target ==cv::dnn::DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_2GB), + CV_TEST_TAG_LONG, + CV_TEST_TAG_DEBUG_VERYLONG + ); + + float scoreDiff = default_l1, iouDiff = default_lInf; + if (backend == cv::dnn::DNN_BACKEND_OPENCV && (target ==cv::dnn::DNN_TARGET_OPENCL_FP16 || target ==cv::dnn::DNN_TARGET_CPU_FP16)) + { + scoreDiff = 4e-3; + iouDiff = 8e-2; + } + if (target ==cv::dnn::DNN_TARGET_CUDA_FP16) + { + scoreDiff = 0.0034; + iouDiff = 0.12; + } + + #if defined(INF_ENGINE_RELEASE) + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + { + scoreDiff = 0.1f; + iouDiff = 0.2f; + } + + // Check 'backward_compatible_check || in_out_elements_equal' failed at core/src/op/reshape.cpp:427: + // While validating node 'v1::Reshape bbox_pred_reshape (ave_bbox_pred_rois[0]:f32{1,8,1,1}, Constant_388[0]:i64{4}) -> (f32{?,?,?,?})' with friendly_name 'bbox_pred_reshape': + // Requested output shape {1,300,8,1} is incompatible with input shape {1, 8, 1, 1} + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target ==cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // Exception: Function contains several inputs and outputs with one friendly name! (HETERO bug?) + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target !=cv::dnn::DNN_TARGET_CPU) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + #elif defined(INF_ENGINE_RELEASE) + if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || + backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target ==cv::dnn::DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16); + if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || + backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target ==cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD); + #endif + + static Mat ref = (Mat_(2, 7) << 0, 7, 0.991359, 491.822, 81.1668, 702.573, 178.234, + 0, 12, 0.94786, 132.093, 223.903, 338.077, 566.16); + testFaster("rfcn_pascal_voc_resnet50.prototxt", "resnet50_rfcn_final.caffemodel", ref, scoreDiff, iouDiff); + } + +INSTANTIATE_TEST_CASE_P(/**/, Test_Caffe_nets, dnnBackendsAndTargets()); + +}} // namespace diff --git a/modules/dnnlegacy/test/test_common.cpp b/modules/dnnlegacy/test/test_common.cpp new file mode 100644 index 00000000000..a2ea6ead530 --- /dev/null +++ b/modules/dnnlegacy/test/test_common.cpp @@ -0,0 +1,6 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +#include "test_precomp.hpp" +#include "test_common.impl.hpp" // shared with perf tests diff --git a/modules/dnnlegacy/test/test_common.hpp b/modules/dnnlegacy/test/test_common.hpp new file mode 100644 index 00000000000..cb1e81ada95 --- /dev/null +++ b/modules/dnnlegacy/test/test_common.hpp @@ -0,0 +1,246 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +#ifndef __OPENCV_TEST_DNNLEGACY_COMMON_HPP__ +#define __OPENCV_TEST_DNNLEGACY_COMMON_HPP__ +#include +#include "opencv2/dnn/utils/inference_engine.hpp" + +#ifdef HAVE_OPENCL +#include "opencv2/core/ocl.hpp" +#endif + +// src/op_inf_engine.hpp +#define INF_ENGINE_VER_MAJOR_GT(ver) (((INF_ENGINE_RELEASE) / 10000) > ((ver) / 10000)) +#define INF_ENGINE_VER_MAJOR_GE(ver) (((INF_ENGINE_RELEASE) / 10000) >= ((ver) / 10000)) +#define INF_ENGINE_VER_MAJOR_LT(ver) (((INF_ENGINE_RELEASE) / 10000) < ((ver) / 10000)) +#define INF_ENGINE_VER_MAJOR_LE(ver) (((INF_ENGINE_RELEASE) / 10000) <= ((ver) / 10000)) +#define INF_ENGINE_VER_MAJOR_EQ(ver) (((INF_ENGINE_RELEASE) / 10000) == ((ver) / 10000)) + +#define CV_TEST_TAG_DNN_SKIP_OPENCV_BACKEND "dnnlegacy_skip_opencv_backend" +#define CV_TEST_TAG_DNN_SKIP_HALIDE "dnnlegacy_skip_halide" +#define CV_TEST_TAG_DNN_SKIP_CPU "dnnlegacy_skip_cpu" +#define CV_TEST_TAG_DNN_SKIP_CPU_FP16 "dnnlegacy_skip_cpu_fp16" +#define CV_TEST_TAG_DNN_SKIP_OPENCL "dnnlegacy_skip_ocl" +#define CV_TEST_TAG_DNN_SKIP_OPENCL_FP16 "dnnlegacy_skip_ocl_fp16" +#define CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER "dnnlegacy_skip_ie_nn_builder" +#define CV_TEST_TAG_DNN_SKIP_IE_NGRAPH "dnnlegacy_skip_ie_ngraph" +#define CV_TEST_TAG_DNN_SKIP_IE "dnnlegacy_skip_ie" +#define CV_TEST_TAG_DNN_SKIP_IE_2018R5 "dnnlegacy_skip_ie_2018r5" +#define CV_TEST_TAG_DNN_SKIP_IE_2019R1 "dnnlegacy_skip_ie_2019r1" +#define CV_TEST_TAG_DNN_SKIP_IE_2019R1_1 "dnnlegacy_skip_ie_2019r1_1" +#define CV_TEST_TAG_DNN_SKIP_IE_2019R2 "dnnlegacy_skip_ie_2019r2" +#define CV_TEST_TAG_DNN_SKIP_IE_2019R3 "dnnlegacy_skip_ie_2019r3" +#define CV_TEST_TAG_DNN_SKIP_IE_CPU "dnnlegacy_skip_ie_cpu" +#define CV_TEST_TAG_DNN_SKIP_IE_OPENCL "dnnlegacy_skip_ie_ocl" +#define CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16 "dnnlegacy_skip_ie_ocl_fp16" +#define CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_2 "dnnlegacy_skip_ie_myriad2" +#define CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X "dnnlegacy_skip_ie_myriadx" +#define CV_TEST_TAG_DNN_SKIP_IE_MYRIAD CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_2, CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X +#define CV_TEST_TAG_DNN_SKIP_IE_ARM_CPU "dnnlegacy_skip_ie_arm_cpu" + +#define CV_TEST_TAG_DNN_SKIP_VULKAN "dnnlegacy_skip_vulkan" + +#define CV_TEST_TAG_DNN_SKIP_CUDA "dnnlegacy_skip_cuda" +#define CV_TEST_TAG_DNN_SKIP_CUDA_FP16 "dnnlegacy_skip_cuda_fp16" +#define CV_TEST_TAG_DNN_SKIP_CUDA_FP32 "dnnlegacy_skip_cuda_fp32" + +#define CV_TEST_TAG_DNN_SKIP_ONNX_CONFORMANCE "dnnlegacy_skip_onnx_conformance" +#define CV_TEST_TAG_DNN_SKIP_PARSER "dnnlegacy_skip_parser" +#define CV_TEST_TAG_DNN_SKIP_GLOBAL "dnnlegacy_skip_global" + +#define CV_TEST_TAG_DNN_SKIP_TIMVX "dnnlegacy_skip_timvx" +#define CV_TEST_TAG_DNN_SKIP_CANN "dnnlegacy_skip_cann" + +#ifdef HAVE_INF_ENGINE +#if INF_ENGINE_VER_MAJOR_EQ(2018050000) +# define CV_TEST_TAG_DNN_SKIP_IE_VERSION CV_TEST_TAG_DNN_SKIP_IE, CV_TEST_TAG_DNN_SKIP_IE_2018R5 +#elif INF_ENGINE_VER_MAJOR_EQ(2019010000) +# if INF_ENGINE_RELEASE < 2019010100 +# define CV_TEST_TAG_DNN_SKIP_IE_VERSION CV_TEST_TAG_DNN_SKIP_IE, CV_TEST_TAG_DNN_SKIP_IE_2019R1 +# else +# define CV_TEST_TAG_DNN_SKIP_IE_VERSION CV_TEST_TAG_DNN_SKIP_IE, CV_TEST_TAG_DNN_SKIP_IE_2019R1_1 +# endif +#elif INF_ENGINE_VER_MAJOR_EQ(2019020000) +# define CV_TEST_TAG_DNN_SKIP_IE_VERSION CV_TEST_TAG_DNN_SKIP_IE, CV_TEST_TAG_DNN_SKIP_IE_2019R2 +#elif INF_ENGINE_VER_MAJOR_EQ(2019030000) +# define CV_TEST_TAG_DNN_SKIP_IE_VERSION CV_TEST_TAG_DNN_SKIP_IE, CV_TEST_TAG_DNN_SKIP_IE_2019R3 +#endif +#endif // HAVE_INF_ENGINE + +#ifndef CV_TEST_TAG_DNN_SKIP_IE_VERSION +# define CV_TEST_TAG_DNN_SKIP_IE_VERSION CV_TEST_TAG_DNN_SKIP_IE +#endif + + +namespace cv { namespace dnnlegacy { + +void PrintTo(const cv::dnn::Backend& v, std::ostream* os); +void PrintTo(const cv::dnn::Target& v, std::ostream* os); +using opencv_test::tuple; +using opencv_test::get; +void PrintTo(const tuple v, std::ostream* os); + + +}} // namespace cv::dnn + + + +namespace opencv_test { + + void initDNNTests(); + + using namespace cv::dnnlegacy; + + static inline const std::string& getOpenCVExtraDir() + { + return cvtest::TS::ptr()->get_data_path(); + } + + void normAssert( + cv::InputArray ref, cv::InputArray test, const char* comment = "", + double l1 = 0.00001, double lInf = 0.0001); + + std::vector matToBoxes(const cv::Mat& m); + + void normAssertDetections( + const std::vector& refClassIds, + const std::vector& refScores, + const std::vector& refBoxes, + const std::vector& testClassIds, + const std::vector& testScores, + const std::vector& testBoxes, + const char* comment = "", double confThreshold = 0.0, + double scores_diff = 1e-5, double boxes_iou_diff = 1e-4); + + // For SSD-based object detection networks which produce output of shape 1x1xNx7 + // where N is a number of detections and an every detection is represented by + // a vector [batchId, classId, confidence, left, top, right, bottom]. + void normAssertDetections( + cv::Mat ref, cv::Mat out, const char* comment = "", + double confThreshold = 0.0, double scores_diff = 1e-5, + double boxes_iou_diff = 1e-4); + + // For text detection networks + // Curved text polygon is not supported in the current version. + // (concave polygon is invalid input to intersectConvexConvex) + void normAssertTextDetections( + const std::vector>& gtPolys, + const std::vector>& testPolys, + const char* comment = "", double boxes_iou_diff = 1e-4); + + void readFileContent(const std::string& filename, CV_OUT std::vector& content); + + bool validateVPUType(); + + testing::internal::ParamGenerator< std::tuple > dnnBackendsAndTargets( + bool withInferenceEngine = true, + bool withHalide = false, + bool withCpuOCV = true, + bool withVkCom = true, + bool withCUDA = true, + bool withNgraph = true, + bool withWebnn = true, + bool withCann = true + ); + + testing::internal::ParamGenerator< std::tuple > dnnBackendsAndTargetsIE(); + + + class DNNlegacyTestLayer : public TestWithParam< std::tuple > + { + public: + cv::dnn::Backend backend; + cv::dnn::Target target; + double default_l1, default_lInf; + + DNNlegacyTestLayer() + { + backend = (cv::dnn::Backend)(int)get<0>(GetParam()); + target = (cv::dnn::Target)(int)get<1>(GetParam()); + getDefaultThresholds(backend, target, &default_l1, &default_lInf); + } + + static void getDefaultThresholds(int backend, int target, double* l1, double* lInf) + { + if (target == cv::dnn::DNN_TARGET_CPU_FP16 || target == cv::dnn::DNN_TARGET_CUDA_FP16 || target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_MYRIAD) + { + *l1 = 4e-3; + *lInf = 2e-2; + } + else + { + *l1 = 1e-5; + *lInf = 1e-4; + } + } + + static void checkBackend(int backend, int target, cv::Mat* inp = 0, cv::Mat* ref = 0) + { + CV_UNUSED(backend); CV_UNUSED(target); CV_UNUSED(inp); CV_UNUSED(ref); +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021000000) + if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + && target == DNN_TARGET_MYRIAD) + { + if (inp && ref && inp->dims == 4 && ref->dims == 4 && + inp->size[0] != 1 && inp->size[0] != ref->size[0]) + { + std::cout << "Inconsistent batch size of input and output blobs for Myriad plugin" << std::endl; + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD); + } + } +#endif + } + + void expectNoFallbacks(cv::dnn::Net& net, bool raiseError = true) + { + // Check if all the layers are supported with current backend and target. + // Some layers might be fused so their timings equal to zero. + std::vector timings; + net.getPerfProfile(timings); + std::vector names = net.getLayerNames(); + CV_Assert(names.size() == timings.size()); + + bool hasFallbacks = false; + for (int i = 0; i < names.size(); ++i) + { + Ptr l = net.getLayer(net.getLayerId(names[i])); + bool fused = !timings[i]; + if ((!l->supportBackend(backend) || l->preferableTarget != target) && !fused) + { + hasFallbacks = true; + std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to has backend implementation" << endl; + } + } + if (hasFallbacks && raiseError) + CV_Error(Error::StsNotImplemented, "Implementation fallbacks are not expected in this test"); + } + + void expectNoFallbacksFromIE(cv::dnn::Net& net) + { + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) + expectNoFallbacks(net); + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + expectNoFallbacks(net, false); + } + + void expectNoFallbacksFromCUDA(cv::dnn::Net& net) + { + if (backend == cv::dnn::DNN_BACKEND_CUDA) + expectNoFallbacks(net); + } + + size_t getTopMemoryUsageMB(); + + protected: + void checkBackend(cv::Mat* inp = 0, cv::Mat* ref = 0) + { + checkBackend(backend, target, inp, ref); + } + }; + +} // namespace + + +#endif diff --git a/modules/dnnlegacy/test/test_common.impl.hpp b/modules/dnnlegacy/test/test_common.impl.hpp new file mode 100644 index 00000000000..9f3b5ce498c --- /dev/null +++ b/modules/dnnlegacy/test/test_common.impl.hpp @@ -0,0 +1,540 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Used in accuracy and perf tests as a content of .cpp file +// Note: don't use "precomp.hpp" here +#include "opencv2/ts.hpp" +#include "opencv2/ts/ts_perf.hpp" +#include "opencv2/core/utility.hpp" +#include "opencv2/core/ocl.hpp" + +#include "opencv2/dnnlegacy.hpp" +#include "test_common.hpp" + +#include +#include + +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include +#include +#endif // _WIN32 + +namespace cv { namespace dnnlegacy { +CV__DNN_INLINE_NS_BEGIN + +void PrintTo(const cv::dnn::Backend& v, std::ostream* os) +{ + switch (v) { + case cv::dnn::DNN_BACKEND_DEFAULT: *os << "DEFAULT"; return; + /* remove in opencv 5.0 + case cv::dnn::DNN_BACKEND_HALIDE: *os << "HALIDE"; return; + */ + case cv::dnn::DNN_BACKEND_INFERENCE_ENGINE: *os << "DLIE*"; return; + case cv::dnn::DNN_BACKEND_VKCOM: *os << "VKCOM"; return; + case cv::dnn::DNN_BACKEND_OPENCV: *os << "OCV"; return; + case cv::dnn::DNN_BACKEND_CUDA: *os << "CUDA"; return; + case cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019: *os << "DLIE"; return; + case cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH: *os << "NGRAPH"; return; + case cv::dnn::DNN_BACKEND_WEBNN: *os << "WEBNN"; return; + case cv::dnn::DNN_BACKEND_TIMVX: *os << "TIMVX"; return; + case cv::dnn::DNN_BACKEND_CANN: *os << "CANN"; return; + } // don't use "default:" to emit compiler warnings + *os << "cv::dnn::DNN_BACKEND_UNKNOWN(" << (int)v << ")"; +} + +void PrintTo(const cv::dnn::Target& v, std::ostream* os) +{ + switch (v) { + case cv::dnn::DNN_TARGET_CPU: *os << "CPU"; return; + case cv::dnn::DNN_TARGET_OPENCL: *os << "OCL"; return; + case cv::dnn::DNN_TARGET_OPENCL_FP16: *os << "OCL_FP16"; return; + case cv::dnn::DNN_TARGET_MYRIAD: *os << "MYRIAD"; return; + case cv::dnn::DNN_TARGET_HDDL: *os << "HDDL"; return; + case cv::dnn::DNN_TARGET_VULKAN: *os << "VULKAN"; return; + case cv::dnn::DNN_TARGET_FPGA: *os << "FPGA"; return; + case cv::dnn::DNN_TARGET_CUDA: *os << "CUDA"; return; + case cv::dnn::DNN_TARGET_CUDA_FP16: *os << "CUDA_FP16"; return; + case cv::dnn::DNN_TARGET_NPU: *os << "NPU"; return; + case cv::dnn::DNN_TARGET_CPU_FP16: *os << "CPU_FP16"; return; + } // don't use "default:" to emit compiler warnings + *os << "cv::dnn::DNN_TARGET_UNKNOWN(" << (int)v << ")"; +} + +void PrintTo(const tuple v, std::ostream* os) +{ + PrintTo(get<0>(v), os); + *os << "/"; + PrintTo(get<1>(v), os); +} +CV__DNN_INLINE_NS_END +}} // namespace + + + +namespace opencv_test { + +void normAssert( + cv::InputArray ref, cv::InputArray test, const char *comment /*= ""*/, + double l1 /*= 0.00001*/, double lInf /*= 0.0001*/) +{ + double normL1 = cvtest::norm(ref, test, cv::NORM_L1) / ref.getMat().total(); + EXPECT_LE(normL1, l1) << comment << " |ref| = " << cvtest::norm(ref, cv::NORM_INF); + + double normInf = cvtest::norm(ref, test, cv::NORM_INF); + EXPECT_LE(normInf, lInf) << comment << " |ref| = " << cvtest::norm(ref, cv::NORM_INF); +} + +std::vector matToBoxes(const cv::Mat& m) +{ + EXPECT_EQ(m.type(), CV_32FC1); + EXPECT_EQ(m.dims, 2); + EXPECT_EQ(m.cols, 4); + + std::vector boxes(m.rows); + for (int i = 0; i < m.rows; ++i) + { + CV_Assert(m.row(i).isContinuous()); + const float* data = m.ptr(i); + double l = data[0], t = data[1], r = data[2], b = data[3]; + boxes[i] = cv::Rect2d(l, t, r - l, b - t); + } + return boxes; +} + +void normAssertDetections( + const std::vector& refClassIds, + const std::vector& refScores, + const std::vector& refBoxes, + const std::vector& testClassIds, + const std::vector& testScores, + const std::vector& testBoxes, + const char *comment /*= ""*/, double confThreshold /*= 0.0*/, + double scores_diff /*= 1e-5*/, double boxes_iou_diff /*= 1e-4*/) +{ + ASSERT_FALSE(testClassIds.empty()) << "No detections"; + std::vector matchedRefBoxes(refBoxes.size(), false); + std::vector refBoxesIoUDiff(refBoxes.size(), 1.0); + for (int i = 0; i < testBoxes.size(); ++i) + { + //cout << "Test[i=" << i << "]: score=" << testScores[i] << " id=" << testClassIds[i] << " box " << testBoxes[i] << endl; + double testScore = testScores[i]; + if (testScore < confThreshold) + continue; + + int testClassId = testClassIds[i]; + const cv::Rect2d& testBox = testBoxes[i]; + bool matched = false; + double topIoU = 0; + for (int j = 0; j < refBoxes.size() && !matched; ++j) + { + if (!matchedRefBoxes[j] && testClassId == refClassIds[j] && + std::abs(testScore - refScores[j]) < scores_diff) + { + double interArea = (testBox & refBoxes[j]).area(); + double iou = interArea / (testBox.area() + refBoxes[j].area() - interArea); + topIoU = std::max(topIoU, iou); + refBoxesIoUDiff[j] = std::min(refBoxesIoUDiff[j], 1.0f - iou); + if (1.0 - iou < boxes_iou_diff) + { + matched = true; + matchedRefBoxes[j] = true; + } + } + } + if (!matched) + { + std::cout << cv::format("Unmatched prediction: class %d score %f box ", + testClassId, testScore) << testBox << std::endl; + std::cout << "Highest IoU: " << topIoU << std::endl; + } + EXPECT_TRUE(matched) << comment; + } + + // Check unmatched reference detections. + for (int i = 0; i < refBoxes.size(); ++i) + { + if (!matchedRefBoxes[i] && refScores[i] > confThreshold) + { + std::cout << cv::format("Unmatched reference: class %d score %f box ", + refClassIds[i], refScores[i]) << refBoxes[i] + << " IoU diff: " << refBoxesIoUDiff[i] + << std::endl; + EXPECT_LE(refScores[i], confThreshold) << comment; + } + } +} + +// For SSD-based object detection networks which produce output of shape 1x1xNx7 +// where N is a number of detections and an every detection is represented by +// a vector [batchId, classId, confidence, left, top, right, bottom]. +void normAssertDetections( + cv::Mat ref, cv::Mat out, const char *comment /*= ""*/, + double confThreshold /*= 0.0*/, double scores_diff /*= 1e-5*/, + double boxes_iou_diff /*= 1e-4*/) +{ + CV_Assert(ref.total() % 7 == 0); + CV_Assert(out.total() % 7 == 0); + ref = ref.reshape(1, ref.total() / 7); + out = out.reshape(1, out.total() / 7); + + cv::Mat refClassIds, testClassIds; + ref.col(1).convertTo(refClassIds, CV_32SC1); + out.col(1).convertTo(testClassIds, CV_32SC1); + std::vector refScores(ref.col(2)), testScores(out.col(2)); + std::vector refBoxes = matToBoxes(ref.colRange(3, 7)); + std::vector testBoxes = matToBoxes(out.colRange(3, 7)); + normAssertDetections(refClassIds, refScores, refBoxes, testClassIds, testScores, + testBoxes, comment, confThreshold, scores_diff, boxes_iou_diff); +} + +// For text detection networks +// Curved text polygon is not supported in the current version. +// (concave polygon is invalid input to intersectConvexConvex) +void normAssertTextDetections( + const std::vector>& gtPolys, + const std::vector>& testPolys, + const char *comment /*= ""*/, double boxes_iou_diff /*= 1e-4*/) +{ + std::vector matchedRefBoxes(gtPolys.size(), false); + for (uint i = 0; i < testPolys.size(); ++i) + { + const std::vector& testPoly = testPolys[i]; + bool matched = false; + double topIoU = 0; + for (uint j = 0; j < gtPolys.size() && !matched; ++j) + { + if (!matchedRefBoxes[j]) + { + std::vector intersectionPolygon; + float intersectArea = intersectConvexConvex(testPoly, gtPolys[j], intersectionPolygon, true); + double iou = intersectArea / (contourArea(testPoly) + contourArea(gtPolys[j]) - intersectArea); + topIoU = std::max(topIoU, iou); + if (1.0 - iou < boxes_iou_diff) + { + matched = true; + matchedRefBoxes[j] = true; + } + } + } + if (!matched) { + std::cout << cv::format("Unmatched-det:") << testPoly << std::endl; + std::cout << "Highest IoU: " << topIoU << std::endl; + } + EXPECT_TRUE(matched) << comment; + } + + // Check unmatched groundtruth. + for (uint i = 0; i < gtPolys.size(); ++i) + { + if (!matchedRefBoxes[i]) { + std::cout << cv::format("Unmatched-gt:") << gtPolys[i] << std::endl; + } + EXPECT_TRUE(matchedRefBoxes[i]); + } +} + +void readFileContent(const std::string& filename, CV_OUT std::vector& content) +{ + const std::ios::openmode mode = std::ios::in | std::ios::binary; + std::ifstream ifs(filename.c_str(), mode); + ASSERT_TRUE(ifs.is_open()); + + content.clear(); + + ifs.seekg(0, std::ios::end); + const size_t sz = ifs.tellg(); + content.resize(sz); + ifs.seekg(0, std::ios::beg); + + ifs.read((char*)content.data(), sz); + ASSERT_FALSE(ifs.fail()); +} + + +testing::internal::ParamGenerator< tuple > dnnBackendsAndTargets( + bool withInferenceEngine /*= true*/, + bool withHalide /*= false*/, + bool withCpuOCV /*= true*/, + bool withVkCom /*= true*/, + bool withCUDA /*= true*/, + bool withNgraph /*= true*/, + bool withWebnn /*= false*/, + bool withCann /*= true*/ +) +{ + bool withVPU = validateVPUType(); + + std::vector< tuple > targets; + std::vector< cv::dnn::Target > available; + if (withHalide) + { + /* remove in opencv 5.0 + available = getAvailableTargets(cv::dnn::DNN_BACKEND_HALIDE); + for (std::vector< Target >::const_iterator i = available.begin(); i != available.end(); ++i) + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_HALIDE, *i)); + */ + } + if (withInferenceEngine) + { + available = getAvailableTargets(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019); + for (std::vector< cv::dnn::Target >::const_iterator i = available.begin(); i != available.end(); ++i) + { + if ((*i == cv::dnn::DNN_TARGET_MYRIAD || *i == cv::dnn::DNN_TARGET_HDDL) && !withVPU) + continue; + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019, *i)); + } + } + if (withNgraph) + { + available = getAvailableTargets(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH); + for (std::vector< cv::dnn::Target >::const_iterator i = available.begin(); i != available.end(); ++i) + { + if ((*i == cv::dnn::DNN_TARGET_MYRIAD || *i == cv::dnn::DNN_TARGET_HDDL) && !withVPU) + continue; + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH, *i)); + } + + } + if (withVkCom) + { + available = getAvailableTargets(cv::dnn::DNN_BACKEND_VKCOM); + for (std::vector< cv::dnn::Target >::const_iterator i = available.begin(); i != available.end(); ++i) + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_VKCOM, *i)); + } + +#ifdef HAVE_CUDA + if(withCUDA) + { + for (auto target : getAvailableTargets(cv::dnn::DNN_BACKEND_CUDA)) + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_CUDA, target)); + } +#endif + +#ifdef HAVE_WEBNN + if (withWebnn) + { + for (auto target : getAvailableTargets(cv::dnn::DNN_BACKEND_WEBNN)) { + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_WEBNN, target)); + } + } +#else + CV_UNUSED(withWebnn); +#endif + +#ifdef HAVE_CANN + if (withCann) + { + for (auto target : getAvailableTargets(cv::dnn::DNN_BACKEND_CANN)) + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_CANN, target)); + } +#else + CV_UNUSED(withCann); +#endif // HAVE_CANN + + { + available = getAvailableTargets(cv::dnn::DNN_BACKEND_OPENCV); + for (std::vector< cv::dnn::Target >::const_iterator i = available.begin(); i != available.end(); ++i) + { + if (!withCpuOCV && *i == cv::dnn::DNN_TARGET_CPU) + continue; + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_OPENCV, *i)); + } + } + if (targets.empty()) // validate at least CPU mode + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_OPENCV, cv::dnn::DNN_TARGET_CPU)); + return testing::ValuesIn(targets); +} + +testing::internal::ParamGenerator< tuple > dnnBackendsAndTargetsIE() +{ +#ifdef HAVE_INF_ENGINE + bool withVPU = validateVPUType(); + + std::vector< tuple > targets; + std::vector< cv::dnn::Target > available; + + { + available = getAvailableTargets(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH); + for (std::vector< cv::dnn::Target >::const_iterator i = available.begin(); i != available.end(); ++i) + { + if ((*i == cv::dnn::DNN_TARGET_MYRIAD || *i == cv::dnn::DNN_TARGET_HDDL) && !withVPU) + continue; + targets.push_back(make_tuple(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH, *i)); + } + + } + + return testing::ValuesIn(targets); +#else + return testing::ValuesIn(std::vector< tuple >()); +#endif +} + +static std::string getTestInferenceEngineVPUType() +{ + static std::string param_vpu_type = utils::getConfigurationParameterString("OPENCV_TEST_cv::dnn::DNN_IE_VPU_TYPE", ""); + return param_vpu_type; +} + +static bool validateVPUType_() +{ + std::string test_vpu_type = getTestInferenceEngineVPUType(); + if (test_vpu_type == "DISABLED" || test_vpu_type == "disabled") + { + return false; + } + + std::vector available = getAvailableTargets(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE); + bool have_vpu_target = false; + for (std::vector::const_iterator i = available.begin(); i != available.end(); ++i) + { + if (*i == cv::dnn::DNN_TARGET_MYRIAD || *i == cv::dnn::DNN_TARGET_HDDL) + { + have_vpu_target = true; + break; + } + } + + if (test_vpu_type.empty()) + { + if (have_vpu_target) + { + CV_LOG_INFO(NULL, "OpenCV-DNN-Test: VPU type for testing is not specified via 'OPENCV_TEST_cv::dnn::DNN_IE_VPU_TYPE' parameter.") + } + } + else + { + if (!have_vpu_target) + { + CV_LOG_FATAL(NULL, "OpenCV-DNN-Test: 'OPENCV_TEST_cv::dnn::DNN_IE_VPU_TYPE' parameter requires VPU of type = '" << test_vpu_type << "', but VPU is not detected. STOP."); + exit(1); + } + std::string dnn_vpu_type = cv::dnn::getInferenceEngineVPUType(); + if (dnn_vpu_type != test_vpu_type) + { + CV_LOG_FATAL(NULL, "OpenCV-DNN-Test: 'testing' and 'detected' VPU types mismatch: '" << test_vpu_type << "' vs '" << dnn_vpu_type << "'. STOP."); + exit(1); + } + } + if (have_vpu_target) + { + std::string dnn_vpu_type = cv::dnn::getInferenceEngineVPUType(); + if (dnn_vpu_type == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_2) + registerGlobalSkipTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_2); + if (dnn_vpu_type == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + registerGlobalSkipTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X); + } + return true; +} + +bool validateVPUType() +{ + static bool result = validateVPUType_(); + return result; +} + + +void initDNNTests() +{ + const char* extraTestDataPath = +#ifdef WINRT + NULL; +#else + getenv("OPENCV_cv::dnn::DNN_TEST_DATA_PATH"); +#endif + if (extraTestDataPath) + cvtest::addDataSearchPath(extraTestDataPath); + + registerGlobalSkipTag( + CV_TEST_TAG_DNN_SKIP_OPENCV_BACKEND, + CV_TEST_TAG_DNN_SKIP_CPU, CV_TEST_TAG_DNN_SKIP_CPU_FP16, + CV_TEST_TAG_DNN_SKIP_OPENCL, CV_TEST_TAG_DNN_SKIP_OPENCL_FP16 + ); +#if defined(HAVE_HALIDE) + registerGlobalSkipTag( + CV_TEST_TAG_cv::dnn::DNN_SKIP_HALIDE + ); +#endif +#if defined(INF_ENGINE_RELEASE) + registerGlobalSkipTag( + CV_TEST_TAG_DNN_SKIP_IE, +#if INF_ENGINE_VER_MAJOR_EQ(2018050000) + CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_2018R5, +#elif INF_ENGINE_VER_MAJOR_EQ(2019010000) + CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_2019R1, +# if INF_ENGINE_RELEASE == 2019010100 + CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_2019R1_1, +# endif +#elif INF_ENGINE_VER_MAJOR_EQ(2019020000) + CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_2019R2, +#elif INF_ENGINE_VER_MAJOR_EQ(2019030000) + CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_2019R3, +#endif +#ifdef HAVE_cv::dnn::DNN_NGRAPH + CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_NGRAPH, +#endif +#ifdef HAVE_cv::dnn::DNN_IE_NN_BUILDER_2019 + CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_NN_BUILDER, +#endif + CV_TEST_TAG_DNN_SKIP_IE_CPU + ); + registerGlobalSkipTag( + // see validateVPUType(): CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_MYRIAD_2, CV_TEST_TAG_cv::dnn::DNN_SKIP_IE_MYRIAD_X + CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16 + ); +#endif +#ifdef HAVE_VULKAN + registerGlobalSkipTag( + CV_TEST_TAG_cv::dnn::DNN_SKIP_VULKAN + ); +#endif +#ifdef HAVE_CUDA + registerGlobalSkipTag( + CV_TEST_TAG_DNN_SKIP_CUDA, CV_TEST_TAG_DNN_SKIP_CUDA_FP32, CV_TEST_TAG_DNN_SKIP_CUDA_FP16 + ); +#endif +#ifdef HAVE_TIMVX + registerGlobalSkipTag( + CV_TEST_TAG_cv::dnn::DNN_SKIP_TIMVX + ); +#endif +#ifdef HAVE_CANN + registerGlobalSkipTag( + CV_TEST_TAG_cv::dnn::DNN_SKIP_CANN + ); +#endif + registerGlobalSkipTag( + CV_TEST_TAG_DNN_SKIP_ONNX_CONFORMANCE, + CV_TEST_TAG_DNN_SKIP_PARSER + ); +} + +size_t DNNlegacyTestLayer::getTopMemoryUsageMB() +{ +#ifdef _WIN32 + PROCESS_MEMORY_COUNTERS proc; + GetProcessMemoryInfo(GetCurrentProcess(), &proc, sizeof(proc)); + return proc.PeakWorkingSetSize / pow(1024, 2); // bytes to megabytes +#else + std::ifstream status("/proc/self/status"); + std::string line, title; + while (std::getline(status, line)) + { + std::istringstream iss(line); + iss >> title; + if (title == "VmHWM:") + { + size_t mem; + iss >> mem; + return mem / 1024; + } + } + return 0l; +#endif +} + +} // namespace diff --git a/modules/dnnlegacy/test/test_darknet_importer.cpp b/modules/dnnlegacy/test/test_darknet_importer.cpp new file mode 100644 index 00000000000..3e62daf6bea --- /dev/null +++ b/modules/dnnlegacy/test/test_darknet_importer.cpp @@ -0,0 +1,1157 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// (3-clause BSD License) +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * Neither the names of the copyright holders nor the names of the contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall copyright holders or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" +#include "npy_blob.hpp" +#include + +namespace opencv_test { namespace { + +template +static std::string _tf(TString filename) +{ + return (getOpenCVExtraDir() + "/dnn/") + filename; +} + +TEST(Test_Darknet, read_tiny_yolo_voc) +{ + cv::dnn::Net net = readNetFromDarknet(_tf("tiny-yolo-voc.cfg")); + ASSERT_FALSE(net.empty()); +} + +TEST(Test_Darknet, read_yolo_voc) +{ + cv::dnn::Net net = cv::dnnlegacy::readNetFromDarknet(_tf("yolo-voc.cfg")); + ASSERT_FALSE(net.empty()); +} + +TEST(Test_Darknet, read_yolo_voc_stream) +{ + applyTestTag( + CV_TEST_TAG_MEMORY_1GB, + CV_TEST_TAG_DEBUG_VERYLONG + ); + Mat ref; + Mat sample = imread(_tf("dog416.png")); + Mat inp = cv::dnn::blobFromImage(sample, 1.0/255, Size(416, 416), Scalar(), true, false); + const std::string cfgFile = findDataFile("dnn/yolo-voc.cfg"); + const std::string weightsFile = findDataFile("dnn/yolo-voc.weights", false); + // Import by paths. + { + cv::dnn::Net net = cv::dnnlegacy::readNetFromDarknet(cfgFile, weightsFile); + net.setInput(inp); + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + net.enableWinograd(false); + ref = net.forward(); + } + // Import from bytes array. + { + std::vector cfg, weights; + readFileContent(cfgFile, cfg); + readFileContent(weightsFile, weights); + + cv::dnn::Net net = cv::dnnlegacy::readNetFromDarknet(cfg.data(), cfg.size(), weights.data(), weights.size()); + net.setInput(inp); + net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV); + net.enableWinograd(false); + Mat out = net.forward(); + normAssert(ref, out); + } +} + +class Test_Darknet_layers : public DNNlegacyTestLayer +{ +public: + void testDarknetLayer(const std::string& name, bool hasWeights = false, bool testBatchProcessing = true, + double l1 = 0.0, double lInf = 0.0) + { + SCOPED_TRACE(name); + Mat inp = blobFromNPY(findDataFile("dnn/darknet/" + name + "_in.npy")); + Mat ref = blobFromNPY(findDataFile("dnn/darknet/" + name + "_out.npy")); + l1 = l1 ? l1 : default_l1; + lInf = lInf ? lInf : default_lInf; + + std::string cfg = findDataFile("dnn/darknet/" + name + ".cfg"); + std::string model = ""; + if (hasWeights) + model = findDataFile("dnn/darknet/" + name + ".weights"); + + checkBackend(&inp, &ref); + + cv::dnn::Net net = cv::dnnlegacy::readNetFromDarknet(cfg, model); + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + net.setInput(inp); + Mat out = net.forward(); + normAssert(out, ref, "", l1, lInf); + + if (inp.size[0] == 1 && testBatchProcessing) // test handling of batch size + { + SCOPED_TRACE("batch size 2"); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000) + if (target == DNN_TARGET_MYRIAD && name == "shortcut") + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD); +#endif + + std::vector sz2 = cv::dnn::shape(inp); + sz2[0] = 2; + + cv::dnn::Net net2 = cv::dnnlegacy::readNetFromDarknet(cfg, model); + net2.setPreferableBackend(backend); + net2.setPreferableTarget(target); + Range ranges0[4] = { Range(0, 1), Range::all(), Range::all(), Range::all() }; + Range ranges1[4] = { Range(1, 2), Range::all(), Range::all(), Range::all() }; + Mat inp2(sz2, inp.type(), Scalar::all(0)); + inp.copyTo(inp2(ranges0)); + inp.copyTo(inp2(ranges1)); + net2.setInput(inp2); + Mat out2 = net2.forward(); + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + { + EXPECT_LT(cv::norm(out2(ranges0), out2(ranges1), NORM_INF), 1e-4) << "Batch result is not similar: " << name; + } + else + { + EXPECT_EQ(0, cv::norm(out2(ranges0), out2(ranges1), NORM_INF)) << "Batch result is not equal: " << name; + } + + Mat ref2 = ref; + if (ref.dims == 2 && out2.dims == 3) + { + int ref_3d_sizes[3] = {1, ref.rows, ref.cols}; + ref2 = Mat(3, ref_3d_sizes, ref.type(), (void*)ref.data); + } + /*else if (ref.dims == 3 && out2.dims == 4) + { + int ref_4d_sizes[4] = {1, ref.size[0], ref.size[1], ref.size[2]}; + ref2 = Mat(4, ref_4d_sizes, ref.type(), (void*)ref.data); + }*/ + ASSERT_EQ(out2.dims, ref2.dims) << ref.dims; + + normAssert(out2(ranges0), ref2, "", l1, lInf); + normAssert(out2(ranges1), ref2, "", l1, lInf); + } + } +}; + +class Test_Darknet_nets : public DNNlegacyTestLayer +{ +public: + // Test object detection network from Darknet framework. + void testDarknetModel(const std::string& cfg, const std::string& weights, + const std::vector >& refClassIds, + const std::vector >& refConfidences, + const std::vector >& refBoxes, + double scoreDiff, double iouDiff, float confThreshold = 0.24, + float nmsThreshold = 0.4, bool useWinograd = true, + int zeroPadW = 0) + { + checkBackend(); + + Mat img1 = imread(_tf("dog416.png")); + Mat img2 = imread(_tf("street.png")); + cv::resize(img2, img2, Size(416, 416)); + + // Pad images by black pixel at the right to test not equal width and height sizes + if (zeroPadW) { + cv::copyMakeBorder(img1, img1, 0, 0, 0, zeroPadW, BORDER_CONSTANT); + cv::copyMakeBorder(img2, img2, 0, 0, 0, zeroPadW, BORDER_CONSTANT); + } + + std::vector samples(2); + samples[0] = img1; samples[1] = img2; + + // determine test type, whether batch or single img + int batch_size = refClassIds.size(); + CV_Assert(batch_size == 1 || batch_size == 2); + samples.resize(batch_size); + + Mat inp = cv::dnn::blobFromImages(samples, 1.0/255, Size(), Scalar(), true, false); + + cv::dnn::Net net = cv::dnnlegacy::readNetFromDarknet(findDataFile("dnn/" + cfg), + findDataFile("dnn/" + weights, false)); + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + net.enableWinograd(useWinograd); + net.setInput(inp); + std::vector outs; + net.forward(outs, net.getUnconnectedOutLayersNames()); + + for (int b = 0; b < batch_size; ++b) + { + std::vector classIds; + std::vector confidences; + std::vector boxes; + for (int i = 0; i < outs.size(); ++i) + { + Mat out; + if (batch_size > 1){ + // get the sample slice from 3D matrix (batch, box, classes+5) + Range ranges[3] = {Range(b, b+1), Range::all(), Range::all()}; + out = outs[i](ranges).reshape(1, outs[i].size[1]); + }else{ + out = outs[i]; + } + for (int j = 0; j < out.rows; ++j) + { + Mat scores = out.row(j).colRange(5, out.cols); + double confidence; + Point maxLoc; + minMaxLoc(scores, 0, &confidence, 0, &maxLoc); + + if (confidence > confThreshold) { + float* detection = out.ptr(j); + double centerX = detection[0]; + double centerY = detection[1]; + double width = detection[2]; + double height = detection[3]; + boxes.push_back(Rect2d(centerX - 0.5 * width, centerY - 0.5 * height, + width, height)); + confidences.push_back(confidence); + classIds.push_back(maxLoc.x); + } + } + } + + // here we need NMS of boxes + std::vector indices; + cv::dnn::NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices); + + std::vector nms_classIds; + std::vector nms_confidences; + std::vector nms_boxes; + + for (size_t i = 0; i < indices.size(); ++i) + { + int idx = indices[i]; + Rect2d box = boxes[idx]; + float conf = confidences[idx]; + int class_id = classIds[idx]; + nms_boxes.push_back(box); + nms_confidences.push_back(conf); + nms_classIds.push_back(class_id); + if (cvtest::debugLevel > 0) + { + std::cout << b << ", " << class_id << ", " << conf << "f, " + << box.x << "f, " << box.y << "f, " + << box.x + box.width << "f, " << box.y + box.height << "f," + << std::endl; + } + } + + if (cvIsNaN(iouDiff)) + { + if (b == 0) + std::cout << "Skip accuracy checks" << std::endl; + continue; + } + + // Return predictions from padded image to the origin + if (zeroPadW) { + float scale = static_cast(inp.size[3]) / (inp.size[3] - zeroPadW); + for (auto& box : nms_boxes) { + box.x *= scale; + box.width *= scale; + } + } + normAssertDetections(refClassIds[b], refConfidences[b], refBoxes[b], nms_classIds, + nms_confidences, nms_boxes, format("batch size %d, sample %d\n", batch_size, b).c_str(), confThreshold, scoreDiff, iouDiff); + } + } + + void testDarknetModel(const std::string& cfg, const std::string& weights, + const std::vector& refClassIds, + const std::vector& refConfidences, + const std::vector& refBoxes, + double scoreDiff, double iouDiff, float confThreshold = 0.24, + float nmsThreshold = 0.4, bool useWinograd = true, + int zeroPadW = 0) + { + testDarknetModel(cfg, weights, + std::vector >(1, refClassIds), + std::vector >(1, refConfidences), + std::vector >(1, refBoxes), + scoreDiff, iouDiff, confThreshold, nmsThreshold, useWinograd, zeroPadW); + } + + void testDarknetModel(const std::string& cfg, const std::string& weights, + const cv::Mat& ref, double scoreDiff, double iouDiff, + float confThreshold = 0.24, float nmsThreshold = 0.4, bool useWinograd = true, + int zeroPadW = 0) + { + CV_Assert(ref.cols == 7); + std::vector > refClassIds; + std::vector > refScores; + std::vector > refBoxes; + for (int i = 0; i < ref.rows; ++i) + { + int batchId = static_cast(ref.at(i, 0)); + int classId = static_cast(ref.at(i, 1)); + float score = ref.at(i, 2); + float left = ref.at(i, 3); + float top = ref.at(i, 4); + float right = ref.at(i, 5); + float bottom = ref.at(i, 6); + Rect2d box(left, top, right - left, bottom - top); + if (batchId >= refClassIds.size()) + { + refClassIds.resize(batchId + 1); + refScores.resize(batchId + 1); + refBoxes.resize(batchId + 1); + } + refClassIds[batchId].push_back(classId); + refScores[batchId].push_back(score); + refBoxes[batchId].push_back(box); + } + testDarknetModel(cfg, weights, refClassIds, refScores, refBoxes, + scoreDiff, iouDiff, confThreshold, nmsThreshold, useWinograd, zeroPadW); + } +}; + +TEST_P(Test_Darknet_nets, YoloVoc) +{ + applyTestTag( +#if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL) + CV_TEST_TAG_MEMORY_2GB, +#else + CV_TEST_TAG_MEMORY_1GB, +#endif + CV_TEST_TAG_LONG, + CV_TEST_TAG_DEBUG_VERYLONG + ); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2020040000) // nGraph compilation failure + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2019010000) + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == cv::dnn::DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16); +#elif defined(INF_ENGINE_RELEASE) + if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && + target == DNN_TARGET_MYRIAD && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X); // need to update check function +#endif + + // batchId, classId, confidence, left, top, right, bottom + Mat ref = (Mat_(6, 7) << 0, 6, 0.750469f, 0.577374f, 0.127391f, 0.902949f, 0.300809f, // a car + 0, 1, 0.780879f, 0.270762f, 0.264102f, 0.732475f, 0.745412f, // a bicycle + 0, 11, 0.901615f, 0.1386f, 0.338509f, 0.421337f, 0.938789f, // a dog + 1, 14, 0.623813f, 0.183179f, 0.381921f, 0.247726f, 0.625847f, // a person + 1, 6, 0.667770f, 0.446555f, 0.453578f, 0.499986f, 0.519167f, // a car + 1, 6, 0.844947f, 0.637058f, 0.460398f, 0.828508f, 0.66427f); // a car + + double nmsThreshold = (target == cv::dnn::DNN_TARGET_MYRIAD || target == cv::dnn::DNN_TARGET_CPU_FP16) ? 0.397 : 0.4; + double scoreDiff = 8e-5, iouDiff = 3e-4; + if (target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_MYRIAD || target == cv::dnn::DNN_TARGET_CPU_FP16) + { + scoreDiff = 1e-2; + iouDiff = 0.018; + } + else if (target == cv::dnn::DNN_TARGET_CUDA_FP16) + { + scoreDiff = 0.03; + iouDiff = 0.018; + } +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000) + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + { + iouDiff = std::numeric_limits::quiet_NaN(); + } + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) + { + iouDiff = std::numeric_limits::quiet_NaN(); + } +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + { + iouDiff = std::numeric_limits::quiet_NaN(); + } + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) + { + iouDiff = std::numeric_limits::quiet_NaN(); + } +#endif + + std::string config_file = "yolo-voc.cfg"; + std::string weights_file = "yolo-voc.weights"; + + { + SCOPED_TRACE("batch size 1"); + testDarknetModel(config_file, weights_file, ref.rowRange(0, 3), scoreDiff, iouDiff, 0.24, 0.4, false); + } + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000) + // Exception: input != output + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // [ GENERAL_ERROR ] AssertionFailed: input != output + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif + { + SCOPED_TRACE("batch size 2"); + testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff, 0.24, nmsThreshold, false); + } + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000) + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif +} + + +TEST_P(Test_Darknet_nets, TinyYoloVoc) +{ + applyTestTag(CV_TEST_TAG_MEMORY_512MB); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2020040000) // nGraph compilation failure + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif +#if defined(INF_ENGINE_RELEASE) + if ((backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && + target == cv::dnn::DNN_TARGET_MYRIAD && cv::dnn::getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X); // need to update check function +#endif + // batchId, classId, confidence, left, top, right, bottom + Mat ref = (Mat_(4, 7) << 0, 6, 0.761967f, 0.579042f, 0.159161f, 0.894482f, 0.31994f, // a car + 0, 11, 0.780595f, 0.129696f, 0.386467f, 0.445275f, 0.920994f, // a dog + 1, 6, 0.651450f, 0.460526f, 0.458019f, 0.522527f, 0.5341f, // a car + 1, 6, 0.928758f, 0.651024f, 0.463539f, 0.823784f, 0.654998f); // a car + + double scoreDiff = 8e-5, iouDiff = 3e-4; + bool useWinograd = true; + if (target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_MYRIAD) + { + scoreDiff = 8e-3; + iouDiff = 0.018; + } + else if(target == cv::dnn::DNN_TARGET_CUDA_FP16) + { + scoreDiff = 0.008; + iouDiff = 0.02; + } + else if (target == cv::dnn::DNN_TARGET_CPU_FP16) + { + useWinograd = false; + scoreDiff = 8e-3; + iouDiff = 0.018; + } + + std::string config_file = "tiny-yolo-voc.cfg"; + std::string weights_file = "tiny-yolo-voc.weights"; + + { + SCOPED_TRACE("batch size 1"); + testDarknetModel(config_file, weights_file, ref.rowRange(0, 2), scoreDiff, iouDiff, 0.24, 0.4, useWinograd); + } + + { + SCOPED_TRACE("batch size 2"); + testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff, 0.24, 0.4, useWinograd); + } +} + +#ifdef HAVE_INF_ENGINE +static const std::chrono::milliseconds async_timeout(10000); + +typedef testing::TestWithParam > > Test_Darknet_nets_async; +TEST_P(Test_Darknet_nets_async, Accuracy) +{ + cv::dnn::Backend backendId = get<0>(get<1>(GetParam())); + cv::dnn::Target targetId = get<1>(get<1>(GetParam())); + std::string prefix = get<0>(GetParam()); + + applyTestTag(CV_TEST_TAG_MEMORY_512MB); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000) + if (INF_ENGINE_VER_MAJOR_LT(2019020000) && backendId == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); + + if (backendId == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); +#endif + + if (backendId != cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && backendId != cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + throw SkipTestException("No support for async forward"); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000) + if (targetId == DNN_TARGET_MYRIAD && prefix == "yolov3") // NC_OUT_OF_MEMORY + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + if (targetId == DNN_TARGET_MYRIAD && prefix == "yolov3") // NC_OUT_OF_MEMORY + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#elif defined(INF_ENGINE_RELEASE) + if (targetId == cv::dnn::DNN_TARGET_MYRIAD && prefix == "yolov4") // NC_OUT_OF_MEMORY + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif + + const int numInputs = 2; + std::vector inputs(numInputs); + int blobSize[] = {1, 3, 416, 416}; + for (int i = 0; i < numInputs; ++i) + { + inputs[i].create(4, &blobSize[0], CV_32F); + randu(inputs[i], 0, 1); + } + + cv::dnn::Net netSync = cv::dnnlegacy::readNetFromDarknet(findDataFile("dnn/" + prefix + ".cfg"), + findDataFile("dnn/" + prefix + ".weights", false)); + netSync.setPreferableBackend(backendId); + netSync.setPreferableTarget(targetId); + + // Run synchronously. + std::vector refs(numInputs); + for (int i = 0; i < numInputs; ++i) + { + netSync.setInput(inputs[i]); + refs[i] = netSync.forward().clone(); + } + + cv::dnn::Net netAsync = cv::dnnlegacy::readNetFromDarknet(findDataFile("dnn/" + prefix + ".cfg"), + findDataFile("dnn/" + prefix + ".weights", false)); + netAsync.setPreferableBackend(backendId); + netAsync.setPreferableTarget(targetId); + + double l1 = 0.0; + double lInf = 0.0; +#if defined(INF_ENGINE_RELEASE) + if (backendId == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + { + if (targetId == cv::dnn::DNN_TARGET_MYRIAD && prefix == "yolo-voc") + { + l1 = 0.02; + lInf = 0.15; + } + if (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 && prefix == "yolo-voc") + { + l1 = 0.02; + lInf = 0.1; + } + if (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 && prefix == "yolov3") + { + l1 = 0.001; + lInf = 0.007; + } + if (targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 && prefix == "yolov4") + { + l1 = 0.001; + lInf = 0.005; + } + if (INF_ENGINE_VER_MAJOR_EQ(2021040000) && targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 && prefix == "yolov4-tiny-2020-12") // FIXIT: 4.x only, 3.4 branch works well + { + l1 = 0.001; + lInf = 0.005; + } + if (INF_ENGINE_VER_MAJOR_EQ(2022010000) && targetId == cv::dnn::DNN_TARGET_OPENCL_FP16 && prefix == "yolov4-tiny-2020-12") // FIXIT: 4.x only, 3.4 branch works well + { + l1 = 0.001; + lInf = 0.005; + } + if (targetId == cv::dnn::DNN_TARGET_MYRIAD && prefix == "yolov4") + { + l1 = 0.005; + lInf = 1.6f; // |ref| = 0.95431125164031982 + } + } +#endif + + // Run asynchronously. To make test more robust, process inputs in the reversed order. + for (int i = numInputs - 1; i >= 0; --i) + { + netAsync.setInput(inputs[i]); + + AsyncArray out = netAsync.forwardAsync(); + ASSERT_TRUE(out.valid()); + Mat result; + EXPECT_TRUE(out.get(result, async_timeout)); + normAssert(refs[i], result, format("Index: %d", i).c_str(), l1, lInf); + } +} + +INSTANTIATE_TEST_CASE_P(/**/, Test_Darknet_nets_async, Combine( + Values("yolo-voc", "tiny-yolo-voc", "yolov3", "yolov4", "yolov4-tiny-2020-12"), + dnnBackendsAndTargets() +)); + +#endif + +TEST_P(Test_Darknet_nets, YOLOv3) +{ + applyTestTag( + CV_TEST_TAG_LONG, + CV_TEST_TAG_MEMORY_2GB, + CV_TEST_TAG_DEBUG_VERYLONG + ); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2020040000) // nGraph compilation failure + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif + + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); + + // batchId, classId, confidence, left, top, right, bottom + const int N0 = 3; + const int N1 = 6; + static const float ref_[/* (N0 + N1) * 7 */] = { +0, 16, 0.998836f, 0.160024f, 0.389964f, 0.417885f, 0.943716f, +0, 1, 0.987908f, 0.150913f, 0.221933f, 0.742255f, 0.746261f, +0, 7, 0.952983f, 0.614621f, 0.150257f, 0.901368f, 0.289251f, + +1, 2, 0.997412f, 0.647584f, 0.459939f, 0.821037f, 0.663947f, +1, 2, 0.989633f, 0.450719f, 0.463353f, 0.496306f, 0.522258f, +1, 0, 0.980053f, 0.195856f, 0.378454f, 0.258626f, 0.629257f, +1, 9, 0.785341f, 0.665503f, 0.373543f, 0.688893f, 0.439244f, +1, 9, 0.733275f, 0.376029f, 0.315694f, 0.401776f, 0.395165f, +1, 9, 0.384815f, 0.659824f, 0.372389f, 0.673927f, 0.429412f, + }; + Mat ref(N0 + N1, 7, CV_32FC1, (void*)ref_); + + double scoreDiff = 8e-5, iouDiff = 3e-4; + if (target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_MYRIAD || target == cv::dnn::DNN_TARGET_CPU_FP16) + { +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2022010000) + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) + scoreDiff = 0.009; + else +#endif + scoreDiff = 0.006; + iouDiff = 0.042; + } + else if (target == cv::dnn::DNN_TARGET_CUDA_FP16) + { + scoreDiff = 0.04; + iouDiff = 0.03; + } + std::string config_file = "yolov3.cfg"; + std::string weights_file = "yolov3.weights"; + +#if defined(INF_ENGINE_RELEASE) + if ((backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || + backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target == cv::dnn::DNN_TARGET_MYRIAD && + cv::dnn::getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + { + scoreDiff = 0.04; + iouDiff = 0.2; + } +#endif + + { + SCOPED_TRACE("batch size 1"); + testDarknetModel(config_file, weights_file, ref.rowRange(0, N0), scoreDiff, iouDiff, 0.24, 0.4, false); + } + +#if defined(INF_ENGINE_RELEASE) + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) + { + if (target == cv::dnn::DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + else if (target == cv::dnn::DNN_TARGET_OPENCL_FP16 && INF_ENGINE_VER_MAJOR_LE(202010000)) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + else if (target == cv::dnn::DNN_TARGET_MYRIAD && + cv::dnn::getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X); + } +#endif + + { + SCOPED_TRACE("batch size 2"); + testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff, 0.24, 0.4, false); + } +} + +TEST_P(Test_Darknet_nets, YOLOv4) +{ + applyTestTag( + CV_TEST_TAG_LONG, + CV_TEST_TAG_MEMORY_2GB, + CV_TEST_TAG_DEBUG_VERYLONG + ); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2020040000) // nGraph compilation failure + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2022010000) + if (target == DNN_TARGET_MYRIAD) // NC_OUT_OF_MEMORY + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif + + // batchId, classId, confidence, left, top, right, bottom + const int N0 = 3; + const int N1 = 7; + static const float ref_[/* (N0 + N1) * 7 */] = { +0, 16, 0.992194f, 0.172375f, 0.402458f, 0.403918f, 0.932801f, +0, 1, 0.988326f, 0.166708f, 0.228236f, 0.737208f, 0.735803f, +0, 7, 0.94639f, 0.602523f, 0.130399f, 0.901623f, 0.298452f, + +1, 2, 0.99761f, 0.646556f, 0.45985f, 0.816041f, 0.659067f, +1, 0, 0.988913f, 0.201726f, 0.360282f, 0.266181f, 0.631728f, +1, 2, 0.98233f, 0.452007f, 0.462217f, 0.495612f, 0.521687f, +1, 9, 0.919195f, 0.374642f, 0.316524f, 0.398126f, 0.393714f, +1, 9, 0.856303f, 0.666842f, 0.372215f, 0.685539f, 0.44141f, +1, 9, 0.313516f, 0.656791f, 0.374734f, 0.671959f, 0.438371f, +1, 9, 0.256625f, 0.940232f, 0.326931f, 0.967586f, 0.374002f, + }; + Mat ref(N0 + N1, 7, CV_32FC1, (void*)ref_); + + double scoreDiff = (target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_MYRIAD || target == cv::dnn::DNN_TARGET_CPU_FP16) ? 0.006 : 8e-5; + double iouDiff = (target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_MYRIAD || target == cv::dnn::DNN_TARGET_CPU_FP16) ? 0.042 : 3e-4; + if (target == cv::dnn::DNN_TARGET_CUDA_FP16) + { + scoreDiff = 0.008; + iouDiff = 0.03; + } + + std::string config_file = "yolov4.cfg"; + std::string weights_file = "yolov4.weights"; + + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000) + // accuracy (batch 1): no detections + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + { + iouDiff = std::numeric_limits::quiet_NaN(); + } + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) + { + iouDiff = std::numeric_limits::quiet_NaN(); + } +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // accuracy (batch 1) + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + { + iouDiff = std::numeric_limits::quiet_NaN(); + } +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2022010000) + if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || + backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target == DNN_TARGET_MYRIAD && + getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + { + scoreDiff = 0.04; + iouDiff = 0.2; + } +#endif + + { + SCOPED_TRACE("batch size 1"); + testDarknetModel(config_file, weights_file, ref.rowRange(0, N0), scoreDiff, iouDiff, 0.24, 0.4, false); + // Test not equal width and height applying zero padding + testDarknetModel(config_file, weights_file, ref.rowRange(0, N0), 0.006, 0.008, 0.24, 0.4, false, /*zeroPadW*/ 32); + } + + { + SCOPED_TRACE("batch size 2"); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000) + // accuracy (batch 2) + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + { + scoreDiff = 0.008f; + iouDiff = 0.05f; + } + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) + { + iouDiff = std::numeric_limits::quiet_NaN(); + } +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // accuracy (batch 2) + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + { + iouDiff = 0.45f; + } +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2022010000) + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) + { + if (target == DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + else if (target == DNN_TARGET_OPENCL_FP16 && INF_ENGINE_VER_MAJOR_LE(202010000)) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + else if (target == DNN_TARGET_MYRIAD && + getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X); + } +#endif + + testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff, 0.24, 0.4, false); + } + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000) + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // accuracy + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif +} + +TEST_P(Test_Darknet_nets, YOLOv4_tiny) +{ + applyTestTag( + target == cv::dnn::DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB + ); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2021010000) // nGraph compilation failure + if (target == cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif + + const double confThreshold = 0.5; + // batchId, classId, confidence, left, top, right, bottom + const int N0 = 3; + const int N1 = 3; + static const float ref_[/* (N0 + N1) * 7 */] = { +0, 16, 0.889883f, 0.177204f, 0.356279f, 0.417204f, 0.937517f, +0, 7, 0.816615f, 0.604293f, 0.137345f, 0.918016f, 0.295708f, +0, 1, 0.595912f, 0.0940107f, 0.178122f, 0.750619f, 0.829336f, + +1, 2, 0.998224f, 0.652883f, 0.463477f, 0.813952f, 0.657163f, +1, 2, 0.967396f, 0.4539f, 0.466368f, 0.497716f, 0.520299f, +1, 0, 0.807866f, 0.205039f, 0.361842f, 0.260984f, 0.643621f, + }; + Mat ref(N0 + N1, 7, CV_32FC1, (void*)ref_); + + double scoreDiff = 0.012f; + double iouDiff = (target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_MYRIAD || target == cv::dnn::DNN_TARGET_CPU_FP16) ? 0.15 : 0.01f; + if (target == cv::dnn::DNN_TARGET_CUDA_FP16) + iouDiff = 0.02; + + std::string config_file = "yolov4-tiny-2020-12.cfg"; + std::string weights_file = "yolov4-tiny-2020-12.weights"; + +#if defined(INF_ENGINE_RELEASE) + if (target == cv::dnn::DNN_TARGET_MYRIAD) // bad accuracy + iouDiff = std::numeric_limits::quiet_NaN(); + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == cv::dnn::DNN_TARGET_OPENCL) + iouDiff = std::numeric_limits::quiet_NaN(); + if ((backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || + backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target == cv::dnn::DNN_TARGET_OPENCL_FP16) + iouDiff = std::numeric_limits::quiet_NaN(); +#endif + + { + SCOPED_TRACE("batch size 1"); + testDarknetModel(config_file, weights_file, ref.rowRange(0, N0), scoreDiff, iouDiff, confThreshold, 0.4, false); + } + + { + SCOPED_TRACE("batch size 2"); + testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff, confThreshold, 0.4, false); + } + +#if defined(INF_ENGINE_RELEASE) + if (target == cv::dnn::DNN_TARGET_MYRIAD) // bad accuracy + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == cv::dnn::DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if ((backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || + backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target == cv::dnn::DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif +} + +TEST_P(Test_Darknet_nets, YOLOv4x_mish) +{ + applyTestTag( + CV_TEST_TAG_MEMORY_2GB, + CV_TEST_TAG_LONG, + CV_TEST_TAG_DEBUG_VERYLONG + ); + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // IE exception: Ngraph operation Transpose with name permute_168 has dynamic output shape on 0 port, but CPU plug-in supports only static shape + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)) + applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, + CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION + ); +#endif +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2020040000) // nGraph compilation failure + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif +#if defined(INF_ENGINE_RELEASE) + if (target == cv::dnn::DNN_TARGET_MYRIAD) // NC_OUT_OF_MEMORY + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif + + // batchId, classId, confidence, left, top, right, bottom + const int N0 = 3; + const int N1 = 5; + static const float ref_[/* (N0 + N1) * 7 */] = { +0, 16, 0.925536f, 0.17188f, 0.386832f, 0.406138f, 0.941696f, +0, 1, 0.912028f, 0.162125f, 0.208863f, 0.741316f, 0.729332f, +0, 7, 0.841018f, 0.608953f, 0.128653f, 0.900692f, 0.295657f, + +1, 2, 0.925697f, 0.650438f, 0.458118f, 0.813927f, 0.661775f, +1, 0, 0.882156f, 0.203644f, 0.365763f, 0.265473f, 0.632195f, +1, 2, 0.848857f, 0.451044f, 0.462997f, 0.496629f, 0.522719f, +1, 9, 0.736015f, 0.374503f, 0.316029f, 0.399358f, 0.392883f, +1, 9, 0.727129f, 0.662469f, 0.373687f, 0.687877f, 0.441335f, + }; + Mat ref(N0 + N1, 7, CV_32FC1, (void*)ref_); + + double scoreDiff = 8e-5; + double iouDiff = 3e-4; + + if (target == cv::dnn::DNN_TARGET_OPENCL_FP16 || target == cv::dnn::DNN_TARGET_MYRIAD || target == cv::dnn::DNN_TARGET_CUDA_FP16 || target == cv::dnn::DNN_TARGET_CPU_FP16) + { + scoreDiff = 0.006; + iouDiff = 0.042; + } + + std::string config_file = "yolov4x-mish.cfg"; + std::string weights_file = "yolov4x-mish.weights"; + +#if defined(INF_ENGINE_RELEASE) + if ((backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || + backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target == cv::dnn::DNN_TARGET_MYRIAD && + cv::dnn::getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + { + scoreDiff = 0.04; + iouDiff = 0.2; + } +#endif + + { + SCOPED_TRACE("batch size 1"); + testDarknetModel(config_file, weights_file, ref.rowRange(0, N0), scoreDiff, iouDiff, 0.24, 0.4, false); + } + + { + SCOPED_TRACE("batch size 2"); + +#if defined(INF_ENGINE_RELEASE) + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) + { + if (target == cv::dnn::DNN_TARGET_OPENCL) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + else if (target == cv::dnn::DNN_TARGET_OPENCL_FP16 && INF_ENGINE_VER_MAJOR_LE(202010000)) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + else if (target == cv::dnn::DNN_TARGET_MYRIAD && + cv::dnn::getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X); + } +#endif + + testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff, 0.24, 0.4, false); + } +} + + +INSTANTIATE_TEST_CASE_P(/**/, Test_Darknet_nets, dnnBackendsAndTargets()); + +TEST_P(Test_Darknet_layers, shortcut) +{ + testDarknetLayer("shortcut"); +} +TEST_P(Test_Darknet_layers, shortcut_leaky) +{ + testDarknetLayer("shortcut_leaky"); +} +TEST_P(Test_Darknet_layers, shortcut_unequal) +{ + testDarknetLayer("shortcut_unequal"); +} +TEST_P(Test_Darknet_layers, shortcut_unequal_2) +{ + testDarknetLayer("shortcut_unequal_2"); +} + +TEST_P(Test_Darknet_layers, upsample) +{ +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021030000) + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); // exception +#endif + testDarknetLayer("upsample"); +} + +TEST_P(Test_Darknet_layers, mish) +{ + testDarknetLayer("mish", true); +} + +TEST_P(Test_Darknet_layers, tanh) +{ + testDarknetLayer("tanh"); +} + +TEST_P(Test_Darknet_layers, avgpool_softmax) +{ + testDarknetLayer("avgpool_softmax"); +} + +TEST_P(Test_Darknet_layers, crop) +{ + testDarknetLayer("crop"); +} + +TEST_P(Test_Darknet_layers, region) +{ +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000) + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && INF_ENGINE_VER_MAJOR_GE(2020020000)) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif + +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2022010000) + // accuracy on CPU, OpenCL + // Expected: (normL1) <= (l1), actual: 0.000358148 vs 1e-05 + // |ref| = 1.207319974899292 + // Expected: (normInf) <= (lInf), actual: 0.763223 vs 0.0001 + // |ref| = 1.207319974899292 + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == cv::dnn::DNN_TARGET_CPU) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == cv::dnn::DNN_TARGET_OPENCL || target == cv::dnn::DNN_TARGET_OPENCL_FP16)) + applyTestTag(target == cv::dnn::DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, + CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION + ); +#elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000) + // accuracy on CPU, OpenCL + // Expected: (normInf) <= (lInf), actual: 0.763223 vs 0.0001 + // |ref| = 1.207319974899292 + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); + if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)) + applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, + CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION + ); +#endif + + testDarknetLayer("region"); +} + +TEST_P(Test_Darknet_layers, reorg) +{ + testDarknetLayer("reorg"); +} + +TEST_P(Test_Darknet_layers, route) +{ + testDarknetLayer("route"); + testDarknetLayer("route_multi"); +} + +TEST_P(Test_Darknet_layers, maxpool) +{ +#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2020020000) + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); +#endif + testDarknetLayer("maxpool"); +} + +TEST_P(Test_Darknet_layers, convolutional) +{ +#if defined(INF_ENGINE_RELEASE) + if (target == cv::dnn::DNN_TARGET_MYRIAD) + { + default_l1 = 0.01f; + } +#endif + testDarknetLayer("convolutional", true); +} + +TEST_P(Test_Darknet_layers, scale_channels) +{ + bool testBatches = backend == cv::dnn::DNN_BACKEND_CUDA; + testDarknetLayer("scale_channels", false, testBatches); +} + +TEST_P(Test_Darknet_layers, connected) +{ + if (backend == cv::dnn::DNN_BACKEND_OPENCV && target == cv::dnn::DNN_TARGET_OPENCL_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16); + if (backend == cv::dnn::DNN_BACKEND_OPENCV && target == cv::dnn::DNN_TARGET_CPU_FP16) + applyTestTag(CV_TEST_TAG_DNN_SKIP_CPU_FP16); + double l1 = 0.0; + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == cv::dnn::DNN_TARGET_OPENCL) + { + l1 = 3e-5; + } + testDarknetLayer("connected", true, true, l1); +} + +TEST_P(Test_Darknet_layers, relu) +{ + if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == cv::dnn::DNN_TARGET_MYRIAD) + applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD); + testDarknetLayer("relu"); +} + +TEST_P(Test_Darknet_layers, sam) +{ + testDarknetLayer("sam", true); +} + +INSTANTIATE_TEST_CASE_P(/**/, Test_Darknet_layers, dnnBackendsAndTargets()); +}} // namespace diff --git a/modules/dnnlegacy/test/test_main.cpp b/modules/dnnlegacy/test/test_main.cpp new file mode 100644 index 00000000000..0e51ddfd050 --- /dev/null +++ b/modules/dnnlegacy/test/test_main.cpp @@ -0,0 +1,6 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +#include "test_precomp.hpp" + +CV_TEST_MAIN("cv") diff --git a/modules/dnnlegacy/test/test_precomp.hpp b/modules/dnnlegacy/test/test_precomp.hpp new file mode 100644 index 00000000000..e30a57b3a9a --- /dev/null +++ b/modules/dnnlegacy/test/test_precomp.hpp @@ -0,0 +1,52 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ +#ifndef __OPENCV_TEST_PRECOMP_HPP__ +#define __OPENCV_TEST_PRECOMP_HPP__ + +#include "opencv2/ts.hpp" +#include "opencv2/ts/ts_perf.hpp" +#include "opencv2/core/utility.hpp" +#include "opencv2/core/ocl.hpp" + +#include "opencv2/dnnlegacy.hpp" +#include "test_common.hpp" + +#endif