| /*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) 2000-2008, Intel Corporation, all rights reserved. | |
| // Copyright (C) 2009, Willow Garage Inc., all rights reserved. | |
| // 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*/ | |
| // import useful primitives from stl | |
| namespace cv | |
| { | |
| static inline uchar abs(uchar a) { return a; } | |
| static inline ushort abs(ushort a) { return a; } | |
| static inline unsigned abs(unsigned a) { return a; } | |
| static inline uint64 abs(uint64 a) { return a; } | |
| using std::min; | |
| using std::max; | |
| using std::abs; | |
| using std::swap; | |
| using std::sqrt; | |
| using std::exp; | |
| using std::pow; | |
| using std::log; | |
| } | |
| namespace cv { | |
| //! @addtogroup core_utils | |
| //! @{ | |
| //////////////////////////// memory management functions //////////////////////////// | |
| /** @brief Allocates an aligned memory buffer. | |
| The function allocates the buffer of the specified size and returns it. When the buffer size is 16 | |
| bytes or more, the returned buffer is aligned to 16 bytes. | |
| @param bufSize Allocated buffer size. | |
| */ | |
| CV_EXPORTS void* fastMalloc(size_t bufSize); | |
| /** @brief Deallocates a memory buffer. | |
| The function deallocates the buffer allocated with fastMalloc . If NULL pointer is passed, the | |
| function does nothing. C version of the function clears the pointer *pptr* to avoid problems with | |
| double memory deallocation. | |
| @param ptr Pointer to the allocated buffer. | |
| */ | |
| CV_EXPORTS void fastFree(void* ptr); | |
| /*! | |
| The STL-compliant memory Allocator based on cv::fastMalloc() and cv::fastFree() | |
| */ | |
| template<typename _Tp> class Allocator | |
| { | |
| public: | |
| typedef _Tp value_type; | |
| typedef value_type* pointer; | |
| typedef const value_type* const_pointer; | |
| typedef value_type& reference; | |
| typedef const value_type& const_reference; | |
| typedef size_t size_type; | |
| typedef ptrdiff_t difference_type; | |
| template<typename U> class rebind { typedef Allocator<U> other; }; | |
| explicit Allocator() {} | |
| ~Allocator() {} | |
| explicit Allocator(Allocator const&) {} | |
| template<typename U> | |
| explicit Allocator(Allocator<U> const&) {} | |
| // address | |
| pointer address(reference r) { return &r; } | |
| const_pointer address(const_reference r) { return &r; } | |
| pointer allocate(size_type count, const void* =0) { return reinterpret_cast<pointer>(fastMalloc(count * sizeof (_Tp))); } | |
| void deallocate(pointer p, size_type) { fastFree(p); } | |
| void construct(pointer p, const _Tp& v) { new(static_cast<void*>(p)) _Tp(v); } | |
| void destroy(pointer p) { p->~_Tp(); } | |
| size_type max_size() const { return cv::max(static_cast<_Tp>(-1)/sizeof(_Tp), 1); } | |
| }; | |
| //! @} core_utils | |
| //! @addtogroup core_basic | |
| //! @{ | |
| //////////////////////////////// string class //////////////////////////////// | |
| class CV_EXPORTS FileNode; //for string constructor from FileNode | |
| typedef std::string String; | |
| //! @cond IGNORED | |
| namespace details { | |
| // std::tolower is int->int | |
| static inline char char_tolower(char ch) | |
| { | |
| return (char)std::tolower((int)ch); | |
| } | |
| // std::toupper is int->int | |
| static inline char char_toupper(char ch) | |
| { | |
| return (char)std::toupper((int)ch); | |
| } | |
| } // namespace details | |
| //! @endcond | |
| static inline std::string toLowerCase(const std::string& str) | |
| { | |
| std::string result(str); | |
| std::transform(result.begin(), result.end(), result.begin(), details::char_tolower); | |
| return result; | |
| } | |
| static inline std::string toUpperCase(const std::string& str) | |
| { | |
| std::string result(str); | |
| std::transform(result.begin(), result.end(), result.begin(), details::char_toupper); | |
| return result; | |
| } | |
| //! @} core_basic | |
| } // cv | |