//
//M*/
-#ifndef __OPENCV_ML_HPP__
-#define __OPENCV_ML_HPP__
+#ifndef OPENCV_ML_HPP
+#define OPENCV_ML_HPP
#ifdef __cplusplus
# include "opencv2/core.hpp"
}
#endif // __cplusplus
-#endif // __OPENCV_ML_HPP__
+#endif // OPENCV_ML_HPP
/* End of file. */
//
//M*/
-#ifndef __OPENCV_PRECOMP_H__
-#define __OPENCV_PRECOMP_H__
+#ifndef OPENCV_PRECOMP_H
+#define OPENCV_PRECOMP_H
#include "opencv2/core.hpp"
#include "old_ml.hpp"
//
//M*/
-#ifndef __OPENCV_OLD_CV_H__
-#define __OPENCV_OLD_CV_H__
+#ifndef OPENCV_OLD_CV_H
+#define OPENCV_OLD_CV_H
#if defined(_MSC_VER)
#define CV_DO_PRAGMA(x) __pragma(x)
//
//M*/
-#ifndef __OPENCV_OLD_CV_HPP__
-#define __OPENCV_OLD_CV_HPP__
+#ifndef OPENCV_OLD_CV_HPP
+#define OPENCV_OLD_CV_HPP
//#if defined(__GNUC__)
//#warning "This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module"
//
//M*/
-#ifndef __OPENCV_OLD_AUX_H__
-#define __OPENCV_OLD_AUX_H__
+#ifndef OPENCV_OLD_AUX_H
+#define OPENCV_OLD_AUX_H
//#if defined(__GNUC__)
//#warning "This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module"
//
//M*/
-#ifndef __OPENCV_OLD_AUX_HPP__
-#define __OPENCV_OLD_AUX_HPP__
+#ifndef OPENCV_OLD_AUX_HPP
+#define OPENCV_OLD_AUX_HPP
//#if defined(__GNUC__)
//#warning "This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module"
// the use of this software, even if advised of the possibility of such damage.
-#ifndef __OPENCV_OLD_WIMAGE_HPP__
-#define __OPENCV_OLD_WIMAGE_HPP__
+#ifndef OPENCV_OLD_WIMAGE_HPP
+#define OPENCV_OLD_WIMAGE_HPP
#include "opencv2/core/wimage.hpp"
//
//M*/
-#ifndef __OPENCV_OLD_CXCORE_H__
-#define __OPENCV_OLD_CXCORE_H__
+#ifndef OPENCV_OLD_CXCORE_H
+#define OPENCV_OLD_CXCORE_H
//#if defined(__GNUC__)
//#warning "This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module"
//
//M*/
-#ifndef __OPENCV_OLD_CXCORE_HPP__
-#define __OPENCV_OLD_CXCORE_HPP__
+#ifndef OPENCV_OLD_CXCORE_HPP
+#define OPENCV_OLD_CXCORE_HPP
//#if defined(__GNUC__)
//#warning "This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module"
//
//M*/
-#ifndef __OPENCV_OLD_EIGEN_HPP__
-#define __OPENCV_OLD_EIGEN_HPP__
+#ifndef OPENCV_OLD_EIGEN_HPP
+#define OPENCV_OLD_EIGEN_HPP
#include "opencv2/core/eigen.hpp"
-#ifndef __OPENCV_OLD_CXMISC_H__
-#define __OPENCV_OLD_CXMISC_H__
+#ifndef OPENCV_OLD_CXMISC_H
+#define OPENCV_OLD_CXMISC_H
#ifdef __cplusplus
# include "opencv2/core/utility.hpp"
//
//M*/
-#ifndef __OPENCV_OLD_HIGHGUI_H__
-#define __OPENCV_OLD_HIGHGUI_H__
+#ifndef OPENCV_OLD_HIGHGUI_H
+#define OPENCV_OLD_HIGHGUI_H
#include "opencv2/core/core_c.h"
#include "opencv2/highgui/highgui_c.h"
//
//M*/
-#ifndef __OPENCV_OLD_ML_H__
-#define __OPENCV_OLD_ML_H__
+#ifndef OPENCV_OLD_ML_H
+#define OPENCV_OLD_ML_H
#include "opencv2/core/core_c.h"
#include "opencv2/ml.hpp"
//
//M*/
-#ifndef __OPENCV_ALL_HPP__
-#define __OPENCV_ALL_HPP__
+#ifndef OPENCV_ALL_HPP
+#define OPENCV_ALL_HPP
#include "opencv2/opencv_modules.hpp"
//
//M*/
-#ifndef __OPENCV_CALIB3D_HPP__
-#define __OPENCV_CALIB3D_HPP__
+#ifndef OPENCV_CALIB3D_HPP
+#define OPENCV_CALIB3D_HPP
#include "opencv2/core.hpp"
#include "opencv2/features2d.hpp"
//
//M*/
-#ifndef __OPENCV_CALIB3D_C_H__
-#define __OPENCV_CALIB3D_C_H__
+#ifndef OPENCV_CALIB3D_C_H
+#define OPENCV_CALIB3D_C_H
#include "opencv2/core/core_c.h"
#endif
-#endif /* __OPENCV_CALIB3D_C_H__ */
+#endif /* OPENCV_CALIB3D_C_H */
//
//M*/
-#ifndef __OPENCV_CORE_HPP__
-#define __OPENCV_CORE_HPP__
+#ifndef OPENCV_CORE_HPP
+#define OPENCV_CORE_HPP
#ifndef __cplusplus
# error core.hpp header must be compiled as C++
#include "opencv2/core/utility.hpp"
#include "opencv2/core/optim.hpp"
-#endif /*__OPENCV_CORE_HPP__*/
+#endif /*OPENCV_CORE_HPP*/
//
//M*/
-#ifndef __OPENCV_CORE_AFFINE3_HPP__
-#define __OPENCV_CORE_AFFINE3_HPP__
+#ifndef OPENCV_CORE_AFFINE3_HPP
+#define OPENCV_CORE_AFFINE3_HPP
#ifdef __cplusplus
#endif /* __cplusplus */
-#endif /* __OPENCV_CORE_AFFINE3_HPP__ */
+#endif /* OPENCV_CORE_AFFINE3_HPP */
//
//M*/
-#ifndef __OPENCV_CORE_BASE_HPP__
-#define __OPENCV_CORE_BASE_HPP__
+#ifndef OPENCV_CORE_BASE_HPP
+#define OPENCV_CORE_BASE_HPP
#ifndef __cplusplus
# error base.hpp header must be compiled as C++
#include "opencv2/core/neon_utils.hpp"
-#endif //__OPENCV_CORE_BASE_HPP__
+#endif //OPENCV_CORE_BASE_HPP
//
// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
-#ifndef __OPENCV_CORE_BUFFER_POOL_HPP__
-#define __OPENCV_CORE_BUFFER_POOL_HPP__
+#ifndef OPENCV_CORE_BUFFER_POOL_HPP
+#define OPENCV_CORE_BUFFER_POOL_HPP
namespace cv
{
}
-#endif // __OPENCV_CORE_BUFFER_POOL_HPP__
+#endif // OPENCV_CORE_BUFFER_POOL_HPP
//M*/
-#ifndef __OPENCV_CORE_C_H__
-#define __OPENCV_CORE_C_H__
+#ifndef OPENCV_CORE_C_H
+#define OPENCV_CORE_C_H
#include "opencv2/core/types_c.h"
//
//M*/
-#ifndef __OPENCV_CORE_CUDA_HPP__
-#define __OPENCV_CORE_CUDA_HPP__
+#ifndef OPENCV_CORE_CUDA_HPP
+#define OPENCV_CORE_CUDA_HPP
#ifndef __cplusplus
# error cuda.hpp header must be compiled as C++
#include "opencv2/core/cuda.inl.hpp"
-#endif /* __OPENCV_CORE_CUDA_HPP__ */
+#endif /* OPENCV_CORE_CUDA_HPP */
//
//M*/
-#ifndef __OPENCV_CORE_CUDAINL_HPP__
-#define __OPENCV_CORE_CUDAINL_HPP__
+#ifndef OPENCV_CORE_CUDAINL_HPP
+#define OPENCV_CORE_CUDAINL_HPP
#include "opencv2/core/cuda.hpp"
//! @endcond
-#endif // __OPENCV_CORE_CUDAINL_HPP__
+#endif // OPENCV_CORE_CUDAINL_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_DEVICE_BLOCK_HPP__
-#define __OPENCV_CUDA_DEVICE_BLOCK_HPP__
+#ifndef OPENCV_CUDA_DEVICE_BLOCK_HPP
+#define OPENCV_CUDA_DEVICE_BLOCK_HPP
/** @file
* @deprecated Use @ref cudev instead.
//! @endcond
-#endif /* __OPENCV_CUDA_DEVICE_BLOCK_HPP__ */
+#endif /* OPENCV_CUDA_DEVICE_BLOCK_HPP */
//
//M*/
-#ifndef __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__
-#define __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__
+#ifndef OPENCV_CUDA_BORDER_INTERPOLATE_HPP
+#define OPENCV_CUDA_BORDER_INTERPOLATE_HPP
#include "saturate_cast.hpp"
#include "vec_traits.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__
+#endif // OPENCV_CUDA_BORDER_INTERPOLATE_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_COLOR_HPP__
-#define __OPENCV_CUDA_COLOR_HPP__
+#ifndef OPENCV_CUDA_COLOR_HPP
+#define OPENCV_CUDA_COLOR_HPP
#include "detail/color_detail.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__
+#endif // OPENCV_CUDA_BORDER_INTERPOLATE_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_COMMON_HPP__
-#define __OPENCV_CUDA_COMMON_HPP__
+#ifndef OPENCV_CUDA_COMMON_HPP
+#define OPENCV_CUDA_COMMON_HPP
#include <cuda_runtime.h>
#include "opencv2/core/cuda_types.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_COMMON_HPP__
+#endif // OPENCV_CUDA_COMMON_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_DATAMOV_UTILS_HPP__
-#define __OPENCV_CUDA_DATAMOV_UTILS_HPP__
+#ifndef OPENCV_CUDA_DATAMOV_UTILS_HPP
+#define OPENCV_CUDA_DATAMOV_UTILS_HPP
#include "common.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_DATAMOV_UTILS_HPP__
+#endif // OPENCV_CUDA_DATAMOV_UTILS_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_COLOR_DETAIL_HPP__
-#define __OPENCV_CUDA_COLOR_DETAIL_HPP__
+#ifndef OPENCV_CUDA_COLOR_DETAIL_HPP
+#define OPENCV_CUDA_COLOR_DETAIL_HPP
#include "../common.hpp"
#include "../vec_traits.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_COLOR_DETAIL_HPP__
+#endif // OPENCV_CUDA_COLOR_DETAIL_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_REDUCE_DETAIL_HPP__
-#define __OPENCV_CUDA_REDUCE_DETAIL_HPP__
+#ifndef OPENCV_CUDA_REDUCE_DETAIL_HPP
+#define OPENCV_CUDA_REDUCE_DETAIL_HPP
#include <thrust/tuple.h>
#include "../warp.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_REDUCE_DETAIL_HPP__
+#endif // OPENCV_CUDA_REDUCE_DETAIL_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP__
-#define __OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP__
+#ifndef OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP_
+#define OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP_
#include <thrust/tuple.h>
#include "../warp.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP__
+#endif // OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP_
//
//M*/
-#ifndef __OPENCV_CUDA_TRANSFORM_DETAIL_HPP__
-#define __OPENCV_CUDA_TRANSFORM_DETAIL_HPP__
+#ifndef OPENCV_CUDA_TRANSFORM_DETAIL_HPP
+#define OPENCV_CUDA_TRANSFORM_DETAIL_HPP
#include "../common.hpp"
#include "../vec_traits.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_TRANSFORM_DETAIL_HPP__
+#endif // OPENCV_CUDA_TRANSFORM_DETAIL_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP__
-#define __OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP__
+#ifndef OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP
+#define OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP
#include "../common.hpp"
#include "../vec_traits.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP__
+#endif // OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP__
-#define __OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP__
+#ifndef OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP
+#define OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP
#include "../datamov_utils.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP__
+#endif // OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_DYNAMIC_SMEM_HPP__
-#define __OPENCV_CUDA_DYNAMIC_SMEM_HPP__
+#ifndef OPENCV_CUDA_DYNAMIC_SMEM_HPP
+#define OPENCV_CUDA_DYNAMIC_SMEM_HPP
/** @file
* @deprecated Use @ref cudev instead.
//! @endcond
-#endif // __OPENCV_CUDA_DYNAMIC_SMEM_HPP__
+#endif // OPENCV_CUDA_DYNAMIC_SMEM_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_FILTERS_HPP__
-#define __OPENCV_CUDA_FILTERS_HPP__
+#ifndef OPENCV_CUDA_FILTERS_HPP
+#define OPENCV_CUDA_FILTERS_HPP
#include "saturate_cast.hpp"
#include "vec_traits.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_FILTERS_HPP__
+#endif // OPENCV_CUDA_FILTERS_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP_
-#define __OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP_
+#ifndef OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP
+#define OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP
#include <cstdio>
//! @endcond
-#endif /* __OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP_ */
+#endif /* OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP */
//
//M*/
-#ifndef __OPENCV_CUDA_FUNCTIONAL_HPP__
-#define __OPENCV_CUDA_FUNCTIONAL_HPP__
+#ifndef OPENCV_CUDA_FUNCTIONAL_HPP
+#define OPENCV_CUDA_FUNCTIONAL_HPP
#include <functional>
#include "saturate_cast.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_FUNCTIONAL_HPP__
+#endif // OPENCV_CUDA_FUNCTIONAL_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_LIMITS_HPP__
-#define __OPENCV_CUDA_LIMITS_HPP__
+#ifndef OPENCV_CUDA_LIMITS_HPP
+#define OPENCV_CUDA_LIMITS_HPP
#include <limits.h>
#include <float.h>
//! @endcond
-#endif // __OPENCV_CUDA_LIMITS_HPP__
+#endif // OPENCV_CUDA_LIMITS_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_REDUCE_HPP__
-#define __OPENCV_CUDA_REDUCE_HPP__
+#ifndef OPENCV_CUDA_REDUCE_HPP
+#define OPENCV_CUDA_REDUCE_HPP
#include <thrust/tuple.h>
#include "detail/reduce.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_UTILITY_HPP__
+#endif // OPENCV_CUDA_UTILITY_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_SATURATE_CAST_HPP__
-#define __OPENCV_CUDA_SATURATE_CAST_HPP__
+#ifndef OPENCV_CUDA_SATURATE_CAST_HPP
+#define OPENCV_CUDA_SATURATE_CAST_HPP
#include "common.hpp"
//! @endcond
-#endif /* __OPENCV_CUDA_SATURATE_CAST_HPP__ */
+#endif /* OPENCV_CUDA_SATURATE_CAST_HPP */
//
//M*/
-#ifndef __OPENCV_CUDA_SCAN_HPP__
-#define __OPENCV_CUDA_SCAN_HPP__
+#ifndef OPENCV_CUDA_SCAN_HPP
+#define OPENCV_CUDA_SCAN_HPP
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_SCAN_HPP__
+#endif // OPENCV_CUDA_SCAN_HPP
* POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __OPENCV_CUDA_SIMD_FUNCTIONS_HPP__
-#define __OPENCV_CUDA_SIMD_FUNCTIONS_HPP__
+#ifndef OPENCV_CUDA_SIMD_FUNCTIONS_HPP
+#define OPENCV_CUDA_SIMD_FUNCTIONS_HPP
#include "common.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_SIMD_FUNCTIONS_HPP__
+#endif // OPENCV_CUDA_SIMD_FUNCTIONS_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_TRANSFORM_HPP__
-#define __OPENCV_CUDA_TRANSFORM_HPP__
+#ifndef OPENCV_CUDA_TRANSFORM_HPP
+#define OPENCV_CUDA_TRANSFORM_HPP
#include "common.hpp"
#include "utility.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_TRANSFORM_HPP__
+#endif // OPENCV_CUDA_TRANSFORM_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_TYPE_TRAITS_HPP__
-#define __OPENCV_CUDA_TYPE_TRAITS_HPP__
+#ifndef OPENCV_CUDA_REDUCE_DETAIL_HPP
+#define OPENCV_CUDA_REDUCE_DETAIL_HPP
#include "detail/type_traits_detail.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_TYPE_TRAITS_HPP__
+#endif // OPENCV_CUDA_REDUCE_DETAIL_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_UTILITY_HPP__
-#define __OPENCV_CUDA_UTILITY_HPP__
+#ifndef OPENCV_CUDA_UTILITY_HPP
+#define OPENCV_CUDA_UTILITY_HPP
#include "saturate_cast.hpp"
#include "datamov_utils.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_UTILITY_HPP__
+#endif // OPENCV_CUDA_UTILITY_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_VEC_DISTANCE_HPP__
-#define __OPENCV_CUDA_VEC_DISTANCE_HPP__
+#ifndef OPENCV_CUDA_VEC_DISTANCE_HPP
+#define OPENCV_CUDA_VEC_DISTANCE_HPP
#include "reduce.hpp"
#include "functional.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_VEC_DISTANCE_HPP__
+#endif // OPENCV_CUDA_VEC_DISTANCE_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_VECMATH_HPP__
-#define __OPENCV_CUDA_VECMATH_HPP__
+#ifndef OPENCV_CUDA_VECMATH_HPP
+#define OPENCV_CUDA_VECMATH_HPP
#include "vec_traits.hpp"
#include "saturate_cast.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_VECMATH_HPP__
+#endif // OPENCV_CUDA_VECMATH_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_VEC_TRAITS_HPP__
-#define __OPENCV_CUDA_VEC_TRAITS_HPP__
+#ifndef OPENCV_CUDA_VEC_TRAITS_HPP
+#define OPENCV_CUDA_VEC_TRAITS_HPP
#include "common.hpp"
//! @endcond
-#endif // __OPENCV_CUDA_VEC_TRAITS_HPP__
+#endif // OPENCV_CUDA_VEC_TRAITS_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_DEVICE_WARP_HPP__
-#define __OPENCV_CUDA_DEVICE_WARP_HPP__
+#ifndef OPENCV_CUDA_DEVICE_WARP_HPP
+#define OPENCV_CUDA_DEVICE_WARP_HPP
/** @file
* @deprecated Use @ref cudev instead.
//! @endcond
-#endif /* __OPENCV_CUDA_DEVICE_WARP_HPP__ */
+#endif /* OPENCV_CUDA_DEVICE_WARP_HPP */
//
//M*/
-#ifndef __OPENCV_CUDA_WARP_SHUFFLE_HPP__
-#define __OPENCV_CUDA_WARP_SHUFFLE_HPP__
+#ifndef OPENCV_CUDA_WARP_SHUFFLE_HPP
+#define OPENCV_CUDA_WARP_SHUFFLE_HPP
/** @file
* @deprecated Use @ref cudev instead.
//! @endcond
-#endif // __OPENCV_CUDA_WARP_SHUFFLE_HPP__
+#endif // OPENCV_CUDA_WARP_SHUFFLE_HPP
//
//M*/
-#ifndef __OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP__
-#define __OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP__
+#ifndef OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP
+#define OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP
#ifndef __cplusplus
# error cuda_stream_accessor.hpp header must be compiled as C++
}
}
-#endif /* __OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP__ */
+#endif /* OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP */
//
//M*/
-#ifndef __OPENCV_CORE_CUDA_TYPES_HPP__
-#define __OPENCV_CORE_CUDA_TYPES_HPP__
+#ifndef OPENCV_CORE_CUDA_TYPES_HPP
+#define OPENCV_CORE_CUDA_TYPES_HPP
#ifndef __cplusplus
# error cuda_types.hpp header must be compiled as C++
//! @endcond
-#endif /* __OPENCV_CORE_CUDA_TYPES_HPP__ */
+#endif /* OPENCV_CORE_CUDA_TYPES_HPP */
//
//M*/
-#ifndef __OPENCV_CORE_CVDEF_H__
-#define __OPENCV_CORE_CVDEF_H__
+#ifndef OPENCV_CORE_CVDEF_H
+#define OPENCV_CORE_CVDEF_H
//! @addtogroup core_utils
//! @{
//! @}
-#endif // __OPENCV_CORE_CVDEF_H__
+#endif // OPENCV_CORE_CVDEF_H
//
//M*/
-#ifndef __OPENCV_CORE_CVSTD_HPP__
-#define __OPENCV_CORE_CVSTD_HPP__
+#ifndef OPENCV_CORE_CVSTD_HPP
+#define OPENCV_CORE_CVSTD_HPP
#ifndef __cplusplus
# error cvstd.hpp header must be compiled as C++
#include "opencv2/core/ptr.inl.hpp"
-#endif //__OPENCV_CORE_CVSTD_HPP__
+#endif //OPENCV_CORE_CVSTD_HPP
//
//M*/
-#ifndef __OPENCV_CORE_CVSTDINL_HPP__
-#define __OPENCV_CORE_CVSTDINL_HPP__
+#ifndef OPENCV_CORE_CVSTDINL_HPP
+#define OPENCV_CORE_CVSTDINL_HPP
#ifndef OPENCV_NOSTL
# include <complex>
//! @endcond
-#endif // __OPENCV_CORE_CVSTDINL_HPP__
+#endif // OPENCV_CORE_CVSTDINL_HPP
//
//M*/
-#ifndef __OPENCV_CORE_DIRECTX_HPP__
-#define __OPENCV_CORE_DIRECTX_HPP__
+#ifndef OPENCV_CORE_DIRECTX_HPP
+#define OPENCV_CORE_DIRECTX_HPP
#include "mat.hpp"
#include "ocl.hpp"
} } // namespace cv::directx
-#endif // __OPENCV_CORE_DIRECTX_HPP__
+#endif // OPENCV_CORE_DIRECTX_HPP
//M*/
-#ifndef __OPENCV_CORE_EIGEN_HPP__
-#define __OPENCV_CORE_EIGEN_HPP__
+#ifndef OPENCV_CORE_EIGEN_HPP
+#define OPENCV_CORE_EIGEN_HPP
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_CORE_FAST_MATH_HPP__
-#define __OPENCV_CORE_FAST_MATH_HPP__
+#ifndef OPENCV_CORE_FAST_MATH_HPP
+#define OPENCV_CORE_FAST_MATH_HPP
#include "opencv2/core/cvdef.h"
//
//M*/
-#ifndef __OPENCV_HAL_HPP__
-#define __OPENCV_HAL_HPP__
+#ifndef OPENCV_HAL_HPP
+#define OPENCV_HAL_HPP
#include "opencv2/core/cvdef.h"
#include "opencv2/core/cvstd.hpp"
}} //cv::hal
-#endif //__OPENCV_HAL_HPP__
+#endif //OPENCV_HAL_HPP
//
//M*/
-#ifndef __OPENCV_HAL_INTRIN_HPP__
-#define __OPENCV_HAL_INTRIN_HPP__
+#ifndef OPENCV_HAL_INTRIN_HPP
+#define OPENCV_HAL_INTRIN_HPP
#include <cmath>
#include <float.h>
//
//M*/
-#ifndef __OPENCV_HAL_INTRIN_CPP_HPP__
-#define __OPENCV_HAL_INTRIN_CPP_HPP__
+#ifndef OPENCV_HAL_INTRIN_CPP_HPP
+#define OPENCV_HAL_INTRIN_CPP_HPP
#include <limits>
#include <cstring>
//
//M*/
-#ifndef __OPENCV_HAL_INTRIN_NEON_HPP__
-#define __OPENCV_HAL_INTRIN_NEON_HPP__
+#ifndef OPENCV_HAL_INTRIN_NEON_HPP
+#define OPENCV_HAL_INTRIN_NEON_HPP
#include <algorithm>
//
//M*/
-#ifndef __OPENCV_HAL_SSE_HPP__
-#define __OPENCV_HAL_SSE_HPP__
+#ifndef OPENCV_HAL_SSE_HPP
+#define OPENCV_HAL_SSE_HPP
#include <algorithm>
//
//M*/
-#ifndef __OPENCV_CORE_IPPASYNC_HPP__
-#define __OPENCV_CORE_IPPASYNC_HPP__
+#ifndef OPENCV_CORE_IPPASYNC_HPP
+#define OPENCV_CORE_IPPASYNC_HPP
#ifdef HAVE_IPP_A
//
//M*/
-#ifndef __OPENCV_CORE_MAT_HPP__
-#define __OPENCV_CORE_MAT_HPP__
+#ifndef OPENCV_CORE_MAT_HPP
+#define OPENCV_CORE_MAT_HPP
#ifndef __cplusplus
# error mat.hpp header must be compiled as C++
#include "opencv2/core/mat.inl.hpp"
-#endif // __OPENCV_CORE_MAT_HPP__
+#endif // OPENCV_CORE_MAT_HPP
//
//M*/
-#ifndef __OPENCV_CORE_MATRIX_OPERATIONS_HPP__
-#define __OPENCV_CORE_MATRIX_OPERATIONS_HPP__
+#ifndef OPENCV_CORE_MATRIX_OPERATIONS_HPP
+#define OPENCV_CORE_MATRIX_OPERATIONS_HPP
#ifndef __cplusplus
# error mat.inl.hpp header must be compiled as C++
//
//M*/
-#ifndef __OPENCV_CORE_MATX_HPP__
-#define __OPENCV_CORE_MATX_HPP__
+#ifndef OPENCV_CORE_MATX_HPP
+#define OPENCV_CORE_MATX_HPP
#ifndef __cplusplus
# error matx.hpp header must be compiled as C++
} // cv
-#endif // __OPENCV_CORE_MATX_HPP__
+#endif // OPENCV_CORE_MATX_HPP
//
//M*/
-#ifndef __OPENCV_HAL_NEON_UTILS_HPP__
-#define __OPENCV_HAL_NEON_UTILS_HPP__
+#ifndef OPENCV_HAL_NEON_UTILS_HPP
+#define OPENCV_HAL_NEON_UTILS_HPP
#include "opencv2/core/cvdef.h"
//! @}
-#endif // __OPENCV_HAL_NEON_UTILS_HPP__
+#endif // OPENCV_HAL_NEON_UTILS_HPP
//
//M*/
-#ifndef __OPENCV_OPENCL_HPP__
-#define __OPENCV_OPENCL_HPP__
+#ifndef OPENCV_OPENCL_HPP
+#define OPENCV_OPENCL_HPP
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_OPENCL_GENBASE_HPP__
-#define __OPENCV_OPENCL_GENBASE_HPP__
+#ifndef OPENCV_OPENCL_GENBASE_HPP
+#define OPENCV_OPENCL_GENBASE_HPP
namespace cv
{
/* See LICENSE file in the root OpenCV directory */
-#ifndef __OPENCV_CORE_OPENCL_SVM_HPP__
-#define __OPENCV_CORE_OPENCL_SVM_HPP__
+#ifndef OPENCV_CORE_OPENCL_SVM_HPP
+#define OPENCV_CORE_OPENCL_SVM_HPP
//
// Internal usage only (binary compatibility is not guaranteed)
}}} //namespace cv::ocl::svm
#endif
-#endif // __OPENCV_CORE_OPENCL_SVM_HPP__
+#endif // OPENCV_CORE_OPENCL_SVM_HPP
/* End of file. */
//
// AUTOGENERATED, DO NOT EDIT
//
-#ifndef __OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP
#error "Invalid usage"
#endif
//
// AUTOGENERATED, DO NOT EDIT
//
-#ifndef __OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP
#error "Invalid usage"
#endif
//
// AUTOGENERATED, DO NOT EDIT
//
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_CORE_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_CORE_HPP
#error "Invalid usage"
#endif
//
// AUTOGENERATED, DO NOT EDIT
//
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_WRAPPERS_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_WRAPPERS_HPP
#error "Invalid usage"
#endif
//
// AUTOGENERATED, DO NOT EDIT
//
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_HPP
#error "Invalid usage"
#endif
//
// AUTOGENERATED, DO NOT EDIT
//
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_WRAPPERS_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_WRAPPERS_HPP
#error "Invalid usage"
#endif
//
//M*/
-#ifndef __OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP
+#define OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP
#ifdef HAVE_CLAMDBLAS
#endif // HAVE_CLAMDBLAS
-#endif // __OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP
//
//M*/
-#ifndef __OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP
+#define OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP
#ifdef HAVE_CLAMDFFT
#endif // HAVE_CLAMDFFT
-#endif // __OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP
//
//M*/
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_CORE_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_OPENCL_CORE_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_CORE_HPP
+#define OPENCV_CORE_OCL_RUNTIME_OPENCL_CORE_HPP
#ifdef HAVE_OPENCL
#endif // HAVE_OPENCL
-#endif // __OPENCV_CORE_OCL_RUNTIME_OPENCL_CORE_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_OPENCL_CORE_HPP
//
//M*/
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_WRAPPERS_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_OPENCL_WRAPPERS_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_WRAPPERS_HPP
+#define OPENCV_CORE_OCL_RUNTIME_OPENCL_WRAPPERS_HPP
#include "autogenerated/opencl_core_wrappers.hpp"
-#endif // __OPENCV_CORE_OCL_RUNTIME_OPENCL_WRAPPERS_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_OPENCL_WRAPPERS_HPP
//
//M*/
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_HPP
+#define OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_HPP
#if defined HAVE_OPENCL && defined HAVE_OPENGL
#endif // defined HAVE_OPENCL && defined HAVE_OPENGL
-#endif // __OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_HPP
//
//M*/
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_WRAPPERS_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_WRAPPERS_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_WRAPPERS_HPP
+#define OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_WRAPPERS_HPP
#include "autogenerated/opencl_gl_wrappers.hpp"
-#endif // __OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_WRAPPERS_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_OPENCL_GL_WRAPPERS_HPP
/* See LICENSE file in the root OpenCV directory */
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_2_0_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_2_0_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_2_0_HPP
+#define OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_2_0_HPP
#if defined(HAVE_OPENCL_SVM)
#include "opencl_core.hpp"
#endif // HAVE_OPENCL_SVM
-#endif // __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_2_0_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_2_0_HPP
/* See LICENSE file in the root OpenCV directory */
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP
+#define OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP
#if defined(HAVE_OPENCL_SVM)
#if defined(CL_VERSION_2_0)
#endif // CL_VERSION_2_0
#endif // HAVE_OPENCL_SVM
-#endif // __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP
/* See LICENSE file in the root OpenCV directory */
-#ifndef __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_HSA_EXTENSION_HPP__
-#define __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_HSA_EXTENSION_HPP__
+#ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_HSA_EXTENSION_HPP
+#define OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_HSA_EXTENSION_HPP
#if defined(HAVE_OPENCL_SVM)
#include "opencl_core.hpp"
#endif // HAVE_OPENCL_SVM
-#endif // __OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_HSA_EXTENSION_HPP__
+#endif // OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_HSA_EXTENSION_HPP
//
//M*/
-#ifndef __OPENCV_CORE_OPENGL_HPP__
-#define __OPENCV_CORE_OPENGL_HPP__
+#ifndef OPENCV_CORE_OPENGL_HPP
+#define OPENCV_CORE_OPENGL_HPP
#ifndef __cplusplus
# error opengl.hpp header must be compiled as C++
//! @endcond
-#endif /* __OPENCV_CORE_OPENGL_HPP__ */
+#endif /* OPENCV_CORE_OPENGL_HPP */
//
//M*/
-#ifndef __OPENCV_CORE_OPERATIONS_HPP__
-#define __OPENCV_CORE_OPERATIONS_HPP__
+#ifndef OPENCV_CORE_OPERATIONS_HPP
+#define OPENCV_CORE_OPERATIONS_HPP
#ifndef __cplusplus
# error operations.hpp header must be compiled as C++
//
//M*/
-#ifndef __OPENCV_OPTIM_HPP__
-#define __OPENCV_OPTIM_HPP__
+#ifndef OPENCV_OPTIM_HPP
+#define OPENCV_OPTIM_HPP
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_CORE_PERSISTENCE_HPP__
-#define __OPENCV_CORE_PERSISTENCE_HPP__
+#ifndef OPENCV_CORE_PERSISTENCE_HPP
+#define OPENCV_CORE_PERSISTENCE_HPP
#ifndef __cplusplus
# error persistence.hpp header must be compiled as C++
} // cv
-#endif // __OPENCV_CORE_PERSISTENCE_HPP__
\ No newline at end of file
+#endif // OPENCV_CORE_PERSISTENCE_HPP
\ No newline at end of file
//
//M*/
-#ifndef __OPENCV_CORE_PRIVATE_CUDA_HPP__
-#define __OPENCV_CORE_PRIVATE_CUDA_HPP__
+#ifndef OPENCV_CORE_PRIVATE_CUDA_HPP
+#define OPENCV_CORE_PRIVATE_CUDA_HPP
#ifndef __OPENCV_BUILD
# error this is a private header which should not be used from outside of the OpenCV library
//! @endcond
-#endif // __OPENCV_CORE_CUDA_PRIVATE_HPP__
+#endif // OPENCV_CORE_CUDA_PRIVATE_HPP
//
//M*/
-#ifndef __OPENCV_CORE_PRIVATE_HPP__
-#define __OPENCV_CORE_PRIVATE_HPP__
+#ifndef OPENCV_CORE_PRIVATE_HPP
+#define OPENCV_CORE_PRIVATE_HPP
#ifndef __OPENCV_BUILD
# error this is a private header which should not be used from outside of the OpenCV library
//! @endcond
-#endif // __OPENCV_CORE_PRIVATE_HPP__
+#endif // OPENCV_CORE_PRIVATE_HPP
//
//M*/
-#ifndef __OPENCV_CORE_PTR_INL_HPP__
-#define __OPENCV_CORE_PTR_INL_HPP__
+#ifndef OPENCV_CORE_PTR_INL_HPP
+#define OPENCV_CORE_PTR_INL_HPP
#include <algorithm>
//! @endcond
-#endif // __OPENCV_CORE_PTR_INL_HPP__
+#endif // OPENCV_CORE_PTR_INL_HPP
//
//M*/
-#ifndef __OPENCV_CORE_SATURATE_HPP__
-#define __OPENCV_CORE_SATURATE_HPP__
+#ifndef OPENCV_CORE_SATURATE_HPP
+#define OPENCV_CORE_SATURATE_HPP
#include "opencv2/core/cvdef.h"
#include "opencv2/core/fast_math.hpp"
} // cv
-#endif // __OPENCV_CORE_SATURATE_HPP__
+#endif // OPENCV_CORE_SATURATE_HPP
//
//M*/
-#ifndef __OPENCV_CORE_SSE_UTILS_HPP__
-#define __OPENCV_CORE_SSE_UTILS_HPP__
+#ifndef OPENCV_CORE_SSE_UTILS_HPP
+#define OPENCV_CORE_SSE_UTILS_HPP
#ifndef __cplusplus
# error sse_utils.hpp header must be compiled as C++
//! @}
-#endif //__OPENCV_CORE_SSE_UTILS_HPP__
+#endif //OPENCV_CORE_SSE_UTILS_HPP
//
//M*/
-#ifndef __OPENCV_CORE_TRAITS_HPP__
-#define __OPENCV_CORE_TRAITS_HPP__
+#ifndef OPENCV_CORE_TRAITS_HPP
+#define OPENCV_CORE_TRAITS_HPP
#include "opencv2/core/cvdef.h"
} // cv
-#endif // __OPENCV_CORE_TRAITS_HPP__
+#endif // OPENCV_CORE_TRAITS_HPP
//
//M*/
-#ifndef __OPENCV_CORE_TYPES_HPP__
-#define __OPENCV_CORE_TYPES_HPP__
+#ifndef OPENCV_CORE_TYPES_HPP
+#define OPENCV_CORE_TYPES_HPP
#ifndef __cplusplus
# error types.hpp header must be compiled as C++
} // cv
-#endif //__OPENCV_CORE_TYPES_HPP__
+#endif //OPENCV_CORE_TYPES_HPP
//
//M*/
-#ifndef __OPENCV_CORE_TYPES_H__
-#define __OPENCV_CORE_TYPES_H__
+#ifndef OPENCV_CORE_TYPES_H
+#define OPENCV_CORE_TYPES_H
#ifdef HAVE_IPL
# ifndef __IPL_H__
/** @} */
-#endif /*__OPENCV_CORE_TYPES_H__*/
+#endif /*OPENCV_CORE_TYPES_H*/
/* End of file. */
//
//M*/
-#ifndef __OPENCV_CORE_UTILITY_H__
-#define __OPENCV_CORE_UTILITY_H__
+#ifndef OPENCV_CORE_UTILITY_H
+#define OPENCV_CORE_UTILITY_H
#ifndef __cplusplus
# error utility.hpp header must be compiled as C++
#include "opencv2/core/core_c.h"
#endif
-#endif //__OPENCV_CORE_UTILITY_H__
+#endif //OPENCV_CORE_UTILITY_H
// Copyright (C) 2015, Itseez, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
-#ifndef __OPENCV_CORE_VA_INTEL_HPP__
-#define __OPENCV_CORE_VA_INTEL_HPP__
+#ifndef OPENCV_CORE_VA_INTEL_HPP
+#define OPENCV_CORE_VA_INTEL_HPP
#ifndef __cplusplus
# error va_intel.hpp header must be compiled as C++
}} // namespace cv::va_intel
-#endif /* __OPENCV_CORE_VA_INTEL_HPP__ */
+#endif /* OPENCV_CORE_VA_INTEL_HPP */
Usefull to test in user programs
*/
-#ifndef __OPENCV_VERSION_HPP__
-#define __OPENCV_VERSION_HPP__
+#ifndef OPENCV_VERSION_HPP
+#define OPENCV_VERSION_HPP
#define CV_VERSION_MAJOR 3
#define CV_VERSION_MINOR 1
/////////////////////////////////////////////////////////////////////////////////
//M*/
-#ifndef __OPENCV_CORE_WIMAGE_HPP__
-#define __OPENCV_CORE_WIMAGE_HPP__
+#ifndef OPENCV_CORE_WIMAGE_HPP
+#define OPENCV_CORE_WIMAGE_HPP
#include "opencv2/core/core_c.h"
//
//M*/
-#ifndef __OPENCV_CUDAARITHM_HPP__
-#define __OPENCV_CUDAARITHM_HPP__
+#ifndef OPENCV_CUDAARITHM_HPP
+#define OPENCV_CUDAARITHM_HPP
#ifndef __cplusplus
# error cudaarithm.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDAARITHM_HPP__ */
+#endif /* OPENCV_CUDAARITHM_HPP */
//
//M*/
-#ifndef __OPENCV_CUDABGSEGM_HPP__
-#define __OPENCV_CUDABGSEGM_HPP__
+#ifndef OPENCV_CUDABGSEGM_HPP
+#define OPENCV_CUDABGSEGM_HPP
#ifndef __cplusplus
# error cudabgsegm.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDABGSEGM_HPP__ */
+#endif /* OPENCV_CUDABGSEGM_HPP */
# endif
#endif
-#ifndef __OPENCV_PERF_PRECOMP_HPP__
-#define __OPENCV_PERF_PRECOMP_HPP__
+#ifndef OPENCV_PERF_PRECOMP_HPP
+#define OPENCV_PERF_PRECOMP_HPP
#include "opencv2/ts.hpp"
#include "opencv2/ts/cuda_perf.hpp"
//
//M*/
-#ifndef __OPENCV_PRECOMP_H__
-#define __OPENCV_PRECOMP_H__
+#ifndef OPENCV_PRECOMP_H
+#define OPENCV_PRECOMP_H
#include <limits>
#include "opencv2/opencv_modules.hpp"
-#endif /* __OPENCV_PRECOMP_H__ */
+#endif /* OPENCV_PRECOMP_H */
# endif
#endif
-#ifndef __OPENCV_TEST_PRECOMP_HPP__
-#define __OPENCV_TEST_PRECOMP_HPP__
+#ifndef OPENCV_TEST_PRECOMP_HPP
+#define OPENCV_TEST_PRECOMP_HPP
#include <fstream>
//
//M*/
-#ifndef __OPENCV_CUDACODEC_HPP__
-#define __OPENCV_CUDACODEC_HPP__
+#ifndef OPENCV_CUDACODEC_HPP
+#define OPENCV_CUDACODEC_HPP
#ifndef __cplusplus
# error cudacodec.hpp header must be compiled as C++
}} // namespace cv { namespace cudacodec {
-#endif /* __OPENCV_CUDACODEC_HPP__ */
+#endif /* OPENCV_CUDACODEC_HPP */
# endif
#endif
-#ifndef __OPENCV_PERF_PRECOMP_HPP__
-#define __OPENCV_PERF_PRECOMP_HPP__
+#ifndef OPENCV_PERF_PRECOMP_HPP
+#define OPENCV_PERF_PRECOMP_HPP
#include "opencv2/ts.hpp"
#include "opencv2/ts/cuda_perf.hpp"
//
//M*/
-#ifndef __OPENCV_PRECOMP_H__
-#define __OPENCV_PRECOMP_H__
+#ifndef OPENCV_PRECOMP_H
+#define OPENCV_PRECOMP_H
#include <cstdlib>
#include <cstring>
#include "../src/cap_ffmpeg_api.hpp"
#endif
-#endif /* __OPENCV_PRECOMP_H__ */
+#endif /* OPENCV_PRECOMP_H */
# endif
#endif
-#ifndef __OPENCV_TEST_PRECOMP_HPP__
-#define __OPENCV_TEST_PRECOMP_HPP__
+#ifndef OPENCV_TEST_PRECOMP_HPP
+#define OPENCV_TEST_PRECOMP_HPP
#include "opencv2/ts.hpp"
#include "opencv2/ts/cuda_test.hpp"
//
//M*/
-#ifndef __OPENCV_CUDAFEATURES2D_HPP__
-#define __OPENCV_CUDAFEATURES2D_HPP__
+#ifndef OPENCV_CUDAFEATURES2D_HPP
+#define OPENCV_CUDAFEATURES2D_HPP
#ifndef __cplusplus
# error cudafeatures2d.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDAFEATURES2D_HPP__ */
+#endif /* OPENCV_CUDAFEATURES2D_HPP */
//
//M*/
-#ifndef __OPENCV_CUDAFILTERS_HPP__
-#define __OPENCV_CUDAFILTERS_HPP__
+#ifndef OPENCV_CUDAFILTERS_HPP
+#define OPENCV_CUDAFILTERS_HPP
#ifndef __cplusplus
# error cudafilters.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDAFILTERS_HPP__ */
+#endif /*OPENCV_CUDAFILTERS_HPP */
//
//M*/
-#ifndef __OPENCV_CUDAIMGPROC_HPP__
-#define __OPENCV_CUDAIMGPROC_HPP__
+#ifndef OPENCV_CUDAIMGPROC_HPP
+#define OPENCV_CUDAIMGPROC_HPP
#ifndef __cplusplus
# error cudaimgproc.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDAIMGPROC_HPP__ */
+#endif /* OPENCV_CUDAIMGPROC_HPP */
//
//M*/
-#ifndef __OPENCV_CUDALEGACY_HPP__
-#define __OPENCV_CUDALEGACY_HPP__
+#ifndef OPENCV_CUDALEGACY_HPP
+#define OPENCV_CUDALEGACY_HPP
#include "opencv2/core/cuda.hpp"
#include "opencv2/cudalegacy/NCV.hpp"
}}
-#endif /* __OPENCV_CUDALEGACY_HPP__ */
+#endif /* OPENCV_CUDALEGACY_HPP */
//
//M*/
-#ifndef __OPENCV_CORE_CUDALEGACY_PRIVATE_HPP__
-#define __OPENCV_CORE_CUDALEGACY_PRIVATE_HPP__
+#ifndef OPENCV_CORE_CUDALEGACY_PRIVATE_HPP
+#define OPENCV_CORE_CUDALEGACY_PRIVATE_HPP
#ifndef __OPENCV_BUILD
# error this is a private header which should not be used from outside of the OpenCV library
//! @endcond
-#endif // __OPENCV_CORE_CUDALEGACY_PRIVATE_HPP__
+#endif // OPENCV_CORE_CUDALEGACY_PRIVATE_HPP
//
//M*/
-#ifndef __OPENCV_CUDAOBJDETECT_HPP__
-#define __OPENCV_CUDAOBJDETECT_HPP__
+#ifndef OPENCV_CUDAOBJDETECT_HPP
+#define OPENCV_CUDAOBJDETECT_HPP
#ifndef __cplusplus
# error cudaobjdetect.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDAOBJDETECT_HPP__ */
+#endif /* OPENCV_CUDAOBJDETECT_HPP */
//
//M*/
-#ifndef __OPENCV_CUDAOPTFLOW_HPP__
-#define __OPENCV_CUDAOPTFLOW_HPP__
+#ifndef OPENCV_CUDAOPTFLOW_HPP
+#define OPENCV_CUDAOPTFLOW_HPP
#ifndef __cplusplus
# error cudaoptflow.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDAOPTFLOW_HPP__ */
+#endif /* OPENCV_CUDAOPTFLOW_HPP */
//
//M*/
-#ifndef __OPENCV_CUDASTEREO_HPP__
-#define __OPENCV_CUDASTEREO_HPP__
+#ifndef OPENCV_CUDASTEREO_HPP
+#define OPENCV_CUDASTEREO_HPP
#ifndef __cplusplus
# error cudastereo.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDASTEREO_HPP__ */
+#endif /* OPENCV_CUDASTEREO_HPP */
//
//M*/
-#ifndef __OPENCV_CUDAWARPING_HPP__
-#define __OPENCV_CUDAWARPING_HPP__
+#ifndef OPENCV_CUDAWARPING_HPP
+#define OPENCV_CUDAWARPING_HPP
#ifndef __cplusplus
# error cudawarping.hpp header must be compiled as C++
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_CUDAWARPING_HPP__ */
+#endif /* OPENCV_CUDAWARPING_HPP */
#pragma once
-#ifndef __OPENCV_CUDEV_HPP__
-#define __OPENCV_CUDEV_HPP__
+#ifndef OPENCV_CUDEV_HPP
+#define OPENCV_CUDEV_HPP
#include "cudev/common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_BLOCK_BLOCK_HPP__
-#define __OPENCV_CUDEV_BLOCK_BLOCK_HPP__
+#ifndef OPENCV_CUDEV_BLOCK_BLOCK_HPP
+#define OPENCV_CUDEV_BLOCK_BLOCK_HPP
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_BLOCK_REDUCE_DETAIL_HPP__
-#define __OPENCV_CUDEV_BLOCK_REDUCE_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_BLOCK_REDUCE_DETAIL_HPP
+#define OPENCV_CUDEV_BLOCK_REDUCE_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_BLOCK_REDUCE_KEY_VAL_DETAIL_HPP__
-#define __OPENCV_CUDEV_BLOCK_REDUCE_KEY_VAL_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_BLOCK_REDUCE_KEY_VAL_DETAIL_HPP
+#define OPENCV_CUDEV_BLOCK_REDUCE_KEY_VAL_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_BLOCK_DYNAMIC_SMEM_HPP__
-#define __OPENCV_CUDEV_BLOCK_DYNAMIC_SMEM_HPP__
+#ifndef OPENCV_CUDEV_BLOCK_DYNAMIC_SMEM_HPP
+#define OPENCV_CUDEV_BLOCK_DYNAMIC_SMEM_HPP
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_BLOCK_REDUCE_HPP__
-#define __OPENCV_CUDEV_BLOCK_REDUCE_HPP__
+#ifndef OPENCV_CUDEV_BLOCK_REDUCE_HPP
+#define OPENCV_CUDEV_BLOCK_REDUCE_HPP
#include "../common.hpp"
#include "../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_BLOCK_SCAN_HPP__
-#define __OPENCV_CUDEV_BLOCK_SCAN_HPP__
+#ifndef OPENCV_CUDEV_BLOCK_SCAN_HPP
+#define OPENCV_CUDEV_BLOCK_SCAN_HPP
#include "../common.hpp"
#include "../warp/scan.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_BLOCK_VEC_DISTANCE_HPP__
-#define __OPENCV_CUDEV_BLOCK_VEC_DISTANCE_HPP__
+#ifndef OPENCV_CUDEV_BLOCK_VEC_DISTANCE_HPP
+#define OPENCV_CUDEV_BLOCK_VEC_DISTANCE_HPP
#include "../common.hpp"
#include "../functional/functional.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_COMMON_HPP__
-#define __OPENCV_CUDEV_COMMON_HPP__
+#ifndef OPENCV_CUDEV_COMMON_HPP
+#define OPENCV_CUDEV_COMMON_HPP
#include <cuda_runtime.h>
#include "opencv2/core/cuda.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_BINARY_FUNC_HPP__
-#define __OPENCV_CUDEV_EXPR_BINARY_FUNC_HPP__
+#ifndef OPENCV_CUDEV_EXPR_BINARY_FUNC_HPP
+#define OPENCV_CUDEV_EXPR_BINARY_FUNC_HPP
#include "../common.hpp"
#include "../util/type_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_BINARY_OP_HPP__
-#define __OPENCV_CUDEV_EXPR_BINARY_OP_HPP__
+#ifndef OPENCV_CUDEV_EXPR_BINARY_OP_HPP
+#define OPENCV_CUDEV_EXPR_BINARY_OP_HPP
#include "../common.hpp"
#include "../util/type_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_COLOR_HPP__
-#define __OPENCV_CUDEV_EXPR_COLOR_HPP__
+#ifndef OPENCV_CUDEV_EXPR_COLOR_HPP
+#define OPENCV_CUDEV_EXPR_COLOR_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_DERIV_HPP__
-#define __OPENCV_CUDEV_EXPR_DERIV_HPP__
+#ifndef OPENCV_CUDEV_EXPR_DERIV_HPP
+#define OPENCV_CUDEV_EXPR_DERIV_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_EXPR_HPP__
-#define __OPENCV_CUDEV_EXPR_EXPR_HPP__
+#ifndef OPENCV_CUDEV_EXPR_EXPR_HPP
+#define OPENCV_CUDEV_EXPR_EXPR_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_PER_ELEMENT_FUNC_HPP__
-#define __OPENCV_CUDEV_EXPR_PER_ELEMENT_FUNC_HPP__
+#ifndef OPENCV_CUDEV_EXPR_PER_ELEMENT_FUNC_HPP
+#define OPENCV_CUDEV_EXPR_PER_ELEMENT_FUNC_HPP
#include "../common.hpp"
#include "../util/type_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_REDUCTION_HPP__
-#define __OPENCV_CUDEV_EXPR_REDUCTION_HPP__
+#ifndef OPENCV_CUDEV_EXPR_REDUCTION_HPP
+#define OPENCV_CUDEV_EXPR_REDUCTION_HPP
#include "../common.hpp"
#include "../grid/reduce.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_UNARY_FUNC_HPP__
-#define __OPENCV_CUDEV_EXPR_UNARY_FUNC_HPP__
+#ifndef OPENCV_CUDEV_EXPR_UNARY_FUNC_HPP
+#define OPENCV_CUDEV_EXPR_UNARY_FUNC_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_UNARY_OP_HPP__
-#define __OPENCV_CUDEV_EXPR_UNARY_OP_HPP__
+#ifndef OPENCV_CUDEV_EXPR_UNARY_OP_HPP
+#define OPENCV_CUDEV_EXPR_UNARY_OP_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_EXPR_WARPING_HPP__
-#define __OPENCV_CUDEV_EXPR_WARPING_HPP__
+#ifndef OPENCV_CUDEV_EXPR_WARPING_HPP
+#define OPENCV_CUDEV_EXPR_WARPING_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_FUNCTIONAL_COLOR_CVT_HPP__
-#define __OPENCV_CUDEV_FUNCTIONAL_COLOR_CVT_HPP__
+#ifndef OPENCV_CUDEV_FUNCTIONAL_COLOR_CVT_HPP
+#define OPENCV_CUDEV_FUNCTIONAL_COLOR_CVT_HPP
#include "../common.hpp"
#include "detail/color_cvt.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_FUNCTIONAL_COLOR_CVT_DETAIL_HPP__
-#define __OPENCV_CUDEV_FUNCTIONAL_COLOR_CVT_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_FUNCTIONAL_COLOR_CVT_DETAIL_HPP
+#define OPENCV_CUDEV_FUNCTIONAL_COLOR_CVT_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_FUNCTIONAL_FUNCTIONAL_HPP__
-#define __OPENCV_CUDEV_FUNCTIONAL_FUNCTIONAL_HPP__
+#ifndef OPENCV_CUDEV_FUNCTIONAL_FUNCTIONAL_HPP
+#define OPENCV_CUDEV_FUNCTIONAL_FUNCTIONAL_HPP
#include "../common.hpp"
#include "../util/saturate_cast.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_FUNCTIONAL_TUPLE_ADAPTER_HPP__
-#define __OPENCV_CUDEV_FUNCTIONAL_TUPLE_ADAPTER_HPP__
+#ifndef OPENCV_CUDEV_FUNCTIONAL_TUPLE_ADAPTER_HPP
+#define OPENCV_CUDEV_FUNCTIONAL_TUPLE_ADAPTER_HPP
#include "../common.hpp"
#include "../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_COPY_HPP__
-#define __OPENCV_CUDEV_GRID_COPY_HPP__
+#ifndef OPENCV_CUDEV_GRID_COPY_HPP
+#define OPENCV_CUDEV_GRID_COPY_HPP
#include "../common.hpp"
#include "../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_COPY_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_COPY_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_COPY_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_COPY_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_HISTOGRAM_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_HISTOGRAM_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_HISTOGRAM_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_HISTOGRAM_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/atomic.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_INTEGRAL_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_INTEGRAL_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_INTEGRAL_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_INTEGRAL_DETAIL_HPP
#include "../../common.hpp"
#include "../../warp/shuffle.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_MINMAXLOC_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_MINMAXLOC_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_MINMAXLOC_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_MINMAXLOC_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_PYR_DOWN_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_PYR_DOWN_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_PYR_DOWN_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_PYR_DOWN_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_PYR_UP_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_PYR_UP_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_PYR_UP_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_PYR_UP_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_REDUCE_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_REDUCE_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_REDUCE_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_REDUCE_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_REDUCE_TO_COLUMN_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_REDUCE_TO_COLUMN_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_REDUCE_TO_COLUMN_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_REDUCE_TO_COLUMN_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/saturate_cast.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_REDUCE_TO_ROW_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_REDUCE_TO_ROW_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_REDUCE_TO_ROW_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_REDUCE_TO_ROW_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/saturate_cast.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_SPLIT_MERGE_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_SPLIT_MERGE_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_SPLIT_MERGE_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_SPLIT_MERGE_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/saturate_cast.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_TRANSFORM_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_TRANSFORM_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_TRANSFORM_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_TRANSFORM_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_TRANSPOSE_DETAIL_HPP__
-#define __OPENCV_CUDEV_GRID_TRANSPOSE_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_GRID_TRANSPOSE_DETAIL_HPP
+#define OPENCV_CUDEV_GRID_TRANSPOSE_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/saturate_cast.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_HISTOGRAM_HPP__
-#define __OPENCV_CUDEV_GRID_HISTOGRAM_HPP__
+#ifndef OPENCV_CUDEV_GRID_HISTOGRAM_HPP
+#define OPENCV_CUDEV_GRID_HISTOGRAM_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_INTEGRAL_HPP__
-#define __OPENCV_CUDEV_GRID_INTEGRAL_HPP__
+#ifndef OPENCV_CUDEV_GRID_INTEGRAL_HPP
+#define OPENCV_CUDEV_GRID_INTEGRAL_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_PYRAMIDS_HPP__
-#define __OPENCV_CUDEV_GRID_PYRAMIDS_HPP__
+#ifndef OPENCV_CUDEV_GRID_PYRAMIDS_HPP
+#define OPENCV_CUDEV_GRID_PYRAMIDS_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_REDUCE_HPP__
-#define __OPENCV_CUDEV_GRID_REDUCE_HPP__
+#ifndef OPENCV_CUDEV_GRID_REDUCE_HPP
+#define OPENCV_CUDEV_GRID_REDUCE_HPP
#include <limits>
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_REDUCE_TO_VEC_HPP__
-#define __OPENCV_CUDEV_GRID_REDUCE_TO_VEC_HPP__
+#ifndef OPENCV_CUDEV_GRID_REDUCE_TO_VEC_HPP
+#define OPENCV_CUDEV_GRID_REDUCE_TO_VEC_HPP
#include "../common.hpp"
#include "../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_SPLIT_MERGE_HPP__
-#define __OPENCV_CUDEV_GRID_SPLIT_MERGE_HPP__
+#ifndef OPENCV_CUDEV_GRID_SPLIT_MERGE_HPP
+#define OPENCV_CUDEV_GRID_SPLIT_MERGE_HPP
#include "../common.hpp"
#include "../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_TRANSFORM_HPP__
-#define __OPENCV_CUDEV_GRID_TRANSFORM_HPP__
+#ifndef OPENCV_CUDEV_GRID_TRANSFORM_HPP
+#define OPENCV_CUDEV_GRID_TRANSFORM_HPP
#include "../common.hpp"
#include "../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_GRID_TRANSPOSE_HPP__
-#define __OPENCV_CUDEV_GRID_TRANSPOSE_HPP__
+#ifndef OPENCV_CUDEV_GRID_TRANSPOSE_HPP
+#define OPENCV_CUDEV_GRID_TRANSPOSE_HPP
#include "../common.hpp"
#include "../ptr2d/traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_CONSTANT_HPP__
-#define __OPENCV_CUDEV_PTR2D_CONSTANT_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_CONSTANT_HPP
+#define OPENCV_CUDEV_PTR2D_CONSTANT_HPP
#include "../common.hpp"
#include "traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_DERIV_HPP__
-#define __OPENCV_CUDEV_PTR2D_DERIV_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_DERIV_HPP
+#define OPENCV_CUDEV_PTR2D_DERIV_HPP
#include "../common.hpp"
#include "../grid/copy.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_GPUMAT_DETAIL_HPP__
-#define __OPENCV_CUDEV_PTR2D_GPUMAT_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_GPUMAT_DETAIL_HPP
+#define OPENCV_CUDEV_PTR2D_GPUMAT_DETAIL_HPP
#include "../gpumat.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_EXTRAPOLATION_HPP__
-#define __OPENCV_CUDEV_PTR2D_EXTRAPOLATION_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_EXTRAPOLATION_HPP
+#define OPENCV_CUDEV_PTR2D_EXTRAPOLATION_HPP
#include "../common.hpp"
#include "../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_GLOB_HPP__
-#define __OPENCV_CUDEV_PTR2D_GLOB_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_GLOB_HPP
+#define OPENCV_CUDEV_PTR2D_GLOB_HPP
#include "../common.hpp"
#include "traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_GPUMAT_HPP__
-#define __OPENCV_CUDEV_PTR2D_GPUMAT_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_GPUMAT_HPP
+#define OPENCV_CUDEV_PTR2D_GPUMAT_HPP
#include "../common.hpp"
#include "../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_INTERPOLATION_HPP__
-#define __OPENCV_CUDEV_PTR2D_INTERPOLATION_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_INTERPOLATION_HPP
+#define OPENCV_CUDEV_PTR2D_INTERPOLATION_HPP
#include "../common.hpp"
#include "../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_LUT_HPP__
-#define __OPENCV_CUDEV_PTR2D_LUT_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_LUT_HPP
+#define OPENCV_CUDEV_PTR2D_LUT_HPP
#include "../common.hpp"
#include "../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_MASK_HPP__
-#define __OPENCV_CUDEV_PTR2D_MASK_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_MASK_HPP
+#define OPENCV_CUDEV_PTR2D_MASK_HPP
#include "../common.hpp"
#include "traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_REMAP_HPP__
-#define __OPENCV_CUDEV_PTR2D_REMAP_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_REMAP_HPP
+#define OPENCV_CUDEV_PTR2D_REMAP_HPP
#include "opencv2/core/base.hpp"
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_RESIZE_HPP__
-#define __OPENCV_CUDEV_PTR2D_RESIZE_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_RESIZE_HPP
+#define OPENCV_CUDEV_PTR2D_RESIZE_HPP
#include "opencv2/core/base.hpp"
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_TEXTURE_HPP__
-#define __OPENCV_CUDEV_PTR2D_TEXTURE_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_TEXTURE_HPP
+#define OPENCV_CUDEV_PTR2D_TEXTURE_HPP
#include <cstring>
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_TRAITS_HPP__
-#define __OPENCV_CUDEV_PTR2D_TRAITS_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_TRAITS_HPP
+#define OPENCV_CUDEV_PTR2D_TRAITS_HPP
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_TRANSFORM_HPP__
-#define __OPENCV_CUDEV_PTR2D_TRANSFORM_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_TRANSFORM_HPP
+#define OPENCV_CUDEV_PTR2D_TRANSFORM_HPP
#include "../common.hpp"
#include "../grid/copy.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_WARPING_HPP__
-#define __OPENCV_CUDEV_PTR2D_WARPING_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_WARPING_HPP
+#define OPENCV_CUDEV_PTR2D_WARPING_HPP
#include "../common.hpp"
#include "traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_PTR2D_ZIP_HPP__
-#define __OPENCV_CUDEV_PTR2D_ZIP_HPP__
+#ifndef OPENCV_CUDEV_PTR2D_ZIP_HPP
+#define OPENCV_CUDEV_PTR2D_ZIP_HPP
#include "../common.hpp"
#include "../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_ATOMIC_HPP__
-#define __OPENCV_CUDEV_UTIL_ATOMIC_HPP__
+#ifndef OPENCV_CUDEV_UTIL_ATOMIC_HPP
+#define OPENCV_CUDEV_UTIL_ATOMIC_HPP
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_TUPLE_DETAIL_HPP__
-#define __OPENCV_CUDEV_UTIL_TUPLE_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_UTIL_TUPLE_DETAIL_HPP
+#define OPENCV_CUDEV_UTIL_TUPLE_DETAIL_HPP
#include <thrust/tuple.h>
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_TYPE_TRAITS_DETAIL_HPP__
-#define __OPENCV_CUDEV_UTIL_TYPE_TRAITS_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_UTIL_TYPE_TRAITS_DETAIL_HPP
+#define OPENCV_CUDEV_UTIL_TYPE_TRAITS_DETAIL_HPP
#include "../../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_LIMITS_HPP__
-#define __OPENCV_CUDEV_UTIL_LIMITS_HPP__
+#ifndef OPENCV_CUDEV_UTIL_LIMITS_HPP
+#define OPENCV_CUDEV_UTIL_LIMITS_HPP
#include <limits.h>
#include <float.h>
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_SATURATE_CAST_HPP__
-#define __OPENCV_CUDEV_UTIL_SATURATE_CAST_HPP__
+#ifndef OPENCV_CUDEV_UTIL_SATURATE_CAST_HPP
+#define OPENCV_CUDEV_UTIL_SATURATE_CAST_HPP
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_SIMD_FUNCTIONS_HPP__
-#define __OPENCV_CUDEV_UTIL_SIMD_FUNCTIONS_HPP__
+#ifndef OPENCV_CUDEV_UTIL_SIMD_FUNCTIONS_HPP
+#define OPENCV_CUDEV_UTIL_SIMD_FUNCTIONS_HPP
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_TUPLE_HPP__
-#define __OPENCV_CUDEV_UTIL_TUPLE_HPP__
+#ifndef OPENCV_CUDEV_UTIL_TUPLE_HPP
+#define OPENCV_CUDEV_UTIL_TUPLE_HPP
#include "../common.hpp"
#include "detail/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_TYPE_TRAITS_HPP__
-#define __OPENCV_CUDEV_UTIL_TYPE_TRAITS_HPP__
+#ifndef OPENCV_CUDEV_UTIL_TYPE_TRAITS_HPP
+#define OPENCV_CUDEV_UTIL_TYPE_TRAITS_HPP
#include "../common.hpp"
#include "vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_VEC_MATH_HPP__
-#define __OPENCV_CUDEV_UTIL_VEC_MATH_HPP__
+#ifndef OPENCV_CUDEV_UTIL_VEC_MATH_HPP
+#define OPENCV_CUDEV_UTIL_VEC_MATH_HPP
#include "vec_traits.hpp"
#include "saturate_cast.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_UTIL_VEC_TRAITS_HPP__
-#define __OPENCV_CUDEV_UTIL_VEC_TRAITS_HPP__
+#ifndef OPENCV_CUDEV_UTIL_VEC_TRAITS_HPP
+#define OPENCV_CUDEV_UTIL_VEC_TRAITS_HPP
#include "../common.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_WARP_REDUCE_DETAIL_HPP__
-#define __OPENCV_CUDEV_WARP_REDUCE_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_WARP_REDUCE_DETAIL_HPP
+#define OPENCV_CUDEV_WARP_REDUCE_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_WARP_REDUCE_KEY_VAL_DETAIL_HPP__
-#define __OPENCV_CUDEV_WARP_REDUCE_KEY_VAL_DETAIL_HPP__
+#ifndef OPENCV_CUDEV_WARP_REDUCE_KEY_VAL_DETAIL_HPP
+#define OPENCV_CUDEV_WARP_REDUCE_KEY_VAL_DETAIL_HPP
#include "../../common.hpp"
#include "../../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_WARP_REDUCE_HPP__
-#define __OPENCV_CUDEV_WARP_REDUCE_HPP__
+#ifndef OPENCV_CUDEV_WARP_REDUCE_HPP
+#define OPENCV_CUDEV_WARP_REDUCE_HPP
#include "../common.hpp"
#include "../util/tuple.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_WARP_SCAN_HPP__
-#define __OPENCV_CUDEV_WARP_SCAN_HPP__
+#ifndef OPENCV_CUDEV_WARP_SCAN_HPP
+#define OPENCV_CUDEV_WARP_SCAN_HPP
#include "../common.hpp"
#include "warp.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_WARP_SHUFFLE_HPP__
-#define __OPENCV_CUDEV_WARP_SHUFFLE_HPP__
+#ifndef OPENCV_CUDEV_WARP_SHUFFLE_HPP
+#define OPENCV_CUDEV_WARP_SHUFFLE_HPP
#include "../common.hpp"
#include "../util/vec_traits.hpp"
#pragma once
-#ifndef __OPENCV_CUDEV_WARP_WARP_HPP__
-#define __OPENCV_CUDEV_WARP_WARP_HPP__
+#ifndef OPENCV_CUDEV_WARP_WARP_HPP
+#define OPENCV_CUDEV_WARP_WARP_HPP
#include "../common.hpp"
//
//M*/
-#ifndef __OPENCV_FEATURES_2D_HPP__
-#define __OPENCV_FEATURES_2D_HPP__
+#ifndef OPENCV_FEATURES_2D_HPP
+#define OPENCV_FEATURES_2D_HPP
#include "opencv2/core.hpp"
#include "opencv2/flann/miniflann.hpp"
//
//M*/
-#ifndef _OPENCV_FLANN_HPP_
-#define _OPENCV_FLANN_HPP_
+#ifndef OPENCV_FLANN_HPP
+#define OPENCV_FLANN_HPP
#include "opencv2/core.hpp"
#include "opencv2/flann/miniflann.hpp"
//
//M*/
-#ifndef _OPENCV_MINIFLANN_HPP_
-#define _OPENCV_MINIFLANN_HPP_
+#ifndef OPENCV_MINIFLANN_HPP
+#define OPENCV_MINIFLANN_HPP
#include "opencv2/core.hpp"
#include "opencv2/flann/defines.h"
-#ifndef _OPENCV_FLANN_PRECOMP_HPP_
-#define _OPENCV_FLANN_PRECOMP_HPP_
+#ifndef OPENCV_FLANN_PRECOMP_HPP
+#define OPENCV_FLANN_PRECOMP_HPP
#include <cstdio>
#include <cstdarg>
# endif
#endif
-#ifndef __OPENCV_TEST_PRECOMP_HPP__
-#define __OPENCV_TEST_PRECOMP_HPP__
+#ifndef OPENCV_TEST_PRECOMP_HPP
+#define OPENCV_TEST_PRECOMP_HPP
#include "opencv2/ts.hpp"
#include "opencv2/flann.hpp"
//
//M*/
-#ifndef __OPENCV_HIGHGUI_HPP__
-#define __OPENCV_HIGHGUI_HPP__
+#ifndef OPENCV_HIGHGUI_HPP
+#define OPENCV_HIGHGUI_HPP
#include "opencv2/core.hpp"
#include "opencv2/imgcodecs.hpp"
//
//M*/
-#ifndef __OPENCV_HIGHGUI_H__
-#define __OPENCV_HIGHGUI_H__
+#ifndef OPENCV_HIGHGUI_H
+#define OPENCV_HIGHGUI_H
#include "opencv2/core/core_c.h"
#include "opencv2/imgproc/imgproc_c.h"
//
//M*/
-#ifndef __OPENCV_IMGCODECS_HPP__
-#define __OPENCV_IMGCODECS_HPP__
+#ifndef OPENCV_IMGCODECS_HPP
+#define OPENCV_IMGCODECS_HPP
#include "opencv2/core.hpp"
} // cv
-#endif //__OPENCV_IMGCODECS_HPP__
+#endif //OPENCV_IMGCODECS_HPP
//
//M*/
-#ifndef __OPENCV_IMGCODECS_H__
-#define __OPENCV_IMGCODECS_H__
+#ifndef OPENCV_IMGCODECS_H
+#define OPENCV_IMGCODECS_H
#include "opencv2/core/core_c.h"
}
#endif
-#endif // __OPENCV_IMGCODECS_H__
+#endif // OPENCV_IMGCODECS_H
//
//M*/
-#ifndef __OPENCV_IMGPROC_HPP__
-#define __OPENCV_IMGPROC_HPP__
+#ifndef OPENCV_IMGPROC_HPP
+#define OPENCV_IMGPROC_HPP
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP__
-#define __OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP__
+#ifndef OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP
+#define OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP
//! @cond IGNORED
//! @endcond
-#endif // __OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP__
+#endif // OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP
//
//M*/
-#ifndef __OPENCV_IMGPROC_IMGPROC_C_H__
-#define __OPENCV_IMGPROC_IMGPROC_C_H__
+#ifndef OPENCV_IMGPROC_IMGPROC_C_H
+#define OPENCV_IMGPROC_IMGPROC_C_H
#include "opencv2/imgproc/types_c.h"
//
//M*/
-#ifndef __OPENCV_IMGPROC_TYPES_C_H__
-#define __OPENCV_IMGPROC_TYPES_C_H__
+#ifndef OPENCV_IMGPROC_TYPES_C_H
+#define OPENCV_IMGPROC_TYPES_C_H
#include "opencv2/core/core_c.h"
//
//M*/
-#ifndef __OPENCV_ML_HPP__
-#define __OPENCV_ML_HPP__
+#ifndef OPENCV_ML_HPP
+#define OPENCV_ML_HPP
#ifdef __cplusplus
# include "opencv2/core.hpp"
}
#endif // __cplusplus
-#endif // __OPENCV_ML_HPP__
+#endif // OPENCV_ML_HPP
/* End of file. */
//
//M*/
-#ifndef __OPENCV_OBJDETECT_HPP__
-#define __OPENCV_OBJDETECT_HPP__
+#ifndef OPENCV_OBJDETECT_HPP
+#define OPENCV_OBJDETECT_HPP
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_OBJDETECT_DBT_HPP__
-#define __OPENCV_OBJDETECT_DBT_HPP__
+#ifndef OPENCV_OBJDETECT_DBT_HPP
+#define OPENCV_OBJDETECT_DBT_HPP
// After this condition removal update blacklist for bindings: modules/python/common.cmake
#if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(__ANDROID__) || \
//
//M*/
-#ifndef __OPENCV_OBJDETECT_C_H__
-#define __OPENCV_OBJDETECT_C_H__
+#ifndef OPENCV_OBJDETECT_C_H
+#define OPENCV_OBJDETECT_C_H
#include "opencv2/core/core_c.h"
#endif
-#endif /* __OPENCV_OBJDETECT_C_H__ */
+#endif /* OPENCV_OBJDETECT_C_H */
//
//M*/
-#ifndef __OPENCV_PHOTO_HPP__
-#define __OPENCV_PHOTO_HPP__
+#ifndef OPENCV_PHOTO_HPP
+#define OPENCV_PHOTO_HPP
#include "opencv2/core.hpp"
#include "opencv2/imgproc.hpp"
//
//M*/
-#ifndef __OPENCV_PHOTO_CUDA_HPP__
-#define __OPENCV_PHOTO_CUDA_HPP__
+#ifndef OPENCV_PHOTO_CUDA_HPP
+#define OPENCV_PHOTO_CUDA_HPP
#include "opencv2/core/cuda.hpp"
}} // namespace cv { namespace cuda {
-#endif /* __OPENCV_PHOTO_CUDA_HPP__ */
+#endif /* OPENCV_PHOTO_CUDA_HPP */
//
//M*/
-#ifndef __OPENCV_PHOTO_C_H__
-#define __OPENCV_PHOTO_C_H__
+#ifndef OPENCV_PHOTO_C_H
+#define OPENCV_PHOTO_C_H
#include "opencv2/core/core_c.h"
} //extern "C"
#endif
-#endif //__OPENCV_PHOTO_C_H__
+#endif //OPENCV_PHOTO_C_H
//
//M*/
-#ifndef __OPENCV_SHAPE_HPP__
-#define __OPENCV_SHAPE_HPP__
+#ifndef OPENCV_SHAPE_HPP
+#define OPENCV_SHAPE_HPP
#include "opencv2/shape/emdL1.hpp"
#include "opencv2/shape/shape_transformer.hpp"
//
//M*/
-#ifndef __OPENCV_EMD_L1_HPP__
-#define __OPENCV_EMD_L1_HPP__
+#ifndef OPENCV_EMD_L1_HPP
+#define OPENCV_EMD_L1_HPP
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_HIST_COST_HPP__
-#define __OPENCV_HIST_COST_HPP__
+#ifndef OPENCV_HIST_COST_HPP
+#define OPENCV_HIST_COST_HPP
#include "opencv2/imgproc.hpp"
//
//M*/
-#ifndef __OPENCV_SHAPE_SHAPE_DISTANCE_HPP__
-#define __OPENCV_SHAPE_SHAPE_DISTANCE_HPP__
+#ifndef OPENCV_SHAPE_SHAPE_DISTANCE_HPP
+#define OPENCV_SHAPE_SHAPE_DISTANCE_HPP
#include "opencv2/core.hpp"
#include "opencv2/shape/hist_cost.hpp"
#include "opencv2/shape/shape_transformer.hpp"
//
//M*/
-#ifndef __OPENCV_SHAPE_SHAPE_TRANSFORM_HPP__
-#define __OPENCV_SHAPE_SHAPE_TRANSFORM_HPP__
+#ifndef OPENCV_SHAPE_SHAPE_TRANSFORM_HPP
+#define OPENCV_SHAPE_SHAPE_TRANSFORM_HPP
#include <vector>
#include "opencv2/core.hpp"
#include "opencv2/imgproc.hpp"
//
//M*/
-#ifndef __OPENCV_STITCHING_STITCHER_HPP__
-#define __OPENCV_STITCHING_STITCHER_HPP__
+#ifndef OPENCV_STITCHING_STITCHER_HPP
+#define OPENCV_STITCHING_STITCHER_HPP
#include "opencv2/core.hpp"
#include "opencv2/features2d.hpp"
} // namespace cv
-#endif // __OPENCV_STITCHING_STITCHER_HPP__
+#endif // OPENCV_STITCHING_STITCHER_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_AUTOCALIB_HPP__
-#define __OPENCV_STITCHING_AUTOCALIB_HPP__
+#ifndef OPENCV_STITCHING_AUTOCALIB_HPP
+#define OPENCV_STITCHING_AUTOCALIB_HPP
#include "opencv2/core.hpp"
#include "matchers.hpp"
} // namespace detail
} // namespace cv
-#endif // __OPENCV_STITCHING_AUTOCALIB_HPP__
+#endif // OPENCV_STITCHING_AUTOCALIB_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_BLENDERS_HPP__
-#define __OPENCV_STITCHING_BLENDERS_HPP__
+#ifndef OPENCV_STITCHING_BLENDERS_HPP
+#define OPENCV_STITCHING_BLENDERS_HPP
#if defined(NO)
# warning Detected Apple 'NO' macro definition, it can cause build conflicts. Please, include this header before any Apple headers.
} // namespace detail
} // namespace cv
-#endif // __OPENCV_STITCHING_BLENDERS_HPP__
+#endif // OPENCV_STITCHING_BLENDERS_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_CAMERA_HPP__
-#define __OPENCV_STITCHING_CAMERA_HPP__
+#ifndef OPENCV_STITCHING_CAMERA_HPP
+#define OPENCV_STITCHING_CAMERA_HPP
#include "opencv2/core.hpp"
} // namespace detail
} // namespace cv
-#endif // #ifndef __OPENCV_STITCHING_CAMERA_HPP__
+#endif // #ifndef OPENCV_STITCHING_CAMERA_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP__
-#define __OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP__
+#ifndef OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP
+#define OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP
#if defined(NO)
# warning Detected Apple 'NO' macro definition, it can cause build conflicts. Please, include this header before any Apple headers.
} // namespace detail
} // namespace cv
-#endif // __OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP__
+#endif // OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_MATCHERS_HPP__
-#define __OPENCV_STITCHING_MATCHERS_HPP__
+#ifndef OPENCV_STITCHING_MATCHERS_HPP
+#define OPENCV_STITCHING_MATCHERS_HPP
#include "opencv2/core.hpp"
#include "opencv2/features2d.hpp"
} // namespace detail
} // namespace cv
-#endif // __OPENCV_STITCHING_MATCHERS_HPP__
+#endif // OPENCV_STITCHING_MATCHERS_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_MOTION_ESTIMATORS_HPP__
-#define __OPENCV_STITCHING_MOTION_ESTIMATORS_HPP__
+#ifndef OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
+#define OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
#include "opencv2/core.hpp"
#include "matchers.hpp"
} // namespace detail
} // namespace cv
-#endif // __OPENCV_STITCHING_MOTION_ESTIMATORS_HPP__
+#endif // OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_SEAM_FINDERS_HPP__
-#define __OPENCV_STITCHING_SEAM_FINDERS_HPP__
+#ifndef OPENCV_STITCHING_SEAM_FINDERS_HPP
+#define OPENCV_STITCHING_SEAM_FINDERS_HPP
#include <set>
#include "opencv2/core.hpp"
} // namespace detail
} // namespace cv
-#endif // __OPENCV_STITCHING_SEAM_FINDERS_HPP__
+#endif // OPENCV_STITCHING_SEAM_FINDERS_HPP
//M*/
-#ifndef __OPENCV_STITCHING_TIMELAPSERS_HPP__
-#define __OPENCV_STITCHING_TIMELAPSERS_HPP__
+#ifndef OPENCV_STITCHING_TIMELAPSERS_HPP
+#define OPENCV_STITCHING_TIMELAPSERS_HPP
#include "opencv2/core.hpp"
} // namespace detail
} // namespace cv
-#endif // __OPENCV_STITCHING_TIMELAPSERS_HPP__
+#endif // OPENCV_STITCHING_TIMELAPSERS_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_UTIL_HPP__
-#define __OPENCV_STITCHING_UTIL_HPP__
+#ifndef OPENCV_STITCHING_UTIL_HPP
+#define OPENCV_STITCHING_UTIL_HPP
#include <list>
#include "opencv2/core.hpp"
#include "util_inl.hpp"
-#endif // __OPENCV_STITCHING_UTIL_HPP__
+#endif // OPENCV_STITCHING_UTIL_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_UTIL_INL_HPP__
-#define __OPENCV_STITCHING_UTIL_INL_HPP__
+#ifndef OPENCV_STITCHING_UTIL_INL_HPP
+#define OPENCV_STITCHING_UTIL_INL_HPP
#include <queue>
#include "opencv2/core.hpp"
//! @endcond
-#endif // __OPENCV_STITCHING_UTIL_INL_HPP__
+#endif // OPENCV_STITCHING_UTIL_INL_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_WARPERS_HPP__
-#define __OPENCV_STITCHING_WARPERS_HPP__
+#ifndef OPENCV_STITCHING_WARPERS_HPP
+#define OPENCV_STITCHING_WARPERS_HPP
#include "opencv2/core.hpp"
#include "opencv2/core/cuda.hpp"
#include "warpers_inl.hpp"
-#endif // __OPENCV_STITCHING_WARPERS_HPP__
+#endif // OPENCV_STITCHING_WARPERS_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_WARPERS_INL_HPP__
-#define __OPENCV_STITCHING_WARPERS_INL_HPP__
+#ifndef OPENCV_STITCHING_WARPERS_INL_HPP
+#define OPENCV_STITCHING_WARPERS_INL_HPP
#include "opencv2/core.hpp"
#include "warpers.hpp" // Make your IDE see declarations
//! @endcond
-#endif // __OPENCV_STITCHING_WARPERS_INL_HPP__
+#endif // OPENCV_STITCHING_WARPERS_INL_HPP
//
//M*/
-#ifndef __OPENCV_STITCHING_WARPER_CREATORS_HPP__
-#define __OPENCV_STITCHING_WARPER_CREATORS_HPP__
+#ifndef OPENCV_STITCHING_WARPER_CREATORS_HPP
+#define OPENCV_STITCHING_WARPER_CREATORS_HPP
#include "opencv2/stitching/detail/warpers.hpp"
} // namespace cv
-#endif // __OPENCV_STITCHING_WARPER_CREATORS_HPP__
+#endif // OPENCV_STITCHING_WARPER_CREATORS_HPP
//
//M*/
-#ifndef __OPENCV_SUPERRES_HPP__
-#define __OPENCV_SUPERRES_HPP__
+#ifndef OPENCV_SUPERRES_HPP
+#define OPENCV_SUPERRES_HPP
#include "opencv2/core.hpp"
#include "opencv2/superres/optical_flow.hpp"
}
}
-#endif // __OPENCV_SUPERRES_HPP__
+#endif // OPENCV_SUPERRES_HPP
//
//M*/
-#ifndef __OPENCV_SUPERRES_OPTICAL_FLOW_HPP__
-#define __OPENCV_SUPERRES_OPTICAL_FLOW_HPP__
+#ifndef OPENCV_SUPERRES_OPTICAL_FLOW_HPP
+#define OPENCV_SUPERRES_OPTICAL_FLOW_HPP
#include "opencv2/core.hpp"
}
}
-#endif // __OPENCV_SUPERRES_OPTICAL_FLOW_HPP__
+#endif // OPENCV_SUPERRES_OPTICAL_FLOW_HPP
-#ifndef __OPENCV_GTESTCV_HPP__
-#define __OPENCV_GTESTCV_HPP__
+#ifndef OPENCV_GTESTCV_HPP
+#define OPENCV_GTESTCV_HPP
#include "opencv2/core/cvdef.h"
#include <stdarg.h> // for va_list
//
//M*/
-#ifndef __OPENCV_CUDA_PERF_UTILITY_HPP__
-#define __OPENCV_CUDA_PERF_UTILITY_HPP__
+#ifndef OPENCV_CUDA_PERF_UTILITY_HPP
+#define OPENCV_CUDA_PERF_UTILITY_HPP
#include "opencv2/core.hpp"
#include "opencv2/imgcodecs.hpp"
#endif
}
-#endif // __OPENCV_CUDA_PERF_UTILITY_HPP__
+#endif // OPENCV_CUDA_PERF_UTILITY_HPP
//
//M*/
-#ifndef __OPENCV_CUDA_TEST_UTILITY_HPP__
-#define __OPENCV_CUDA_TEST_UTILITY_HPP__
+#ifndef OPENCV_CUDA_TEST_UTILITY_HPP
+#define OPENCV_CUDA_TEST_UTILITY_HPP
#include <stdexcept>
#include "cvconfig.h"
#endif // HAVE_CUDA
-#endif // __OPENCV_CUDA_TEST_UTILITY_HPP__
+#endif // OPENCV_CUDA_TEST_UTILITY_HPP
//
//M*/
-#ifndef __OPENCV_TS_OCL_PERF_HPP__
-#define __OPENCV_TS_OCL_PERF_HPP__
+#ifndef OPENCV_TS_OCL_PERF_HPP
+#define OPENCV_TS_OCL_PERF_HPP
#include "ocl_test.hpp"
#include "ts_perf.hpp"
} // namespace cvtest::ocl
} // namespace cvtest
-#endif // __OPENCV_TS_OCL_PERF_HPP__
+#endif // OPENCV_TS_OCL_PERF_HPP
//
//M*/
-#ifndef __OPENCV_TS_OCL_TEST_HPP__
-#define __OPENCV_TS_OCL_TEST_HPP__
+#ifndef OPENCV_TS_OCL_TEST_HPP
+#define OPENCV_TS_OCL_TEST_HPP
#include "opencv2/opencv_modules.hpp"
} } // namespace cvtest::ocl
-#endif // __OPENCV_TS_OCL_TEST_HPP__
+#endif // OPENCV_TS_OCL_TEST_HPP
// Copyright (C) 2014, Intel, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
-#ifndef __OPENCV_TS_EXT_HPP__
-#define __OPENCV_TS_EXT_HPP__
+#ifndef OPENCV_TS_EXT_HPP
+#define OPENCV_TS_EXT_HPP
void checkIppStatus();
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() { cv::ipp::setIppStatus(0); Body(); checkIppStatus(); } \
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::Body()
-#endif // __OPENCV_TS_EXT_HPP__
+#endif // OPENCV_TS_EXT_HPP
-#ifndef __OPENCV_TS_PERF_HPP__
-#define __OPENCV_TS_PERF_HPP__
+#ifndef OPENCV_TS_PERF_HPP
+#define OPENCV_TS_PERF_HPP
#include "opencv2/core.hpp"
#include "ts_gtest.h"
void CV_EXPORTS sort(std::vector<cv::KeyPoint>& pts, cv::InputOutputArray descriptors);
} //namespace perf
-#endif //__OPENCV_TS_PERF_HPP__
+#endif //OPENCV_TS_PERF_HPP
//
//M*/
-#ifndef __OPENCV_VIDEO_HPP__
-#define __OPENCV_VIDEO_HPP__
+#ifndef OPENCV_VIDEO_HPP
+#define OPENCV_VIDEO_HPP
/**
@defgroup video Video Analysis
#include "opencv2/video/tracking_c.h"
#endif
-#endif //__OPENCV_VIDEO_HPP__
+#endif //OPENCV_VIDEO_HPP
//
//M*/
-#ifndef __OPENCV_BACKGROUND_SEGM_HPP__
-#define __OPENCV_BACKGROUND_SEGM_HPP__
+#ifndef OPENCV_BACKGROUND_SEGM_HPP
+#define OPENCV_BACKGROUND_SEGM_HPP
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_TRACKING_HPP__
-#define __OPENCV_TRACKING_HPP__
+#ifndef OPENCV_TRACKING_HPP
+#define OPENCV_TRACKING_HPP
#include "opencv2/core.hpp"
#include "opencv2/imgproc.hpp"
//
//M*/
-#ifndef __OPENCV_TRACKING_C_H__
-#define __OPENCV_TRACKING_C_H__
+#ifndef OPENCV_TRACKING_C_H
+#define OPENCV_TRACKING_C_H
#include "opencv2/imgproc/types_c.h"
#endif
-#endif // __OPENCV_TRACKING_C_H__
+#endif // OPENCV_TRACKING_C_H
//
//M*/
-#ifndef __OPENCV_VIDEOIO_HPP__
-#define __OPENCV_VIDEOIO_HPP__
+#ifndef OPENCV_VIDEOIO_HPP
+#define OPENCV_VIDEOIO_HPP
#include "opencv2/core.hpp"
} // cv
-#endif //__OPENCV_VIDEOIO_HPP__
+#endif //OPENCV_VIDEOIO_HPP
//
//M*/
-#ifndef __OPENCV_VIDEOIO_H__
-#define __OPENCV_VIDEOIO_H__
+#ifndef OPENCV_VIDEOIO_H
+#define OPENCV_VIDEOIO_H
#include "opencv2/core/core_c.h"
}
#endif
-#endif //__OPENCV_VIDEOIO_H__
+#endif //OPENCV_VIDEOIO_H
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_HPP__
-#define __OPENCV_VIDEOSTAB_HPP__
+#ifndef OPENCV_VIDEOSTAB_HPP
+#define OPENCV_VIDEOSTAB_HPP
/**
@defgroup videostab Video Stabilization
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_DEBLURRING_HPP__
-#define __OPENCV_VIDEOSTAB_DEBLURRING_HPP__
+#ifndef OPENCV_VIDEOSTAB_DEBLURRING_HPP
+#define OPENCV_VIDEOSTAB_DEBLURRING_HPP
#include <vector>
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_FAST_MARCHING_HPP__
-#define __OPENCV_VIDEOSTAB_FAST_MARCHING_HPP__
+#ifndef OPENCV_VIDEOSTAB_FAST_MARCHING_HPP
+#define OPENCV_VIDEOSTAB_FAST_MARCHING_HPP
#include <cmath>
#include <queue>
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_FAST_MARCHING_INL_HPP__
-#define __OPENCV_VIDEOSTAB_FAST_MARCHING_INL_HPP__
+#ifndef OPENCV_VIDEOSTAB_FAST_MARCHING_INL_HPP
+#define OPENCV_VIDEOSTAB_FAST_MARCHING_INL_HPP
#include "opencv2/videostab/fast_marching.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_FRAME_SOURCE_HPP__
-#define __OPENCV_VIDEOSTAB_FRAME_SOURCE_HPP__
+#ifndef OPENCV_VIDEOSTAB_FRAME_SOURCE_HPP
+#define OPENCV_VIDEOSTAB_FRAME_SOURCE_HPP
#include <vector>
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_GLOBAL_MOTION_HPP__
-#define __OPENCV_VIDEOSTAB_GLOBAL_MOTION_HPP__
+#ifndef OPENCV_VIDEOSTAB_GLOBAL_MOTION_HPP
+#define OPENCV_VIDEOSTAB_GLOBAL_MOTION_HPP
#include <vector>
#include <fstream>
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_INPAINTINT_HPP__
-#define __OPENCV_VIDEOSTAB_INPAINTINT_HPP__
+#ifndef OPENCV_VIDEOSTAB_INPAINTINT_HPP
+#define OPENCV_VIDEOSTAB_INPAINTINT_HPP
#include <vector>
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_LOG_HPP__
-#define __OPENCV_VIDEOSTAB_LOG_HPP__
+#ifndef OPENCV_VIDEOSTAB_LOG_HPP
+#define OPENCV_VIDEOSTAB_LOG_HPP
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_MOTION_CORE_HPP__
-#define __OPENCV_VIDEOSTAB_MOTION_CORE_HPP__
+#ifndef OPENCV_VIDEOSTAB_MOTION_CORE_HPP
+#define OPENCV_VIDEOSTAB_MOTION_CORE_HPP
#include <cmath>
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP__
-#define __OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP__
+#ifndef OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP
+#define OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP
#include <vector>
#include <utility>
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_OPTICAL_FLOW_HPP__
-#define __OPENCV_VIDEOSTAB_OPTICAL_FLOW_HPP__
+#ifndef OPENCV_VIDEOSTAB_OPTICAL_FLOW_HPP
+#define OPENCV_VIDEOSTAB_OPTICAL_FLOW_HPP
#include "opencv2/core.hpp"
#include "opencv2/opencv_modules.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_OUTLIER_REJECTION_HPP__
-#define __OPENCV_VIDEOSTAB_OUTLIER_REJECTION_HPP__
+#ifndef OPENCV_VIDEOSTAB_OUTLIER_REJECTION_HPP
+#define OPENCV_VIDEOSTAB_OUTLIER_REJECTION_HPP
#include <vector>
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_RING_BUFFER_HPP__
-#define __OPENCV_VIDEOSTAB_RING_BUFFER_HPP__
+#ifndef OPENCV_VIDEOSTAB_RING_BUFFER_HPP
+#define OPENCV_VIDEOSTAB_RING_BUFFER_HPP
#include <vector>
#include "opencv2/imgproc.hpp"
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_STABILIZER_HPP__
-#define __OPENCV_VIDEOSTAB_STABILIZER_HPP__
+#ifndef OPENCV_VIDEOSTAB_STABILIZER_HPP
+#define OPENCV_VIDEOSTAB_STABILIZER_HPP
#include <vector>
#include <ctime>
//
//M*/
-#ifndef __OPENCV_VIDEOSTAB_WOBBLE_SUPPRESSION_HPP__
-#define __OPENCV_VIDEOSTAB_WOBBLE_SUPPRESSION_HPP__
+#ifndef OPENCV_VIDEOSTAB_WOBBLE_SUPPRESSION_HPP
+#define OPENCV_VIDEOSTAB_WOBBLE_SUPPRESSION_HPP
#include <vector>
#include "opencv2/core.hpp"
//
//M*/
-#ifndef __OPENCV_VIZ_HPP__
-#define __OPENCV_VIZ_HPP__
+#ifndef OPENCV_VIZ_HPP
+#define OPENCV_VIZ_HPP
#include <opencv2/viz/types.hpp>
#include <opencv2/viz/widgets.hpp>
@}
*/
-#endif /* __OPENCV_VIZ_HPP__ */
+#endif /* OPENCV_VIZ_HPP */
//
//M*/
-#ifndef __OPENCV_VIZ_TYPES_HPP__
-#define __OPENCV_VIZ_TYPES_HPP__
+#ifndef OPENCV_VIZ_TYPES_HPP
+#define OPENCV_VIZ_TYPES_HPP
#include <string>
#include <opencv2/core.hpp>
//
//M*/
-#ifndef __OPENCV_VIZ_VIZ3D_HPP__
-#define __OPENCV_VIZ_VIZ3D_HPP__
+#ifndef OPENCV_VIZ_VIZ3D_HPP
+#define OPENCV_VIZ_VIZ3D_HPP
#if !defined YES_I_AGREE_THAT_VIZ_API_IS_NOT_STABLE_NOW_AND_BINARY_COMPARTIBILITY_WONT_BE_SUPPORTED && !defined CVAPI_EXPORTS
//#error "Viz is in beta state now. Please define macro above to use it"
//
//M*/
-#ifndef __OPENCV_VIZCORE_HPP__
-#define __OPENCV_VIZCORE_HPP__
+#ifndef OPENCV_VIZCORE_HPP
+#define OPENCV_VIZCORE_HPP
#include <opencv2/viz/types.hpp>
#include <opencv2/viz/widgets.hpp>
} /* namespace viz */
} /* namespace cv */
-#endif /* __OPENCV_VIZCORE_HPP__ */
+#endif /* OPENCV_VIZCORE_HPP */
//
//M*/
-#ifndef __OPENCV_VIZ_WIDGET_ACCESSOR_HPP__
-#define __OPENCV_VIZ_WIDGET_ACCESSOR_HPP__
+#ifndef OPENCV_VIZ_WIDGET_ACCESSOR_HPP
+#define OPENCV_VIZ_WIDGET_ACCESSOR_HPP
#include <opencv2/core/cvdef.h>
#include <vtkSmartPointer.h>
//
//M*/
-#ifndef __OPENCV_VIZ_WIDGETS_HPP__
-#define __OPENCV_VIZ_WIDGETS_HPP__
+#ifndef OPENCV_VIZ_WIDGETS_HPP
+#define OPENCV_VIZ_WIDGETS_HPP
#include <opencv2/viz/types.hpp>
//
//M*/
-#ifndef __OPENCV_WORLD_HPP__
-#define __OPENCV_WORLD_HPP__
+#ifndef OPENCV_WORLD_HPP
+#define OPENCV_WORLD_HPP
#include "opencv2/core.hpp"