├── bin └── data │ ├── .gitkeep │ ├── Icon.png │ ├── Default.png │ ├── Icon-72.png │ ├── Icon@2x.png │ ├── Default@2x.png │ ├── Icon-72@2x.png │ ├── Default~ipad.png │ ├── targetA1_480.jpg │ ├── targetA2_480.jpg │ ├── Default@2x~ipad.png │ ├── Default~iphone.png │ ├── Default@2x~iphone.png │ ├── Default-568h@2x~iphone.png │ └── markers.yml ├── lib └── opencv2.framework │ ├── Versions │ ├── Current │ └── A │ │ ├── opencv2 │ │ ├── Headers │ │ ├── flann │ │ │ ├── dummy.h │ │ │ ├── config.h │ │ │ ├── general.h │ │ │ ├── timer.h │ │ │ ├── sampling.h │ │ │ ├── object_factory.h │ │ │ ├── params.h │ │ │ ├── ground_truth.h │ │ │ ├── matrix.h │ │ │ ├── linear_index.h │ │ │ ├── logger.h │ │ │ ├── random.h │ │ │ ├── heap.h │ │ │ ├── dynamic_bitset.h │ │ │ ├── defines.h │ │ │ ├── simplex_downhill.h │ │ │ ├── all_indices.h │ │ │ ├── saving.h │ │ │ ├── miniflann.hpp │ │ │ ├── nn_index.h │ │ │ └── composite_index.h │ │ ├── opencv_modules.hpp │ │ ├── core │ │ │ ├── devmem2d.hpp │ │ │ └── version.hpp │ │ ├── videostab │ │ │ ├── videostab.hpp │ │ │ ├── log.hpp │ │ │ ├── frame_source.hpp │ │ │ ├── fast_marching.hpp │ │ │ ├── motion_stabilizing.hpp │ │ │ ├── deblurring.hpp │ │ │ ├── optical_flow.hpp │ │ │ ├── global_motion.hpp │ │ │ └── fast_marching_inl.hpp │ │ ├── world │ │ │ └── world.hpp │ │ ├── nonfree │ │ │ ├── nonfree.hpp │ │ │ └── features2d.hpp │ │ ├── video │ │ │ └── video.hpp │ │ ├── photo │ │ │ ├── photo_c.h │ │ │ └── photo.hpp │ │ ├── opencv.hpp │ │ ├── stitching │ │ │ ├── detail │ │ │ │ ├── camera.hpp │ │ │ │ ├── autocalib.hpp │ │ │ │ ├── util_inl.hpp │ │ │ │ ├── exposure_compensate.hpp │ │ │ │ ├── blenders.hpp │ │ │ │ └── util.hpp │ │ │ └── warpers.hpp │ │ ├── contrib │ │ │ └── detection_based_tracker.hpp │ │ ├── legacy │ │ │ └── streams.hpp │ │ └── highgui │ │ │ └── cap_ios.h │ │ └── Resources │ │ └── Info.plist │ ├── Headers │ ├── opencv2 │ └── Resources ├── .gitignore ├── src ├── main.mm ├── ofApp.h └── ofApp.mm ├── Project.xcconfig ├── README.md ├── LICENSE └── ofxiOS-Info.plist /bin/data/.gitkeep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/Current: -------------------------------------------------------------------------------- 1 | A -------------------------------------------------------------------------------- /lib/opencv2.framework/Headers: -------------------------------------------------------------------------------- 1 | Versions/A/Headers -------------------------------------------------------------------------------- /lib/opencv2.framework/opencv2: -------------------------------------------------------------------------------- 1 | Versions/A/opencv2 -------------------------------------------------------------------------------- /lib/opencv2.framework/Resources: -------------------------------------------------------------------------------- 1 | Versions/A/Resources -------------------------------------------------------------------------------- /bin/data/Icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Icon.png -------------------------------------------------------------------------------- /bin/data/Default.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Default.png -------------------------------------------------------------------------------- /bin/data/Icon-72.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Icon-72.png -------------------------------------------------------------------------------- /bin/data/Icon@2x.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Icon@2x.png -------------------------------------------------------------------------------- /bin/data/Default@2x.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Default@2x.png -------------------------------------------------------------------------------- /bin/data/Icon-72@2x.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Icon-72@2x.png -------------------------------------------------------------------------------- /bin/data/Default~ipad.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Default~ipad.png -------------------------------------------------------------------------------- /bin/data/targetA1_480.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/targetA1_480.jpg -------------------------------------------------------------------------------- /bin/data/targetA2_480.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/targetA2_480.jpg -------------------------------------------------------------------------------- /bin/data/Default@2x~ipad.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Default@2x~ipad.png -------------------------------------------------------------------------------- /bin/data/Default~iphone.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Default~iphone.png -------------------------------------------------------------------------------- /bin/data/Default@2x~iphone.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Default@2x~iphone.png -------------------------------------------------------------------------------- /bin/data/Default-568h@2x~iphone.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/bin/data/Default-568h@2x~iphone.png -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/opencv2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/royshil/ofxNaturalFeatureTracker/master/lib/opencv2.framework/Versions/A/opencv2 -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/dummy.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef OPENCV_FLANN_DUMMY_H_ 3 | #define OPENCV_FLANN_DUMMY_H_ 4 | 5 | namespace cvflann 6 | { 7 | 8 | #if (defined WIN32 || defined _WIN32 || defined WINCE) && defined CVAPI_EXPORTS 9 | __declspec(dllexport) 10 | #endif 11 | void dummyfunc(); 12 | 13 | } 14 | 15 | 16 | #endif /* OPENCV_FLANN_DUMMY_H_ */ 17 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | *.xcodeproj 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | 22 | # Compiled Static libraries 23 | *.lai 24 | *.la 25 | *.a 26 | *.lib 27 | 28 | # Executables 29 | *.exe 30 | *.out 31 | *.app 32 | -------------------------------------------------------------------------------- /src/main.mm: -------------------------------------------------------------------------------- 1 | #include "ofMain.h" 2 | #include "ofApp.h" 3 | 4 | int main(){ 5 | 6 | // ofAppiOSWindow * window = new ofAppiOSWindow(); 7 | // window->enableRendererES2(); // ofxiOSVideoWriter only works properly using ES2 renderer, because it needs shaders on iOS. 8 | // window->enableDepthBuffer(); 9 | // window->enableRetina(); 10 | 11 | // ofSetupOpenGL(window, 1024, 768, OF_FULLSCREEN); 12 | ofSetupOpenGL(1024, 768, OF_FULLSCREEN); 13 | 14 | ofRunApp(new ofApp); 15 | } 16 | -------------------------------------------------------------------------------- /Project.xcconfig: -------------------------------------------------------------------------------- 1 | //THE PATH TO THE ROOT OF OUR OF PATH RELATIVE TO THIS PROJECT. 2 | //THIS NEEDS TO BE DEFINED BEFORE CoreOF.xcconfig IS INCLUDED 3 | OF_PATH = ../../.. 4 | 5 | //THIS HAS ALL THE HEADER AND LIBS FOR OF CORE 6 | #include "../../../libs/openFrameworksCompiled/project/ios/CoreOF.xcconfig" 7 | 8 | OTHER_LDFLAGS = $(OF_CORE_LIBS) 9 | HEADER_SEARCH_PATHS = $(OF_CORE_HEADERS) 10 | 11 | COMPRESS_PNG_FILES = NO 12 | GCC_THUMB_SUPPORT = NO 13 | IPHONEOS_DEPLOYMENT_TARGET = 3.1 14 | TARGETED_DEVICE_FAMILY = 1 15 | -------------------------------------------------------------------------------- /bin/data/markers.yml: -------------------------------------------------------------------------------- 1 | %YAML:1.0 2 | marker_files: 3 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetA1.jpg" 4 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetA2.jpg" 5 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetA3.jpg" 6 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetB1.jpg" 7 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetB2.jpg" 8 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetB3.jpg" 9 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetC1.jpg" 10 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetC2.jpg" 11 | - "/Users/roy_shilkrot/Dropbox/ImageTracker/targetC3.jpg" 12 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Resources/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleName 6 | OpenCV 7 | CFBundleIdentifier 8 | com.itseez.opencv 9 | CFBundleVersion 10 | 2.4 11 | CFBundleShortVersionString 12 | 2.4 13 | CFBundleSignature 14 | ???? 15 | CFBundlePackageType 16 | FMWK 17 | 18 | 19 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/opencv_modules.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * ** File generated automatically, do not modify ** 3 | * 4 | * This file defines the list of modules available in current build configuration 5 | * 6 | * 7 | */ 8 | 9 | #define HAVE_OPENCV_CALIB3D 10 | #define HAVE_OPENCV_CONTRIB 11 | #define HAVE_OPENCV_CORE 12 | #define HAVE_OPENCV_FEATURES2D 13 | #define HAVE_OPENCV_FLANN 14 | #define HAVE_OPENCV_HIGHGUI 15 | #define HAVE_OPENCV_IMGPROC 16 | #define HAVE_OPENCV_LEGACY 17 | #define HAVE_OPENCV_ML 18 | #define HAVE_OPENCV_NONFREE 19 | #define HAVE_OPENCV_OBJDETECT 20 | #define HAVE_OPENCV_PHOTO 21 | #define HAVE_OPENCV_STITCHING 22 | #define HAVE_OPENCV_VIDEO 23 | #define HAVE_OPENCV_VIDEOSTAB 24 | #define HAVE_OPENCV_WORLD 25 | 26 | 27 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ofxNaturalFeatureTracker 2 | A natural features image tracker, detector and Augmented Reality engine. An alternatve to the proprietary AR engine from Qualcomm used in ofxQCAR. 3 | 4 | ## Building and Using 5 | 6 | Import the ImageTrackerLib.h and ImageTrackerLib.mm files to your oF project. 7 | 8 | See the example in ofApp.mm to understand how the tracker works. 9 | The API is rather similar to ofxQCAR. 10 | 11 | Remember to also add (drag) opencv2.framework to your project. It is compiled only for armv7 iOS devices, and is version 2.4.3 (version 2.4.10 did not compile properly for iOS). 12 | OpenCV can be compiled for all iOS version including the simulator by downloading the desired 2.4.X from the repo (for example https://github.com/Itseez/opencv/tree/2.4.3) and running the iOS framework build script in ‘ios/build_framework.py’. -------------------------------------------------------------------------------- /src/ofApp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "ofMain.h" 4 | #include "ofxiOS.h" 5 | #include "ofxiOSExtras.h" 6 | 7 | #include 8 | #import 9 | using namespace cv; 10 | 11 | 12 | #include "ImageTrackerLib.h" 13 | 14 | using namespace ImageTrackerLib; 15 | 16 | class ofApp : public ofxiOSApp{ 17 | ofPtr trackers; 18 | 19 | ofVideoGrabber grabber; 20 | 21 | public: 22 | void setup(); 23 | void update(); 24 | void draw(); 25 | void exit(); 26 | 27 | void touchDown(ofTouchEventArgs & touch); 28 | void touchMoved(ofTouchEventArgs & touch); 29 | void touchUp(ofTouchEventArgs & touch); 30 | void touchDoubleTap(ofTouchEventArgs & touch); 31 | void touchCancelled(ofTouchEventArgs & touch); 32 | 33 | void lostFocus(); 34 | void gotFocus(); 35 | void gotMemoryWarning(); 36 | void deviceOrientationChanged(int newOrientation); 37 | 38 | }; 39 | 40 | 41 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Roy Shilkrot 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /ofxiOS-Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleDisplayName 8 | ${PRODUCT_NAME} 9 | CFBundleExecutable 10 | ${EXECUTABLE_NAME} 11 | CFBundleIconFile 12 | 13 | CFBundleIcons 14 | 15 | CFBundlePrimaryIcon 16 | 17 | CFBundleIconFiles 18 | 19 | Icon.png 20 | Icon@2x.png 21 | 22 | 23 | 24 | CFBundleIdentifier 25 | ${PRODUCT_NAME:identifier} 26 | CFBundleInfoDictionaryVersion 27 | 6.0 28 | CFBundleName 29 | ${PRODUCT_NAME} 30 | CFBundlePackageType 31 | APPL 32 | CFBundleShortVersionString 33 | 1.0 34 | CFBundleSignature 35 | ???? 36 | CFBundleVersion 37 | 1.0 38 | LSRequiresIPhoneOS 39 | 40 | UIApplicationExitsOnSuspend 41 | 42 | UIStatusBarHidden 43 | 44 | UISupportedInterfaceOrientations 45 | 46 | UIInterfaceOrientationPortrait 47 | UIInterfaceOrientationPortraitUpsideDown 48 | UIInterfaceOrientationLandscapeLeft 49 | UIInterfaceOrientationLandscapeRight 50 | 51 | UISupportedInterfaceOrientations~ipad 52 | 53 | UIInterfaceOrientationLandscapeRight 54 | 55 | UIViewControllerBasedStatusBarAppearance 56 | 57 | 58 | 59 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/config.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2011 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2011 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 11 | * 1. Redistributions of source code must retain the above copyright 12 | * notice, this list of conditions and the following disclaimer. 13 | * 2. Redistributions in binary form must reproduce the above copyright 14 | * notice, this list of conditions and the following disclaimer in the 15 | * documentation and/or other materials provided with the distribution. 16 | * 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | *************************************************************************/ 28 | 29 | 30 | #ifndef OPENCV_FLANN_CONFIG_H_ 31 | #define OPENCV_FLANN_CONFIG_H_ 32 | 33 | #ifdef FLANN_VERSION_ 34 | #undef FLANN_VERSION_ 35 | #endif 36 | #define FLANN_VERSION_ "1.6.10" 37 | 38 | #endif /* OPENCV_FLANN_CONFIG_H_ */ 39 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/general.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_GENERAL_H_ 32 | #define OPENCV_FLANN_GENERAL_H_ 33 | 34 | #include "defines.h" 35 | #include 36 | #include 37 | 38 | namespace cvflann 39 | { 40 | 41 | class FLANNException : public std::runtime_error 42 | { 43 | public: 44 | FLANNException(const char* message) : std::runtime_error(message) { } 45 | 46 | FLANNException(const std::string& message) : std::runtime_error(message) { } 47 | }; 48 | 49 | } 50 | 51 | 52 | #endif /* OPENCV_FLANN_GENERAL_H_ */ 53 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/core/devmem2d.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other GpuMaterials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #include "opencv2/core/cuda_devptrs.hpp" 44 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/videostab.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_HPP__ 44 | #define __OPENCV_VIDEOSTAB_HPP__ 45 | 46 | #include "opencv2/videostab/stabilizer.hpp" 47 | 48 | #endif 49 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/world/world.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_WORLD_HPP__ 44 | #define __OPENCV_WORLD_HPP__ 45 | 46 | #include "opencv2/core/core.hpp" 47 | 48 | #ifdef __cplusplus 49 | namespace cv 50 | { 51 | 52 | CV_EXPORTS_W bool initAll(); 53 | 54 | } 55 | 56 | #endif 57 | 58 | #endif 59 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/nonfree/nonfree.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2012, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_NONFREE_HPP__ 44 | #define __OPENCV_NONFREE_HPP__ 45 | 46 | #include "opencv2/nonfree/features2d.hpp" 47 | 48 | namespace cv 49 | { 50 | 51 | CV_EXPORTS_W bool initModule_nonfree(); 52 | 53 | } 54 | 55 | #endif 56 | 57 | /* End of file. */ 58 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/video/video.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEO_HPP__ 44 | #define __OPENCV_VIDEO_HPP__ 45 | 46 | #include "opencv2/video/tracking.hpp" 47 | #include "opencv2/video/background_segm.hpp" 48 | 49 | #ifdef __cplusplus 50 | namespace cv 51 | { 52 | 53 | CV_EXPORTS bool initModule_video(void); 54 | 55 | } 56 | #endif 57 | 58 | #endif //__OPENCV_VIDEO_HPP__ 59 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/core/version.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // Intel License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright( C) 2000, Intel Corporation, all rights reserved. 14 | // Third party copyrights are property of their respective owners. 15 | // 16 | // Redistribution and use in source and binary forms, with or without modification, 17 | // are permitted provided that the following conditions are met: 18 | // 19 | // * Redistribution's of source code must retain the above copyright notice, 20 | // this list of conditions and the following disclaimer. 21 | // 22 | // * Redistribution's in binary form must reproduce the above copyright notice, 23 | // this list of conditions and the following disclaimer in the documentation 24 | // and/or other materials provided with the distribution. 25 | // 26 | // * The name of Intel Corporation may not be used to endorse or promote products 27 | // derived from this software without specific prior written permission. 28 | // 29 | // This software is provided by the copyright holders and contributors "as is" and 30 | // any express or implied warranties, including, but not limited to, the implied 31 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 32 | // In no event shall the Intel Corporation or contributors be liable for any direct, 33 | // indirect, incidental, special, exemplary, or consequential damages 34 | //(including, but not limited to, procurement of substitute goods or services; 35 | // loss of use, data, or profits; or business interruption) however caused 36 | // and on any theory of liability, whether in contract, strict liability, 37 | // or tort(including negligence or otherwise) arising in any way out of 38 | // the use of this software, even if advised of the possibility of such damage. 39 | // 40 | //M*/ 41 | 42 | /* 43 | definition of the current version of OpenCV 44 | Usefull to test in user programs 45 | */ 46 | 47 | #ifndef __OPENCV_VERSION_HPP__ 48 | #define __OPENCV_VERSION_HPP__ 49 | 50 | #define CV_MAJOR_VERSION 2 51 | #define CV_MINOR_VERSION 4 52 | #define CV_SUBMINOR_VERSION 3 53 | 54 | #define CVAUX_STR_EXP(__A) #__A 55 | #define CVAUX_STR(__A) CVAUX_STR_EXP(__A) 56 | #define CV_VERSION CVAUX_STR(CV_MAJOR_VERSION) "." CVAUX_STR(CV_MINOR_VERSION) "." CVAUX_STR(CV_SUBMINOR_VERSION) 57 | 58 | #endif 59 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/timer.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_TIMER_H 32 | #define OPENCV_FLANN_TIMER_H 33 | 34 | #include 35 | 36 | 37 | namespace cvflann 38 | { 39 | 40 | /** 41 | * A start-stop timer class. 42 | * 43 | * Can be used to time portions of code. 44 | */ 45 | class StartStopTimer 46 | { 47 | clock_t startTime; 48 | 49 | public: 50 | /** 51 | * Value of the timer. 52 | */ 53 | double value; 54 | 55 | 56 | /** 57 | * Constructor. 58 | */ 59 | StartStopTimer() 60 | { 61 | reset(); 62 | } 63 | 64 | /** 65 | * Starts the timer. 66 | */ 67 | void start() 68 | { 69 | startTime = clock(); 70 | } 71 | 72 | /** 73 | * Stops the timer and updates timer value. 74 | */ 75 | void stop() 76 | { 77 | clock_t stopTime = clock(); 78 | value += ( (double)stopTime - startTime) / CLOCKS_PER_SEC; 79 | } 80 | 81 | /** 82 | * Resets the timer value to 0. 83 | */ 84 | void reset() 85 | { 86 | value = 0; 87 | } 88 | 89 | }; 90 | 91 | } 92 | 93 | #endif // FLANN_TIMER_H 94 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/photo/photo_c.h: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_PHOTO_C_H__ 44 | #define __OPENCV_PHOTO_C_H__ 45 | 46 | #include "opencv2/core/core_c.h" 47 | 48 | #ifdef __cplusplus 49 | extern "C" { 50 | #endif 51 | 52 | /* Inpainting algorithms */ 53 | enum 54 | { 55 | CV_INPAINT_NS =0, 56 | CV_INPAINT_TELEA =1 57 | }; 58 | 59 | 60 | /* Inpaints the selected region in the image */ 61 | CVAPI(void) cvInpaint( const CvArr* src, const CvArr* inpaint_mask, 62 | CvArr* dst, double inpaintRange, int flags ); 63 | 64 | 65 | #ifdef __cplusplus 66 | } //extern "C" 67 | #endif 68 | 69 | #endif //__OPENCV_PHOTO_C_H__ 70 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/opencv.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_ALL_HPP__ 44 | #define __OPENCV_ALL_HPP__ 45 | 46 | #include "opencv2/core/core_c.h" 47 | #include "opencv2/core/core.hpp" 48 | #include "opencv2/flann/miniflann.hpp" 49 | #include "opencv2/imgproc/imgproc_c.h" 50 | #include "opencv2/imgproc/imgproc.hpp" 51 | #include "opencv2/photo/photo.hpp" 52 | #include "opencv2/video/video.hpp" 53 | #include "opencv2/features2d/features2d.hpp" 54 | #include "opencv2/objdetect/objdetect.hpp" 55 | #include "opencv2/calib3d/calib3d.hpp" 56 | #include "opencv2/ml/ml.hpp" 57 | #include "opencv2/highgui/highgui_c.h" 58 | #include "opencv2/highgui/highgui.hpp" 59 | #include "opencv2/contrib/contrib.hpp" 60 | 61 | #endif 62 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/log.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_LOG_HPP__ 44 | #define __OPENCV_VIDEOSTAB_LOG_HPP__ 45 | 46 | #include "opencv2/core/core.hpp" 47 | 48 | namespace cv 49 | { 50 | namespace videostab 51 | { 52 | 53 | class CV_EXPORTS ILog 54 | { 55 | public: 56 | virtual ~ILog() {} 57 | virtual void print(const char *format, ...) = 0; 58 | }; 59 | 60 | class CV_EXPORTS NullLog : public ILog 61 | { 62 | public: 63 | virtual void print(const char * /*format*/, ...) {} 64 | }; 65 | 66 | class CV_EXPORTS LogToStdout : public ILog 67 | { 68 | public: 69 | virtual void print(const char *format, ...); 70 | }; 71 | 72 | } // namespace videostab 73 | } // namespace cv 74 | 75 | #endif 76 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/stitching/detail/camera.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_STITCHING_CAMERA_HPP__ 44 | #define __OPENCV_STITCHING_CAMERA_HPP__ 45 | 46 | #include "opencv2/core/core.hpp" 47 | 48 | namespace cv { 49 | namespace detail { 50 | 51 | struct CV_EXPORTS CameraParams 52 | { 53 | CameraParams(); 54 | CameraParams(const CameraParams& other); 55 | const CameraParams& operator =(const CameraParams& other); 56 | Mat K() const; 57 | 58 | double focal; // Focal length 59 | double aspect; // Aspect ratio 60 | double ppx; // Principal point X 61 | double ppy; // Principal point Y 62 | Mat R; // Rotation 63 | Mat t; // Translation 64 | }; 65 | 66 | } // namespace detail 67 | } // namespace cv 68 | 69 | #endif // #ifndef __OPENCV_STITCHING_CAMERA_HPP__ 70 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/sampling.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 11 | * 1. Redistributions of source code must retain the above copyright 12 | * notice, this list of conditions and the following disclaimer. 13 | * 2. Redistributions in binary form must reproduce the above copyright 14 | * notice, this list of conditions and the following disclaimer in the 15 | * documentation and/or other materials provided with the distribution. 16 | * 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | *************************************************************************/ 28 | 29 | 30 | #ifndef OPENCV_FLANN_SAMPLING_H_ 31 | #define OPENCV_FLANN_SAMPLING_H_ 32 | 33 | #include "matrix.h" 34 | #include "random.h" 35 | 36 | namespace cvflann 37 | { 38 | 39 | template 40 | Matrix random_sample(Matrix& srcMatrix, long size, bool remove = false) 41 | { 42 | Matrix newSet(new T[size * srcMatrix.cols], size,srcMatrix.cols); 43 | 44 | T* src,* dest; 45 | for (long i=0; i 63 | Matrix random_sample(const Matrix& srcMatrix, size_t size) 64 | { 65 | UniqueRandom rand((int)srcMatrix.rows); 66 | Matrix newSet(new T[size * srcMatrix.cols], size,srcMatrix.cols); 67 | 68 | T* src,* dest; 69 | for (size_t i=0; i &features, 57 | const std::vector &pairwise_matches, 58 | std::vector &focals); 59 | 60 | bool CV_EXPORTS calibrateRotatingCamera(const std::vector &Hs, Mat &K); 61 | 62 | } // namespace detail 63 | } // namespace cv 64 | 65 | #endif // __OPENCV_STITCHING_AUTOCALIB_HPP__ 66 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/object_factory.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_OBJECT_FACTORY_H_ 32 | #define OPENCV_FLANN_OBJECT_FACTORY_H_ 33 | 34 | #include 35 | 36 | namespace cvflann 37 | { 38 | 39 | class CreatorNotFound 40 | { 41 | }; 42 | 43 | template 46 | class ObjectFactory 47 | { 48 | typedef ObjectFactory ThisClass; 49 | typedef std::map ObjectRegistry; 50 | 51 | // singleton class, private constructor 52 | ObjectFactory() {} 53 | 54 | public: 55 | 56 | bool subscribe(UniqueIdType id, ObjectCreator creator) 57 | { 58 | if (object_registry.find(id) != object_registry.end()) return false; 59 | 60 | object_registry[id] = creator; 61 | return true; 62 | } 63 | 64 | bool unregister(UniqueIdType id) 65 | { 66 | return object_registry.erase(id) == 1; 67 | } 68 | 69 | ObjectCreator create(UniqueIdType id) 70 | { 71 | typename ObjectRegistry::const_iterator iter = object_registry.find(id); 72 | 73 | if (iter == object_registry.end()) { 74 | throw CreatorNotFound(); 75 | } 76 | 77 | return iter->second; 78 | } 79 | 80 | static ThisClass& instance() 81 | { 82 | static ThisClass the_factory; 83 | return the_factory; 84 | } 85 | private: 86 | ObjectRegistry object_registry; 87 | }; 88 | 89 | } 90 | 91 | #endif /* OPENCV_FLANN_OBJECT_FACTORY_H_ */ 92 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/frame_source.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_FRAME_SOURCE_HPP__ 44 | #define __OPENCV_VIDEOSTAB_FRAME_SOURCE_HPP__ 45 | 46 | #include 47 | #include 48 | #include "opencv2/core/core.hpp" 49 | #include "opencv2/highgui/highgui.hpp" 50 | 51 | namespace cv 52 | { 53 | namespace videostab 54 | { 55 | 56 | class CV_EXPORTS IFrameSource 57 | { 58 | public: 59 | virtual ~IFrameSource() {} 60 | virtual void reset() = 0; 61 | virtual Mat nextFrame() = 0; 62 | }; 63 | 64 | class CV_EXPORTS NullFrameSource : public IFrameSource 65 | { 66 | public: 67 | virtual void reset() {} 68 | virtual Mat nextFrame() { return Mat(); } 69 | }; 70 | 71 | class CV_EXPORTS VideoFileSource : public IFrameSource 72 | { 73 | public: 74 | VideoFileSource(const std::string &path, bool volatileFrame = false); 75 | 76 | virtual void reset(); 77 | virtual Mat nextFrame(); 78 | 79 | int frameCount() { return static_cast(reader_.get(CV_CAP_PROP_FRAME_COUNT)); } 80 | double fps() { return reader_.get(CV_CAP_PROP_FPS); } 81 | 82 | private: 83 | std::string path_; 84 | bool volatileFrame_; 85 | VideoCapture reader_; 86 | }; 87 | 88 | } // namespace videostab 89 | } // namespace cv 90 | 91 | #endif 92 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/params.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2011 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2011 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 11 | * 1. Redistributions of source code must retain the above copyright 12 | * notice, this list of conditions and the following disclaimer. 13 | * 2. Redistributions in binary form must reproduce the above copyright 14 | * notice, this list of conditions and the following disclaimer in the 15 | * documentation and/or other materials provided with the distribution. 16 | * 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | *************************************************************************/ 28 | 29 | 30 | #ifndef OPENCV_FLANN_PARAMS_H_ 31 | #define OPENCV_FLANN_PARAMS_H_ 32 | 33 | #include "any.h" 34 | #include "general.h" 35 | #include 36 | #include 37 | 38 | 39 | namespace cvflann 40 | { 41 | 42 | typedef std::map IndexParams; 43 | 44 | struct SearchParams : public IndexParams 45 | { 46 | SearchParams(int checks = 32, float eps = 0, bool sorted = true ) 47 | { 48 | // how many leafs to visit when searching for neighbours (-1 for unlimited) 49 | (*this)["checks"] = checks; 50 | // search for eps-approximate neighbours (default: 0) 51 | (*this)["eps"] = eps; 52 | // only for radius search, require neighbours sorted by distance (default: true) 53 | (*this)["sorted"] = sorted; 54 | } 55 | }; 56 | 57 | 58 | template 59 | T get_param(const IndexParams& params, std::string name, const T& default_value) 60 | { 61 | IndexParams::const_iterator it = params.find(name); 62 | if (it != params.end()) { 63 | return it->second.cast(); 64 | } 65 | else { 66 | return default_value; 67 | } 68 | } 69 | 70 | template 71 | T get_param(const IndexParams& params, std::string name) 72 | { 73 | IndexParams::const_iterator it = params.find(name); 74 | if (it != params.end()) { 75 | return it->second.cast(); 76 | } 77 | else { 78 | throw FLANNException(std::string("Missing parameter '")+name+std::string("' in the parameters given")); 79 | } 80 | } 81 | 82 | inline void print_params(const IndexParams& params) 83 | { 84 | IndexParams::const_iterator it; 85 | 86 | for(it=params.begin(); it!=params.end(); ++it) { 87 | std::cout << it->first << " : " << it->second << std::endl; 88 | } 89 | } 90 | 91 | 92 | 93 | } 94 | 95 | 96 | #endif /* OPENCV_FLANN_PARAMS_H_ */ 97 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/contrib/detection_based_tracker.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(ANDROID) 4 | 5 | #include 6 | #include 7 | 8 | #include 9 | 10 | class DetectionBasedTracker 11 | { 12 | public: 13 | struct Parameters 14 | { 15 | int minObjectSize; 16 | int maxObjectSize; 17 | double scaleFactor; 18 | int maxTrackLifetime; 19 | int minNeighbors; 20 | int minDetectionPeriod; //the minimal time between run of the big object detector (on the whole frame) in ms (1000 mean 1 sec), default=0 21 | 22 | Parameters(); 23 | }; 24 | 25 | DetectionBasedTracker(const std::string& cascadeFilename, const Parameters& params); 26 | virtual ~DetectionBasedTracker(); 27 | 28 | virtual bool run(); 29 | virtual void stop(); 30 | virtual void resetTracking(); 31 | 32 | virtual void process(const cv::Mat& imageGray); 33 | 34 | bool setParameters(const Parameters& params); 35 | const Parameters& getParameters(); 36 | 37 | 38 | typedef std::pair Object; 39 | virtual void getObjects(std::vector& result) const; 40 | virtual void getObjects(std::vector& result) const; 41 | 42 | protected: 43 | class SeparateDetectionWork; 44 | cv::Ptr separateDetectionWork; 45 | friend void* workcycleObjectDetectorFunction(void* p); 46 | 47 | 48 | struct InnerParameters 49 | { 50 | int numLastPositionsToTrack; 51 | int numStepsToWaitBeforeFirstShow; 52 | int numStepsToTrackWithoutDetectingIfObjectHasNotBeenShown; 53 | int numStepsToShowWithoutDetecting; 54 | 55 | float coeffTrackingWindowSize; 56 | float coeffObjectSizeToTrack; 57 | float coeffObjectSpeedUsingInPrediction; 58 | 59 | InnerParameters(); 60 | }; 61 | Parameters parameters; 62 | InnerParameters innerParameters; 63 | 64 | struct TrackedObject 65 | { 66 | typedef std::vector PositionsVector; 67 | 68 | PositionsVector lastPositions; 69 | 70 | int numDetectedFrames; 71 | int numFramesNotDetected; 72 | int id; 73 | 74 | TrackedObject(const cv::Rect& rect):numDetectedFrames(1), numFramesNotDetected(0) 75 | { 76 | lastPositions.push_back(rect); 77 | id=getNextId(); 78 | }; 79 | 80 | static int getNextId() 81 | { 82 | static int _id=0; 83 | return _id++; 84 | } 85 | }; 86 | 87 | int numTrackedSteps; 88 | std::vector trackedObjects; 89 | 90 | std::vector weightsPositionsSmoothing; 91 | std::vector weightsSizesSmoothing; 92 | 93 | cv::CascadeClassifier cascadeForTracking; 94 | 95 | 96 | void updateTrackedObjects(const std::vector& detectedObjects); 97 | cv::Rect calcTrackedObjectPositionToShow(int i) const; 98 | void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector& detectedObjectsInRegions); 99 | }; 100 | 101 | namespace cv 102 | { 103 | using ::DetectionBasedTracker; 104 | } //end of cv namespace 105 | 106 | #endif 107 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/ground_truth.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_GROUND_TRUTH_H_ 32 | #define OPENCV_FLANN_GROUND_TRUTH_H_ 33 | 34 | #include "dist.h" 35 | #include "matrix.h" 36 | 37 | 38 | namespace cvflann 39 | { 40 | 41 | template 42 | void find_nearest(const Matrix& dataset, typename Distance::ElementType* query, int* matches, int nn, 43 | int skip = 0, Distance distance = Distance()) 44 | { 45 | typedef typename Distance::ElementType ElementType; 46 | typedef typename Distance::ResultType DistanceType; 47 | int n = nn + skip; 48 | 49 | std::vector match(n); 50 | std::vector dists(n); 51 | 52 | dists[0] = distance(dataset[0], query, dataset.cols); 53 | match[0] = 0; 54 | int dcnt = 1; 55 | 56 | for (size_t i=1; i=1 && dists[j] 84 | void compute_ground_truth(const Matrix& dataset, const Matrix& testset, Matrix& matches, 85 | int skip=0, Distance d = Distance()) 86 | { 87 | for (size_t i=0; i(dataset, testset[i], matches[i], (int)matches.cols, skip, d); 89 | } 90 | } 91 | 92 | 93 | } 94 | 95 | #endif //OPENCV_FLANN_GROUND_TRUTH_H_ 96 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/matrix.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_DATASET_H_ 32 | #define OPENCV_FLANN_DATASET_H_ 33 | 34 | #include 35 | 36 | #include "general.h" 37 | 38 | namespace cvflann 39 | { 40 | 41 | /** 42 | * Class that implements a simple rectangular matrix stored in a memory buffer and 43 | * provides convenient matrix-like access using the [] operators. 44 | */ 45 | template 46 | class Matrix 47 | { 48 | public: 49 | typedef T type; 50 | 51 | size_t rows; 52 | size_t cols; 53 | size_t stride; 54 | T* data; 55 | 56 | Matrix() : rows(0), cols(0), stride(0), data(NULL) 57 | { 58 | } 59 | 60 | Matrix(T* data_, size_t rows_, size_t cols_, size_t stride_ = 0) : 61 | rows(rows_), cols(cols_), stride(stride_), data(data_) 62 | { 63 | if (stride==0) stride = cols; 64 | } 65 | 66 | /** 67 | * Convenience function for deallocating the storage data. 68 | */ 69 | FLANN_DEPRECATED void free() 70 | { 71 | fprintf(stderr, "The cvflann::Matrix::free() method is deprecated " 72 | "and it does not do any memory deallocation any more. You are" 73 | "responsible for deallocating the matrix memory (by doing" 74 | "'delete[] matrix.data' for example)"); 75 | } 76 | 77 | /** 78 | * Operator that return a (pointer to a) row of the data. 79 | */ 80 | T* operator[](size_t index) const 81 | { 82 | return data+index*stride; 83 | } 84 | }; 85 | 86 | 87 | class UntypedMatrix 88 | { 89 | public: 90 | size_t rows; 91 | size_t cols; 92 | void* data; 93 | flann_datatype_t type; 94 | 95 | UntypedMatrix(void* data_, long rows_, long cols_) : 96 | rows(rows_), cols(cols_), data(data_) 97 | { 98 | } 99 | 100 | ~UntypedMatrix() 101 | { 102 | } 103 | 104 | 105 | template 106 | Matrix as() 107 | { 108 | return Matrix((T*)data, rows, cols); 109 | } 110 | }; 111 | 112 | 113 | 114 | } 115 | 116 | #endif //OPENCV_FLANN_DATASET_H_ 117 | -------------------------------------------------------------------------------- /src/ofApp.mm: -------------------------------------------------------------------------------- 1 | #include "ofApp.h" 2 | 3 | 4 | using namespace cv; 5 | 6 | //-------------------------------------------------------------- 7 | void ofApp::setup(){ 8 | // ofSetOrientation(OF_ORIENTATION_90_RIGHT);//Set iOS to Orientation Landscape Right 9 | 10 | ofSetFrameRate(60); 11 | 12 | grabber.initGrabber(ofGetWidth(), ofGetHeight(), OF_PIXELS_BGRA); 13 | trackers = ofPtr(new ImageTracker(&grabber)); 14 | trackers->setup(); 15 | trackers->setDebug(false); 16 | trackers->startThread(); 17 | } 18 | 19 | //-------------------------------------------------------------- 20 | void ofApp::update(){ 21 | trackers->update(); 22 | } 23 | 24 | //-------------------------------------------------------------- 25 | void ofApp::draw(){ 26 | ofDisableDepthTest(); 27 | ofDisableLighting(); 28 | 29 | ofSetHexColor(0xffffff); 30 | // grabber.draw(0, 0, ofGetViewportWidth(), ofGetViewportHeight()); 31 | trackers->draw(ofGetViewportWidth(), ofGetViewportHeight()); 32 | 33 | const vector >& trackersList = trackers->getTrackers(); 34 | if(trackersList.size() > 0) { 35 | glMatrixMode( GL_PROJECTION ); 36 | glPushMatrix(); 37 | glLoadMatrixf((float*)trackers->persp.data); 38 | 39 | for (int i=0; icanCalcModelViewMatrix()) { 41 | glMatrixMode(GL_MODELVIEW); 42 | glPushMatrix(); 43 | glLoadMatrixf((float*)(trackersList[i]->getModelViewMatrix().data)); 44 | 45 | ofPushMatrix(); 46 | ofScale(0.01, 0.01); 47 | stringstream ss; ss <getTrackedFeatures().size(); 48 | ofDrawBitmapString(ss.str(), ofPoint(-10,-10)); 49 | ofPopMatrix(); 50 | 51 | ofSetColor(255, 0, 0); 52 | ofNoFill(); 53 | 54 | glTranslatef(0, 0, -0.25); 55 | ofSetLineWidth(2.0); 56 | ofDrawBox(.5, .5, .5); 57 | 58 | glPopMatrix(); 59 | } 60 | } 61 | 62 | glMatrixMode( GL_PROJECTION ); 63 | glPopMatrix(); 64 | glMatrixMode(GL_MODELVIEW); 65 | } 66 | 67 | ofPushMatrix(); 68 | ofSetColor(255, 0, 0); 69 | ofDrawBitmapString("fps = " + ofToString((int)ofGetFrameRate()), ofGetViewportWidth() - 180, 20); 70 | ofPopMatrix(); 71 | 72 | ofEnableDepthTest(); 73 | ofEnableLighting(); 74 | } 75 | 76 | //-------------------------------------------------------------- 77 | void ofApp::exit(){ 78 | } 79 | 80 | //-------------------------------------------------------------- 81 | void ofApp::touchDown(ofTouchEventArgs & touch){ 82 | 83 | } 84 | 85 | //-------------------------------------------------------------- 86 | void ofApp::touchMoved(ofTouchEventArgs & touch){ 87 | 88 | } 89 | 90 | //-------------------------------------------------------------- 91 | void ofApp::touchUp(ofTouchEventArgs & touch){ 92 | 93 | } 94 | 95 | //-------------------------------------------------------------- 96 | void ofApp::touchDoubleTap(ofTouchEventArgs & touch){ 97 | 98 | } 99 | 100 | //-------------------------------------------------------------- 101 | void ofApp::touchCancelled(ofTouchEventArgs & touch){ 102 | 103 | } 104 | 105 | //-------------------------------------------------------------- 106 | void ofApp::lostFocus(){ 107 | 108 | } 109 | 110 | //-------------------------------------------------------------- 111 | void ofApp::gotFocus(){ 112 | 113 | } 114 | 115 | //-------------------------------------------------------------- 116 | void ofApp::gotMemoryWarning(){ 117 | 118 | } 119 | 120 | //-------------------------------------------------------------- 121 | void ofApp::deviceOrientationChanged(int newOrientation){ 122 | 123 | } 124 | 125 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/fast_marching.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_FAST_MARCHING_HPP__ 44 | #define __OPENCV_VIDEOSTAB_FAST_MARCHING_HPP__ 45 | 46 | #include 47 | #include 48 | #include 49 | #include "opencv2/core/core.hpp" 50 | 51 | namespace cv 52 | { 53 | namespace videostab 54 | { 55 | 56 | // See http://iwi.eldoc.ub.rug.nl/FILES/root/2004/JGraphToolsTelea/2004JGraphToolsTelea.pdf 57 | class CV_EXPORTS FastMarchingMethod 58 | { 59 | public: 60 | FastMarchingMethod() : inf_(1e6f) {} 61 | 62 | template 63 | Inpaint run(const Mat &mask, Inpaint inpaint); 64 | 65 | Mat distanceMap() const { return dist_; } 66 | 67 | private: 68 | enum { INSIDE = 0, BAND = 1, KNOWN = 255 }; 69 | 70 | struct DXY 71 | { 72 | float dist; 73 | int x, y; 74 | 75 | DXY() : dist(0), x(0), y(0) {} 76 | DXY(float _dist, int _x, int _y) : dist(_dist), x(_x), y(_y) {} 77 | bool operator <(const DXY &dxy) const { return dist < dxy.dist; } 78 | }; 79 | 80 | float solve(int x1, int y1, int x2, int y2) const; 81 | int& indexOf(const DXY &dxy) { return index_(dxy.y, dxy.x); } 82 | 83 | void heapUp(int idx); 84 | void heapDown(int idx); 85 | void heapAdd(const DXY &dxy); 86 | void heapRemoveMin(); 87 | 88 | float inf_; 89 | 90 | cv::Mat_ flag_; // flag map 91 | cv::Mat_ dist_; // distance map 92 | 93 | cv::Mat_ index_; // index of point in the narrow band 94 | std::vector narrowBand_; // narrow band heap 95 | int size_; // narrow band size 96 | }; 97 | 98 | } // namespace videostab 99 | } // namespace cv 100 | 101 | #include "fast_marching_inl.hpp" 102 | 103 | #endif 104 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/motion_stabilizing.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP__ 44 | #define __OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP__ 45 | 46 | #include 47 | #include "opencv2/core/core.hpp" 48 | 49 | namespace cv 50 | { 51 | namespace videostab 52 | { 53 | 54 | class CV_EXPORTS IMotionStabilizer 55 | { 56 | public: 57 | virtual void stabilize(const Mat *motions, int size, Mat *stabilizationMotions) const = 0; 58 | 59 | #ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY 60 | virtual ~IMotionStabilizer() {} 61 | #endif 62 | }; 63 | 64 | class CV_EXPORTS MotionFilterBase : public IMotionStabilizer 65 | { 66 | public: 67 | MotionFilterBase() : radius_(0) {} 68 | virtual ~MotionFilterBase() {} 69 | 70 | virtual void setRadius(int val) { radius_ = val; } 71 | virtual int radius() const { return radius_; } 72 | 73 | virtual void update() {} 74 | 75 | virtual Mat stabilize(int index, const Mat *motions, int size) const = 0; 76 | virtual void stabilize(const Mat *motions, int size, Mat *stabilizationMotions) const; 77 | 78 | protected: 79 | int radius_; 80 | }; 81 | 82 | class CV_EXPORTS GaussianMotionFilter : public MotionFilterBase 83 | { 84 | public: 85 | GaussianMotionFilter() : stdev_(-1.f) {} 86 | 87 | void setStdev(float val) { stdev_ = val; } 88 | float stdev() const { return stdev_; } 89 | 90 | virtual void update(); 91 | 92 | virtual Mat stabilize(int index, const Mat *motions, int size) const; 93 | 94 | private: 95 | float stdev_; 96 | std::vector weight_; 97 | }; 98 | 99 | CV_EXPORTS Mat ensureInclusionConstraint(const Mat &M, Size size, float trimRatio); 100 | 101 | CV_EXPORTS float estimateOptimalTrimRatio(const Mat &M, Size size); 102 | 103 | } // namespace videostab 104 | } // namespace 105 | 106 | #endif 107 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/photo/photo.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_PHOTO_HPP__ 44 | #define __OPENCV_PHOTO_HPP__ 45 | 46 | #include "opencv2/core/core.hpp" 47 | #include "opencv2/imgproc/imgproc.hpp" 48 | 49 | #include "opencv2/photo/photo_c.h" 50 | 51 | #ifdef __cplusplus 52 | 53 | /*! \namespace cv 54 | Namespace where all the C++ OpenCV functionality resides 55 | */ 56 | namespace cv 57 | { 58 | 59 | //! the inpainting algorithm 60 | enum 61 | { 62 | INPAINT_NS=CV_INPAINT_NS, // Navier-Stokes algorithm 63 | INPAINT_TELEA=CV_INPAINT_TELEA // A. Telea algorithm 64 | }; 65 | 66 | //! restores the damaged image areas using one of the available intpainting algorithms 67 | CV_EXPORTS_W void inpaint( InputArray src, InputArray inpaintMask, 68 | OutputArray dst, double inpaintRadius, int flags ); 69 | 70 | 71 | CV_EXPORTS_W void fastNlMeansDenoising( InputArray src, OutputArray dst, float h = 3, 72 | int templateWindowSize = 7, int searchWindowSize = 21); 73 | 74 | CV_EXPORTS_W void fastNlMeansDenoisingColored( InputArray src, OutputArray dst, 75 | float h = 3, float hColor = 3, 76 | int templateWindowSize = 7, int searchWindowSize = 21); 77 | 78 | CV_EXPORTS_W void fastNlMeansDenoisingMulti( InputArrayOfArrays srcImgs, OutputArray dst, 79 | int imgToDenoiseIndex, int temporalWindowSize, 80 | float h = 3, int templateWindowSize = 7, int searchWindowSize = 21); 81 | 82 | CV_EXPORTS_W void fastNlMeansDenoisingColoredMulti( InputArrayOfArrays srcImgs, OutputArray dst, 83 | int imgToDenoiseIndex, int temporalWindowSize, 84 | float h = 3, float hColor = 3, 85 | int templateWindowSize = 7, int searchWindowSize = 21); 86 | 87 | } 88 | 89 | #endif //__cplusplus 90 | 91 | #endif 92 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/linear_index.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_LINEAR_INDEX_H_ 32 | #define OPENCV_FLANN_LINEAR_INDEX_H_ 33 | 34 | #include "general.h" 35 | #include "nn_index.h" 36 | 37 | namespace cvflann 38 | { 39 | 40 | struct LinearIndexParams : public IndexParams 41 | { 42 | LinearIndexParams() 43 | { 44 | (* this)["algorithm"] = FLANN_INDEX_LINEAR; 45 | } 46 | }; 47 | 48 | template 49 | class LinearIndex : public NNIndex 50 | { 51 | public: 52 | 53 | typedef typename Distance::ElementType ElementType; 54 | typedef typename Distance::ResultType DistanceType; 55 | 56 | 57 | LinearIndex(const Matrix& inputData, const IndexParams& params = LinearIndexParams(), 58 | Distance d = Distance()) : 59 | dataset_(inputData), index_params_(params), distance_(d) 60 | { 61 | } 62 | 63 | LinearIndex(const LinearIndex&); 64 | LinearIndex& operator=(const LinearIndex&); 65 | 66 | flann_algorithm_t getType() const 67 | { 68 | return FLANN_INDEX_LINEAR; 69 | } 70 | 71 | 72 | size_t size() const 73 | { 74 | return dataset_.rows; 75 | } 76 | 77 | size_t veclen() const 78 | { 79 | return dataset_.cols; 80 | } 81 | 82 | 83 | int usedMemory() const 84 | { 85 | return 0; 86 | } 87 | 88 | void buildIndex() 89 | { 90 | /* nothing to do here for linear search */ 91 | } 92 | 93 | void saveIndex(FILE*) 94 | { 95 | /* nothing to do here for linear search */ 96 | } 97 | 98 | 99 | void loadIndex(FILE*) 100 | { 101 | /* nothing to do here for linear search */ 102 | 103 | index_params_["algorithm"] = getType(); 104 | } 105 | 106 | void findNeighbors(ResultSet& resultSet, const ElementType* vec, const SearchParams& /*searchParams*/) 107 | { 108 | ElementType* data = dataset_.data; 109 | for (size_t i = 0; i < dataset_.rows; ++i, data += dataset_.cols) { 110 | DistanceType dist = distance_(data, vec, dataset_.cols); 111 | resultSet.addPoint(dist, (int)i); 112 | } 113 | } 114 | 115 | IndexParams getParameters() const 116 | { 117 | return index_params_; 118 | } 119 | 120 | private: 121 | /** The dataset */ 122 | const Matrix dataset_; 123 | /** Index parameters */ 124 | IndexParams index_params_; 125 | /** Index distance */ 126 | Distance distance_; 127 | 128 | }; 129 | 130 | } 131 | 132 | #endif // OPENCV_FLANN_LINEAR_INDEX_H_ 133 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/logger.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_LOGGER_H 32 | #define OPENCV_FLANN_LOGGER_H 33 | 34 | #include 35 | #include 36 | 37 | #include "defines.h" 38 | 39 | 40 | namespace cvflann 41 | { 42 | 43 | class Logger 44 | { 45 | Logger() : stream(stdout), logLevel(FLANN_LOG_WARN) {} 46 | 47 | ~Logger() 48 | { 49 | if ((stream!=NULL)&&(stream!=stdout)) { 50 | fclose(stream); 51 | } 52 | } 53 | 54 | static Logger& instance() 55 | { 56 | static Logger logger; 57 | return logger; 58 | } 59 | 60 | void _setDestination(const char* name) 61 | { 62 | if (name==NULL) { 63 | stream = stdout; 64 | } 65 | else { 66 | stream = fopen(name,"w"); 67 | if (stream == NULL) { 68 | stream = stdout; 69 | } 70 | } 71 | } 72 | 73 | int _log(int level, const char* fmt, va_list arglist) 74 | { 75 | if (level > logLevel ) return -1; 76 | int ret = vfprintf(stream, fmt, arglist); 77 | return ret; 78 | } 79 | 80 | public: 81 | /** 82 | * Sets the logging level. All messages with lower priority will be ignored. 83 | * @param level Logging level 84 | */ 85 | static void setLevel(int level) { instance().logLevel = level; } 86 | 87 | /** 88 | * Sets the logging destination 89 | * @param name Filename or NULL for console 90 | */ 91 | static void setDestination(const char* name) { instance()._setDestination(name); } 92 | 93 | /** 94 | * Print log message 95 | * @param level Log level 96 | * @param fmt Message format 97 | * @return 98 | */ 99 | static int log(int level, const char* fmt, ...) 100 | { 101 | va_list arglist; 102 | va_start(arglist, fmt); 103 | int ret = instance()._log(level,fmt,arglist); 104 | va_end(arglist); 105 | return ret; 106 | } 107 | 108 | #define LOG_METHOD(NAME,LEVEL) \ 109 | static int NAME(const char* fmt, ...) \ 110 | { \ 111 | va_list ap; \ 112 | va_start(ap, fmt); \ 113 | int ret = instance()._log(LEVEL, fmt, ap); \ 114 | va_end(ap); \ 115 | return ret; \ 116 | } 117 | 118 | LOG_METHOD(fatal, FLANN_LOG_FATAL) 119 | LOG_METHOD(error, FLANN_LOG_ERROR) 120 | LOG_METHOD(warn, FLANN_LOG_WARN) 121 | LOG_METHOD(info, FLANN_LOG_INFO) 122 | 123 | private: 124 | FILE* stream; 125 | int logLevel; 126 | }; 127 | 128 | } 129 | 130 | #endif //OPENCV_FLANN_LOGGER_H 131 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/random.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_RANDOM_H 32 | #define OPENCV_FLANN_RANDOM_H 33 | 34 | #include 35 | #include 36 | #include 37 | 38 | #include "general.h" 39 | 40 | namespace cvflann 41 | { 42 | 43 | /** 44 | * Seeds the random number generator 45 | * @param seed Random seed 46 | */ 47 | inline void seed_random(unsigned int seed) 48 | { 49 | srand(seed); 50 | } 51 | 52 | /* 53 | * Generates a random double value. 54 | */ 55 | /** 56 | * Generates a random double value. 57 | * @param high Upper limit 58 | * @param low Lower limit 59 | * @return Random double value 60 | */ 61 | inline double rand_double(double high = 1.0, double low = 0) 62 | { 63 | return low + ((high-low) * (std::rand() / (RAND_MAX + 1.0))); 64 | } 65 | 66 | /** 67 | * Generates a random integer value. 68 | * @param high Upper limit 69 | * @param low Lower limit 70 | * @return Random integer value 71 | */ 72 | inline int rand_int(int high = RAND_MAX, int low = 0) 73 | { 74 | return low + (int) ( double(high-low) * (std::rand() / (RAND_MAX + 1.0))); 75 | } 76 | 77 | /** 78 | * Random number generator that returns a distinct number from 79 | * the [0,n) interval each time. 80 | */ 81 | class UniqueRandom 82 | { 83 | std::vector vals_; 84 | int size_; 85 | int counter_; 86 | 87 | public: 88 | /** 89 | * Constructor. 90 | * @param n Size of the interval from which to generate 91 | * @return 92 | */ 93 | UniqueRandom(int n) 94 | { 95 | init(n); 96 | } 97 | 98 | /** 99 | * Initializes the number generator. 100 | * @param n the size of the interval from which to generate random numbers. 101 | */ 102 | void init(int n) 103 | { 104 | // create and initialize an array of size n 105 | vals_.resize(n); 106 | size_ = n; 107 | for (int i = 0; i < size_; ++i) vals_[i] = i; 108 | 109 | // shuffle the elements in the array 110 | std::random_shuffle(vals_.begin(), vals_.end()); 111 | 112 | counter_ = 0; 113 | } 114 | 115 | /** 116 | * Return a distinct random integer in greater or equal to 0 and less 117 | * than 'n' on each call. It should be called maximum 'n' times. 118 | * Returns: a random integer 119 | */ 120 | int next() 121 | { 122 | if (counter_ == size_) { 123 | return -1; 124 | } 125 | else { 126 | return vals_[counter_++]; 127 | } 128 | } 129 | }; 130 | 131 | } 132 | 133 | #endif //OPENCV_FLANN_RANDOM_H 134 | 135 | 136 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/deblurring.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_DEBLURRING_HPP__ 44 | #define __OPENCV_VIDEOSTAB_DEBLURRING_HPP__ 45 | 46 | #include 47 | #include "opencv2/core/core.hpp" 48 | 49 | namespace cv 50 | { 51 | namespace videostab 52 | { 53 | 54 | CV_EXPORTS float calcBlurriness(const Mat &frame); 55 | 56 | class CV_EXPORTS DeblurerBase 57 | { 58 | public: 59 | DeblurerBase() : radius_(0), frames_(0), motions_(0) {} 60 | 61 | virtual ~DeblurerBase() {} 62 | 63 | virtual void setRadius(int val) { radius_ = val; } 64 | virtual int radius() const { return radius_; } 65 | 66 | virtual void setFrames(const std::vector &val) { frames_ = &val; } 67 | virtual const std::vector& frames() const { return *frames_; } 68 | 69 | virtual void setMotions(const std::vector &val) { motions_ = &val; } 70 | virtual const std::vector& motions() const { return *motions_; } 71 | 72 | virtual void setBlurrinessRates(const std::vector &val) { blurrinessRates_ = &val; } 73 | virtual const std::vector& blurrinessRates() const { return *blurrinessRates_; } 74 | 75 | virtual void update() {} 76 | 77 | virtual void deblur(int idx, Mat &frame) = 0; 78 | 79 | protected: 80 | int radius_; 81 | const std::vector *frames_; 82 | const std::vector *motions_; 83 | const std::vector *blurrinessRates_; 84 | }; 85 | 86 | class CV_EXPORTS NullDeblurer : public DeblurerBase 87 | { 88 | public: 89 | virtual void deblur(int /*idx*/, Mat &/*frame*/) {} 90 | }; 91 | 92 | class CV_EXPORTS WeightingDeblurer : public DeblurerBase 93 | { 94 | public: 95 | WeightingDeblurer(); 96 | 97 | void setSensitivity(float val) { sensitivity_ = val; } 98 | float sensitivity() const { return sensitivity_; } 99 | 100 | virtual void deblur(int idx, Mat &frame); 101 | 102 | private: 103 | float sensitivity_; 104 | Mat_ bSum_, gSum_, rSum_, wSum_; 105 | }; 106 | 107 | } // namespace videostab 108 | } // namespace cv 109 | 110 | #endif 111 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/legacy/streams.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // Intel License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000, Intel Corporation, all rights reserved. 14 | // Third party copyrights are property of their respective owners. 15 | // 16 | // Redistribution and use in source and binary forms, with or without modification, 17 | // are permitted provided that the following conditions are met: 18 | // 19 | // * Redistribution's of source code must retain the above copyright notice, 20 | // this list of conditions and the following disclaimer. 21 | // 22 | // * Redistribution's in binary form must reproduce the above copyright notice, 23 | // this list of conditions and the following disclaimer in the documentation 24 | // and/or other materials provided with the distribution. 25 | // 26 | // * The name of Intel Corporation may not be used to endorse or promote products 27 | // derived from this software without specific prior written permission. 28 | // 29 | // This software is provided by the copyright holders and contributors "as is" and 30 | // any express or implied warranties, including, but not limited to, the implied 31 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 32 | // In no event shall the Intel Corporation or contributors be liable for any direct, 33 | // indirect, incidental, special, exemplary, or consequential damages 34 | // (including, but not limited to, procurement of substitute goods or services; 35 | // loss of use, data, or profits; or business interruption) however caused 36 | // and on any theory of liability, whether in contract, strict liability, 37 | // or tort (including negligence or otherwise) arising in any way out of 38 | // the use of this software, even if advised of the possibility of such damage. 39 | // 40 | //M*/ 41 | 42 | #ifndef __OPENCV_CVSTREAMS_H__ 43 | #define __OPENCV_CVSTREAMS_H__ 44 | 45 | #ifdef WIN32 46 | #include /* !!! IF YOU'VE GOT AN ERROR HERE, PLEASE READ BELOW !!! */ 47 | /***************** How to get Visual Studio understand streams.h ****************\ 48 | 49 | You need DirectShow SDK that is now a part of Platform SDK 50 | (Windows Server 2003 SP1 SDK or later), 51 | and DirectX SDK (2006 April or later). 52 | 53 | 1. Download the Platform SDK from 54 | http://www.microsoft.com/msdownload/platformsdk/sdkupdate/ 55 | and DirectX SDK from msdn.microsoft.com/directx/ 56 | (They are huge, but you can download it by parts). 57 | If it doesn't work for you, consider HighGUI that can capture video via VFW or MIL 58 | 59 | 2. Install Platform SDK together with DirectShow SDK. 60 | Install DirectX (with or without sample code). 61 | 62 | 3. Build baseclasses. 63 | See \samples\multimedia\directshow\readme.txt. 64 | 65 | 4. Copy the built libraries (called strmbase.lib and strmbasd.lib 66 | in Release and Debug versions, respectively) to 67 | \lib. 68 | 69 | 5. In Developer Studio add the following paths: 70 | \include 71 | \include 72 | \samples\multimedia\directshow\baseclasses 73 | to the includes' search path 74 | (at Tools->Options->Directories->Include files in case of Visual Studio 6.0, 75 | at Tools->Options->Projects and Solutions->VC++ Directories->Include files in case 76 | of Visual Studio 2005) 77 | Add 78 | \lib 79 | \lib 80 | to the libraries' search path (in the same dialog, ...->"Library files" page) 81 | 82 | NOTE: PUT THE ADDED LINES ON THE VERY TOP OF THE LISTS, OTHERWISE YOU MAY STILL GET 83 | COMPILER OR LINKER ERRORS. This is necessary, because Visual Studio 84 | may include older versions of the same headers and libraries. 85 | 86 | 6. Now you can build OpenCV DirectShow filters. 87 | 88 | \***********************************************************************************/ 89 | 90 | #endif 91 | 92 | #endif 93 | 94 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/stitching/detail/util_inl.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_STITCHING_UTIL_INL_HPP__ 44 | #define __OPENCV_STITCHING_UTIL_INL_HPP__ 45 | 46 | #include 47 | #include "opencv2/core/core.hpp" 48 | #include "util.hpp" // Make your IDE see declarations 49 | 50 | namespace cv { 51 | namespace detail { 52 | 53 | template 54 | B Graph::forEach(B body) const 55 | { 56 | for (int i = 0; i < numVertices(); ++i) 57 | { 58 | std::list::const_iterator edge = edges_[i].begin(); 59 | for (; edge != edges_[i].end(); ++edge) 60 | body(*edge); 61 | } 62 | return body; 63 | } 64 | 65 | 66 | template 67 | B Graph::walkBreadthFirst(int from, B body) const 68 | { 69 | std::vector was(numVertices(), false); 70 | std::queue vertices; 71 | 72 | was[from] = true; 73 | vertices.push(from); 74 | 75 | while (!vertices.empty()) 76 | { 77 | int vertex = vertices.front(); 78 | vertices.pop(); 79 | 80 | std::list::const_iterator edge = edges_[vertex].begin(); 81 | for (; edge != edges_[vertex].end(); ++edge) 82 | { 83 | if (!was[edge->to]) 84 | { 85 | body(*edge); 86 | was[edge->to] = true; 87 | vertices.push(edge->to); 88 | } 89 | } 90 | } 91 | 92 | return body; 93 | } 94 | 95 | 96 | ////////////////////////////////////////////////////////////////////////////// 97 | // Some auxiliary math functions 98 | 99 | static inline 100 | float normL2(const Point3f& a) 101 | { 102 | return a.x * a.x + a.y * a.y + a.z * a.z; 103 | } 104 | 105 | 106 | static inline 107 | float normL2(const Point3f& a, const Point3f& b) 108 | { 109 | return normL2(a - b); 110 | } 111 | 112 | 113 | static inline 114 | double normL2sq(const Mat &r) 115 | { 116 | return r.dot(r); 117 | } 118 | 119 | 120 | static inline int sqr(int x) { return x * x; } 121 | static inline float sqr(float x) { return x * x; } 122 | static inline double sqr(double x) { return x * x; } 123 | 124 | } // namespace detail 125 | } // namespace cv 126 | 127 | #endif // __OPENCV_STITCHING_UTIL_INL_HPP__ 128 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/stitching/detail/exposure_compensate.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP__ 44 | #define __OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP__ 45 | 46 | #include "opencv2/core/core.hpp" 47 | 48 | namespace cv { 49 | namespace detail { 50 | 51 | class CV_EXPORTS ExposureCompensator 52 | { 53 | public: 54 | virtual ~ExposureCompensator() {} 55 | 56 | enum { NO, GAIN, GAIN_BLOCKS }; 57 | static Ptr createDefault(int type); 58 | 59 | void feed(const std::vector &corners, const std::vector &images, 60 | const std::vector &masks); 61 | virtual void feed(const std::vector &corners, const std::vector &images, 62 | const std::vector > &masks) = 0; 63 | virtual void apply(int index, Point corner, Mat &image, const Mat &mask) = 0; 64 | }; 65 | 66 | 67 | class CV_EXPORTS NoExposureCompensator : public ExposureCompensator 68 | { 69 | public: 70 | void feed(const std::vector &/*corners*/, const std::vector &/*images*/, 71 | const std::vector > &/*masks*/) {}; 72 | void apply(int /*index*/, Point /*corner*/, Mat &/*image*/, const Mat &/*mask*/) {}; 73 | }; 74 | 75 | 76 | class CV_EXPORTS GainCompensator : public ExposureCompensator 77 | { 78 | public: 79 | void feed(const std::vector &corners, const std::vector &images, 80 | const std::vector > &masks); 81 | void apply(int index, Point corner, Mat &image, const Mat &mask); 82 | std::vector gains() const; 83 | 84 | private: 85 | Mat_ gains_; 86 | }; 87 | 88 | 89 | class CV_EXPORTS BlocksGainCompensator : public ExposureCompensator 90 | { 91 | public: 92 | BlocksGainCompensator(int bl_width = 32, int bl_height = 32) 93 | : bl_width_(bl_width), bl_height_(bl_height) {} 94 | void feed(const std::vector &corners, const std::vector &images, 95 | const std::vector > &masks); 96 | void apply(int index, Point corner, Mat &image, const Mat &mask); 97 | 98 | private: 99 | int bl_width_, bl_height_; 100 | std::vector > gain_maps_; 101 | }; 102 | 103 | } // namespace detail 104 | } // namespace cv 105 | 106 | #endif // __OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP__ 107 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/optical_flow.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_OPTICAL_FLOW_HPP__ 44 | #define __OPENCV_VIDEOSTAB_OPTICAL_FLOW_HPP__ 45 | 46 | #include "opencv2/core/core.hpp" 47 | #include "opencv2/opencv_modules.hpp" 48 | 49 | #ifdef HAVE_OPENCV_GPU 50 | # include "opencv2/gpu/gpu.hpp" 51 | #endif 52 | 53 | namespace cv 54 | { 55 | namespace videostab 56 | { 57 | 58 | class CV_EXPORTS ISparseOptFlowEstimator 59 | { 60 | public: 61 | virtual ~ISparseOptFlowEstimator() {} 62 | virtual void run( 63 | InputArray frame0, InputArray frame1, InputArray points0, InputOutputArray points1, 64 | OutputArray status, OutputArray errors) = 0; 65 | }; 66 | 67 | class CV_EXPORTS IDenseOptFlowEstimator 68 | { 69 | public: 70 | virtual ~IDenseOptFlowEstimator() {} 71 | virtual void run( 72 | InputArray frame0, InputArray frame1, InputOutputArray flowX, InputOutputArray flowY, 73 | OutputArray errors) = 0; 74 | }; 75 | 76 | class CV_EXPORTS PyrLkOptFlowEstimatorBase 77 | { 78 | public: 79 | PyrLkOptFlowEstimatorBase() { setWinSize(Size(21, 21)); setMaxLevel(3); } 80 | 81 | void setWinSize(Size val) { winSize_ = val; } 82 | Size winSize() const { return winSize_; } 83 | 84 | void setMaxLevel(int val) { maxLevel_ = val; } 85 | int maxLevel() const { return maxLevel_; } 86 | 87 | protected: 88 | Size winSize_; 89 | int maxLevel_; 90 | }; 91 | 92 | class CV_EXPORTS SparsePyrLkOptFlowEstimator 93 | : public PyrLkOptFlowEstimatorBase, public ISparseOptFlowEstimator 94 | { 95 | public: 96 | virtual void run( 97 | InputArray frame0, InputArray frame1, InputArray points0, InputOutputArray points1, 98 | OutputArray status, OutputArray errors); 99 | }; 100 | 101 | #ifdef HAVE_OPENCV_GPU 102 | class CV_EXPORTS DensePyrLkOptFlowEstimatorGpu 103 | : public PyrLkOptFlowEstimatorBase, public IDenseOptFlowEstimator 104 | { 105 | public: 106 | DensePyrLkOptFlowEstimatorGpu(); 107 | 108 | virtual void run( 109 | InputArray frame0, InputArray frame1, InputOutputArray flowX, InputOutputArray flowY, 110 | OutputArray errors); 111 | private: 112 | gpu::PyrLKOpticalFlow optFlowEstimator_; 113 | gpu::GpuMat frame0_, frame1_, flowX_, flowY_, errors_; 114 | }; 115 | #endif 116 | 117 | } // namespace videostab 118 | } // namespace cv 119 | 120 | #endif 121 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/heap.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_HEAP_H_ 32 | #define OPENCV_FLANN_HEAP_H_ 33 | 34 | #include 35 | #include 36 | 37 | namespace cvflann 38 | { 39 | 40 | /** 41 | * Priority Queue Implementation 42 | * 43 | * The priority queue is implemented with a heap. A heap is a complete 44 | * (full) binary tree in which each parent is less than both of its 45 | * children, but the order of the children is unspecified. 46 | */ 47 | template 48 | class Heap 49 | { 50 | 51 | /** 52 | * Storage array for the heap. 53 | * Type T must be comparable. 54 | */ 55 | std::vector heap; 56 | int length; 57 | 58 | /** 59 | * Number of element in the heap 60 | */ 61 | int count; 62 | 63 | 64 | 65 | public: 66 | /** 67 | * Constructor. 68 | * 69 | * Params: 70 | * sz = heap size 71 | */ 72 | 73 | Heap(int sz) 74 | { 75 | length = sz; 76 | heap.reserve(length); 77 | count = 0; 78 | } 79 | 80 | /** 81 | * 82 | * Returns: heap size 83 | */ 84 | int size() 85 | { 86 | return count; 87 | } 88 | 89 | /** 90 | * Tests if the heap is empty 91 | * 92 | * Returns: true is heap empty, false otherwise 93 | */ 94 | bool empty() 95 | { 96 | return size()==0; 97 | } 98 | 99 | /** 100 | * Clears the heap. 101 | */ 102 | void clear() 103 | { 104 | heap.clear(); 105 | count = 0; 106 | } 107 | 108 | struct CompareT 109 | { 110 | bool operator()(const T& t_1, const T& t_2) const 111 | { 112 | return t_2 < t_1; 113 | } 114 | }; 115 | 116 | /** 117 | * Insert a new element in the heap. 118 | * 119 | * We select the next empty leaf node, and then keep moving any larger 120 | * parents down until the right location is found to store this element. 121 | * 122 | * Params: 123 | * value = the new element to be inserted in the heap 124 | */ 125 | void insert(T value) 126 | { 127 | /* If heap is full, then return without adding this element. */ 128 | if (count == length) { 129 | return; 130 | } 131 | 132 | heap.push_back(value); 133 | static CompareT compareT; 134 | std::push_heap(heap.begin(), heap.end(), compareT); 135 | ++count; 136 | } 137 | 138 | 139 | 140 | /** 141 | * Returns the node of minimum value from the heap (top of the heap). 142 | * 143 | * Params: 144 | * value = out parameter used to return the min element 145 | * Returns: false if heap empty 146 | */ 147 | bool popMin(T& value) 148 | { 149 | if (count == 0) { 150 | return false; 151 | } 152 | 153 | value = heap[0]; 154 | static CompareT compareT; 155 | std::pop_heap(heap.begin(), heap.end(), compareT); 156 | heap.pop_back(); 157 | --count; 158 | 159 | return true; /* Return old last node. */ 160 | } 161 | }; 162 | 163 | } 164 | 165 | #endif //OPENCV_FLANN_HEAP_H_ 166 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/dynamic_bitset.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | /*********************************************************************** 32 | * Author: Vincent Rabaud 33 | *************************************************************************/ 34 | 35 | #ifndef OPENCV_FLANN_DYNAMIC_BITSET_H_ 36 | #define OPENCV_FLANN_DYNAMIC_BITSET_H_ 37 | 38 | #ifndef FLANN_USE_BOOST 39 | # define FLANN_USE_BOOST 0 40 | #endif 41 | //#define FLANN_USE_BOOST 1 42 | #if FLANN_USE_BOOST 43 | #include 44 | typedef boost::dynamic_bitset<> DynamicBitset; 45 | #else 46 | 47 | #include 48 | 49 | #include "dist.h" 50 | 51 | namespace cvflann { 52 | 53 | /** Class re-implementing the boost version of it 54 | * This helps not depending on boost, it also does not do the bound checks 55 | * and has a way to reset a block for speed 56 | */ 57 | class DynamicBitset 58 | { 59 | public: 60 | /** @param default constructor 61 | */ 62 | DynamicBitset() 63 | { 64 | } 65 | 66 | /** @param only constructor we use in our code 67 | * @param the size of the bitset (in bits) 68 | */ 69 | DynamicBitset(size_t sz) 70 | { 71 | resize(sz); 72 | reset(); 73 | } 74 | 75 | /** Sets all the bits to 0 76 | */ 77 | void clear() 78 | { 79 | std::fill(bitset_.begin(), bitset_.end(), 0); 80 | } 81 | 82 | /** @brief checks if the bitset is empty 83 | * @return true if the bitset is empty 84 | */ 85 | bool empty() const 86 | { 87 | return bitset_.empty(); 88 | } 89 | 90 | /** @param set all the bits to 0 91 | */ 92 | void reset() 93 | { 94 | std::fill(bitset_.begin(), bitset_.end(), 0); 95 | } 96 | 97 | /** @brief set one bit to 0 98 | * @param 99 | */ 100 | void reset(size_t index) 101 | { 102 | bitset_[index / cell_bit_size_] &= ~(size_t(1) << (index % cell_bit_size_)); 103 | } 104 | 105 | /** @brief sets a specific bit to 0, and more bits too 106 | * This function is useful when resetting a given set of bits so that the 107 | * whole bitset ends up being 0: if that's the case, we don't care about setting 108 | * other bits to 0 109 | * @param 110 | */ 111 | void reset_block(size_t index) 112 | { 113 | bitset_[index / cell_bit_size_] = 0; 114 | } 115 | 116 | /** @param resize the bitset so that it contains at least size bits 117 | * @param size 118 | */ 119 | void resize(size_t sz) 120 | { 121 | size_ = sz; 122 | bitset_.resize(sz / cell_bit_size_ + 1); 123 | } 124 | 125 | /** @param set a bit to true 126 | * @param index the index of the bit to set to 1 127 | */ 128 | void set(size_t index) 129 | { 130 | bitset_[index / cell_bit_size_] |= size_t(1) << (index % cell_bit_size_); 131 | } 132 | 133 | /** @param gives the number of contained bits 134 | */ 135 | size_t size() const 136 | { 137 | return size_; 138 | } 139 | 140 | /** @param check if a bit is set 141 | * @param index the index of the bit to check 142 | * @return true if the bit is set 143 | */ 144 | bool test(size_t index) const 145 | { 146 | return (bitset_[index / cell_bit_size_] & (size_t(1) << (index % cell_bit_size_))) != 0; 147 | } 148 | 149 | private: 150 | std::vector bitset_; 151 | size_t size_; 152 | static const unsigned int cell_bit_size_ = CHAR_BIT * sizeof(size_t); 153 | }; 154 | 155 | } // namespace cvflann 156 | 157 | #endif 158 | 159 | #endif // OPENCV_FLANN_DYNAMIC_BITSET_H_ 160 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/defines.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2011 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2011 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 11 | * 1. Redistributions of source code must retain the above copyright 12 | * notice, this list of conditions and the following disclaimer. 13 | * 2. Redistributions in binary form must reproduce the above copyright 14 | * notice, this list of conditions and the following disclaimer in the 15 | * documentation and/or other materials provided with the distribution. 16 | * 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | *************************************************************************/ 28 | 29 | 30 | #ifndef OPENCV_FLANN_DEFINES_H_ 31 | #define OPENCV_FLANN_DEFINES_H_ 32 | 33 | #include "config.h" 34 | 35 | #ifdef FLANN_EXPORT 36 | #undef FLANN_EXPORT 37 | #endif 38 | #ifdef WIN32 39 | /* win32 dll export/import directives */ 40 | #ifdef FLANN_EXPORTS 41 | #define FLANN_EXPORT __declspec(dllexport) 42 | #elif defined(FLANN_STATIC) 43 | #define FLANN_EXPORT 44 | #else 45 | #define FLANN_EXPORT __declspec(dllimport) 46 | #endif 47 | #else 48 | /* unix needs nothing */ 49 | #define FLANN_EXPORT 50 | #endif 51 | 52 | 53 | #ifdef FLANN_DEPRECATED 54 | #undef FLANN_DEPRECATED 55 | #endif 56 | #ifdef __GNUC__ 57 | #define FLANN_DEPRECATED __attribute__ ((deprecated)) 58 | #elif defined(_MSC_VER) 59 | #define FLANN_DEPRECATED __declspec(deprecated) 60 | #else 61 | #pragma message("WARNING: You need to implement FLANN_DEPRECATED for this compiler") 62 | #define FLANN_DEPRECATED 63 | #endif 64 | 65 | 66 | #undef FLANN_PLATFORM_32_BIT 67 | #undef FLANN_PLATFORM_64_BIT 68 | #if defined __amd64__ || defined __x86_64__ || defined _WIN64 || defined _M_X64 69 | #define FLANN_PLATFORM_64_BIT 70 | #else 71 | #define FLANN_PLATFORM_32_BIT 72 | #endif 73 | 74 | 75 | #undef FLANN_ARRAY_LEN 76 | #define FLANN_ARRAY_LEN(a) (sizeof(a)/sizeof(a[0])) 77 | 78 | namespace cvflann { 79 | 80 | /* Nearest neighbour index algorithms */ 81 | enum flann_algorithm_t 82 | { 83 | FLANN_INDEX_LINEAR = 0, 84 | FLANN_INDEX_KDTREE = 1, 85 | FLANN_INDEX_KMEANS = 2, 86 | FLANN_INDEX_COMPOSITE = 3, 87 | FLANN_INDEX_KDTREE_SINGLE = 4, 88 | FLANN_INDEX_HIERARCHICAL = 5, 89 | FLANN_INDEX_LSH = 6, 90 | FLANN_INDEX_SAVED = 254, 91 | FLANN_INDEX_AUTOTUNED = 255, 92 | 93 | // deprecated constants, should use the FLANN_INDEX_* ones instead 94 | LINEAR = 0, 95 | KDTREE = 1, 96 | KMEANS = 2, 97 | COMPOSITE = 3, 98 | KDTREE_SINGLE = 4, 99 | SAVED = 254, 100 | AUTOTUNED = 255 101 | }; 102 | 103 | 104 | 105 | enum flann_centers_init_t 106 | { 107 | FLANN_CENTERS_RANDOM = 0, 108 | FLANN_CENTERS_GONZALES = 1, 109 | FLANN_CENTERS_KMEANSPP = 2, 110 | 111 | // deprecated constants, should use the FLANN_CENTERS_* ones instead 112 | CENTERS_RANDOM = 0, 113 | CENTERS_GONZALES = 1, 114 | CENTERS_KMEANSPP = 2 115 | }; 116 | 117 | enum flann_log_level_t 118 | { 119 | FLANN_LOG_NONE = 0, 120 | FLANN_LOG_FATAL = 1, 121 | FLANN_LOG_ERROR = 2, 122 | FLANN_LOG_WARN = 3, 123 | FLANN_LOG_INFO = 4 124 | }; 125 | 126 | enum flann_distance_t 127 | { 128 | FLANN_DIST_EUCLIDEAN = 1, 129 | FLANN_DIST_L2 = 1, 130 | FLANN_DIST_MANHATTAN = 2, 131 | FLANN_DIST_L1 = 2, 132 | FLANN_DIST_MINKOWSKI = 3, 133 | FLANN_DIST_MAX = 4, 134 | FLANN_DIST_HIST_INTERSECT = 5, 135 | FLANN_DIST_HELLINGER = 6, 136 | FLANN_DIST_CHI_SQUARE = 7, 137 | FLANN_DIST_CS = 7, 138 | FLANN_DIST_KULLBACK_LEIBLER = 8, 139 | FLANN_DIST_KL = 8, 140 | FLANN_DIST_HAMMING = 9, 141 | 142 | // deprecated constants, should use the FLANN_DIST_* ones instead 143 | EUCLIDEAN = 1, 144 | MANHATTAN = 2, 145 | MINKOWSKI = 3, 146 | MAX_DIST = 4, 147 | HIST_INTERSECT = 5, 148 | HELLINGER = 6, 149 | CS = 7, 150 | KL = 8, 151 | KULLBACK_LEIBLER = 8 152 | }; 153 | 154 | enum flann_datatype_t 155 | { 156 | FLANN_INT8 = 0, 157 | FLANN_INT16 = 1, 158 | FLANN_INT32 = 2, 159 | FLANN_INT64 = 3, 160 | FLANN_UINT8 = 4, 161 | FLANN_UINT16 = 5, 162 | FLANN_UINT32 = 6, 163 | FLANN_UINT64 = 7, 164 | FLANN_FLOAT32 = 8, 165 | FLANN_FLOAT64 = 9 166 | }; 167 | 168 | enum 169 | { 170 | FLANN_CHECKS_UNLIMITED = -1, 171 | FLANN_CHECKS_AUTOTUNED = -2 172 | }; 173 | 174 | } 175 | 176 | #endif /* OPENCV_FLANN_DEFINES_H_ */ 177 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/stitching/detail/blenders.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_STITCHING_BLENDERS_HPP__ 44 | #define __OPENCV_STITCHING_BLENDERS_HPP__ 45 | 46 | #include "opencv2/core/core.hpp" 47 | 48 | namespace cv { 49 | namespace detail { 50 | 51 | 52 | // Simple blender which puts one image over another 53 | class CV_EXPORTS Blender 54 | { 55 | public: 56 | virtual ~Blender() {} 57 | 58 | enum { NO, FEATHER, MULTI_BAND }; 59 | static Ptr createDefault(int type, bool try_gpu = false); 60 | 61 | void prepare(const std::vector &corners, const std::vector &sizes); 62 | virtual void prepare(Rect dst_roi); 63 | virtual void feed(const Mat &img, const Mat &mask, Point tl); 64 | virtual void blend(Mat &dst, Mat &dst_mask); 65 | 66 | protected: 67 | Mat dst_, dst_mask_; 68 | Rect dst_roi_; 69 | }; 70 | 71 | 72 | class CV_EXPORTS FeatherBlender : public Blender 73 | { 74 | public: 75 | FeatherBlender(float sharpness = 0.02f); 76 | 77 | float sharpness() const { return sharpness_; } 78 | void setSharpness(float val) { sharpness_ = val; } 79 | 80 | void prepare(Rect dst_roi); 81 | void feed(const Mat &img, const Mat &mask, Point tl); 82 | void blend(Mat &dst, Mat &dst_mask); 83 | 84 | // Creates weight maps for fixed set of source images by their masks and top-left corners. 85 | // Final image can be obtained by simple weighting of the source images. 86 | Rect createWeightMaps(const std::vector &masks, const std::vector &corners, 87 | std::vector &weight_maps); 88 | 89 | private: 90 | float sharpness_; 91 | Mat weight_map_; 92 | Mat dst_weight_map_; 93 | }; 94 | 95 | inline FeatherBlender::FeatherBlender(float _sharpness) { setSharpness(_sharpness); } 96 | 97 | 98 | class CV_EXPORTS MultiBandBlender : public Blender 99 | { 100 | public: 101 | MultiBandBlender(int try_gpu = false, int num_bands = 5, int weight_type = CV_32F); 102 | 103 | int numBands() const { return actual_num_bands_; } 104 | void setNumBands(int val) { actual_num_bands_ = val; } 105 | 106 | void prepare(Rect dst_roi); 107 | void feed(const Mat &img, const Mat &mask, Point tl); 108 | void blend(Mat &dst, Mat &dst_mask); 109 | 110 | private: 111 | int actual_num_bands_, num_bands_; 112 | std::vector dst_pyr_laplace_; 113 | std::vector dst_band_weights_; 114 | Rect dst_roi_final_; 115 | bool can_use_gpu_; 116 | int weight_type_; //CV_32F or CV_16S 117 | }; 118 | 119 | 120 | ////////////////////////////////////////////////////////////////////////////// 121 | // Auxiliary functions 122 | 123 | void CV_EXPORTS normalizeUsingWeightMap(const Mat& weight, Mat& src); 124 | 125 | void CV_EXPORTS createWeightMap(const Mat& mask, float sharpness, Mat& weight); 126 | 127 | void CV_EXPORTS createLaplacePyr(const Mat &img, int num_levels, std::vector& pyr); 128 | void CV_EXPORTS createLaplacePyrGpu(const Mat &img, int num_levels, std::vector& pyr); 129 | 130 | // Restores source image 131 | void CV_EXPORTS restoreImageFromLaplacePyr(std::vector& pyr); 132 | void CV_EXPORTS restoreImageFromLaplacePyrGpu(std::vector& pyr); 133 | 134 | } // namespace detail 135 | } // namespace cv 136 | 137 | #endif // __OPENCV_STITCHING_BLENDERS_HPP__ 138 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/highgui/cap_ios.h: -------------------------------------------------------------------------------- 1 | /* 2 | * cap_ios.h 3 | * For iOS video I/O 4 | * by Eduard Feicho on 29/07/12 5 | * Copyright 2012. All rights reserved. 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions are met: 9 | * 10 | * 1. Redistributions of source code must retain the above copyright notice, 11 | * this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright notice, 13 | * this list of conditions and the following disclaimer in the documentation 14 | * and/or other materials provided with the distribution. 15 | * 3. The name of the author may not be used to endorse or promote products 16 | * derived from this software without specific prior written permission. 17 | * 18 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED 19 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 20 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 21 | * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 23 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 24 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 27 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | * 29 | */ 30 | 31 | #import 32 | #import 33 | #import 34 | #import 35 | #include "opencv2/core/core.hpp" 36 | 37 | /////////////////////////////////////// CvAbstractCamera ///////////////////////////////////// 38 | 39 | @class CvAbstractCamera; 40 | 41 | @interface CvAbstractCamera : NSObject 42 | { 43 | AVCaptureSession* captureSession; 44 | AVCaptureConnection* videoCaptureConnection; 45 | AVCaptureVideoPreviewLayer *captureVideoPreviewLayer; 46 | 47 | UIDeviceOrientation currentDeviceOrientation; 48 | 49 | BOOL cameraAvailable; 50 | BOOL captureSessionLoaded; 51 | BOOL running; 52 | BOOL useAVCaptureVideoPreviewLayer; 53 | 54 | AVCaptureDevicePosition defaultAVCaptureDevicePosition; 55 | AVCaptureVideoOrientation defaultAVCaptureVideoOrientation; 56 | NSString *const defaultAVCaptureSessionPreset; 57 | 58 | int defaultFPS; 59 | 60 | UIView* parentView; 61 | 62 | int imageWidth; 63 | int imageHeight; 64 | } 65 | 66 | @property (nonatomic, retain) AVCaptureSession* captureSession; 67 | @property (nonatomic, retain) AVCaptureConnection* videoCaptureConnection; 68 | 69 | @property (nonatomic, readonly) BOOL running; 70 | @property (nonatomic, readonly) BOOL captureSessionLoaded; 71 | 72 | @property (nonatomic, assign) int defaultFPS; 73 | @property (nonatomic, assign) AVCaptureDevicePosition defaultAVCaptureDevicePosition; 74 | @property (nonatomic, assign) AVCaptureVideoOrientation defaultAVCaptureVideoOrientation; 75 | @property (nonatomic, assign) BOOL useAVCaptureVideoPreviewLayer; 76 | @property (nonatomic, strong) NSString *const defaultAVCaptureSessionPreset; 77 | 78 | @property (nonatomic, assign) int imageWidth; 79 | @property (nonatomic, assign) int imageHeight; 80 | 81 | @property (nonatomic, retain) UIView* parentView; 82 | 83 | - (void)start; 84 | - (void)stop; 85 | - (void)switchCameras; 86 | 87 | - (id)initWithParentView:(UIView*)parent; 88 | 89 | - (void)createCaptureOutput; 90 | - (void)createVideoPreviewLayer; 91 | - (void)updateOrientation; 92 | 93 | 94 | @end 95 | 96 | ///////////////////////////////// CvVideoCamera /////////////////////////////////////////// 97 | 98 | @class CvVideoCamera; 99 | 100 | @protocol CvVideoCameraDelegate 101 | 102 | #ifdef __cplusplus 103 | // delegate method for processing image frames 104 | - (void)processImage:(cv::Mat&)image; 105 | #endif 106 | 107 | @end 108 | 109 | @interface CvVideoCamera : CvAbstractCamera 110 | { 111 | AVCaptureVideoDataOutput *videoDataOutput; 112 | 113 | dispatch_queue_t videoDataOutputQueue; 114 | CALayer *customPreviewLayer; 115 | 116 | BOOL grayscaleMode; 117 | 118 | BOOL recordVideo; 119 | AVAssetWriterInput* recordAssetWriterInput; 120 | AVAssetWriterInputPixelBufferAdaptor* recordPixelBufferAdaptor; 121 | AVAssetWriter* recordAssetWriter; 122 | 123 | CMTime lastSampleTime; 124 | 125 | } 126 | 127 | @property (nonatomic, assign) id delegate; 128 | @property (nonatomic, assign) BOOL grayscaleMode; 129 | 130 | @property (nonatomic, assign) BOOL recordVideo; 131 | @property (nonatomic, retain) AVAssetWriterInput* recordAssetWriterInput; 132 | @property (nonatomic, retain) AVAssetWriterInputPixelBufferAdaptor* recordPixelBufferAdaptor; 133 | @property (nonatomic, retain) AVAssetWriter* recordAssetWriter; 134 | 135 | - (void)adjustLayoutToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation; 136 | - (void)layoutPreviewLayer; 137 | - (void)saveVideo; 138 | - (NSURL *)videoFileURL; 139 | 140 | 141 | @end 142 | 143 | ///////////////////////////////// CvPhotoCamera /////////////////////////////////////////// 144 | 145 | @class CvPhotoCamera; 146 | 147 | @protocol CvPhotoCameraDelegate 148 | 149 | - (void)photoCamera:(CvPhotoCamera*)photoCamera capturedImage:(UIImage *)image; 150 | - (void)photoCameraCancel:(CvPhotoCamera*)photoCamera; 151 | 152 | @end 153 | 154 | @interface CvPhotoCamera : CvAbstractCamera 155 | { 156 | AVCaptureStillImageOutput *stillImageOutput; 157 | } 158 | 159 | @property (nonatomic, assign) id delegate; 160 | 161 | - (void)takePicture; 162 | 163 | @end 164 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/global_motion.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_GLOBAL_MOTION_HPP__ 44 | #define __OPENCV_VIDEOSTAB_GLOBAL_MOTION_HPP__ 45 | 46 | #include 47 | #include "opencv2/core/core.hpp" 48 | #include "opencv2/features2d/features2d.hpp" 49 | #include "opencv2/videostab/optical_flow.hpp" 50 | 51 | namespace cv 52 | { 53 | namespace videostab 54 | { 55 | 56 | enum MotionModel 57 | { 58 | TRANSLATION = 0, 59 | TRANSLATION_AND_SCALE = 1, 60 | LINEAR_SIMILARITY = 2, 61 | AFFINE = 3 62 | }; 63 | 64 | CV_EXPORTS Mat estimateGlobalMotionLeastSquares( 65 | const std::vector &points0, const std::vector &points1, 66 | int model = AFFINE, float *rmse = 0); 67 | 68 | struct CV_EXPORTS RansacParams 69 | { 70 | int size; // subset size 71 | float thresh; // max error to classify as inlier 72 | float eps; // max outliers ratio 73 | float prob; // probability of success 74 | 75 | RansacParams(int _size, float _thresh, float _eps, float _prob) 76 | : size(_size), thresh(_thresh), eps(_eps), prob(_prob) {} 77 | 78 | static RansacParams translationMotionStd() { return RansacParams(2, 0.5f, 0.5f, 0.99f); } 79 | static RansacParams translationAndScale2dMotionStd() { return RansacParams(3, 0.5f, 0.5f, 0.99f); } 80 | static RansacParams linearSimilarityMotionStd() { return RansacParams(4, 0.5f, 0.5f, 0.99f); } 81 | static RansacParams affine2dMotionStd() { return RansacParams(6, 0.5f, 0.5f, 0.99f); } 82 | }; 83 | 84 | CV_EXPORTS Mat estimateGlobalMotionRobust( 85 | const std::vector &points0, const std::vector &points1, 86 | int model = AFFINE, const RansacParams ¶ms = RansacParams::affine2dMotionStd(), 87 | float *rmse = 0, int *ninliers = 0); 88 | 89 | class CV_EXPORTS IGlobalMotionEstimator 90 | { 91 | public: 92 | virtual ~IGlobalMotionEstimator() {} 93 | virtual Mat estimate(const Mat &frame0, const Mat &frame1) = 0; 94 | }; 95 | 96 | class CV_EXPORTS PyrLkRobustMotionEstimator : public IGlobalMotionEstimator 97 | { 98 | public: 99 | PyrLkRobustMotionEstimator(); 100 | 101 | void setDetector(Ptr val) { detector_ = val; } 102 | Ptr detector() const { return detector_; } 103 | 104 | void setOptFlowEstimator(Ptr val) { optFlowEstimator_ = val; } 105 | Ptr optFlowEstimator() const { return optFlowEstimator_; } 106 | 107 | void setMotionModel(MotionModel val) { motionModel_ = val; } 108 | MotionModel motionModel() const { return motionModel_; } 109 | 110 | void setRansacParams(const RansacParams &val) { ransacParams_ = val; } 111 | RansacParams ransacParams() const { return ransacParams_; } 112 | 113 | void setMaxRmse(float val) { maxRmse_ = val; } 114 | float maxRmse() const { return maxRmse_; } 115 | 116 | void setMinInlierRatio(float val) { minInlierRatio_ = val; } 117 | float minInlierRatio() const { return minInlierRatio_; } 118 | 119 | virtual Mat estimate(const Mat &frame0, const Mat &frame1); 120 | 121 | private: 122 | Ptr detector_; 123 | Ptr optFlowEstimator_; 124 | MotionModel motionModel_; 125 | RansacParams ransacParams_; 126 | std::vector status_; 127 | std::vector keypointsPrev_; 128 | std::vector pointsPrev_, points_; 129 | std::vector pointsPrevGood_, pointsGood_; 130 | float maxRmse_; 131 | float minInlierRatio_; 132 | }; 133 | 134 | CV_EXPORTS Mat getMotion(int from, int to, const Mat *motions, int size); 135 | 136 | CV_EXPORTS Mat getMotion(int from, int to, const std::vector &motions); 137 | 138 | } // namespace videostab 139 | } // namespace cv 140 | 141 | #endif 142 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/stitching/warpers.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_STITCHING_WARPER_CREATORS_HPP__ 44 | #define __OPENCV_STITCHING_WARPER_CREATORS_HPP__ 45 | 46 | #include "opencv2/stitching/detail/warpers.hpp" 47 | 48 | namespace cv { 49 | 50 | class WarperCreator 51 | { 52 | public: 53 | virtual ~WarperCreator() {} 54 | virtual Ptr create(float scale) const = 0; 55 | }; 56 | 57 | 58 | class PlaneWarper : public WarperCreator 59 | { 60 | public: 61 | Ptr create(float scale) const { return new detail::PlaneWarper(scale); } 62 | }; 63 | 64 | 65 | class CylindricalWarper: public WarperCreator 66 | { 67 | public: 68 | Ptr create(float scale) const { return new detail::CylindricalWarper(scale); } 69 | }; 70 | 71 | 72 | class SphericalWarper: public WarperCreator 73 | { 74 | public: 75 | Ptr create(float scale) const { return new detail::SphericalWarper(scale); } 76 | }; 77 | 78 | class FisheyeWarper : public WarperCreator 79 | { 80 | public: 81 | Ptr create(float scale) const { return new detail::FisheyeWarper(scale); } 82 | }; 83 | 84 | class StereographicWarper: public WarperCreator 85 | { 86 | public: 87 | Ptr create(float scale) const { return new detail::StereographicWarper(scale); } 88 | }; 89 | 90 | class CompressedRectilinearWarper: public WarperCreator 91 | { 92 | float a, b; 93 | public: 94 | CompressedRectilinearWarper(float A = 1, float B = 1) 95 | { 96 | a = A; b = B; 97 | } 98 | Ptr create(float scale) const { return new detail::CompressedRectilinearWarper(scale, a, b); } 99 | }; 100 | 101 | class CompressedRectilinearPortraitWarper: public WarperCreator 102 | { 103 | float a, b; 104 | public: 105 | CompressedRectilinearPortraitWarper(float A = 1, float B = 1) 106 | { 107 | a = A; b = B; 108 | } 109 | Ptr create(float scale) const { return new detail::CompressedRectilinearPortraitWarper(scale, a, b); } 110 | }; 111 | 112 | class PaniniWarper: public WarperCreator 113 | { 114 | float a, b; 115 | public: 116 | PaniniWarper(float A = 1, float B = 1) 117 | { 118 | a = A; b = B; 119 | } 120 | Ptr create(float scale) const { return new detail::PaniniWarper(scale, a, b); } 121 | }; 122 | 123 | class PaniniPortraitWarper: public WarperCreator 124 | { 125 | float a, b; 126 | public: 127 | PaniniPortraitWarper(float A = 1, float B = 1) 128 | { 129 | a = A; b = B; 130 | } 131 | Ptr create(float scale) const { return new detail::PaniniPortraitWarper(scale, a, b); } 132 | }; 133 | 134 | class MercatorWarper: public WarperCreator 135 | { 136 | public: 137 | Ptr create(float scale) const { return new detail::MercatorWarper(scale); } 138 | }; 139 | 140 | class TransverseMercatorWarper: public WarperCreator 141 | { 142 | public: 143 | Ptr create(float scale) const { return new detail::TransverseMercatorWarper(scale); } 144 | }; 145 | 146 | 147 | 148 | #ifdef HAVE_OPENCV_GPU 149 | class PlaneWarperGpu: public WarperCreator 150 | { 151 | public: 152 | Ptr create(float scale) const { return new detail::PlaneWarperGpu(scale); } 153 | }; 154 | 155 | 156 | class CylindricalWarperGpu: public WarperCreator 157 | { 158 | public: 159 | Ptr create(float scale) const { return new detail::CylindricalWarperGpu(scale); } 160 | }; 161 | 162 | 163 | class SphericalWarperGpu: public WarperCreator 164 | { 165 | public: 166 | Ptr create(float scale) const { return new detail::SphericalWarperGpu(scale); } 167 | }; 168 | #endif 169 | 170 | } // namespace cv 171 | 172 | #endif // __OPENCV_STITCHING_WARPER_CREATORS_HPP__ 173 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/videostab/fast_marching_inl.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_VIDEOSTAB_FAST_MARCHING_INL_HPP__ 44 | #define __OPENCV_VIDEOSTAB_FAST_MARCHING_INL_HPP__ 45 | 46 | #include "opencv2/videostab/fast_marching.hpp" 47 | 48 | namespace cv 49 | { 50 | namespace videostab 51 | { 52 | 53 | template 54 | Inpaint FastMarchingMethod::run(const cv::Mat &mask, Inpaint inpaint) 55 | { 56 | using namespace std; 57 | using namespace cv; 58 | 59 | CV_Assert(mask.type() == CV_8U); 60 | 61 | static const int lut[4][2] = {{-1,0}, {0,-1}, {1,0}, {0,1}}; 62 | 63 | mask.copyTo(flag_); 64 | flag_.create(mask.size()); 65 | dist_.create(mask.size()); 66 | index_.create(mask.size()); 67 | narrowBand_.clear(); 68 | size_ = 0; 69 | 70 | // init 71 | for (int y = 0; y < flag_.rows; ++y) 72 | { 73 | for (int x = 0; x < flag_.cols; ++x) 74 | { 75 | if (flag_(y,x) == KNOWN) 76 | dist_(y,x) = 0.f; 77 | else 78 | { 79 | int n = 0; 80 | int nunknown = 0; 81 | 82 | for (int i = 0; i < 4; ++i) 83 | { 84 | int xn = x + lut[i][0]; 85 | int yn = y + lut[i][1]; 86 | 87 | if (xn >= 0 && xn < flag_.cols && yn >= 0 && yn < flag_.rows) 88 | { 89 | n++; 90 | if (flag_(yn,xn) != KNOWN) 91 | nunknown++; 92 | } 93 | } 94 | 95 | if (n>0 && nunknown == n) 96 | { 97 | dist_(y,x) = inf_; 98 | flag_(y,x) = INSIDE; 99 | } 100 | else 101 | { 102 | dist_(y,x) = 0.f; 103 | flag_(y,x) = BAND; 104 | inpaint(x, y); 105 | 106 | narrowBand_.push_back(DXY(0.f,x,y)); 107 | index_(y,x) = size_++; 108 | } 109 | } 110 | } 111 | } 112 | 113 | // make heap 114 | for (int i = size_/2-1; i >= 0; --i) 115 | heapDown(i); 116 | 117 | // main cycle 118 | while (size_ > 0) 119 | { 120 | int x = narrowBand_[0].x; 121 | int y = narrowBand_[0].y; 122 | heapRemoveMin(); 123 | 124 | flag_(y,x) = KNOWN; 125 | for (int n = 0; n < 4; ++n) 126 | { 127 | int xn = x + lut[n][0]; 128 | int yn = y + lut[n][1]; 129 | 130 | if (xn >= 0 && xn < flag_.cols && yn >= 0 && yn < flag_.rows && flag_(yn,xn) != KNOWN) 131 | { 132 | dist_(yn,xn) = min(min(solve(xn-1, yn, xn, yn-1), solve(xn+1, yn, xn, yn-1)), 133 | min(solve(xn-1, yn, xn, yn+1), solve(xn+1, yn, xn, yn+1))); 134 | 135 | if (flag_(yn,xn) == INSIDE) 136 | { 137 | flag_(yn,xn) = BAND; 138 | inpaint(xn, yn); 139 | heapAdd(DXY(dist_(yn,xn),xn,yn)); 140 | } 141 | else 142 | { 143 | int i = index_(yn,xn); 144 | if (dist_(yn,xn) < narrowBand_[i].dist) 145 | { 146 | narrowBand_[i].dist = dist_(yn,xn); 147 | heapUp(i); 148 | } 149 | // works better if it's commented out 150 | /*else if (dist(yn,xn) > narrowBand[i].dist) 151 | { 152 | narrowBand[i].dist = dist(yn,xn); 153 | heapDown(i); 154 | }*/ 155 | } 156 | } 157 | } 158 | } 159 | 160 | return inpaint; 161 | } 162 | 163 | } // namespace videostab 164 | } // namespace cv 165 | 166 | #endif 167 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/stitching/detail/util.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_STITCHING_UTIL_HPP__ 44 | #define __OPENCV_STITCHING_UTIL_HPP__ 45 | 46 | #include 47 | #include "opencv2/core/core.hpp" 48 | 49 | #define ENABLE_LOG 0 50 | 51 | // TODO remove LOG macros, add logging class 52 | #if ENABLE_LOG 53 | #ifdef ANDROID 54 | #include 55 | #include 56 | #include 57 | #define LOG_STITCHING_MSG(msg) \ 58 | do { \ 59 | std::stringstream _os; \ 60 | _os << msg; \ 61 | __android_log_print(ANDROID_LOG_DEBUG, "STITCHING", "%s", _os.str().c_str()); \ 62 | } while(0); 63 | #else 64 | #include 65 | #define LOG_STITCHING_MSG(msg) for(;;) { std::cout << msg; std::cout.flush(); break; } 66 | #endif 67 | #else 68 | #define LOG_STITCHING_MSG(msg) 69 | #endif 70 | 71 | #define LOG_(_level, _msg) \ 72 | for(;;) \ 73 | { \ 74 | if ((_level) >= ::cv::detail::stitchingLogLevel()) \ 75 | { \ 76 | LOG_STITCHING_MSG(_msg); \ 77 | } \ 78 | break; \ 79 | } 80 | 81 | 82 | #define LOG(msg) LOG_(1, msg) 83 | #define LOG_CHAT(msg) LOG_(0, msg) 84 | 85 | #define LOGLN(msg) LOG(msg << std::endl) 86 | #define LOGLN_CHAT(msg) LOG_CHAT(msg << std::endl) 87 | 88 | //#if DEBUG_LOG_CHAT 89 | // #define LOG_CHAT(msg) LOG(msg) 90 | // #define LOGLN_CHAT(msg) LOGLN(msg) 91 | //#else 92 | // #define LOG_CHAT(msg) do{}while(0) 93 | // #define LOGLN_CHAT(msg) do{}while(0) 94 | //#endif 95 | 96 | namespace cv { 97 | namespace detail { 98 | 99 | class CV_EXPORTS DisjointSets 100 | { 101 | public: 102 | DisjointSets(int elem_count = 0) { createOneElemSets(elem_count); } 103 | 104 | void createOneElemSets(int elem_count); 105 | int findSetByElem(int elem); 106 | int mergeSets(int set1, int set2); 107 | 108 | std::vector parent; 109 | std::vector size; 110 | 111 | private: 112 | std::vector rank_; 113 | }; 114 | 115 | 116 | struct CV_EXPORTS GraphEdge 117 | { 118 | GraphEdge(int from, int to, float weight); 119 | bool operator <(const GraphEdge& other) const { return weight < other.weight; } 120 | bool operator >(const GraphEdge& other) const { return weight > other.weight; } 121 | 122 | int from, to; 123 | float weight; 124 | }; 125 | 126 | inline GraphEdge::GraphEdge(int _from, int _to, float _weight) : from(_from), to(_to), weight(_weight) {} 127 | 128 | 129 | class CV_EXPORTS Graph 130 | { 131 | public: 132 | Graph(int num_vertices = 0) { create(num_vertices); } 133 | void create(int num_vertices) { edges_.assign(num_vertices, std::list()); } 134 | int numVertices() const { return static_cast(edges_.size()); } 135 | void addEdge(int from, int to, float weight); 136 | template B forEach(B body) const; 137 | template B walkBreadthFirst(int from, B body) const; 138 | 139 | private: 140 | std::vector< std::list > edges_; 141 | }; 142 | 143 | 144 | ////////////////////////////////////////////////////////////////////////////// 145 | // Auxiliary functions 146 | 147 | CV_EXPORTS bool overlapRoi(Point tl1, Point tl2, Size sz1, Size sz2, Rect &roi); 148 | CV_EXPORTS Rect resultRoi(const std::vector &corners, const std::vector &images); 149 | CV_EXPORTS Rect resultRoi(const std::vector &corners, const std::vector &sizes); 150 | CV_EXPORTS Point resultTl(const std::vector &corners); 151 | 152 | // Returns random 'count' element subset of the {0,1,...,size-1} set 153 | CV_EXPORTS void selectRandomSubset(int count, int size, std::vector &subset); 154 | 155 | CV_EXPORTS int& stitchingLogLevel(); 156 | 157 | } // namespace detail 158 | } // namespace cv 159 | 160 | #include "util_inl.hpp" 161 | 162 | #endif // __OPENCV_STITCHING_UTIL_HPP__ 163 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/nonfree/features2d.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef __OPENCV_NONFREE_FEATURES_2D_HPP__ 44 | #define __OPENCV_NONFREE_FEATURES_2D_HPP__ 45 | 46 | #include "opencv2/features2d/features2d.hpp" 47 | 48 | #ifdef __cplusplus 49 | 50 | namespace cv 51 | { 52 | 53 | /*! 54 | SIFT implementation. 55 | 56 | The class implements SIFT algorithm by D. Lowe. 57 | */ 58 | class CV_EXPORTS_W SIFT : public Feature2D 59 | { 60 | public: 61 | CV_WRAP explicit SIFT( int nfeatures=0, int nOctaveLayers=3, 62 | double contrastThreshold=0.04, double edgeThreshold=10, 63 | double sigma=1.6); 64 | 65 | //! returns the descriptor size in floats (128) 66 | CV_WRAP int descriptorSize() const; 67 | 68 | //! returns the descriptor type 69 | CV_WRAP int descriptorType() const; 70 | 71 | //! finds the keypoints using SIFT algorithm 72 | void operator()(InputArray img, InputArray mask, 73 | vector& keypoints) const; 74 | //! finds the keypoints and computes descriptors for them using SIFT algorithm. 75 | //! Optionally it can compute descriptors for the user-provided keypoints 76 | void operator()(InputArray img, InputArray mask, 77 | vector& keypoints, 78 | OutputArray descriptors, 79 | bool useProvidedKeypoints=false) const; 80 | 81 | AlgorithmInfo* info() const; 82 | 83 | void buildGaussianPyramid( const Mat& base, vector& pyr, int nOctaves ) const; 84 | void buildDoGPyramid( const vector& pyr, vector& dogpyr ) const; 85 | void findScaleSpaceExtrema( const vector& gauss_pyr, const vector& dog_pyr, 86 | vector& keypoints ) const; 87 | 88 | protected: 89 | void detectImpl( const Mat& image, vector& keypoints, const Mat& mask=Mat() ) const; 90 | void computeImpl( const Mat& image, vector& keypoints, Mat& descriptors ) const; 91 | 92 | CV_PROP_RW int nfeatures; 93 | CV_PROP_RW int nOctaveLayers; 94 | CV_PROP_RW double contrastThreshold; 95 | CV_PROP_RW double edgeThreshold; 96 | CV_PROP_RW double sigma; 97 | }; 98 | 99 | typedef SIFT SiftFeatureDetector; 100 | typedef SIFT SiftDescriptorExtractor; 101 | 102 | /*! 103 | SURF implementation. 104 | 105 | The class implements SURF algorithm by H. Bay et al. 106 | */ 107 | class CV_EXPORTS_W SURF : public Feature2D 108 | { 109 | public: 110 | //! the default constructor 111 | CV_WRAP SURF(); 112 | //! the full constructor taking all the necessary parameters 113 | explicit CV_WRAP SURF(double hessianThreshold, 114 | int nOctaves=4, int nOctaveLayers=2, 115 | bool extended=true, bool upright=false); 116 | 117 | //! returns the descriptor size in float's (64 or 128) 118 | CV_WRAP int descriptorSize() const; 119 | 120 | //! returns the descriptor type 121 | CV_WRAP int descriptorType() const; 122 | 123 | //! finds the keypoints using fast hessian detector used in SURF 124 | void operator()(InputArray img, InputArray mask, 125 | CV_OUT vector& keypoints) const; 126 | //! finds the keypoints and computes their descriptors. Optionally it can compute descriptors for the user-provided keypoints 127 | void operator()(InputArray img, InputArray mask, 128 | CV_OUT vector& keypoints, 129 | OutputArray descriptors, 130 | bool useProvidedKeypoints=false) const; 131 | 132 | AlgorithmInfo* info() const; 133 | 134 | CV_PROP_RW double hessianThreshold; 135 | CV_PROP_RW int nOctaves; 136 | CV_PROP_RW int nOctaveLayers; 137 | CV_PROP_RW bool extended; 138 | CV_PROP_RW bool upright; 139 | 140 | protected: 141 | 142 | void detectImpl( const Mat& image, vector& keypoints, const Mat& mask=Mat() ) const; 143 | void computeImpl( const Mat& image, vector& keypoints, Mat& descriptors ) const; 144 | }; 145 | 146 | typedef SURF SurfFeatureDetector; 147 | typedef SURF SurfDescriptorExtractor; 148 | 149 | } /* namespace cv */ 150 | 151 | #endif /* __cplusplus */ 152 | 153 | #endif 154 | 155 | /* End of file. */ 156 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/simplex_downhill.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_SIMPLEX_DOWNHILL_H_ 32 | #define OPENCV_FLANN_SIMPLEX_DOWNHILL_H_ 33 | 34 | namespace cvflann 35 | { 36 | 37 | /** 38 | Adds val to array vals (and point to array points) and keeping the arrays sorted by vals. 39 | */ 40 | template 41 | void addValue(int pos, float val, float* vals, T* point, T* points, int n) 42 | { 43 | vals[pos] = val; 44 | for (int i=0; i0 && vals[j] 69 | float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL ) 70 | { 71 | const int MAX_ITERATIONS = 10; 72 | 73 | assert(n>0); 74 | 75 | T* p_o = new T[n]; 76 | T* p_r = new T[n]; 77 | T* p_e = new T[n]; 78 | 79 | int alpha = 1; 80 | 81 | int iterations = 0; 82 | 83 | bool ownVals = false; 84 | if (vals == NULL) { 85 | ownVals = true; 86 | vals = new float[n+1]; 87 | for (int i=0; i MAX_ITERATIONS) break; 97 | 98 | // compute average of simplex points (except the highest point) 99 | for (int j=0; j=vals[0])&&(val_r=vals[n]) { 151 | for (int i=0; i 50 | struct index_creator 51 | { 52 | static NNIndex* create(const Matrix& dataset, const IndexParams& params, const Distance& distance) 53 | { 54 | flann_algorithm_t index_type = get_param(params, "algorithm"); 55 | 56 | NNIndex* nnIndex; 57 | switch (index_type) { 58 | case FLANN_INDEX_LINEAR: 59 | nnIndex = new LinearIndex(dataset, params, distance); 60 | break; 61 | case FLANN_INDEX_KDTREE_SINGLE: 62 | nnIndex = new KDTreeSingleIndex(dataset, params, distance); 63 | break; 64 | case FLANN_INDEX_KDTREE: 65 | nnIndex = new KDTreeIndex(dataset, params, distance); 66 | break; 67 | case FLANN_INDEX_KMEANS: 68 | nnIndex = new KMeansIndex(dataset, params, distance); 69 | break; 70 | case FLANN_INDEX_COMPOSITE: 71 | nnIndex = new CompositeIndex(dataset, params, distance); 72 | break; 73 | case FLANN_INDEX_AUTOTUNED: 74 | nnIndex = new AutotunedIndex(dataset, params, distance); 75 | break; 76 | case FLANN_INDEX_HIERARCHICAL: 77 | nnIndex = new HierarchicalClusteringIndex(dataset, params, distance); 78 | break; 79 | case FLANN_INDEX_LSH: 80 | nnIndex = new LshIndex(dataset, params, distance); 81 | break; 82 | default: 83 | throw FLANNException("Unknown index type"); 84 | } 85 | 86 | return nnIndex; 87 | } 88 | }; 89 | 90 | template 91 | struct index_creator 92 | { 93 | static NNIndex* create(const Matrix& dataset, const IndexParams& params, const Distance& distance) 94 | { 95 | flann_algorithm_t index_type = get_param(params, "algorithm"); 96 | 97 | NNIndex* nnIndex; 98 | switch (index_type) { 99 | case FLANN_INDEX_LINEAR: 100 | nnIndex = new LinearIndex(dataset, params, distance); 101 | break; 102 | case FLANN_INDEX_KMEANS: 103 | nnIndex = new KMeansIndex(dataset, params, distance); 104 | break; 105 | case FLANN_INDEX_HIERARCHICAL: 106 | nnIndex = new HierarchicalClusteringIndex(dataset, params, distance); 107 | break; 108 | case FLANN_INDEX_LSH: 109 | nnIndex = new LshIndex(dataset, params, distance); 110 | break; 111 | default: 112 | throw FLANNException("Unknown index type"); 113 | } 114 | 115 | return nnIndex; 116 | } 117 | }; 118 | 119 | template 120 | struct index_creator 121 | { 122 | static NNIndex* create(const Matrix& dataset, const IndexParams& params, const Distance& distance) 123 | { 124 | flann_algorithm_t index_type = get_param(params, "algorithm"); 125 | 126 | NNIndex* nnIndex; 127 | switch (index_type) { 128 | case FLANN_INDEX_LINEAR: 129 | nnIndex = new LinearIndex(dataset, params, distance); 130 | break; 131 | case FLANN_INDEX_HIERARCHICAL: 132 | nnIndex = new HierarchicalClusteringIndex(dataset, params, distance); 133 | break; 134 | case FLANN_INDEX_LSH: 135 | nnIndex = new LshIndex(dataset, params, distance); 136 | break; 137 | default: 138 | throw FLANNException("Unknown index type"); 139 | } 140 | 141 | return nnIndex; 142 | } 143 | }; 144 | 145 | template 146 | NNIndex* create_index_by_type(const Matrix& dataset, const IndexParams& params, const Distance& distance) 147 | { 148 | return index_creator::create(dataset, params,distance); 151 | } 152 | 153 | } 154 | 155 | #endif /* OPENCV_FLANN_ALL_INDICES_H_ */ 156 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/saving.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 11 | * 1. Redistributions of source code must retain the above copyright 12 | * notice, this list of conditions and the following disclaimer. 13 | * 2. Redistributions in binary form must reproduce the above copyright 14 | * notice, this list of conditions and the following disclaimer in the 15 | * documentation and/or other materials provided with the distribution. 16 | * 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE NNIndexGOODS OR SERVICES; LOSS OF USE, 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | *************************************************************************/ 28 | 29 | #ifndef OPENCV_FLANN_SAVING_H_ 30 | #define OPENCV_FLANN_SAVING_H_ 31 | 32 | #include 33 | #include 34 | 35 | #include "general.h" 36 | #include "nn_index.h" 37 | 38 | #ifdef FLANN_SIGNATURE_ 39 | #undef FLANN_SIGNATURE_ 40 | #endif 41 | #define FLANN_SIGNATURE_ "FLANN_INDEX" 42 | 43 | namespace cvflann 44 | { 45 | 46 | template 47 | struct Datatype {}; 48 | template<> 49 | struct Datatype { static flann_datatype_t type() { return FLANN_INT8; } }; 50 | template<> 51 | struct Datatype { static flann_datatype_t type() { return FLANN_INT16; } }; 52 | template<> 53 | struct Datatype { static flann_datatype_t type() { return FLANN_INT32; } }; 54 | template<> 55 | struct Datatype { static flann_datatype_t type() { return FLANN_UINT8; } }; 56 | template<> 57 | struct Datatype { static flann_datatype_t type() { return FLANN_UINT16; } }; 58 | template<> 59 | struct Datatype { static flann_datatype_t type() { return FLANN_UINT32; } }; 60 | template<> 61 | struct Datatype { static flann_datatype_t type() { return FLANN_FLOAT32; } }; 62 | template<> 63 | struct Datatype { static flann_datatype_t type() { return FLANN_FLOAT64; } }; 64 | 65 | 66 | /** 67 | * Structure representing the index header. 68 | */ 69 | struct IndexHeader 70 | { 71 | char signature[16]; 72 | char version[16]; 73 | flann_datatype_t data_type; 74 | flann_algorithm_t index_type; 75 | size_t rows; 76 | size_t cols; 77 | }; 78 | 79 | /** 80 | * Saves index header to stream 81 | * 82 | * @param stream - Stream to save to 83 | * @param index - The index to save 84 | */ 85 | template 86 | void save_header(FILE* stream, const NNIndex& index) 87 | { 88 | IndexHeader header; 89 | memset(header.signature, 0, sizeof(header.signature)); 90 | strcpy(header.signature, FLANN_SIGNATURE_); 91 | memset(header.version, 0, sizeof(header.version)); 92 | strcpy(header.version, FLANN_VERSION_); 93 | header.data_type = Datatype::type(); 94 | header.index_type = index.getType(); 95 | header.rows = index.size(); 96 | header.cols = index.veclen(); 97 | 98 | std::fwrite(&header, sizeof(header),1,stream); 99 | } 100 | 101 | 102 | /** 103 | * 104 | * @param stream - Stream to load from 105 | * @return Index header 106 | */ 107 | inline IndexHeader load_header(FILE* stream) 108 | { 109 | IndexHeader header; 110 | size_t read_size = fread(&header,sizeof(header),1,stream); 111 | 112 | if (read_size!=(size_t)1) { 113 | throw FLANNException("Invalid index file, cannot read"); 114 | } 115 | 116 | if (strcmp(header.signature,FLANN_SIGNATURE_)!=0) { 117 | throw FLANNException("Invalid index file, wrong signature"); 118 | } 119 | 120 | return header; 121 | 122 | } 123 | 124 | 125 | template 126 | void save_value(FILE* stream, const T& value, size_t count = 1) 127 | { 128 | fwrite(&value, sizeof(value),count, stream); 129 | } 130 | 131 | template 132 | void save_value(FILE* stream, const cvflann::Matrix& value) 133 | { 134 | fwrite(&value, sizeof(value),1, stream); 135 | fwrite(value.data, sizeof(T),value.rows*value.cols, stream); 136 | } 137 | 138 | template 139 | void save_value(FILE* stream, const std::vector& value) 140 | { 141 | size_t size = value.size(); 142 | fwrite(&size, sizeof(size_t), 1, stream); 143 | fwrite(&value[0], sizeof(T), size, stream); 144 | } 145 | 146 | template 147 | void load_value(FILE* stream, T& value, size_t count = 1) 148 | { 149 | size_t read_cnt = fread(&value, sizeof(value), count, stream); 150 | if (read_cnt != count) { 151 | throw FLANNException("Cannot read from file"); 152 | } 153 | } 154 | 155 | template 156 | void load_value(FILE* stream, cvflann::Matrix& value) 157 | { 158 | size_t read_cnt = fread(&value, sizeof(value), 1, stream); 159 | if (read_cnt != 1) { 160 | throw FLANNException("Cannot read from file"); 161 | } 162 | value.data = new T[value.rows*value.cols]; 163 | read_cnt = fread(value.data, sizeof(T), value.rows*value.cols, stream); 164 | if (read_cnt != (size_t)(value.rows*value.cols)) { 165 | throw FLANNException("Cannot read from file"); 166 | } 167 | } 168 | 169 | 170 | template 171 | void load_value(FILE* stream, std::vector& value) 172 | { 173 | size_t size; 174 | size_t read_cnt = fread(&size, sizeof(size_t), 1, stream); 175 | if (read_cnt!=1) { 176 | throw FLANNException("Cannot read from file"); 177 | } 178 | value.resize(size); 179 | read_cnt = fread(&value[0], sizeof(T), size, stream); 180 | if (read_cnt != size) { 181 | throw FLANNException("Cannot read from file"); 182 | } 183 | } 184 | 185 | } 186 | 187 | #endif /* OPENCV_FLANN_SAVING_H_ */ 188 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/miniflann.hpp: -------------------------------------------------------------------------------- 1 | /*M/////////////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 | // 5 | // By downloading, copying, installing or using the software you agree to this license. 6 | // If you do not agree to this license, do not download, install, 7 | // copy or use the software. 8 | // 9 | // 10 | // License Agreement 11 | // For Open Source Computer Vision Library 12 | // 13 | // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 | // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 | // Third party copyrights are property of their respective owners. 16 | // 17 | // Redistribution and use in source and binary forms, with or without modification, 18 | // are permitted provided that the following conditions are met: 19 | // 20 | // * Redistribution's of source code must retain the above copyright notice, 21 | // this list of conditions and the following disclaimer. 22 | // 23 | // * Redistribution's in binary form must reproduce the above copyright notice, 24 | // this list of conditions and the following disclaimer in the documentation 25 | // and/or other materials provided with the distribution. 26 | // 27 | // * The name of the copyright holders may not be used to endorse or promote products 28 | // derived from this software without specific prior written permission. 29 | // 30 | // This software is provided by the copyright holders and contributors "as is" and 31 | // any express or implied warranties, including, but not limited to, the implied 32 | // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 | // In no event shall the Intel Corporation or contributors be liable for any direct, 34 | // indirect, incidental, special, exemplary, or consequential damages 35 | // (including, but not limited to, procurement of substitute goods or services; 36 | // loss of use, data, or profits; or business interruption) however caused 37 | // and on any theory of liability, whether in contract, strict liability, 38 | // or tort (including negligence or otherwise) arising in any way out of 39 | // the use of this software, even if advised of the possibility of such damage. 40 | // 41 | //M*/ 42 | 43 | #ifndef _OPENCV_MINIFLANN_HPP_ 44 | #define _OPENCV_MINIFLANN_HPP_ 45 | 46 | #ifdef __cplusplus 47 | 48 | #include "opencv2/core/core.hpp" 49 | #include "opencv2/flann/defines.h" 50 | 51 | namespace cv 52 | { 53 | 54 | namespace flann 55 | { 56 | 57 | struct CV_EXPORTS IndexParams 58 | { 59 | IndexParams(); 60 | ~IndexParams(); 61 | 62 | std::string getString(const std::string& key, const std::string& defaultVal=std::string()) const; 63 | int getInt(const std::string& key, int defaultVal=-1) const; 64 | double getDouble(const std::string& key, double defaultVal=-1) const; 65 | 66 | void setString(const std::string& key, const std::string& value); 67 | void setInt(const std::string& key, int value); 68 | void setDouble(const std::string& key, double value); 69 | void setFloat(const std::string& key, float value); 70 | void setBool(const std::string& key, bool value); 71 | void setAlgorithm(int value); 72 | 73 | void getAll(std::vector& names, 74 | std::vector& types, 75 | std::vector& strValues, 76 | std::vector& numValues) const; 77 | 78 | void* params; 79 | }; 80 | 81 | struct CV_EXPORTS KDTreeIndexParams : public IndexParams 82 | { 83 | KDTreeIndexParams(int trees=4); 84 | }; 85 | 86 | struct CV_EXPORTS LinearIndexParams : public IndexParams 87 | { 88 | LinearIndexParams(); 89 | }; 90 | 91 | struct CV_EXPORTS CompositeIndexParams : public IndexParams 92 | { 93 | CompositeIndexParams(int trees = 4, int branching = 32, int iterations = 11, 94 | cvflann::flann_centers_init_t centers_init = cvflann::FLANN_CENTERS_RANDOM, float cb_index = 0.2 ); 95 | }; 96 | 97 | struct CV_EXPORTS AutotunedIndexParams : public IndexParams 98 | { 99 | AutotunedIndexParams(float target_precision = 0.8, float build_weight = 0.01, 100 | float memory_weight = 0, float sample_fraction = 0.1); 101 | }; 102 | 103 | struct CV_EXPORTS HierarchicalClusteringIndexParams : public IndexParams 104 | { 105 | HierarchicalClusteringIndexParams(int branching = 32, 106 | cvflann::flann_centers_init_t centers_init = cvflann::FLANN_CENTERS_RANDOM, int trees = 4, int leaf_size = 100 ); 107 | }; 108 | 109 | struct CV_EXPORTS KMeansIndexParams : public IndexParams 110 | { 111 | KMeansIndexParams(int branching = 32, int iterations = 11, 112 | cvflann::flann_centers_init_t centers_init = cvflann::FLANN_CENTERS_RANDOM, float cb_index = 0.2 ); 113 | }; 114 | 115 | struct CV_EXPORTS LshIndexParams : public IndexParams 116 | { 117 | LshIndexParams(int table_number, int key_size, int multi_probe_level); 118 | }; 119 | 120 | struct CV_EXPORTS SavedIndexParams : public IndexParams 121 | { 122 | SavedIndexParams(const std::string& filename); 123 | }; 124 | 125 | struct CV_EXPORTS SearchParams : public IndexParams 126 | { 127 | SearchParams( int checks = 32, float eps = 0, bool sorted = true ); 128 | }; 129 | 130 | class CV_EXPORTS_W Index 131 | { 132 | public: 133 | CV_WRAP Index(); 134 | CV_WRAP Index(InputArray features, const IndexParams& params, cvflann::flann_distance_t distType=cvflann::FLANN_DIST_L2); 135 | virtual ~Index(); 136 | 137 | CV_WRAP virtual void build(InputArray features, const IndexParams& params, cvflann::flann_distance_t distType=cvflann::FLANN_DIST_L2); 138 | CV_WRAP virtual void knnSearch(InputArray query, OutputArray indices, 139 | OutputArray dists, int knn, const SearchParams& params=SearchParams()); 140 | 141 | CV_WRAP virtual int radiusSearch(InputArray query, OutputArray indices, 142 | OutputArray dists, double radius, int maxResults, 143 | const SearchParams& params=SearchParams()); 144 | 145 | CV_WRAP virtual void save(const std::string& filename) const; 146 | CV_WRAP virtual bool load(InputArray features, const std::string& filename); 147 | CV_WRAP virtual void release(); 148 | CV_WRAP cvflann::flann_distance_t getDistance() const; 149 | CV_WRAP cvflann::flann_algorithm_t getAlgorithm() const; 150 | 151 | protected: 152 | cvflann::flann_distance_t distType; 153 | cvflann::flann_algorithm_t algo; 154 | int featureType; 155 | void* index; 156 | }; 157 | 158 | } } // namespace cv::flann 159 | 160 | #endif // __cplusplus 161 | 162 | #endif 163 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/nn_index.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_NNINDEX_H 32 | #define OPENCV_FLANN_NNINDEX_H 33 | 34 | #include 35 | 36 | #include "general.h" 37 | #include "matrix.h" 38 | #include "result_set.h" 39 | #include "params.h" 40 | 41 | namespace cvflann 42 | { 43 | 44 | /** 45 | * Nearest-neighbour index base class 46 | */ 47 | template 48 | class NNIndex 49 | { 50 | typedef typename Distance::ElementType ElementType; 51 | typedef typename Distance::ResultType DistanceType; 52 | 53 | public: 54 | 55 | virtual ~NNIndex() {} 56 | 57 | /** 58 | * \brief Builds the index 59 | */ 60 | virtual void buildIndex() = 0; 61 | 62 | /** 63 | * \brief Perform k-nearest neighbor search 64 | * \param[in] queries The query points for which to find the nearest neighbors 65 | * \param[out] indices The indices of the nearest neighbors found 66 | * \param[out] dists Distances to the nearest neighbors found 67 | * \param[in] knn Number of nearest neighbors to return 68 | * \param[in] params Search parameters 69 | */ 70 | virtual void knnSearch(const Matrix& queries, Matrix& indices, Matrix& dists, int knn, const SearchParams& params) 71 | { 72 | assert(queries.cols == veclen()); 73 | assert(indices.rows >= queries.rows); 74 | assert(dists.rows >= queries.rows); 75 | assert(int(indices.cols) >= knn); 76 | assert(int(dists.cols) >= knn); 77 | 78 | #if 0 79 | KNNResultSet resultSet(knn); 80 | for (size_t i = 0; i < queries.rows; i++) { 81 | resultSet.init(indices[i], dists[i]); 82 | findNeighbors(resultSet, queries[i], params); 83 | } 84 | #else 85 | KNNUniqueResultSet resultSet(knn); 86 | for (size_t i = 0; i < queries.rows; i++) { 87 | resultSet.clear(); 88 | findNeighbors(resultSet, queries[i], params); 89 | if (get_param(params,"sorted",true)) resultSet.sortAndCopy(indices[i], dists[i], knn); 90 | else resultSet.copy(indices[i], dists[i], knn); 91 | } 92 | #endif 93 | } 94 | 95 | /** 96 | * \brief Perform radius search 97 | * \param[in] query The query point 98 | * \param[out] indices The indinces of the neighbors found within the given radius 99 | * \param[out] dists The distances to the nearest neighbors found 100 | * \param[in] radius The radius used for search 101 | * \param[in] params Search parameters 102 | * \returns Number of neighbors found 103 | */ 104 | virtual int radiusSearch(const Matrix& query, Matrix& indices, Matrix& dists, float radius, const SearchParams& params) 105 | { 106 | if (query.rows != 1) { 107 | fprintf(stderr, "I can only search one feature at a time for range search\n"); 108 | return -1; 109 | } 110 | assert(query.cols == veclen()); 111 | assert(indices.cols == dists.cols); 112 | 113 | int n = 0; 114 | int* indices_ptr = NULL; 115 | DistanceType* dists_ptr = NULL; 116 | if (indices.cols > 0) { 117 | n = (int)indices.cols; 118 | indices_ptr = indices[0]; 119 | dists_ptr = dists[0]; 120 | } 121 | 122 | RadiusUniqueResultSet resultSet((DistanceType)radius); 123 | resultSet.clear(); 124 | findNeighbors(resultSet, query[0], params); 125 | if (n>0) { 126 | if (get_param(params,"sorted",true)) resultSet.sortAndCopy(indices_ptr, dists_ptr, n); 127 | else resultSet.copy(indices_ptr, dists_ptr, n); 128 | } 129 | 130 | return (int)resultSet.size(); 131 | } 132 | 133 | /** 134 | * \brief Saves the index to a stream 135 | * \param stream The stream to save the index to 136 | */ 137 | virtual void saveIndex(FILE* stream) = 0; 138 | 139 | /** 140 | * \brief Loads the index from a stream 141 | * \param stream The stream from which the index is loaded 142 | */ 143 | virtual void loadIndex(FILE* stream) = 0; 144 | 145 | /** 146 | * \returns number of features in this index. 147 | */ 148 | virtual size_t size() const = 0; 149 | 150 | /** 151 | * \returns The dimensionality of the features in this index. 152 | */ 153 | virtual size_t veclen() const = 0; 154 | 155 | /** 156 | * \returns The amount of memory (in bytes) used by the index. 157 | */ 158 | virtual int usedMemory() const = 0; 159 | 160 | /** 161 | * \returns The index type (kdtree, kmeans,...) 162 | */ 163 | virtual flann_algorithm_t getType() const = 0; 164 | 165 | /** 166 | * \returns The index parameters 167 | */ 168 | virtual IndexParams getParameters() const = 0; 169 | 170 | 171 | /** 172 | * \brief Method that searches for nearest-neighbours 173 | */ 174 | virtual void findNeighbors(ResultSet& result, const ElementType* vec, const SearchParams& searchParams) = 0; 175 | }; 176 | 177 | } 178 | 179 | #endif //OPENCV_FLANN_NNINDEX_H 180 | -------------------------------------------------------------------------------- /lib/opencv2.framework/Versions/A/Headers/flann/composite_index.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * THE BSD LICENSE 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * 1. Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * 2. Redistributions in binary form must reproduce the above copyright 16 | * notice, this list of conditions and the following disclaimer in the 17 | * documentation and/or other materials provided with the distribution. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | *************************************************************************/ 30 | 31 | #ifndef OPENCV_FLANN_COMPOSITE_INDEX_H_ 32 | #define OPENCV_FLANN_COMPOSITE_INDEX_H_ 33 | 34 | #include "general.h" 35 | #include "nn_index.h" 36 | #include "kdtree_index.h" 37 | #include "kmeans_index.h" 38 | 39 | namespace cvflann 40 | { 41 | 42 | /** 43 | * Index parameters for the CompositeIndex. 44 | */ 45 | struct CompositeIndexParams : public IndexParams 46 | { 47 | CompositeIndexParams(int trees = 4, int branching = 32, int iterations = 11, 48 | flann_centers_init_t centers_init = FLANN_CENTERS_RANDOM, float cb_index = 0.2 ) 49 | { 50 | (*this)["algorithm"] = FLANN_INDEX_KMEANS; 51 | // number of randomized trees to use (for kdtree) 52 | (*this)["trees"] = trees; 53 | // branching factor 54 | (*this)["branching"] = branching; 55 | // max iterations to perform in one kmeans clustering (kmeans tree) 56 | (*this)["iterations"] = iterations; 57 | // algorithm used for picking the initial cluster centers for kmeans tree 58 | (*this)["centers_init"] = centers_init; 59 | // cluster boundary index. Used when searching the kmeans tree 60 | (*this)["cb_index"] = cb_index; 61 | } 62 | }; 63 | 64 | 65 | /** 66 | * This index builds a kd-tree index and a k-means index and performs nearest 67 | * neighbour search both indexes. This gives a slight boost in search performance 68 | * as some of the neighbours that are missed by one index are found by the other. 69 | */ 70 | template 71 | class CompositeIndex : public NNIndex 72 | { 73 | public: 74 | typedef typename Distance::ElementType ElementType; 75 | typedef typename Distance::ResultType DistanceType; 76 | 77 | /** 78 | * Index constructor 79 | * @param inputData dataset containing the points to index 80 | * @param params Index parameters 81 | * @param d Distance functor 82 | * @return 83 | */ 84 | CompositeIndex(const Matrix& inputData, const IndexParams& params = CompositeIndexParams(), 85 | Distance d = Distance()) : index_params_(params) 86 | { 87 | kdtree_index_ = new KDTreeIndex(inputData, params, d); 88 | kmeans_index_ = new KMeansIndex(inputData, params, d); 89 | 90 | } 91 | 92 | CompositeIndex(const CompositeIndex&); 93 | CompositeIndex& operator=(const CompositeIndex&); 94 | 95 | virtual ~CompositeIndex() 96 | { 97 | delete kdtree_index_; 98 | delete kmeans_index_; 99 | } 100 | 101 | /** 102 | * @return The index type 103 | */ 104 | flann_algorithm_t getType() const 105 | { 106 | return FLANN_INDEX_COMPOSITE; 107 | } 108 | 109 | /** 110 | * @return Size of the index 111 | */ 112 | size_t size() const 113 | { 114 | return kdtree_index_->size(); 115 | } 116 | 117 | /** 118 | * \returns The dimensionality of the features in this index. 119 | */ 120 | size_t veclen() const 121 | { 122 | return kdtree_index_->veclen(); 123 | } 124 | 125 | /** 126 | * \returns The amount of memory (in bytes) used by the index. 127 | */ 128 | int usedMemory() const 129 | { 130 | return kmeans_index_->usedMemory() + kdtree_index_->usedMemory(); 131 | } 132 | 133 | /** 134 | * \brief Builds the index 135 | */ 136 | void buildIndex() 137 | { 138 | Logger::info("Building kmeans tree...\n"); 139 | kmeans_index_->buildIndex(); 140 | Logger::info("Building kdtree tree...\n"); 141 | kdtree_index_->buildIndex(); 142 | } 143 | 144 | /** 145 | * \brief Saves the index to a stream 146 | * \param stream The stream to save the index to 147 | */ 148 | void saveIndex(FILE* stream) 149 | { 150 | kmeans_index_->saveIndex(stream); 151 | kdtree_index_->saveIndex(stream); 152 | } 153 | 154 | /** 155 | * \brief Loads the index from a stream 156 | * \param stream The stream from which the index is loaded 157 | */ 158 | void loadIndex(FILE* stream) 159 | { 160 | kmeans_index_->loadIndex(stream); 161 | kdtree_index_->loadIndex(stream); 162 | } 163 | 164 | /** 165 | * \returns The index parameters 166 | */ 167 | IndexParams getParameters() const 168 | { 169 | return index_params_; 170 | } 171 | 172 | /** 173 | * \brief Method that searches for nearest-neighbours 174 | */ 175 | void findNeighbors(ResultSet& result, const ElementType* vec, const SearchParams& searchParams) 176 | { 177 | kmeans_index_->findNeighbors(result, vec, searchParams); 178 | kdtree_index_->findNeighbors(result, vec, searchParams); 179 | } 180 | 181 | private: 182 | /** The k-means index */ 183 | KMeansIndex* kmeans_index_; 184 | 185 | /** The kd-tree index */ 186 | KDTreeIndex* kdtree_index_; 187 | 188 | /** The index parameters */ 189 | const IndexParams index_params_; 190 | }; 191 | 192 | } 193 | 194 | #endif //OPENCV_FLANN_COMPOSITE_INDEX_H_ 195 | --------------------------------------------------------------------------------