diff --git a/modules/dnnlegacy/CMakeLists.txt b/modules/dnnlegacy/CMakeLists.txt
new file mode 100644
index 000000000..ab856cc55
--- /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) # <MSVS2019, .pb.cc generated files
+ ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4189) # local variable is initialized but not referenced
+ ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4592) # symbol will be dynamically initialized (implementation limitation)
+ endif()
+else()
+ ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-deprecated -Wmissing-prototypes -Wmissing-declarations -Wshadow
+ -Wunused-parameter -Wsign-compare
+ )
+endif()
+if(HAVE_CUDA)
+ ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
+endif()
+if(NOT HAVE_CXX11)
+ ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-undef) # LANG_CXX11 from protobuf files
+endif()
+
+if(APPLE_FRAMEWORK)
+ ocv_warnings_disable(CMAKE_CXX_FLAGS -Wshorten-64-to-32)
+endif()
+
+if(ANDROID)
+ add_definitions(-DDISABLE_POSIX_MEMALIGN -DTH_DISABLE_HEAP_TRACKING)
+endif()
+if(NOT BUILD_PROTOBUF)
+ ocv_target_compile_definitions(${the_module} PRIVATE "OPENCV_DNN_EXTERNAL_PROTOBUF=1")
+endif()
+
+#suppress warnings in autogenerated caffe.pb.* files
+ocv_warnings_disable(CMAKE_CXX_FLAGS
+ /wd4125 /wd4267 /wd4127 /wd4244 /wd4512 /wd4702
+ /wd4456 /wd4510 /wd4610 /wd4800
+ /wd4701 /wd4703 # potentially uninitialized local/pointer variable 'value' used
+ /wd4505 # unreferenced local function has been removed
+ /wd4458 # declaration of 'x' hides class member. GCC still works, MSVC bug is here: https://developercommunity.visualstudio.com/content/problem/219311/c-c4458-declaration-hides-class-member-warning-iss.html
+ -wd858 -wd2196
+ -Winvalid-offsetof # Apple Clang (attr_value.pb.cc)
+)
+
+set(include_dirs "")
+set(libs "")
+
+if(HAVE_PROTOBUF)
+ ocv_target_compile_definitions(${the_module} PRIVATE "HAVE_PROTOBUF=1")
+
+ if(PROTOBUF_UPDATE_FILES)
+ file(GLOB proto_files "${CMAKE_CURRENT_LIST_DIR}/src/tensorflow/*.proto" "${CMAKE_CURRENT_LIST_DIR}/src/caffe/opencv-caffe.proto" "${CMAKE_CURRENT_LIST_DIR}/src/onnx/opencv-onnx.proto")
+ set(PROTOBUF_GENERATE_CPP_APPEND_PATH ON) # required for tensorflow
+ protobuf_generate_cpp(fw_srcs fw_hdrs ${proto_files})
+ else()
+ file(GLOB fw_srcs "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.cc" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx/opencv-onnx.pb.cc")
+ file(GLOB fw_hdrs "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.h" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx/opencv-onnx.pb.h")
+ set(fw_inc "${CMAKE_CURRENT_LIST_DIR}/misc/caffe" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx")
+ endif()
+endif()
+
+
+list(APPEND include_dirs ${fw_inc})
+list(APPEND libs ${Protobuf_LIBRARIES})
+if(NOT BUILD_PROTOBUF)
+ list(APPEND include_dirs ${Protobuf_INCLUDE_DIRS})
+endif()
+
+set(sources_options "")
+
+list(APPEND libs ${LAPACK_LIBRARIES})
+if(OPENCV_DNN_OPENCL AND HAVE_OPENCL)
+ list(APPEND include_dirs ${OPENCL_INCLUDE_DIRS})
+else()
+ set(sources_options EXCLUDE_OPENCL)
+endif()
+
+if(OPENCV_DNN_CUDA AND HAVE_CUDA AND HAVE_CUBLAS AND HAVE_CUDNN)
+ list(APPEND include_dirs ${CUDA_TOOLKIT_INCLUDE} ${CUDNN_INCLUDE_DIRS})
+ set(CC_LIST ${CUDA_ARCH_BIN})
+ separate_arguments(CC_LIST)
+ foreach(cc ${CC_LIST})
+ if(cc VERSION_LESS 3.0)
+ message(FATAL_ERROR "CUDA backend for DNN module requires CC 3.0 or higher. Please remove unsupported architectures from CUDA_ARCH_BIN option or disable OPENCV_DNN_CUDA=OFF.")
+ endif()
+ endforeach()
+ unset(CC_LIST)
+ if(ENABLE_CUDA_FIRST_CLASS_LANGUAGE)
+ list(APPEND libs ${CUDNN_LIBRARIES} CUDA::cublas${CUDA_LIB_EXT})
+ if(NOT CUDA_VERSION VERSION_LESS 10.1)
+ list(APPEND libs CUDA::cublasLt${CUDA_LIB_EXT})
+ endif()
+ endif()
+else()
+ set(sources_options ${sources_options} EXCLUDE_CUDA)
+endif()
+
+if(HAVE_TIMVX)
+ list(APPEND include_dirs ${TIMVX_INCLUDE_DIR})
+ list(APPEND libs -Wl,--whole-archive ${TIMVX_LIBRARY} -Wl,--no-whole-archive)
+endif()
+
+if(HAVE_CANN)
+ list(APPEND include_dirs ${CANN_INCLUDE_DIRS})
+ list(APPEND libs -Wl,--whole-archive ${CANN_LIBRARIES} -Wl,--no-whole-archive)
+endif()
+
+set(webnn_srcs "")
+if(NOT EMSCRIPTEN)
+ if(HAVE_WEBNN)
+ list(APPEND include_dirs ${WEBNN_HEADER_DIRS})
+ list(APPEND include_dirs ${WEBNN_INCLUDE_DIRS})
+ list(APPEND libs -Wl,--whole-archive ${WEBNN_LIBRARIES} -Wl,--no-whole-archive)
+ list(APPEND webnn_srcs $ENV{WEBNN_NATIVE_DIR}/gen/src/webnn/webnn_cpp.cpp)
+ endif()
+endif()
+
+ocv_module_include_directories(${include_dirs})
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+ ocv_append_source_files_cxx_compiler_options(fw_srcs "-Wno-suggest-override") # GCC
+ ocv_append_source_files_cxx_compiler_options(fw_srcs "-Wno-array-bounds") # GCC 9.3.0 (Ubuntu 20.04)
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+ ocv_append_source_files_cxx_compiler_options(fw_srcs "-Wno-inconsistent-missing-override") # Clang
+endif()
+
+set(dnn_runtime_libs "")
+
+file(GLOB_RECURSE dnn_srcs
+ "${CMAKE_CURRENT_LIST_DIR}/src/*.cpp"
+)
+file(GLOB_RECURSE dnn_int_hdrs
+ "${CMAKE_CURRENT_LIST_DIR}/src/*.hpp"
+ "${CMAKE_CURRENT_LIST_DIR}/src/*.h"
+)
+set(dnn_plugin_srcs ${dnn_srcs} ${dnn_int_hdrs})
+ocv_list_filterout_ex(dnn_plugin_srcs
+ # importers
+ "/src/(caffe|darknet|onnx)/"
+)
+
+ocv_option(OPENCV_DNN_OPENVINO "Build with OpenVINO support (2021.4+)" (TARGET ocv.3rdparty.openvino))
+if(TARGET ocv.3rdparty.openvino AND OPENCV_DNN_OPENVINO)
+ if(NOT HAVE_OPENVINO AND NOT HAVE_NGRAPH)
+ message(FATAL_ERROR "DNN: Inference Engine is not supported without enabled 'nGraph'. Check build configuration.")
+ endif()
+ if("openvino" IN_LIST DNN_PLUGIN_LIST OR DNN_PLUGIN_LIST STREQUAL "all")
+ # plugin doesn't support PCH, separate directory scope is necessary
+ # opencv_world requires absolute path
+ add_subdirectory("${CMAKE_CURRENT_LIST_DIR}/misc/plugin/openvino" "${CMAKE_CURRENT_BINARY_DIR}/dnn_plugin_openvino")
+ elseif(NOT OPENCV_DNN_BUILTIN_BACKEND)
+ list(APPEND dnn_runtime_libs ocv.3rdparty.openvino)
+ endif()
+endif()
+
+set(OPENCV_DNN_BACKEND_DEFAULT "" CACHE STRING "Default backend used by the DNN module (DNN_BACKEND_OPENCV if empty)")
+if(OPENCV_DNN_BACKEND_DEFAULT)
+ ocv_append_source_file_compile_definitions("${CMAKE_CURRENT_LIST_DIR}/src/dnn_params.cpp" "OPENCV_DNN_BACKEND_DEFAULT=${OPENCV_DNN_BACKEND_DEFAULT}")
+endif()
+
+ocv_install_used_external_targets(${libs} ${dnn_runtime_libs})
+
+ocv_glob_module_sources(${sources_options} SOURCES ${fw_srcs})
+ocv_create_module(${libs} ${dnn_runtime_libs})
+ocv_add_samples()
+ocv_add_accuracy_tests(${dnn_runtime_libs})
+
+if(NOT BUILD_PROTOBUF)
+ if(TARGET opencv_test_dnn)
+ ocv_target_compile_definitions(opencv_test_dnn PRIVATE "OPENCV_DNN_EXTERNAL_PROTOBUF=1")
+ endif()
+endif()
+
+set(perf_path "${CMAKE_CURRENT_LIST_DIR}/perf")
+file(GLOB_RECURSE perf_srcs "${perf_path}/*.cpp")
+file(GLOB_RECURSE perf_hdrs "${perf_path}/*.hpp" "${perf_path}/*.h")
+ocv_add_perf_tests(${dnn_runtime_libs}
+ FILES test_common "${CMAKE_CURRENT_LIST_DIR}/test/test_common.hpp" "${CMAKE_CURRENT_LIST_DIR}/test/test_common.impl.hpp"
+ FILES Src ${perf_srcs}
+ FILES Include ${perf_hdrs}
+)
+
+ocv_option(OPENCV_DNN_PERF_CAFFE "Add performance tests of Caffe framework" OFF)
+ocv_option(OPENCV_DNN_PERF_CLCAFFE "Add performance tests of clCaffe framework" OFF)
+if(BUILD_PERF_TESTS)
+ if (OPENCV_DNN_PERF_CAFFE
+ OR ${the_module}_PERF_CAFFE # compatibility for deprecated option
+ )
+ find_package(Caffe QUIET)
+ if (Caffe_FOUND)
+ ocv_target_compile_definitions(opencv_perf_dnn PRIVATE "HAVE_CAFFE=1")
+ ocv_target_link_libraries(opencv_perf_dnn caffe)
+ endif()
+ elseif(OPENCV_DNN_PERF_CLCAFFE
+ OR ${the_module}_PERF_CAFFE # compatibility for deprecated option
+ )
+ find_package(Caffe QUIET)
+ if (Caffe_FOUND)
+ ocv_target_compile_definitions(opencv_perf_dnn PRIVATE "HAVE_CLCAFFE=1")
+ ocv_target_link_libraries(opencv_perf_dnn caffe)
+ endif()
+ endif()
+endif()
diff --git a/modules/dnnlegacy/LICENSE b/modules/dnnlegacy/LICENSE
new file mode 100644
index 000000000..261eeb9e9
--- /dev/null
+++ b/modules/dnnlegacy/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/modules/dnnlegacy/README.md b/modules/dnnlegacy/README.md
new file mode 100644
index 000000000..8a4b32056
--- /dev/null
+++ b/modules/dnnlegacy/README.md
@@ -0,0 +1,2 @@
+# dnnlegacy
+opencv 5.0 caffe and darknet importer and onnx importer for model with dynamic shape. Shape are fixed after onnx file is loaded
diff --git a/modules/dnnlegacy/include/opencv2/dnnlegacy.hpp b/modules/dnnlegacy/include/opencv2/dnnlegacy.hpp
new file mode 100644
index 000000000..12d71f325
--- /dev/null
+++ b/modules/dnnlegacy/include/opencv2/dnnlegacy.hpp
@@ -0,0 +1,61 @@
+/*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
+#define OPENCV_DNNLEGACY_HPP
+
+// This is an umbrella header to include into you project.
+// We are free to change headers layout in dnn subfolder, so please include
+// this header for future compatibility
+
+
+/** @defgroup dnn Deep Neural Network module
+ @{
+ This module contains:
+ - API to read Caffe or Darkent models;
+
+ Functionality of this module is designed only for forward pass computations (i.e. network testing).
+ A network training is in principle not supported.
+ @}
+*/
+#include <opencv2/dnnlegacy/dnnlegacy.hpp>
+
+#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 000000000..51fd1397a
--- /dev/null
+++ b/modules/dnnlegacy/include/opencv2/dnnlegacy/dnnlegacy.hpp
@@ -0,0 +1,134 @@
+/*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 <vector>
+#include <opencv2/core.hpp>
+#include <opencv2/dnn.hpp>
+#include "opencv2/core/async.hpp"
+
+#include <opencv2/dnn/dict.hpp>
+
+namespace cv {
+namespace dnnlegacy {
+
+ template <typename Importer, typename ... Args>
+ cv::dnn::Net readNet(Args&& ... args)
+ {
+ cv::dnn::Net net;
+ Importer importer(net, std::forward<Args>(args)...);
+ return net;
+ }
+
+ /** @brief Reads a network model stored in <a href="https://pjreddie.com/darknet/">Darknet</a> 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 <a href="https://pjreddie.com/darknet/">Darknet</a> 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<uchar>& bufferCfg,
+ const std::vector<uchar>& bufferModel = std::vector<uchar>());
+
+ /** @brief Reads a network model stored in <a href="https://pjreddie.com/darknet/">Darknet</a> 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 <a href="http://caffe.berkeleyvision.org">Caffe</a> 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<uchar>& bufferProto,
+ const std::vector<uchar>& bufferModel = std::vector<uchar>());
+
+ /** @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<String>& layersTypes = std::vector<String>());
+}
+}
+
+#
+#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 000000000..65feaf088
--- /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 <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+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<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_BlobShape_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_BlobProto_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_BlobProtoVector_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_PermuteParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_NormalizeBBoxParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_PriorBoxParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_DetectionOutputParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_Datum_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_FillerParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_NetParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_SolverParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_SolverState_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_NetState_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_NetStateRule_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ParamSpec_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_LayerParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_TransformationParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_LossParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_AccuracyParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ArgMaxParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ConcatParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_BatchNormParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_BiasParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ContrastiveLossParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ConvolutionParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_CropParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_DataParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_NonMaximumSuppressionParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_SaveOutputParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_DropoutParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_DummyDataParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_EltwiseParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ELUParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_EmbedParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ExpParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_FlattenParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_HDF5DataParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_HDF5OutputParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_HingeLossParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ImageDataParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_InfogainLossParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_InnerProductParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_InputParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_LogParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_LRNParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_MemoryDataParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_MVNParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ParameterParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_PoolingParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_PowerParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_PythonParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_RecurrentParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ReductionParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ReLUParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ReshapeParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ScaleParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_SigmoidParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_SliceParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_SoftmaxParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_TanHParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_TileParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ThresholdParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_WindowDataParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_SPPParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_V1LayerParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_V0LayerParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_PReLUParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_NormalizedBBox_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ROIPoolingParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::opencv_caffe::_ProposalParameter_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::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<uint8_t>(tag) == 10)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_dim(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<uint8_t>(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<int32_t>(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<BlobShape *>(to)->MergeFrom(
+ static_cast<const BlobShape &>(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<BlobProto>()._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<size_t>(reinterpret_cast<char*>(&raw_data_type_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&shape_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&raw_data_type_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&raw_data_type_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 42)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_data(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<uint8_t>(tag) == 45) {
+ _internal_add_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // repeated float diff = 6 [packed = true];
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_diff(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<uint8_t>(tag) == 53) {
+ _internal_add_diff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional .opencv_caffe.BlobShape shape = 7;
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(tag) == 66)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_data(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<uint8_t>(tag) == 65) {
+ _internal_add_double_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
+ ptr += sizeof(double);
+ } else
+ goto handle_unusual;
+ continue;
+ // repeated double double_diff = 9 [packed = true];
+ case 9:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_diff(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<uint8_t>(tag) == 73) {
+ _internal_add_double_diff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(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<uint8_t>(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<uint8_t>(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<unsigned int>(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<int32_t>(data_size));
+ }
+ total_size += data_size;
+ }
+
+ // repeated float diff = 6 [packed = true];
+ {
+ unsigned int count = static_cast<unsigned int>(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<int32_t>(data_size));
+ }
+ total_size += data_size;
+ }
+
+ // repeated double double_data = 8 [packed = true];
+ {
+ unsigned int count = static_cast<unsigned int>(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<int32_t>(data_size));
+ }
+ total_size += data_size;
+ }
+
+ // repeated double double_diff = 9 [packed = true];
+ {
+ unsigned int count = static_cast<unsigned int>(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<int32_t>(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<BlobProto *>(to)->MergeFrom(
+ static_cast<const BlobProto &>(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<char*>(&shape_),
+ reinterpret_cast<char*>(&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<uint8_t>(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<unsigned int>(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<BlobProtoVector *>(to)->MergeFrom(
+ static_cast<const BlobProtoVector &>(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<uint8_t>(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<uint8_t>(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<PermuteParameter *>(to)->MergeFrom(
+ static_cast<const PermuteParameter &>(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<NormalizeBBoxParameter>()._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<size_t>(reinterpret_cast<char*>(&eps_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 37)) {
+ _Internal::set_has_eps(&has_bits);
+ eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<NormalizeBBoxParameter *>(to)->MergeFrom(
+ static_cast<const NormalizeBBoxParameter &>(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<PriorBoxParameter>()._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<size_t>(reinterpret_cast<char*>(&offset_) -
+ reinterpret_cast<char*>(&img_size_)) + sizeof(offset_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.PriorBoxParameter)
+}
+
+inline void PriorBoxParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&img_size_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&step_w_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&step_w_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_min_size(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<13>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(tag) == 21)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_max_size(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<21>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(tag) == 29)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_aspect_ratio(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<29>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 53)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_variance(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<53>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 85)) {
+ _Internal::set_has_step(&has_bits);
+ step_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float step_h = 11;
+ case 11:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 93)) {
+ _Internal::set_has_step_h(&has_bits);
+ step_h_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float step_w = 12;
+ case 12:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 101)) {
+ _Internal::set_has_step_w(&has_bits);
+ step_w_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float offset = 13 [default = 0.5];
+ case 13:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 109)) {
+ _Internal::set_has_offset(&has_bits);
+ offset_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // repeated float offset_h = 14;
+ case 14:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 117)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_offset_h(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<117>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(tag) == 125)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_offset_w(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<125>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(tag) == 133)) {
+ ptr -= 2;
+ do {
+ ptr += 2;
+ _internal_add_width(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<133>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(tag) == 141)) {
+ ptr -= 2;
+ do {
+ ptr += 2;
+ _internal_add_height(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<141>(ptr));
+ } else if (static_cast<uint8_t>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<PriorBoxParameter *>(to)->MergeFrom(
+ static_cast<const PriorBoxParameter &>(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<char*>(&img_size_),
+ reinterpret_cast<char*>(&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<DetectionOutputParameter>()._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<size_t>(reinterpret_cast<char*>(&normalized_bbox_) -
+ reinterpret_cast<char*>(&num_classes_)) + sizeof(normalized_bbox_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.DetectionOutputParameter)
+}
+
+inline void DetectionOutputParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&nms_param_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&clip_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&clip_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 77)) {
+ _Internal::set_has_confidence_threshold(&has_bits);
+ confidence_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional bool normalized_bbox = 10 [default = true];
+ case 10:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<DetectionOutputParameter *>(to)->MergeFrom(
+ static_cast<const DetectionOutputParameter &>(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<char*>(&nms_param_),
+ reinterpret_cast<char*>(&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<Datum>()._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<size_t>(reinterpret_cast<char*>(&encoded_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&channels_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&encoded_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&encoded_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 53)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_float_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<53>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<unsigned int>(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<Datum *>(to)->MergeFrom(
+ static_cast<const Datum &>(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<char*>(&channels_),
+ reinterpret_cast<char*>(&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<FillerParameter>()._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<size_t>(reinterpret_cast<char*>(&std_) -
+ reinterpret_cast<char*>(&value_)) + sizeof(std_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.FillerParameter)
+}
+
+inline void FillerParameter::SharedCtor() {
+type_.UnsafeSetDefault(nullptr);
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&value_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&variance_norm_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&variance_norm_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(tag) == 21)) {
+ _Internal::set_has_value(&has_bits);
+ value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float min = 3 [default = 0];
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+ _Internal::set_has_min(&has_bits);
+ min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float max = 4 [default = 1];
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 37)) {
+ _Internal::set_has_max(&has_bits);
+ max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float mean = 5 [default = 0];
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 45)) {
+ _Internal::set_has_mean(&has_bits);
+ mean_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float std = 6 [default = 1];
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 53)) {
+ _Internal::set_has_std(&has_bits);
+ std_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional int32 sparse = 7 [default = -1];
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<int>(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<FillerParameter *>(to)->MergeFrom(
+ static_cast<const FillerParameter &>(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<char*>(&value_),
+ reinterpret_cast<char*>(&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<NetParameter>()._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<size_t>(reinterpret_cast<char*>(&debug_info_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&state_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&debug_info_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&debug_info_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<unsigned int>(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<int>(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<unsigned int>(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<unsigned int>(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<NetParameter *>(to)->MergeFrom(
+ static_cast<const NetParameter &>(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<char*>(&state_),
+ reinterpret_cast<char*>(&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<SolverParameter>()._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<size_t>(reinterpret_cast<char*>(&rms_decay_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&train_net_param_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&solver_type_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&momentum_) -
+ reinterpret_cast<char*>(&test_interval_)) + sizeof(momentum_));
+ }
+ if (cached_has_bits & 0x00ff0000u) {
+ ::memset(&weight_decay_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&solver_type_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 45)) {
+ _Internal::set_has_base_lr(&_has_bits_);
+ base_lr_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional int32 display = 6;
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 77)) {
+ _Internal::set_has_gamma(&_has_bits_);
+ gamma_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float power = 10;
+ case 10:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 85)) {
+ _Internal::set_has_power(&_has_bits_);
+ power_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float momentum = 11;
+ case 11:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 93)) {
+ _Internal::set_has_momentum(&_has_bits_);
+ momentum_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float weight_decay = 12;
+ case 12:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 101)) {
+ _Internal::set_has_weight_decay(&_has_bits_);
+ weight_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional int32 stepsize = 13;
+ case 13:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 253)) {
+ _Internal::set_has_delta(&_has_bits_);
+ delta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional bool test_initialization = 32 [default = true];
+ case 32:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 29)) {
+ _Internal::set_has_clip_gradients(&_has_bits_);
+ clip_gradients_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional int32 iter_size = 36 [default = 1];
+ case 36:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 53)) {
+ _Internal::set_has_rms_decay(&_has_bits_);
+ rms_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float momentum2 = 39 [default = 0.999];
+ case 39:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 61)) {
+ _Internal::set_has_momentum2(&_has_bits_);
+ momentum2_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional string type = 40 [default = "SGD"];
+ case 40:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<int>(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<int>(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<int>(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<int>(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<unsigned int>(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<int>(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<unsigned int>(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<int>(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<int>(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<SolverParameter *>(to)->MergeFrom(
+ static_cast<const SolverParameter &>(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<char*>(&train_net_param_),
+ reinterpret_cast<char*>(&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<SolverState>()._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<size_t>(reinterpret_cast<char*>(¤t_step_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&iter_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(¤t_step_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(¤t_step_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<unsigned int>(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<SolverState *>(to)->MergeFrom(
+ static_cast<const SolverState &>(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<char*>(&iter_),
+ reinterpret_cast<char*>(&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<NetState>()._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<size_t>(reinterpret_cast<char*>(&phase_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<NetState *>(to)->MergeFrom(
+ static_cast<const NetState &>(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<NetStateRule>()._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<size_t>(reinterpret_cast<char*>(&max_level_) -
+ reinterpret_cast<char*>(&phase_)) + sizeof(max_level_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetStateRule)
+}
+
+inline void NetStateRule::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&phase_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&max_level_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&max_level_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<NetStateRule *>(to)->MergeFrom(
+ static_cast<const NetStateRule &>(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<char*>(&phase_),
+ reinterpret_cast<char*>(&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<ParamSpec>()._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<size_t>(reinterpret_cast<char*>(&decay_mult_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 29)) {
+ _Internal::set_has_lr_mult(&has_bits);
+ lr_mult_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float decay_mult = 4 [default = 1];
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 37)) {
+ _Internal::set_has_decay_mult(&has_bits);
+ decay_mult_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<int>(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<ParamSpec *>(to)->MergeFrom(
+ static_cast<const ParamSpec &>(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<LayerParameter>()._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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&transform_param_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 45)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_loss_weight(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<int>(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<int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<LayerParameter *>(to)->MergeFrom(
+ static_cast<const LayerParameter &>(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<char*>(&transform_param_),
+ reinterpret_cast<char*>(&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<TransformationParameter>()._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<size_t>(reinterpret_cast<char*>(&scale_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&crop_size_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&force_gray_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&force_gray_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_scale(&has_bits);
+ scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional bool mirror = 2 [default = false];
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 45)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_mean_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<unsigned int>(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<TransformationParameter *>(to)->MergeFrom(
+ static_cast<const TransformationParameter &>(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<char*>(&crop_size_),
+ reinterpret_cast<char*>(&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<LossParameter>()._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<size_t>(reinterpret_cast<char*>(&normalization_) -
+ reinterpret_cast<char*>(&ignore_label_)) + sizeof(normalization_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.LossParameter)
+}
+
+inline void LossParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&ignore_label_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&normalize_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&normalize_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<LossParameter *>(to)->MergeFrom(
+ static_cast<const LossParameter &>(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<char*>(&ignore_label_),
+ reinterpret_cast<char*>(&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<AccuracyParameter>()._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<size_t>(reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<AccuracyParameter *>(to)->MergeFrom(
+ static_cast<const AccuracyParameter &>(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<ArgMaxParameter>()._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<size_t>(reinterpret_cast<char*>(&top_k_) -
+ reinterpret_cast<char*>(&out_max_val_)) + sizeof(top_k_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.ArgMaxParameter)
+}
+
+inline void ArgMaxParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&out_max_val_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<ArgMaxParameter *>(to)->MergeFrom(
+ static_cast<const ArgMaxParameter &>(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<char*>(&out_max_val_),
+ reinterpret_cast<char*>(&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<ConcatParameter>()._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<size_t>(reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<ConcatParameter *>(to)->MergeFrom(
+ static_cast<const ConcatParameter &>(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<BatchNormParameter>()._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<size_t>(reinterpret_cast<char*>(&eps_) -
+ reinterpret_cast<char*>(&use_global_stats_)) + sizeof(eps_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.BatchNormParameter)
+}
+
+inline void BatchNormParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&use_global_stats_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&scale_bias_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&scale_bias_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(tag) == 21)) {
+ _Internal::set_has_moving_average_fraction(&has_bits);
+ moving_average_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float eps = 3 [default = 1e-05];
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+ _Internal::set_has_eps(&has_bits);
+ eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional bool scale_bias = 7 [default = false];
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<BatchNormParameter *>(to)->MergeFrom(
+ static_cast<const BatchNormParameter &>(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<char*>(&use_global_stats_),
+ reinterpret_cast<char*>(&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<BiasParameter>()._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<size_t>(reinterpret_cast<char*>(&num_axes_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<BiasParameter *>(to)->MergeFrom(
+ static_cast<const BiasParameter &>(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<ContrastiveLossParameter>()._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<size_t>(reinterpret_cast<char*>(&margin_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_margin(&has_bits);
+ margin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional bool legacy_version = 2 [default = false];
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<ContrastiveLossParameter *>(to)->MergeFrom(
+ static_cast<const ContrastiveLossParameter &>(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<ConvolutionParameter>()._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<size_t>(reinterpret_cast<char*>(&group_) -
+ reinterpret_cast<char*>(&num_output_)) + sizeof(group_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.ConvolutionParameter)
+}
+
+inline void ConvolutionParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&weight_filler_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&force_nd_im2col_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&stride_h_) -
+ reinterpret_cast<char*>(&num_output_)) + sizeof(stride_h_));
+ }
+ if (cached_has_bits & 0x00003f00u) {
+ ::memset(&stride_w_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&force_nd_im2col_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<ConvolutionParameter *>(to)->MergeFrom(
+ static_cast<const ConvolutionParameter &>(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<char*>(&weight_filler_),
+ reinterpret_cast<char*>(&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<CropParameter>()._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<uint8_t>(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<uint8_t>(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<uint8_t>(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<CropParameter *>(to)->MergeFrom(
+ static_cast<const CropParameter &>(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<DataParameter>()._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<size_t>(reinterpret_cast<char*>(&prefetch_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&batch_size_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&backend_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&backend_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(tag) == 21)) {
+ _Internal::set_has_scale(&has_bits);
+ scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional string mean_file = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<DataParameter *>(to)->MergeFrom(
+ static_cast<const DataParameter &>(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<char*>(&batch_size_),
+ reinterpret_cast<char*>(&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<NonMaximumSuppressionParameter>()._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<size_t>(reinterpret_cast<char*>(&eta_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_nms_threshold(&has_bits);
+ nms_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional int32 top_k = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(tag) == 29)) {
+ _Internal::set_has_eta(&has_bits);
+ eta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<NonMaximumSuppressionParameter *>(to)->MergeFrom(
+ static_cast<const NonMaximumSuppressionParameter &>(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<SaveOutputParameter>()._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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<int>(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<int>(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<int>(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<SaveOutputParameter *>(to)->MergeFrom(
+ static_cast<const SaveOutputParameter &>(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<DropoutParameter>()._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<size_t>(reinterpret_cast<char*>(&scale_train_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_dropout_ratio(&has_bits);
+ dropout_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional bool scale_train = 2 [default = true];
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<DropoutParameter *>(to)->MergeFrom(
+ static_cast<const DropoutParameter &>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<unsigned int>(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<unsigned int>(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<DummyDataParameter *>(to)->MergeFrom(
+ static_cast<const DummyDataParameter &>(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<EltwiseParameter>()._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<size_t>(reinterpret_cast<char*>(&stable_prod_grad_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(tag) == 21)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_coeff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<21>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<unsigned int>(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<EltwiseParameter *>(to)->MergeFrom(
+ static_cast<const EltwiseParameter &>(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<ELUParameter>()._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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_alpha(&has_bits);
+ alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<ELUParameter *>(to)->MergeFrom(
+ static_cast<const ELUParameter &>(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<EmbedParameter>()._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<size_t>(reinterpret_cast<char*>(&bias_term_) -
+ reinterpret_cast<char*>(&num_output_)) + sizeof(bias_term_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.EmbedParameter)
+}
+
+inline void EmbedParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&weight_filler_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&input_dim_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&input_dim_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<EmbedParameter *>(to)->MergeFrom(
+ static_cast<const EmbedParameter &>(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<char*>(&weight_filler_),
+ reinterpret_cast<char*>(&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<ExpParameter>()._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<size_t>(reinterpret_cast<char*>(&scale_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_base(&has_bits);
+ base_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float scale = 2 [default = 1];
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+ _Internal::set_has_scale(&has_bits);
+ scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float shift = 3 [default = 0];
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+ _Internal::set_has_shift(&has_bits);
+ shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<ExpParameter *>(to)->MergeFrom(
+ static_cast<const ExpParameter &>(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<FlattenParameter>()._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<size_t>(reinterpret_cast<char*>(&end_axis_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<FlattenParameter *>(to)->MergeFrom(
+ static_cast<const FlattenParameter &>(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<HDF5DataParameter>()._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<size_t>(reinterpret_cast<char*>(&shuffle_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&batch_size_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&shuffle_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&shuffle_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<HDF5DataParameter *>(to)->MergeFrom(
+ static_cast<const HDF5DataParameter &>(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<char*>(&batch_size_),
+ reinterpret_cast<char*>(&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<HDF5OutputParameter>()._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<uint8_t>(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<int>(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<HDF5OutputParameter *>(to)->MergeFrom(
+ static_cast<const HDF5OutputParameter &>(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<HingeLossParameter>()._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<uint8_t>(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<HingeLossParameter *>(to)->MergeFrom(
+ static_cast<const HingeLossParameter &>(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<ImageDataParameter>()._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<size_t>(reinterpret_cast<char*>(&batch_size_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&crop_size_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&new_width_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&new_height_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(tag) == 21)) {
+ _Internal::set_has_scale(&has_bits);
+ scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional string mean_file = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<int>(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<ImageDataParameter *>(to)->MergeFrom(
+ static_cast<const ImageDataParameter &>(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<char*>(&crop_size_),
+ reinterpret_cast<char*>(&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<InfogainLossParameter>()._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<uint8_t>(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<int>(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<InfogainLossParameter *>(to)->MergeFrom(
+ static_cast<const InfogainLossParameter &>(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<InnerProductParameter>()._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<size_t>(reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&num_output_)) + sizeof(axis_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.InnerProductParameter)
+}
+
+inline void InnerProductParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&weight_filler_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&transpose_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&transpose_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<InnerProductParameter *>(to)->MergeFrom(
+ static_cast<const InnerProductParameter &>(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<char*>(&weight_filler_),
+ reinterpret_cast<char*>(&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<uint8_t>(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<unsigned int>(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<InputParameter *>(to)->MergeFrom(
+ static_cast<const InputParameter &>(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<LogParameter>()._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<size_t>(reinterpret_cast<char*>(&scale_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_base(&has_bits);
+ base_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float scale = 2 [default = 1];
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+ _Internal::set_has_scale(&has_bits);
+ scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float shift = 3 [default = 0];
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+ _Internal::set_has_shift(&has_bits);
+ shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<LogParameter *>(to)->MergeFrom(
+ static_cast<const LogParameter &>(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<LRNParameter>()._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<size_t>(reinterpret_cast<char*>(&k_) -
+ reinterpret_cast<char*>(&norm_region_)) + sizeof(k_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.LRNParameter)
+}
+
+inline void LRNParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&norm_region_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&engine_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&engine_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(tag) == 21)) {
+ _Internal::set_has_alpha(&has_bits);
+ alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float beta = 3 [default = 0.75];
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+ _Internal::set_has_beta(&has_bits);
+ beta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<uint8_t>(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<uint8_t>(tag) == 45)) {
+ _Internal::set_has_k(&has_bits);
+ k_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<uint8_t>(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<LRNParameter *>(to)->MergeFrom(
+ static_cast<const LRNParameter &>(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<char*>(&norm_region_),
+ reinterpret_cast<char*>(&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<MemoryDataParameter>()._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<size_t>(reinterpret_cast<char*>(&width_) -
+ reinterpret_cast<char*>(&batch_size_)) + sizeof(width_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.MemoryDataParameter)
+}
+
+inline void MemoryDataParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&batch_size_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&width_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&width_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<MemoryDataParameter *>(to)->MergeFrom(
+ static_cast<const MemoryDataParameter &>(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<char*>(&batch_size_),
+ reinterpret_cast<char*>(&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<MVNParameter>()._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<size_t>(reinterpret_cast<char*>(&eps_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 29)) {
+ _Internal::set_has_eps(&has_bits);
+ eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<MVNParameter *>(to)->MergeFrom(
+ static_cast<const MVNParameter &>(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<ParameterParameter>()._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<uint8_t>(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<ParameterParameter *>(to)->MergeFrom(
+ static_cast<const ParameterParameter &>(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<PoolingParameter>()._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<size_t>(reinterpret_cast<char*>(&ceil_mode_) -
+ reinterpret_cast<char*>(&pool_)) + sizeof(ceil_mode_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.PoolingParameter)
+}
+
+inline void PoolingParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&pool_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&global_pooling_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&pad_h_) -
+ reinterpret_cast<char*>(&pool_)) + sizeof(pad_h_));
+ }
+ if (cached_has_bits & 0x00001f00u) {
+ ::memset(&pad_w_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&global_pooling_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<PoolingParameter *>(to)->MergeFrom(
+ static_cast<const PoolingParameter &>(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<char*>(&pool_),
+ reinterpret_cast<char*>(&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<PowerParameter>()._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<size_t>(reinterpret_cast<char*>(&scale_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_power(&has_bits);
+ power_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float scale = 2 [default = 1];
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+ _Internal::set_has_scale(&has_bits);
+ scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float shift = 3 [default = 0];
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+ _Internal::set_has_shift(&has_bits);
+ shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<PowerParameter *>(to)->MergeFrom(
+ static_cast<const PowerParameter &>(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<PythonParameter>()._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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<int>(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<PythonParameter *>(to)->MergeFrom(
+ static_cast<const PythonParameter &>(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<RecurrentParameter>()._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<size_t>(reinterpret_cast<char*>(&expose_hidden_) -
+ reinterpret_cast<char*>(&num_output_)) + sizeof(expose_hidden_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.RecurrentParameter)
+}
+
+inline void RecurrentParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&weight_filler_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&expose_hidden_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&expose_hidden_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<RecurrentParameter *>(to)->MergeFrom(
+ static_cast<const RecurrentParameter &>(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<char*>(&weight_filler_),
+ reinterpret_cast<char*>(&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<ReductionParameter>()._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<size_t>(reinterpret_cast<char*>(&coeff_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 29)) {
+ _Internal::set_has_coeff(&has_bits);
+ coeff_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<ReductionParameter *>(to)->MergeFrom(
+ static_cast<const ReductionParameter &>(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<ReLUParameter>()._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<size_t>(reinterpret_cast<char*>(&engine_) -
+ reinterpret_cast<char*>(&negative_slope_)) + sizeof(engine_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReLUParameter)
+}
+
+inline void ReLUParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&negative_slope_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&engine_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&engine_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_negative_slope(&has_bits);
+ negative_slope_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<uint8_t>(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<ReLUParameter *>(to)->MergeFrom(
+ static_cast<const ReLUParameter &>(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<char*>(&negative_slope_),
+ reinterpret_cast<char*>(&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<ReshapeParameter>()._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<size_t>(reinterpret_cast<char*>(&num_axes_) -
+ reinterpret_cast<char*>(&axis_)) + sizeof(num_axes_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReshapeParameter)
+}
+
+inline void ReshapeParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&shape_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<ReshapeParameter *>(to)->MergeFrom(
+ static_cast<const ReshapeParameter &>(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<char*>(&shape_),
+ reinterpret_cast<char*>(&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<ScaleParameter>()._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<size_t>(reinterpret_cast<char*>(&num_axes_) -
+ reinterpret_cast<char*>(&bias_term_)) + sizeof(num_axes_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.ScaleParameter)
+}
+
+inline void ScaleParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&filler_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&bias_term_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<ScaleParameter *>(to)->MergeFrom(
+ static_cast<const ScaleParameter &>(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<char*>(&filler_),
+ reinterpret_cast<char*>(&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<SigmoidParameter>()._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<uint8_t>(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<SigmoidParameter *>(to)->MergeFrom(
+ static_cast<const SigmoidParameter &>(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<SliceParameter>()._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<size_t>(reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<SliceParameter *>(to)->MergeFrom(
+ static_cast<const SliceParameter &>(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<SoftmaxParameter>()._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<size_t>(reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<SoftmaxParameter *>(to)->MergeFrom(
+ static_cast<const SoftmaxParameter &>(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<TanHParameter>()._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<uint8_t>(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<TanHParameter *>(to)->MergeFrom(
+ static_cast<const TanHParameter &>(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<TileParameter>()._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<size_t>(reinterpret_cast<char*>(&axis_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<TileParameter *>(to)->MergeFrom(
+ static_cast<const TileParameter &>(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<ThresholdParameter>()._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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_threshold(&has_bits);
+ threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<ThresholdParameter *>(to)->MergeFrom(
+ static_cast<const ThresholdParameter &>(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<WindowDataParameter>()._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<size_t>(reinterpret_cast<char*>(&fg_fraction_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&batch_size_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&context_pad_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&cache_images_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(tag) == 21)) {
+ _Internal::set_has_scale(&has_bits);
+ scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional string mean_file = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 61)) {
+ _Internal::set_has_fg_threshold(&has_bits);
+ fg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<uint8_t>(tag) == 69)) {
+ _Internal::set_has_bg_threshold(&has_bits);
+ bg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<uint8_t>(tag) == 77)) {
+ _Internal::set_has_fg_fraction(&has_bits);
+ fg_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional uint32 context_pad = 10 [default = 0];
+ case 10:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<int>(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<int>(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<WindowDataParameter *>(to)->MergeFrom(
+ static_cast<const WindowDataParameter &>(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<char*>(&batch_size_),
+ reinterpret_cast<char*>(&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<SPPParameter>()._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<size_t>(reinterpret_cast<char*>(&engine_) -
+ reinterpret_cast<char*>(&pyramid_height_)) + sizeof(engine_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.SPPParameter)
+}
+
+inline void SPPParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&pyramid_height_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&engine_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&engine_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<SPPParameter *>(to)->MergeFrom(
+ static_cast<const SPPParameter &>(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<char*>(&pyramid_height_),
+ reinterpret_cast<char*>(&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<V1LayerParameter>()._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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&layer_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 61)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_blobs_lr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<61>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(tag) == 69)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_weight_decay(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<69>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 29)) {
+ ptr -= 2;
+ do {
+ ptr += 2;
+ _internal_add_loss_weight(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<285>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<int>(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<V1LayerParameter *>(to)->MergeFrom(
+ static_cast<const V1LayerParameter &>(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<char*>(&layer_),
+ reinterpret_cast<char*>(&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<V0LayerParameter>()._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<size_t>(reinterpret_cast<char*>(&det_fg_fraction_) -
+ reinterpret_cast<char*>(&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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&weight_filler_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&new_height_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&mirror_) -
+ reinterpret_cast<char*>(&num_output_)) + sizeof(mirror_));
+ }
+ if (cached_has_bits & 0x00ff0000u) {
+ ::memset(&shuffle_images_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&new_height_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 101)) {
+ _Internal::set_has_dropout_ratio(&_has_bits_);
+ dropout_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional uint32 local_size = 13 [default = 5];
+ case 13:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(tag) == 117)) {
+ _Internal::set_has_alpha(&_has_bits_);
+ alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float beta = 15 [default = 0.75];
+ case 15:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 125)) {
+ _Internal::set_has_beta(&_has_bits_);
+ beta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional string source = 16;
+ case 16:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(tag) == 141)) {
+ _Internal::set_has_scale(&_has_bits_);
+ scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional string meanfile = 18;
+ case 18:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 181)) {
+ _Internal::set_has_k(&_has_bits_);
+ k_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // repeated .opencv_caffe.BlobProto blobs = 50;
+ case 50:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(tag) == 157)) {
+ ptr -= 2;
+ do {
+ ptr += 2;
+ _internal_add_blobs_lr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<413>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(tag) == 165)) {
+ ptr -= 2;
+ do {
+ ptr += 2;
+ _internal_add_weight_decay(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<421>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 181)) {
+ _Internal::set_has_det_fg_threshold(&_has_bits_);
+ det_fg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<uint8_t>(tag) == 189)) {
+ _Internal::set_has_det_bg_threshold(&_has_bits_);
+ det_bg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<uint8_t>(tag) == 197)) {
+ _Internal::set_has_det_fg_fraction(&_has_bits_);
+ det_fg_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<int>(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<int>(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<int>(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<int>(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<unsigned int>(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<int>(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<unsigned int>(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<unsigned int>(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<V0LayerParameter *>(to)->MergeFrom(
+ static_cast<const V0LayerParameter &>(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<char*>(&weight_filler_),
+ reinterpret_cast<char*>(&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<PReLUParameter>()._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<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&filler_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&channel_shared_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<PReLUParameter *>(to)->MergeFrom(
+ static_cast<const PReLUParameter &>(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<char*>(&filler_),
+ reinterpret_cast<char*>(&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<NormalizedBBox>()._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<size_t>(reinterpret_cast<char*>(&size_) -
+ reinterpret_cast<char*>(&xmin_)) + sizeof(size_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.NormalizedBBox)
+}
+
+inline void NormalizedBBox::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&xmin_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&size_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&size_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_xmin(&has_bits);
+ xmin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float ymin = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+ _Internal::set_has_ymin(&has_bits);
+ ymin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float xmax = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+ _Internal::set_has_xmax(&has_bits);
+ xmax_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float ymax = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 37)) {
+ _Internal::set_has_ymax(&has_bits);
+ ymax_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional int32 label = 5;
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 61)) {
+ _Internal::set_has_score(&has_bits);
+ score_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // optional float size = 8;
+ case 8:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 69)) {
+ _Internal::set_has_size(&has_bits);
+ size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<NormalizedBBox *>(to)->MergeFrom(
+ static_cast<const NormalizedBBox &>(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<char*>(&xmin_),
+ reinterpret_cast<char*>(&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<ROIPoolingParameter>()._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<size_t>(reinterpret_cast<char*>(&spatial_scale_) -
+ reinterpret_cast<char*>(&pooled_h_)) + sizeof(spatial_scale_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.ROIPoolingParameter)
+}
+
+inline void ROIPoolingParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&pooled_h_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&pooled_w_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&pooled_w_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 29)) {
+ _Internal::set_has_spatial_scale(&has_bits);
+ spatial_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<ROIPoolingParameter *>(to)->MergeFrom(
+ static_cast<const ROIPoolingParameter &>(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<char*>(&pooled_h_),
+ reinterpret_cast<char*>(&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<ProposalParameter>()._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<size_t>(reinterpret_cast<char*>(&nms_thresh_) -
+ reinterpret_cast<char*>(&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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 37)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_ratio(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<37>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(tag) == 45)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ _internal_add_scale(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr));
+ } else if (static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(tag) == 69)) {
+ _Internal::set_has_nms_thresh(&has_bits);
+ nms_thresh_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(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<unsigned int>(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<unsigned int>(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<ProposalParameter *>(to)->MergeFrom(
+ static_cast<const ProposalParameter &>(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<PSROIPoolingParameter>()._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<size_t>(reinterpret_cast<char*>(&group_size_) -
+ reinterpret_cast<char*>(&spatial_scale_)) + sizeof(group_size_));
+ // @@protoc_insertion_point(copy_constructor:opencv_caffe.PSROIPoolingParameter)
+}
+
+inline void PSROIPoolingParameter::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&spatial_scale_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&group_size_) -
+ reinterpret_cast<char*>(&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<size_t>(
+ reinterpret_cast<char*>(&group_size_) -
+ reinterpret_cast<char*>(&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<uint8_t>(tag) == 13)) {
+ _Internal::set_has_spatial_scale(&has_bits);
+ spatial_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // required int32 output_dim = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(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<uint8_t>(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<PSROIPoolingParameter *>(to)->MergeFrom(
+ static_cast<const PSROIPoolingParameter &>(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<char*>(&spatial_scale_),
+ reinterpret_cast<char*>(&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 <google/protobuf/port_undef.inc>
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 000000000..74ec5ca6e
--- /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 <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#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 <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h> // IWYU pragma: export
+#include <google/protobuf/extension_set.h> // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_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<typename T>
+inline const std::string& PriorBoxParameter_CodeType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, PriorBoxParameter_CodeType>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& FillerParameter_VarianceNorm_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, FillerParameter_VarianceNorm>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& SolverParameter_SnapshotFormat_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SolverParameter_SnapshotFormat>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& SolverParameter_SolverMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SolverParameter_SolverMode>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& SolverParameter_SolverType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SolverParameter_SolverType>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& ParamSpec_DimCheckMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, ParamSpec_DimCheckMode>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& LossParameter_NormalizationMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, LossParameter_NormalizationMode>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& ConvolutionParameter_Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, ConvolutionParameter_Engine>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& DataParameter_DB_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, DataParameter_DB>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& EltwiseParameter_EltwiseOp_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, EltwiseParameter_EltwiseOp>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& HingeLossParameter_Norm_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, HingeLossParameter_Norm>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& LRNParameter_NormRegion_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, LRNParameter_NormRegion>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& LRNParameter_Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, LRNParameter_Engine>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& PoolingParameter_PoolMethod_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, PoolingParameter_PoolMethod>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& PoolingParameter_Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, PoolingParameter_Engine>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& ReductionParameter_ReductionOp_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, ReductionParameter_ReductionOp>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& ReLUParameter_Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, ReLUParameter_Engine>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& SigmoidParameter_Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SigmoidParameter_Engine>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& SoftmaxParameter_Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SoftmaxParameter_Engine>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& TanHParameter_Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, TanHParameter_Engine>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& SPPParameter_PoolMethod_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SPPParameter_PoolMethod>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& SPPParameter_Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SPPParameter_Engine>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& V1LayerParameter_LayerType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, V1LayerParameter_LayerType>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& V1LayerParameter_DimCheckMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, V1LayerParameter_DimCheckMode>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& V0LayerParameter_PoolMethod_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, V0LayerParameter_PoolMethod>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& Type_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Type>::value ||
+ ::std::is_integral<T>::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>(
+ 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<typename T>
+inline const std::string& Phase_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Phase>::value ||
+ ::std::is_integral<T>::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>(
+ 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<const BlobShape*>(
+ &_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<BlobShape>(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 <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dim_;
+ mutable std::atomic<int> _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<const BlobProto*>(
+ &_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<BlobProto>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const BlobProtoVector*>(
+ &_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<BlobProtoVector>(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 <typename T> 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<const PermuteParameter*>(
+ &_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<PermuteParameter>(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 <typename T> 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<const NormalizeBBoxParameter*>(
+ &_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<NormalizeBBoxParameter>(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 <typename T> 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<const PriorBoxParameter*>(
+ &_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<PriorBoxParameter>(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<typename T>
+ static inline const std::string& CodeType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, CodeType>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const DetectionOutputParameter*>(
+ &_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<DetectionOutputParameter>(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 <typename T> 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<const Datum*>(
+ &_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<Datum>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const FillerParameter*>(
+ &_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<FillerParameter>(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<typename T>
+ static inline const std::string& VarianceNorm_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, VarianceNorm>::value ||
+ ::std::is_integral<T>::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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const NetParameter*>(
+ &_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<NetParameter>(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<std::string>& input() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<std::string> 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<const SolverParameter*>(
+ &_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<SolverParameter>(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<typename T>
+ static inline const std::string& SnapshotFormat_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SnapshotFormat>::value ||
+ ::std::is_integral<T>::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<typename T>
+ static inline const std::string& SolverMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SolverMode>::value ||
+ ::std::is_integral<T>::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<typename T>
+ static inline const std::string& SolverType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, SolverType>::value ||
+ ::std::is_integral<T>::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<std::string>& test_net() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<std::string> 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<const SolverState*>(
+ &_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<SolverState>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const NetState*>(
+ &_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<NetState>(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<std::string>& stage() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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 <typename T> 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<std::string> 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<const NetStateRule*>(
+ &_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<NetStateRule>(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<std::string>& stage() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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<std::string>& not_stage() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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 <typename T> 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<std::string> stage_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> 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<const ParamSpec*>(
+ &_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<ParamSpec>(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<typename T>
+ static inline const std::string& DimCheckMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, DimCheckMode>::value ||
+ ::std::is_integral<T>::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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const LayerParameter*>(
+ &_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<LayerParameter>(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<std::string>& bottom() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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<std::string>& top() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<std::string> bottom_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> 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<const TransformationParameter*>(
+ &_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<TransformationParameter>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const LossParameter*>(
+ &_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<LossParameter>(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<typename T>
+ static inline const std::string& NormalizationMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, NormalizationMode>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const AccuracyParameter*>(
+ &_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<AccuracyParameter>(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 <typename T> 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<const ArgMaxParameter*>(
+ &_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<ArgMaxParameter>(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 <typename T> 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<const ConcatParameter*>(
+ &_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<ConcatParameter>(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 <typename T> 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<const BatchNormParameter*>(
+ &_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<BatchNormParameter>(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 <typename T> 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<const BiasParameter*>(
+ &_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<BiasParameter>(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 <typename T> 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<const ContrastiveLossParameter*>(
+ &_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<ContrastiveLossParameter>(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 <typename T> 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<const ConvolutionParameter*>(
+ &_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<ConvolutionParameter>(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<typename T>
+ static inline const std::string& Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Engine>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const CropParameter*>(
+ &_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<CropParameter>(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 <typename T> 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<const DataParameter*>(
+ &_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<DataParameter>(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<typename T>
+ static inline const std::string& DB_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, DB>::value ||
+ ::std::is_integral<T>::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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const NonMaximumSuppressionParameter*>(
+ &_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<NonMaximumSuppressionParameter>(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 <typename T> 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<const SaveOutputParameter*>(
+ &_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<SaveOutputParameter>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const DropoutParameter*>(
+ &_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<DropoutParameter>(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 <typename T> 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<const DummyDataParameter*>(
+ &_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<DummyDataParameter>(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 <typename T> 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<const EltwiseParameter*>(
+ &_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<EltwiseParameter>(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<typename T>
+ static inline const std::string& EltwiseOp_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, EltwiseOp>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const ELUParameter*>(
+ &_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<ELUParameter>(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 <typename T> 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<const EmbedParameter*>(
+ &_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<EmbedParameter>(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 <typename T> 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<const ExpParameter*>(
+ &_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<ExpParameter>(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 <typename T> 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<const FlattenParameter*>(
+ &_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<FlattenParameter>(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 <typename T> 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<const HDF5DataParameter*>(
+ &_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<HDF5DataParameter>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const HDF5OutputParameter*>(
+ &_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<HDF5OutputParameter>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const HingeLossParameter*>(
+ &_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<HingeLossParameter>(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<typename T>
+ static inline const std::string& Norm_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Norm>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const ImageDataParameter*>(
+ &_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<ImageDataParameter>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const InfogainLossParameter*>(
+ &_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<InfogainLossParameter>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const InnerProductParameter*>(
+ &_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<InnerProductParameter>(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 <typename T> 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<const InputParameter*>(
+ &_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<InputParameter>(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 <typename T> 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<const LogParameter*>(
+ &_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<LogParameter>(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 <typename T> 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<const LRNParameter*>(
+ &_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<LRNParameter>(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<typename T>
+ static inline const std::string& NormRegion_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, NormRegion>::value ||
+ ::std::is_integral<T>::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<typename T>
+ static inline const std::string& Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Engine>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const MemoryDataParameter*>(
+ &_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<MemoryDataParameter>(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 <typename T> 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<const MVNParameter*>(
+ &_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<MVNParameter>(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 <typename T> 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<const ParameterParameter*>(
+ &_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<ParameterParameter>(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 <typename T> 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<const PoolingParameter*>(
+ &_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<PoolingParameter>(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<typename T>
+ static inline const std::string& PoolMethod_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, PoolMethod>::value ||
+ ::std::is_integral<T>::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<typename T>
+ static inline const std::string& Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Engine>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const PowerParameter*>(
+ &_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<PowerParameter>(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 <typename T> 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<const PythonParameter*>(
+ &_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<PythonParameter>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const RecurrentParameter*>(
+ &_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<RecurrentParameter>(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 <typename T> 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<const ReductionParameter*>(
+ &_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<ReductionParameter>(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<typename T>
+ static inline const std::string& ReductionOp_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, ReductionOp>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const ReLUParameter*>(
+ &_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<ReLUParameter>(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<typename T>
+ static inline const std::string& Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Engine>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const ReshapeParameter*>(
+ &_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<ReshapeParameter>(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 <typename T> 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<const ScaleParameter*>(
+ &_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<ScaleParameter>(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 <typename T> 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<const SigmoidParameter*>(
+ &_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<SigmoidParameter>(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<typename T>
+ static inline const std::string& Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Engine>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const SliceParameter*>(
+ &_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<SliceParameter>(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 <typename T> 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<const SoftmaxParameter*>(
+ &_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<SoftmaxParameter>(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<typename T>
+ static inline const std::string& Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Engine>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const TanHParameter*>(
+ &_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<TanHParameter>(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<typename T>
+ static inline const std::string& Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Engine>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const TileParameter*>(
+ &_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<TileParameter>(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 <typename T> 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<const ThresholdParameter*>(
+ &_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<ThresholdParameter>(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 <typename T> 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<const WindowDataParameter*>(
+ &_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<WindowDataParameter>(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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const SPPParameter*>(
+ &_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<SPPParameter>(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<typename T>
+ static inline const std::string& PoolMethod_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, PoolMethod>::value ||
+ ::std::is_integral<T>::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<typename T>
+ static inline const std::string& Engine_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Engine>::value ||
+ ::std::is_integral<T>::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 <typename T> 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<const V1LayerParameter*>(
+ &_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<V1LayerParameter>(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<typename T>
+ static inline const std::string& LayerType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, LayerType>::value ||
+ ::std::is_integral<T>::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<typename T>
+ static inline const std::string& DimCheckMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, DimCheckMode>::value ||
+ ::std::is_integral<T>::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<std::string>& bottom() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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<std::string>& top() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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<std::string>& param() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* 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<int>* _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<int>& blob_share_mode() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<std::string> bottom_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> 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<std::string> param_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> 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<const V0LayerParameter*>(
+ &_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<V0LayerParameter>(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<typename T>
+ static inline const std::string& PoolMethod_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, PoolMethod>::value ||
+ ::std::is_integral<T>::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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename ArgT0 = const std::string&, typename... ArgT>
+ 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 <typename T> 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<const PReLUParameter*>(
+ &_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<PReLUParameter>(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 <typename T> 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<const NormalizedBBox*>(
+ &_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<NormalizedBBox>(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 <typename T> 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<const ROIPoolingParameter*>(
+ &_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<ROIPoolingParameter>(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 <typename T> 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<const ProposalParameter*>(
+ &_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<ProposalParameter>(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 <typename T> 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<const PSROIPoolingParameter*>(
+ &_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<PSROIPoolingParameter>(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 <typename T> 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<const ::opencv_caffe::BlobShape&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::NonMaximumSuppressionParameter&>(
+ ::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<const ::opencv_caffe::SaveOutputParameter&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetParameter.input)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+NetParameter::input() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input)
+ return input_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+NetParameter::mutable_input() {
+ // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input)
+ return &input_;
+}
+
+// repeated .opencv_caffe.BlobShape input_shape = 8;
+inline int NetParameter::_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<const ::opencv_caffe::NetState&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const ::opencv_caffe::NetParameter&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.SolverParameter.test_net)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+SolverParameter::test_net() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_net)
+ return test_net_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+SolverParameter::mutable_test_net() {
+ // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_net)
+ return &test_net_;
+}
+
+// optional .opencv_caffe.NetParameter train_net_param = 21;
+inline bool SolverParameter::_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<const ::opencv_caffe::NetParameter&>(
+ ::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<const ::opencv_caffe::NetState&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetState.stage)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+NetState::stage() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.NetState.stage)
+ return stage_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+NetState::mutable_stage() {
+ // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetState.stage)
+ return &stage_;
+}
+
+// -------------------------------------------------------------------
+
+// NetStateRule
+
+// optional .opencv_caffe.Phase phase = 1;
+inline bool NetStateRule::_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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetStateRule.stage)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+NetStateRule::stage() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.NetStateRule.stage)
+ return stage_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+NetStateRule::mutable_stage() {
+ // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetStateRule.stage)
+ return &stage_;
+}
+
+// repeated string not_stage = 5;
+inline int NetStateRule::_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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetStateRule.not_stage)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+NetStateRule::not_stage() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.NetStateRule.not_stage)
+ return not_stage_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.LayerParameter.bottom)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+LayerParameter::bottom() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.bottom)
+ return bottom_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+LayerParameter::mutable_bottom() {
+ // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.bottom)
+ return &bottom_;
+}
+
+// repeated string top = 4;
+inline int LayerParameter::_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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.LayerParameter.top)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+LayerParameter::top() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.top)
+ return top_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+LayerParameter::mutable_top() {
+ // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.top)
+ return &top_;
+}
+
+// optional .opencv_caffe.Phase phase = 10;
+inline bool LayerParameter::_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<const ::opencv_caffe::TransformationParameter&>(
+ ::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<const ::opencv_caffe::LossParameter&>(
+ ::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<const ::opencv_caffe::AccuracyParameter&>(
+ ::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<const ::opencv_caffe::ArgMaxParameter&>(
+ ::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<const ::opencv_caffe::BatchNormParameter&>(
+ ::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<const ::opencv_caffe::BiasParameter&>(
+ ::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<const ::opencv_caffe::ConcatParameter&>(
+ ::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<const ::opencv_caffe::ContrastiveLossParameter&>(
+ ::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<const ::opencv_caffe::ConvolutionParameter&>(
+ ::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<const ::opencv_caffe::CropParameter&>(
+ ::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<const ::opencv_caffe::DataParameter&>(
+ ::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<const ::opencv_caffe::DetectionOutputParameter&>(
+ ::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<const ::opencv_caffe::DropoutParameter&>(
+ ::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<const ::opencv_caffe::DummyDataParameter&>(
+ ::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<const ::opencv_caffe::EltwiseParameter&>(
+ ::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<const ::opencv_caffe::ELUParameter&>(
+ ::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<const ::opencv_caffe::EmbedParameter&>(
+ ::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<const ::opencv_caffe::ExpParameter&>(
+ ::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<const ::opencv_caffe::FlattenParameter&>(
+ ::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<const ::opencv_caffe::HDF5DataParameter&>(
+ ::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<const ::opencv_caffe::HDF5OutputParameter&>(
+ ::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<const ::opencv_caffe::HingeLossParameter&>(
+ ::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<const ::opencv_caffe::ImageDataParameter&>(
+ ::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<const ::opencv_caffe::InfogainLossParameter&>(
+ ::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<const ::opencv_caffe::InnerProductParameter&>(
+ ::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<const ::opencv_caffe::InputParameter&>(
+ ::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<const ::opencv_caffe::LogParameter&>(
+ ::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<const ::opencv_caffe::LRNParameter&>(
+ ::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<const ::opencv_caffe::MemoryDataParameter&>(
+ ::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<const ::opencv_caffe::MVNParameter&>(
+ ::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<const ::opencv_caffe::NormalizeBBoxParameter&>(
+ ::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<const ::opencv_caffe::PermuteParameter&>(
+ ::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<const ::opencv_caffe::ParameterParameter&>(
+ ::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<const ::opencv_caffe::PoolingParameter&>(
+ ::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<const ::opencv_caffe::PowerParameter&>(
+ ::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<const ::opencv_caffe::PReLUParameter&>(
+ ::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<const ::opencv_caffe::PriorBoxParameter&>(
+ ::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<const ::opencv_caffe::ProposalParameter&>(
+ ::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<const ::opencv_caffe::PSROIPoolingParameter&>(
+ ::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<const ::opencv_caffe::PythonParameter&>(
+ ::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<const ::opencv_caffe::RecurrentParameter&>(
+ ::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<const ::opencv_caffe::ReductionParameter&>(
+ ::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<const ::opencv_caffe::ReLUParameter&>(
+ ::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<const ::opencv_caffe::ReshapeParameter&>(
+ ::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<const ::opencv_caffe::ROIPoolingParameter&>(
+ ::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<const ::opencv_caffe::ScaleParameter&>(
+ ::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<const ::opencv_caffe::SigmoidParameter&>(
+ ::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<const ::opencv_caffe::SoftmaxParameter&>(
+ ::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<const ::opencv_caffe::SPPParameter&>(
+ ::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<const ::opencv_caffe::SliceParameter&>(
+ ::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<const ::opencv_caffe::TanHParameter&>(
+ ::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<const ::opencv_caffe::ThresholdParameter&>(
+ ::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<const ::opencv_caffe::TileParameter&>(
+ ::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<const ::opencv_caffe::WindowDataParameter&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::BlobShape&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::BlobShape&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.bottom)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+V1LayerParameter::bottom() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.bottom)
+ return bottom_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+V1LayerParameter::mutable_bottom() {
+ // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.bottom)
+ return &bottom_;
+}
+
+// repeated string top = 3;
+inline int V1LayerParameter::_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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.top)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+V1LayerParameter::top() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.top)
+ return top_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+V1LayerParameter::mutable_top() {
+ // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.top)
+ return &top_;
+}
+
+// optional string name = 4;
+inline bool V1LayerParameter::_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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const char*>(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<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.param)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+V1LayerParameter::param() const {
+ // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.param)
+ return param_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+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<int>&
+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<int>*
+V1LayerParameter::_internal_mutable_blob_share_mode() {
+ return &blob_share_mode_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+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<const ::opencv_caffe::AccuracyParameter&>(
+ ::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<const ::opencv_caffe::ArgMaxParameter&>(
+ ::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<const ::opencv_caffe::ConcatParameter&>(
+ ::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<const ::opencv_caffe::ContrastiveLossParameter&>(
+ ::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<const ::opencv_caffe::ConvolutionParameter&>(
+ ::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<const ::opencv_caffe::DataParameter&>(
+ ::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<const ::opencv_caffe::DropoutParameter&>(
+ ::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<const ::opencv_caffe::DummyDataParameter&>(
+ ::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<const ::opencv_caffe::EltwiseParameter&>(
+ ::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<const ::opencv_caffe::ExpParameter&>(
+ ::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<const ::opencv_caffe::HDF5DataParameter&>(
+ ::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<const ::opencv_caffe::HDF5OutputParameter&>(
+ ::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<const ::opencv_caffe::HingeLossParameter&>(
+ ::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<const ::opencv_caffe::ImageDataParameter&>(
+ ::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<const ::opencv_caffe::InfogainLossParameter&>(
+ ::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<const ::opencv_caffe::InnerProductParameter&>(
+ ::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<const ::opencv_caffe::LRNParameter&>(
+ ::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<const ::opencv_caffe::MemoryDataParameter&>(
+ ::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<const ::opencv_caffe::MVNParameter&>(
+ ::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<const ::opencv_caffe::PoolingParameter&>(
+ ::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<const ::opencv_caffe::PowerParameter&>(
+ ::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<const ::opencv_caffe::ReLUParameter&>(
+ ::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<const ::opencv_caffe::SigmoidParameter&>(
+ ::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<const ::opencv_caffe::SoftmaxParameter&>(
+ ::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<const ::opencv_caffe::SliceParameter&>(
+ ::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<const ::opencv_caffe::TanHParameter&>(
+ ::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<const ::opencv_caffe::ThresholdParameter&>(
+ ::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<const ::opencv_caffe::WindowDataParameter&>(
+ ::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<const ::opencv_caffe::TransformationParameter&>(
+ ::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<const ::opencv_caffe::LossParameter&>(
+ ::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<const ::opencv_caffe::V0LayerParameter&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const ::opencv_caffe::FillerParameter&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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 <typename ArgT0, typename... ArgT>
+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<ArgT0 &&>(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<const ::opencv_caffe::HDF5OutputParameter&>(
+ ::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<const ::opencv_caffe::FillerParameter&>(
+ ::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 <google/protobuf/port_undef.inc>
+#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 000000000..02ad0d615
--- /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 <iostream>
+#include <fstream>
+#include <sstream>
+#include <algorithm>
+#include <google/protobuf/message.h>
+#include <google/protobuf/text_format.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <google/protobuf/reflection.h>
+#include "caffe_io.hpp"
+#endif
+#include <opencv2/core.hpp>
+#include <opencv2/dnnlegacy/dnnlegacy.hpp>
+#include <opencv2/core/utils/fp_control_utils.hpp>
+
+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<typename T>
+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<gtype> v = refl->GetRepeatedFieldRef<gtype>(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<std::string> v = refl->GetRepeatedFieldRef<std::string>(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<cv::String> 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<caffe::BlobProto*> 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<BlobNote> addedBlobs;
+ std::map<String, int> 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<String> netInputs(net.input_size());
+ std::vector<MatShape> 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<bool>("use_global_stats", true))
+ {
+ CV_Assert_N(layer.bottom_size() == 1, layer.top_size() == 1);
+
+ LayerParams mvnParams;
+ mvnParams.set("eps", layerParams.get<float>("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<String>("type"));
+ layerParams.set("interpolation", interp == "linear" ? "bilinear" : interp);
+
+ if (layerParams.has("factor"))
+ {
+ float factor = layerParams.get<float>("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<uchar>& bufferProto, const std::vector<uchar>& bufferModel)
+{
+ const char* bufferProtoPtr = reinterpret_cast<const char*>(&bufferProto[0]);
+ const char* bufferModelPtr = bufferModel.empty() ? NULL :
+ reinterpret_cast<const char*>(&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<uchar>&, const std::vector<uchar>&) {
+ 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 000000000..cdb8c751c
--- /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 <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/text_format.h>
+
+#include <opencv2/core.hpp>
+#include <opencv2/dnn.hpp>
+#include <opencv2/core/utils/trace.hpp>
+
+#include <map>
+#include <string>
+#include <fstream>
+#include <vector>
+
+#include "caffe_io.hpp"
+
+
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+
+#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<string, int> 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 000000000..8b86c4c42
--- /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 000000000..0957ff101
--- /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 <fstream>
+#include "caffe_io.hpp"
+#endif
+
+namespace cv { namespace dnnlegacy {
+#ifdef HAVE_PROTOBUF
+
+
+void shrinkCaffeModel(const String& src, const String& dst, const std::vector<String>& layersTypes)
+{
+ CV_TRACE_FUNCTION();
+
+ std::vector<String> 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<size_t>(net.ByteSize());
+#else
+ size_t msgSize = net.ByteSizeLong();
+#endif
+ std::vector<uint8_t> 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<String>& 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 000000000..d540591f8
--- /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 000000000..3dc579a38
--- /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 <iostream>
+#include <fstream>
+#include <algorithm>
+#include <vector>
+#include <map>
+
+#include "darknet_io.hpp"
+
+#include <opencv2/core/utils/fp_control_utils.hpp>
+
+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<BlobNote> addedBlobs;
+ std::map<String, int> 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<String> 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<char*>(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<uchar>& bufferCfg, const std::vector<uchar>& bufferModel)
+{
+ const char* bufferCfgPtr = reinterpret_cast<const char*>(&bufferCfg[0]);
+ const char* bufferModelPtr = bufferModel.empty() ? NULL :
+ reinterpret_cast<const char*>(&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 000000000..9e6e81e32
--- /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 <opencv2/dnn/dnn.hpp>
+#include <opencv2/dnn/shape_utils.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+
+#include "darknet_io.hpp"
+
+namespace cv {
+ namespace dnnlegacy {
+ namespace darknet {
+
+ template<typename T>
+ T getParam(const std::map<std::string, std::string> ¶ms, const std::string param_name, T init_val)
+ {
+ std::map<std::string, std::string>::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<std::string> fused_layer_names;
+
+ public:
+ setLayersParams(NetParameter *_net) :
+ net(_net), layer_id(0), last_layer(kFirstLayerName)
+ {}
+
+ void setLayerBlobs(int i, std::vector<cv::Mat> 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<bool>("has_weight", true);
+ bn_param.set<bool>("has_bias", true);
+ bn_param.set<float>("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<int>("kernel_size", kernel);
+ params.set<int>("pad", pad);
+ params.set<int>("stride", stride);
+
+ params.set<bool>("bias_term", false); // true only if(BatchNorm == false)
+ params.set<int>("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<bool>("bias_term", true);
+ }
+
+ conv_param.set<int>("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<bool>("bias_term", false); // true only if(BatchNorm == false)
+ params.set<int>("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<bool>("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<float>("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<cv::String>("pool", "max");
+ maxpool_param.set<int>("kernel_size", kernel);
+ maxpool_param.set<int>("pad_l", floor((float)pad / 2));
+ maxpool_param.set<int>("pad_r", ceil((float)pad / 2));
+ maxpool_param.set<int>("pad_t", floor((float)pad / 2));
+ maxpool_param.set<int>("pad_b", ceil((float)pad / 2));
+ maxpool_param.set<bool>("ceil_mode", false);
+ maxpool_param.set<int>("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<cv::String>("pool", "ave");
+ avgpool_param.set<bool>("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<int> begin = {0, 0, (inp_height - crop_height) / 2, (inp_width - crop_width) / 2};
+ std::vector<int> 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<int>("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<int>("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<float>("thresh", thresh);
+ region_param.set<int>("coords", coords);
+ region_param.set<int>("classes", classes);
+ region_param.set<int>("anchors", anchors);
+ region_param.set<int>("classfix", classfix);
+ region_param.set<bool>("softmax_tree", softmax_tree);
+ region_param.set<bool>("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<int>& mask, const std::vector<float>& 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<int>("classes", classes);
+ region_param.set<int>("anchors", numAnchors);
+ region_param.set<bool>("logistic", true);
+ region_param.set<float>("thresh", thresh);
+ region_param.set<float>("nms_threshold", nms_threshold);
+ region_param.set<float>("scale_x_y", scale_x_y);
+ region_param.set<int>("new_coords", new_coords);
+
+ std::vector<float> 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<float> coeffs(2, 1);
+ coeffs[0] = alpha;
+ shortcut_param.set("coeff", cv::dnn::DictValue::arrayReal<float*>(&coeffs[0], coeffs.size()));
+ }
+
+ shortcut_param.set<std::string>("op", "sum");
+ shortcut_param.set<std::string>("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<std::string>("operation", "prod");
+ eltwise_param.set<std::string>("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<int>("zoom_factor", scaleFactor);
+ param.set<String>("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<typename T>
+ std::vector<T> getNumbers(const std::string &src)
+ {
+ std::vector<T> 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<float> vec = getNumbers<float>(anchors);
+ std::map<std::string, std::string> &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<int, std::map<std::string, std::string> >::iterator it_type;
+ for (it_type i = net->layers_cfg.begin(); i != net->layers_cfg.end(); ++i) {
+ ++layers_counter;
+ std::map<std::string, std::string> &layer_params = i->second;
+ std::string layer_type = layer_params["layer_type"];
+
+ if (layer_type == "convolutional")
+ {
+ int kernel_size = getParam<int>(layer_params, "size", -1);
+ int pad = getParam<int>(layer_params, "pad", 0);
+ int padding = getParam<int>(layer_params, "padding", 0);
+ int stride = getParam<int>(layer_params, "stride", 1);
+ int filters = getParam<int>(layer_params, "filters", -1);
+ int groups = getParam<int>(layer_params, "groups", 1);
+ bool batch_normalize = getParam<int>(layer_params, "batch_normalize", 0) == 1;
+ int flipped = getParam<int>(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<int>(layer_params, "output", 1);
+ bool batch_normalize = getParam<int>(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<int>(layer_params, "size", 2);
+ int stride = getParam<int>(layer_params, "stride", 2);
+ int padding = getParam<int>(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<int>(layer_params, "crop_height", 0);
+ int crop_width = getParam<int>(layer_params, "crop_width", 0);
+ bool noadjust = getParam<int>(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<int>(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<std::string>(layer_params, "layers", "");
+ CV_Assert(!bottom_layers.empty());
+ int groups = getParam<int>(layer_params, "groups", 1);
+ std::vector<int> layers_vec = getNumbers<int>(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<int>(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<int>(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<float>(layer_params, "thresh", 0.001);
+ int coords = getParam<int>(layer_params, "coords", 4);
+ int classes = getParam<int>(layer_params, "classes", -1);
+ int num_of_anchors = getParam<int>(layer_params, "num", -1);
+ int classfix = getParam<int>(layer_params, "classfix", 0);
+ bool softmax = (getParam<int>(layer_params, "softmax", 0) == 1);
+ bool softmax_tree = (getParam<std::string>(layer_params, "tree", "").size() > 0);
+
+ std::string anchors_values = getParam<std::string>(layer_params, "anchors", std::string());
+ CV_Assert(!anchors_values.empty());
+ std::vector<float> anchors_vec = getNumbers<float>(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<std::string>(layer_params, "from", "");
+ float alpha = getParam<float>(layer_params, "alpha", 1);
+ float beta = getParam<float>(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<std::string>(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<std::string>(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<int>(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<int>(layer_params, "classes", -1);
+ int num_of_anchors = getParam<int>(layer_params, "num", -1);
+ float thresh = getParam<float>(layer_params, "thresh", 0.2);
+ float nms_threshold = getParam<float>(layer_params, "nms_threshold", 0.0);
+ float scale_x_y = getParam<float>(layer_params, "scale_x_y", 1.0);
+ int new_coords = getParam<int>(layer_params, "new_coords", 0);
+
+ std::string anchors_values = getParam<std::string>(layer_params, "anchors", std::string());
+ CV_Assert(!anchors_values.empty());
+ std::vector<float> anchors_vec = getNumbers<float>(anchors_values);
+
+ std::string mask_values = getParam<std::string>(layer_params, "mask", std::string());
+ CV_Assert(!mask_values.empty());
+ std::vector<int> mask_vec = getNumbers<int>(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<std::string>(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<char *>(&major_ver), sizeof(int32_t));
+ ifile.read(reinterpret_cast<char *>(&minor_ver), sizeof(int32_t));
+ ifile.read(reinterpret_cast<char *>(&revision), sizeof(int32_t));
+
+ uint64_t seen;
+ if ((major_ver * 10 + minor_ver) >= 2) {
+ ifile.read(reinterpret_cast<char *>(&seen), sizeof(uint64_t));
+ }
+ else {
+ int32_t iseen = 0;
+ ifile.read(reinterpret_cast<char *>(&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<int, std::map<std::string, std::string> >::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<std::string, std::string> &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<int>(layer_params, "size", -1);
+ filters = getParam<int>(layer_params, "filters", -1);
+ int groups = getParam<int>(layer_params, "groups", 1);
+ use_batch_normalize = getParam<int>(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<int>(layer_params, "output", 1);
+ use_batch_normalize = getParam<int>(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<char *>(biasData_mat.ptr<float>()), sizeof(float)*filters);
+ if (use_batch_normalize) {
+ ifile.read(reinterpret_cast<char *>(weightsData_mat.ptr<float>()), sizeof(float)*filters);
+ ifile.read(reinterpret_cast<char *>(meanData_mat.ptr<float>()), sizeof(float)*filters);
+ ifile.read(reinterpret_cast<char *>(stdData_mat.ptr<float>()), sizeof(float)*filters);
+ }
+ ifile.read(reinterpret_cast<char *>(weightsBlob.ptr<float>()), sizeof(float)*weights_size);
+
+ // set conv/connected weights
+ std::vector<cv::Mat> 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<cv::Mat> 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<std::string>(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 000000000..4e524befc
--- /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 <opencv2/dnnlegacy/dnnlegacy.hpp>
+
+namespace cv {
+ namespace dnnlegacy {
+ namespace darknet {
+
+ class LayerParameter {
+ std::string layer_name, layer_type;
+ std::vector<std::string> 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<LayerParameter> layers;
+ std::vector<int> out_channels_vec;
+
+ std::map<int, std::map<std::string, std::string> > layers_cfg;
+ std::map<std::string, std::string> 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 000000000..a761a0252
--- /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 <opencv2/core/cvdef.h>
+#undef __OPENCV_BUILD // allow public API only
+#endif
+
+#include <opencv2/core.hpp>
+
+#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 <numeric>
+#include <memory>
+#include <algorithm>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <set>
+#include <iterator>
+
+#include <opencv2/core/ocl.hpp>
+#include <opencv2/core/opencl/ocl_defs.hpp>
+
+#include <opencv2/core/utils/trace.hpp>
+#include <opencv2/dnnlegacy.hpp>
+
+//#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 000000000..a966801af
--- /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<int> 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<int>(1, 1);
+
+ // Remove all commas.
+ shapeStr.erase(std::remove(shapeStr.begin(), shapeStr.end(), ','),
+ shapeStr.end());
+
+ std::istringstream ss(shapeStr);
+ int value;
+
+ std::vector<int> 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) == "<f4");
+ CV_Assert(getFortranOrder(header) == "False");
+ std::vector<int> 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 000000000..13b29df1f
--- /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 000000000..e483b233f
--- /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 <tuple>
+#include "test_precomp.hpp"
+#include <opencv2/dnnlegacy/dnnlegacy.hpp>
+#include "npy_blob.hpp"
+#include <opencv2/dnn/shape_utils.hpp>
+
+using namespace cv;
+
+namespace opencv_test {
+ namespace {
+
+ template<typename Tstring>
+ 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_<float>(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<char> dataProto;
+ readFileContent(proto, dataProto);
+
+ std::vector<char> 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<float>(idx) = inp.at<float>(idx) * scale.at<float>(scale_idx) +
+ shift.at<float>(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<std::tuple<bool, cv::dnn::Target> > 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<char> dataProto;
+ readFileContent(proto, dataProto);
+ std::vector<char> 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<cv::dnn::MatShape> inLayerShapes;
+ std::vector<cv::dnn::MatShape> 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<int> layerIds;
+ std::vector<size_t> 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<std::tuple<cv::dnn::Backend, cv::dnn::Target> > 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<float>(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<Mat>(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<cv::dnn::Target> 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<UMat> 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<cv::dnn::Target> 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<Mat> 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<Mat> 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_<float>(2, 2) << 0., 2., 4., 6.);
+ Mat input_2 = (Mat_<float>(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<float>(0,0), 12.);
+ EXPECT_EQ(sum.at<float>(0,1), 16.);
+ }
+
+ typedef testing::TestWithParam<std::tuple<std::string, cv::dnn::Target> > 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_<float>(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_<float>(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_<float>(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_<float>(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_<float>(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 000000000..a2ea6ead5
--- /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 000000000..cb1e81ada
--- /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 <tuple>
+#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<cv::dnn::Backend, cv::dnn::Target> 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<cv::Rect2d> matToBoxes(const cv::Mat& m);
+
+ void normAssertDetections(
+ const std::vector<int>& refClassIds,
+ const std::vector<float>& refScores,
+ const std::vector<cv::Rect2d>& refBoxes,
+ const std::vector<int>& testClassIds,
+ const std::vector<float>& testScores,
+ const std::vector<cv::Rect2d>& 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<std::vector<cv::Point>>& gtPolys,
+ const std::vector<std::vector<cv::Point>>& testPolys,
+ const char* comment = "", double boxes_iou_diff = 1e-4);
+
+ void readFileContent(const std::string& filename, CV_OUT std::vector<char>& content);
+
+ bool validateVPUType();
+
+ testing::internal::ParamGenerator< std::tuple<cv::dnn::Backend, cv::dnn::Target> > 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<cv::dnn::Backend, cv::dnn::Target> > dnnBackendsAndTargetsIE();
+
+
+ class DNNlegacyTestLayer : public TestWithParam< std::tuple<cv::dnn::Backend, cv::dnn::Target> >
+ {
+ 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<double> timings;
+ net.getPerfProfile(timings);
+ std::vector<String> names = net.getLayerNames();
+ CV_Assert(names.size() == timings.size());
+
+ bool hasFallbacks = false;
+ for (int i = 0; i < names.size(); ++i)
+ {
+ Ptr<dnn::Layer> 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 000000000..6b721aa3c
--- /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 <opencv2/core/utils/configuration.private.hpp>
+#include <opencv2/core/utils/logger.hpp>
+
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#include <psapi.h>
+#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<cv::dnn::Backend, cv::dnn::Target> 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<cv::Rect2d> matToBoxes(const cv::Mat& m)
+{
+ EXPECT_EQ(m.type(), CV_32FC1);
+ EXPECT_EQ(m.dims, 2);
+ EXPECT_EQ(m.cols, 4);
+
+ std::vector<cv::Rect2d> boxes(m.rows);
+ for (int i = 0; i < m.rows; ++i)
+ {
+ CV_Assert(m.row(i).isContinuous());
+ const float* data = m.ptr<float>(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<int>& refClassIds,
+ const std::vector<float>& refScores,
+ const std::vector<cv::Rect2d>& refBoxes,
+ const std::vector<int>& testClassIds,
+ const std::vector<float>& testScores,
+ const std::vector<cv::Rect2d>& 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<bool> matchedRefBoxes(refBoxes.size(), false);
+ std::vector<double> 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<float> refScores(ref.col(2)), testScores(out.col(2));
+ std::vector<cv::Rect2d> refBoxes = matToBoxes(ref.colRange(3, 7));
+ std::vector<cv::Rect2d> 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<std::vector<Point>>& gtPolys,
+ const std::vector<std::vector<Point>>& testPolys,
+ const char *comment /*= ""*/, double boxes_iou_diff /*= 1e-4*/)
+{
+ std::vector<bool> matchedRefBoxes(gtPolys.size(), false);
+ for (uint i = 0; i < testPolys.size(); ++i)
+ {
+ const std::vector<Point>& testPoly = testPolys[i];
+ bool matched = false;
+ double topIoU = 0;
+ for (uint j = 0; j < gtPolys.size() && !matched; ++j)
+ {
+ if (!matchedRefBoxes[j])
+ {
+ std::vector<Point> 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<char>& 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<cv::dnn::Backend, cv::dnn::Target> > 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<cv::dnn::Backend, cv::dnn::Target> > 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<cv::dnn::Backend, cv::dnn::Target> > dnnBackendsAndTargetsIE()
+{
+#ifdef HAVE_INF_ENGINE
+ bool withVPU = validateVPUType();
+
+ std::vector< tuple<cv::dnn::Backend, cv::dnn::Target> > 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<Backend, Target> >());
+#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<cv::dnn::Target> available = getAvailableTargets(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE);
+ bool have_vpu_target = false;
+ 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)
+ {
+ 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 000000000..3e62daf6b
--- /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 <opencv2/dnn/shape_utils.hpp>
+
+namespace opencv_test { namespace {
+
+template<typename TString>
+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<char> 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<int> 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<std::vector<int> >& refClassIds,
+ const std::vector<std::vector<float> >& refConfidences,
+ const std::vector<std::vector<Rect2d> >& 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<Mat> 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<Mat> outs;
+ net.forward(outs, net.getUnconnectedOutLayersNames());
+
+ for (int b = 0; b < batch_size; ++b)
+ {
+ std::vector<int> classIds;
+ std::vector<float> confidences;
+ std::vector<Rect2d> 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<float>(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<int> indices;
+ cv::dnn::NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);
+
+ std::vector<int> nms_classIds;
+ std::vector<float> nms_confidences;
+ std::vector<Rect2d> 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<float>(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<int>& refClassIds,
+ const std::vector<float>& refConfidences,
+ const std::vector<Rect2d>& refBoxes,
+ double scoreDiff, double iouDiff, float confThreshold = 0.24,
+ float nmsThreshold = 0.4, bool useWinograd = true,
+ int zeroPadW = 0)
+ {
+ testDarknetModel(cfg, weights,
+ std::vector<std::vector<int> >(1, refClassIds),
+ std::vector<std::vector<float> >(1, refConfidences),
+ std::vector<std::vector<Rect2d> >(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<std::vector<int> > refClassIds;
+ std::vector<std::vector<float> > refScores;
+ std::vector<std::vector<Rect2d> > refBoxes;
+ for (int i = 0; i < ref.rows; ++i)
+ {
+ int batchId = static_cast<int>(ref.at<float>(i, 0));
+ int classId = static_cast<int>(ref.at<float>(i, 1));
+ float score = ref.at<float>(i, 2);
+ float left = ref.at<float>(i, 3);
+ float top = ref.at<float>(i, 4);
+ float right = ref.at<float>(i, 5);
+ float bottom = ref.at<float>(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_<float>(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<double>::quiet_NaN();
+ }
+ // accuracy
+ if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
+ {
+ iouDiff = std::numeric_limits<double>::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<double>::quiet_NaN();
+ }
+ // accuracy
+ if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
+ {
+ iouDiff = std::numeric_limits<double>::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_<float>(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<tuple<std::string, tuple<cv::dnn::Backend, cv::dnn::Target> > > 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<Mat> 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<Mat> 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<double>::quiet_NaN();
+ }
+ // accuracy
+ if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
+ {
+ iouDiff = std::numeric_limits<double>::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<double>::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<double>::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<double>::quiet_NaN();
+ if (backend == cv::dnn::DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == cv::dnn::DNN_TARGET_OPENCL)
+ iouDiff = std::numeric_limits<double>::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<double>::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 000000000..0e51ddfd0
--- /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 000000000..e30a57b3a
--- /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