Version for 3.0.0 release

Small typo fix in the documentation.
It was written 'devie' instead of 'device' in: 'Switching active device can be done using cuda::setDevice() function'

.gitignore

@@ -1,9 +1,24 @@
 *.autosave
 *.pyc
 *.user
+*~
 .*.swp
 .DS_Store
 .sw[a-z]
 Thumbs.db
 tags
 tegra/
+bin/
+*.sdf
+*.opensdf
+*.obj
+*.stamp
+*.depend
+*.rule
+*.tmp
+*/debug
+*/CMakeFiles
+CMakeCache.txt
+*.suo
+*.log
+*.tlog

.tgitconfig

@@ -0,0 +1,2 @@
+[tgit]
+    icon = doc/opencv.ico

3rdparty/ffmpeg/build_win32.txt

@@ -0,0 +1,42 @@
+The build script is to be fixed.
+Right now it assumes that 32-bit MinGW is in the system path and
+64-bit mingw is installed to c:\Apps\MinGW64.
+
+It is important that gcc is used, not g++!
+Otherwise the produced DLL will likely be dependent on libgcc_s_dw2-1.dll or similar DLL.
+While we want to make the DLLs with minimum dependencies: Win32 libraries + msvcrt.dll.
+
+ffopencv.c is really a C++ source, hence -x c++ is used.
+
+How to update opencv_ffmpeg.dll and opencv_ffmpeg_64.dll when a new version of FFMPEG is release?
+
+1. Install 32-bit MinGW + MSYS from
+   http://sourceforge.net/projects/mingw/files/Automated%20MinGW%20Installer/mingw-get-inst/
+   Let's assume, it's installed in C:\MSYS32.
+2. Install 64-bit MinGW. http://mingw-w64.sourceforge.net/
+   Let's assume, it's installed in C:\MSYS64
+3. Copy C:\MSYS32\msys to C:\MSYS64\msys. Edit C:\MSYS64\msys\etc\fstab, change C:\MSYS32 to C:\MSYS64.
+
+4. Now you have working MSYS32 and MSYS64 environments.
+   Launch, one by one, C:\MSYS32\msys\msys.bat and C:\MSYS64\msys\msys.bat to create your home directories.
+
+4. Download ffmpeg-x.y.z.tar.gz (where x.y.z denotes the actual ffmpeg version).
+   Copy it to C:\MSYS{32|64}\msys\home\<loginname> directory.
+
+5. To build 32-bit ffmpeg libraries, run C:\MSYS32\msys\msys.bat and type the following commands:
+
+   5.1. tar -xzf ffmpeg-x.y.z.tar.gz
+   5.2. mkdir build
+   5.3. cd build
+   5.4. ../ffmpeg-x.y.z/configure --enable-w32threads
+   5.5. make
+   5.6. make install
+   5.7. cd /local/lib
+   5.8. strip -g *.a
+
+6. Then repeat the same for 64-bit case. The output libs: libavcodec.a etc. need to be renamed to libavcodec64.a etc.
+
+7. Then, copy all those libs to <opencv>\3rdparty\lib\, copy the headers to <opencv>\3rdparty\include\ffmpeg_.
+
+8. Then, go to <opencv>\3rdparty\ffmpeg, edit make.bat
+   (change paths to the actual paths to your msys32 and msys64 distributions) and then run make.bat

3rdparty/ffmpeg/ffmpeg_version.cmake

@@ -3,9 +3,11 @@ set(HAVE_FFMPEG_CODEC 1)
 set(HAVE_FFMPEG_FORMAT 1)
 set(HAVE_FFMPEG_UTIL 1)
 set(HAVE_FFMPEG_SWSCALE 1)
+set(HAVE_FFMPEG_RESAMPLE 0)
 set(HAVE_GENTOO_FFMPEG 1)
 
 set(ALIASOF_libavcodec_VERSION 55.18.102)
 set(ALIASOF_libavformat_VERSION 55.12.100)
 set(ALIASOF_libavutil_VERSION 52.38.100)
 set(ALIASOF_libswscale_VERSION 2.3.100)
+set(ALIASOF_libavresample_VERSION 1.0.1)

3rdparty/ffmpeg/license.txt

@@ -0,0 +1,520 @@
+              Copyright (C) 2001 Fabrice Bellard
+
+    FFmpeg is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    FFmpeg is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with FFmpeg; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+==================================================================================
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

3rdparty/ffmpeg/readme.txt

@@ -1,42 +1,32 @@
-The build script is to be fixed.
-Right now it assumes that 32-bit MinGW is in the system path and
-64-bit mingw is installed to c:\Apps\MinGW64.
+* On Linux and other Unix flavors OpenCV uses default or user-built ffmpeg/libav libraries.
+  If user builds ffmpeg/libav from source and wants OpenCV to stay BSD library, not GPL/LGPL,
+  he/she should use --enabled-shared configure flag and make sure that no GPL components are
+  enabled (some notable examples are x264 (H264 encoder) and libac3 (Dolby AC3 audio codec)).
+  See https://www.ffmpeg.org/legal.html for details.
+  
+  If you want to play very safe and do not want to use FFMPEG at all, regardless of whether it's installed on
+  your system or not, configure and build OpenCV using CMake with WITH_FFMPEG=OFF flag. OpenCV will then use
+  AVFoundation (OSX), GStreamer (Linux) or other available backends supported by opencv_videoio module.
+  
+  There is also our self-contained motion jpeg codec, which you can use without any worries.
+  It handles CV_FOURCC('M', 'J', 'P', 'G') streams within an AVI container (".avi").
+  
+* On Windows OpenCV uses pre-built ffmpeg binaries, built with proper flags (without GPL components) and
+  wrapped with simple, stable OpenCV-compatible API.
+  The binaries are opencv_ffmpeg.dll (version for 32-bit Windows) and
+  opencv_ffmpeg_64.dll (version for 64-bit Windows).
+  
+  See build_win32.txt for the build instructions, if you want to rebuild opencv_ffmpeg*.dll from scratch.
 
-It is important that gcc is used, not g++!
-Otherwise the produced DLL will likely be dependent on libgcc_s_dw2-1.dll or similar DLL.
-While we want to make the DLLs with minimum dependencies: Win32 libraries + msvcrt.dll.
+  The pre-built opencv_ffmpeg*.dll is:
+  * LGPL library, not BSD libraries.
+  * Loaded at runtime by opencv_videoio module.
+    If it succeeds, ffmpeg can be used to decode/encode videos;
+    otherwise, other API is used.
 
-ffopencv.c is really a C++ source, hence -x c++ is used.
-
-How to update opencv_ffmpeg.dll and opencv_ffmpeg_64.dll when a new version of FFMPEG is release?
-
-1. Install 32-bit MinGW + MSYS from
-   http://sourceforge.net/projects/mingw/files/Automated%20MinGW%20Installer/mingw-get-inst/
-   Let's assume, it's installed in C:\MSYS32.
-2. Install 64-bit MinGW. http://mingw-w64.sourceforge.net/
-   Let's assume, it's installed in C:\MSYS64
-3. Copy C:\MSYS32\msys to C:\MSYS64\msys. Edit C:\MSYS64\msys\etc\fstab, change C:\MSYS32 to C:\MSYS64.
-
-4. Now you have working MSYS32 and MSYS64 environments.
-   Launch, one by one, C:\MSYS32\msys\msys.bat and C:\MSYS64\msys\msys.bat to create your home directories.
-
-4. Download ffmpeg-x.y.z.tar.gz (where x.y.z denotes the actual ffmpeg version).
-   Copy it to C:\MSYS{32|64}\msys\home\<loginname> directory.
-
-5. To build 32-bit ffmpeg libraries, run C:\MSYS32\msys\msys.bat and type the following commands:
-
-   5.1. tar -xzf ffmpeg-x.y.z.tar.gz
-   5.2. mkdir build
-   5.3. cd build
-   5.4. ../ffmpeg-x.y.z/configure --enable-w32threads
-   5.5. make
-   5.6. make install
-   5.7. cd /local/lib
-   5.8. strip -g *.a
-
-6. Then repeat the same for 64-bit case. The output libs: libavcodec.a etc. need to be renamed to libavcodec64.a etc.
-
-7. Then, copy all those libs to <opencv>\3rdparty\lib\, copy the headers to <opencv>\3rdparty\include\ffmpeg_.
-
-8. Then, go to <opencv>\3rdparty\ffmpeg, edit make.bat
-   (change paths to the actual paths to your msys32 and msys64 distributions) and then run make.bat
+  If LGPL/GPL software can not be supplied with your OpenCV-based product, simply exclude
+  opencv_ffmpeg*.dll from your distribution; OpenCV will stay fully functional except for the ability to
+  decode/encode videos using FFMPEG (though, it may still be able to do that using other API,
+  such as Video for Windows, Windows Media Foundation or our self-contained motion jpeg codec).
+  
+  See license.txt for the FFMPEG copyright notice and the licensing terms.

3rdparty/include/opencl/1.2/CL/cl.hpp

@@ -210,7 +210,7 @@
 #include <string>
 #endif 
 
-#if defined(linux) || defined(__APPLE__) || defined(__MACOSX)
+#if defined(__linux__) || defined(__APPLE__) || defined(__MACOSX)
 #include <alloca.h>
 
 #include <emmintrin.h>

3rdparty/include/opencl/1.2/CL/cl_platform.h

@@ -332,13 +332,13 @@ typedef unsigned int cl_GLenum;
 /* Define basic vector types */
 #if defined( __VEC__ )
    #include <altivec.h>   /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */
-   typedef vector unsigned char     __cl_uchar16;
-   typedef vector signed char       __cl_char16;
-   typedef vector unsigned short    __cl_ushort8;
-   typedef vector signed short      __cl_short8;
-   typedef vector unsigned int      __cl_uint4;
-   typedef vector signed int        __cl_int4;
-   typedef vector float             __cl_float4;
+   typedef __vector unsigned char     __cl_uchar16;
+   typedef __vector signed char       __cl_char16;
+   typedef __vector unsigned short    __cl_ushort8;
+   typedef __vector signed short      __cl_short8;
+   typedef __vector unsigned int      __cl_uint4;
+   typedef __vector signed int        __cl_int4;
+   typedef __vector float             __cl_float4;
    #define  __CL_UCHAR16__  1
    #define  __CL_CHAR16__   1
    #define  __CL_USHORT8__  1

3rdparty/ippicv/.gitignore

@@ -0,0 +1,2 @@
+downloads/
+unpack/

3rdparty/ippicv/downloader.cmake

@@ -0,0 +1,108 @@
+#
+# The script downloads ICV package
+#
+# On return this will define:
+# OPENCV_ICV_PATH - path to unpacked downloaded package
+#
+
+function(_icv_downloader)
+  # Define actual ICV versions
+  if(APPLE)
+    set(OPENCV_ICV_PACKAGE_NAME "ippicv_macosx_20141027.tgz")
+    set(OPENCV_ICV_PACKAGE_HASH "9662fe0694a67e59491a0dcc82fa26e0")
+    set(OPENCV_ICV_PLATFORM "macosx")
+    set(OPENCV_ICV_PACKAGE_SUBDIR "/ippicv_osx")
+  elseif(UNIX)
+    if(ANDROID AND (NOT ANDROID_ABI STREQUAL x86))
+      return()
+    endif()
+    set(OPENCV_ICV_PACKAGE_NAME "ippicv_linux_20141027.tgz")
+    set(OPENCV_ICV_PACKAGE_HASH "8b449a536a2157bcad08a2b9f266828b")
+    set(OPENCV_ICV_PLATFORM "linux")
+    set(OPENCV_ICV_PACKAGE_SUBDIR "/ippicv_lnx")
+  elseif(WIN32 AND NOT ARM)
+    set(OPENCV_ICV_PACKAGE_NAME "ippicv_windows_20141027.zip")
+    set(OPENCV_ICV_PACKAGE_HASH "b59f865d1ba16e8c84124e19d78eec57")
+    set(OPENCV_ICV_PLATFORM "windows")
+    set(OPENCV_ICV_PACKAGE_SUBDIR "/ippicv_win")
+  else()
+    return() # Not supported
+  endif()
+
+  set(OPENCV_ICV_UNPACK_PATH "${CMAKE_CURRENT_LIST_DIR}/unpack")
+  set(OPENCV_ICV_PATH "${OPENCV_ICV_UNPACK_PATH}${OPENCV_ICV_PACKAGE_SUBDIR}")
+
+  if(DEFINED OPENCV_ICV_PACKAGE_DOWNLOADED
+       AND OPENCV_ICV_PACKAGE_DOWNLOADED STREQUAL OPENCV_ICV_PACKAGE_HASH
+       AND EXISTS ${OPENCV_ICV_PATH})
+    # Package has been downloaded and checked by the previous build
+    set(OPENCV_ICV_PATH "${OPENCV_ICV_PATH}" PARENT_SCOPE)
+    return()
+  else()
+    if(EXISTS ${OPENCV_ICV_UNPACK_PATH})
+      message(STATUS "ICV: Removing previous unpacked package: ${OPENCV_ICV_UNPACK_PATH}")
+      file(REMOVE_RECURSE ${OPENCV_ICV_UNPACK_PATH})
+    endif()
+  endif()
+  unset(OPENCV_ICV_PACKAGE_DOWNLOADED CACHE)
+
+  set(OPENCV_ICV_PACKAGE_ARCHIVE "${CMAKE_CURRENT_LIST_DIR}/downloads/${OPENCV_ICV_PLATFORM}-${OPENCV_ICV_PACKAGE_HASH}/${OPENCV_ICV_PACKAGE_NAME}")
+  get_filename_component(OPENCV_ICV_PACKAGE_ARCHIVE_DIR "${OPENCV_ICV_PACKAGE_ARCHIVE}" PATH)
+  if(EXISTS "${OPENCV_ICV_PACKAGE_ARCHIVE}")
+    file(MD5 "${OPENCV_ICV_PACKAGE_ARCHIVE}" archive_md5)
+    if(NOT archive_md5 STREQUAL OPENCV_ICV_PACKAGE_HASH)
+      message(WARNING "ICV: Local copy of ICV package has invalid MD5 hash: ${archive_md5} (expected: ${OPENCV_ICV_PACKAGE_HASH})")
+      file(REMOVE "${OPENCV_ICV_PACKAGE_ARCHIVE}")
+      file(REMOVE_RECURSE "${OPENCV_ICV_PACKAGE_ARCHIVE_DIR}")
+    endif()
+  endif()
+
+  if(NOT EXISTS "${OPENCV_ICV_PACKAGE_ARCHIVE}")
+    if(NOT DEFINED OPENCV_ICV_URL)
+      if(DEFINED ENV{OPENCV_ICV_URL})
+        set(OPENCV_ICV_URL $ENV{OPENCV_ICV_URL})
+      else()
+        set(OPENCV_ICV_URL "http://sourceforge.net/projects/opencvlibrary/files/3rdparty/ippicv")
+      endif()
+    endif()
+
+    file(MAKE_DIRECTORY ${OPENCV_ICV_PACKAGE_ARCHIVE_DIR})
+    message(STATUS "ICV: Downloading ${OPENCV_ICV_PACKAGE_NAME}...")
+    file(DOWNLOAD "${OPENCV_ICV_URL}/${OPENCV_ICV_PACKAGE_NAME}" "${OPENCV_ICV_PACKAGE_ARCHIVE}"
+         TIMEOUT 600 STATUS __status
+         EXPECTED_MD5 ${OPENCV_ICV_PACKAGE_HASH})
+    if(NOT __status EQUAL 0)
+      message(FATAL_ERROR "ICV: Failed to download ICV package: ${OPENCV_ICV_PACKAGE_NAME}. Status=${__status}")
+    else()
+      # Don't remove this code, because EXPECTED_MD5 parameter doesn't fail "file(DOWNLOAD)" step
+      # on wrong hash 
+      file(MD5 "${OPENCV_ICV_PACKAGE_ARCHIVE}" archive_md5)
+      if(NOT archive_md5 STREQUAL OPENCV_ICV_PACKAGE_HASH)
+        message(FATAL_ERROR "ICV: Downloaded copy of ICV package has invalid MD5 hash: ${archive_md5} (expected: ${OPENCV_ICV_PACKAGE_HASH})")
+      endif()
+    endif()
+  endif()
+
+  ocv_assert(EXISTS "${OPENCV_ICV_PACKAGE_ARCHIVE}")
+  ocv_assert(NOT EXISTS "${OPENCV_ICV_UNPACK_PATH}")
+  file(MAKE_DIRECTORY ${OPENCV_ICV_UNPACK_PATH})
+  ocv_assert(EXISTS "${OPENCV_ICV_UNPACK_PATH}")
+
+  message(STATUS "ICV: Unpacking ${OPENCV_ICV_PACKAGE_NAME} to ${OPENCV_ICV_UNPACK_PATH}...")
+  execute_process(COMMAND ${CMAKE_COMMAND} -E tar xz "${OPENCV_ICV_PACKAGE_ARCHIVE}"
+                  WORKING_DIRECTORY "${OPENCV_ICV_UNPACK_PATH}"
+                  RESULT_VARIABLE __result)
+
+  if(NOT __result EQUAL 0)
+    message(FATAL_ERROR "ICV: Failed to unpack ICV package from ${OPENCV_ICV_PACKAGE_ARCHIVE} to ${OPENCV_ICV_UNPACK_PATH} with error ${__result}")
+  endif()
+
+  ocv_assert(EXISTS "${OPENCV_ICV_PATH}")
+
+  set(OPENCV_ICV_PACKAGE_DOWNLOADED "${OPENCV_ICV_PACKAGE_HASH}" CACHE INTERNAL "ICV package hash")
+
+  message(STATUS "ICV: Package successfully downloaded")
+  set(OPENCV_ICV_PATH "${OPENCV_ICV_PATH}" PARENT_SCOPE)
+endfunction()
+
+_icv_downloader()

3rdparty/jinja2/markupsafe/__init__.py

@@ -9,7 +9,7 @@
     :license: BSD, see LICENSE for more details.
 """
 import re
-from _compat import text_type, string_types, int_types, \
+from ._compat import text_type, string_types, int_types, \
      unichr, PY2
 
 
@@ -227,7 +227,7 @@ class _MarkupEscapeHelper(object):
 try:
     from _speedups import escape, escape_silent, soft_unicode
 except ImportError:
-    from _native import escape, escape_silent, soft_unicode
+    from ._native import escape, escape_silent, soft_unicode
 
 if not PY2:
     soft_str = soft_unicode

3rdparty/jinja2/markupsafe/_native.py

@@ -8,7 +8,7 @@
     :copyright: (c) 2010 by Armin Ronacher.
     :license: BSD, see LICENSE for more details.
 """
-from _compat import text_type
+from ._compat import text_type
 
 
 def escape(s):

3rdparty/jinja2/utils.py

@@ -517,4 +517,4 @@ class Joiner(object):
 
 
 # Imported here because that's where it was in the past
-from markupsafe import Markup, escape, soft_unicode
+from .markupsafe import Markup, escape, soft_unicode

3rdparty/libjasper/CMakeLists.txt

@@ -47,5 +47,5 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()
 
 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${JASPER_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
+  ocv_install_target(${JASPER_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

3rdparty/libjasper/jas_cm.c

@@ -842,7 +842,6 @@ static int jas_cmshapmat_apply(jas_cmpxform_t *pxform, jas_cmreal_t *in,
                 *dst++ = a2;
             }
         } else {
-assert(0);
             while (--cnt >= 0) {
                 a0 = *src++;
                 src++;

3rdparty/libjasper/jas_stream.c

@@ -345,6 +345,7 @@ jas_stream_t *jas_stream_tmpfile()
 {
     jas_stream_t *stream;
     jas_stream_fileobj_t *obj;
+    char *tmpname;
 
     if (!(stream = jas_stream_create())) {
         return 0;
@@ -365,10 +366,12 @@ jas_stream_t *jas_stream_tmpfile()
 
 #ifdef _WIN32
     /* Choose a file name. */
-    tmpnam(obj->pathname);
+    tmpname = tempnam(NULL, NULL);
+    strcpy(obj->pathname, tmpname);
+    free(tmpname);
 
     /* Open the underlying file. */
-    if ((obj->fd = open(obj->pathname, O_CREAT | O_EXCL | O_RDWR | O_TRUNC | O_BINARY,
+    if ((obj->fd = open(obj->pathname, O_CREAT | O_EXCL | O_RDWR | O_TRUNC | O_BINARY | O_TEMPORARY | _O_SHORT_LIVED,
       JAS_STREAM_PERMS)) < 0) {
         jas_stream_destroy(stream);
         return 0;

3rdparty/libjpeg/CMakeLists.txt

@@ -9,12 +9,19 @@ ocv_include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)
 
-if(ANDROID OR IOS)
+if(ANDROID OR IOS OR APPLE)
   ocv_list_filterout(lib_srcs jmemansi.c)
 else()
   ocv_list_filterout(lib_srcs jmemnobs.c)
 endif()
 
+if(WINRT)
+    add_definitions(-DNO_GETENV)
+    get_directory_property( DirDefs COMPILE_DEFINITIONS )
+    message(STATUS "Adding NO_GETENV to compiler definitions for WINRT:")
+    message(STATUS "   COMPILE_DEFINITIONS = ${DirDefs}")
+endif()
+
 # ----------------------------------------------------------------------------------
 #         Define the library target:
 # ----------------------------------------------------------------------------------
@@ -46,5 +53,5 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()
 
 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${JPEG_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
+  ocv_install_target(${JPEG_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

3rdparty/libpng/CMakeLists.txt

@@ -14,7 +14,7 @@ ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" ${ZLIB_INCLUDE_DIRS})
 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)
 
-if(NEON)
+if(NEON AND ARM)
   list(APPEND lib_srcs arm/filter_neon.S)
   add_definitions(-DPNG_ARM_NEON)
 endif()
@@ -29,10 +29,6 @@ if(MSVC)
   add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
 endif(MSVC)
 
-if (HAVE_WINRT)
-  add_definitions(-DHAVE_WINRT)
-endif()
-
 add_library(${PNG_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs})
 target_link_libraries(${PNG_LIBRARY} ${ZLIB_LIBRARIES})
 
@@ -55,5 +51,5 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()
 
 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${PNG_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
+  ocv_install_target(${PNG_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

3rdparty/libpng/opencv-libpng.patch

@@ -7,7 +7,7 @@ index 07b2b0b..e7824b8 100644
  /* Memory model/platform independent fns */
  #ifndef PNG_ABORT
 -#  ifdef _WINDOWS_
-+#  if defined(_WINDOWS_) && !defined(HAVE_WINRT)
++#  if defined(_WINDOWS_) && !defined(WINRT)
  #    define PNG_ABORT() ExitProcess(0)
  #  else
  #    define PNG_ABORT() abort()
@@ -16,7 +16,7 @@ index 07b2b0b..e7824b8 100644
  #  define png_memset  _fmemset
  #else
 -#  ifdef _WINDOWS_  /* Favor Windows over C runtime fns */
-+#  if defined(_WINDOWS_) && !defined(HAVE_WINRT)  /* Favor Windows over C runtime fns */
++#  if defined(_WINDOWS_) && !defined(WINRT)  /* Favor Windows over C runtime fns */
  #    define CVT_PTR(ptr)         (ptr)
  #    define CVT_PTR_NOCHECK(ptr) (ptr)
  #    define png_strlen  lstrlenA

3rdparty/libpng/pngpriv.h

@@ -360,7 +360,7 @@ typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp;
 
 /* Memory model/platform independent fns */
 #ifndef PNG_ABORT
-#  if defined(_WINDOWS_) && !defined(HAVE_WINRT)
+#  if defined(_WINDOWS_) && !defined(WINRT)
 #    define PNG_ABORT() ExitProcess(0)
 #  else
 #    define PNG_ABORT() abort()
@@ -378,7 +378,7 @@ typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp;
 #  define png_memcpy  _fmemcpy
 #  define png_memset  _fmemset
 #else
-#  if defined(_WINDOWS_) && !defined(HAVE_WINRT)  /* Favor Windows over C runtime fns */
+#  if defined(_WINDOWS_) && !defined(WINRT)  /* Favor Windows over C runtime fns */
 #    define CVT_PTR(ptr)         (ptr)
 #    define CVT_PTR_NOCHECK(ptr) (ptr)
 #    define png_strlen  lstrlenA

3rdparty/libtiff/CMakeLists.txt

@@ -17,7 +17,7 @@ check_include_file(string.h HAVE_STRING_H)
 check_include_file(sys/types.h HAVE_SYS_TYPES_H)
 check_include_file(unistd.h HAVE_UNISTD_H)
 
-if(WIN32 AND NOT HAVE_WINRT)
+if(WIN32 AND NOT WINRT)
   set(USE_WIN32_FILEIO 1)
 endif()
 
@@ -79,7 +79,7 @@ set(lib_srcs
     "${CMAKE_CURRENT_BINARY_DIR}/tif_config.h"
     )
 
-if(WIN32 AND NOT HAVE_WINRT)
+if(WIN32 AND NOT WINRT)
   list(APPEND lib_srcs tif_win32.c)
 else()
   list(APPEND lib_srcs tif_unix.c)
@@ -115,5 +115,5 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()
 
 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${TIFF_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
+  ocv_install_target(${TIFF_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

3rdparty/libtiff/tif_config.h.cmakein

@@ -54,7 +54,7 @@
 
 /* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian
    (Intel) */
-#define HOST_BIGENDIAN 0
+#define HOST_BIGENDIAN @WORDS_BIGENDIAN@
 
 /* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */
 #define HOST_FILLORDER FILLORDER_LSB2MSB
@@ -156,15 +156,7 @@
 
 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
    significant byte first (like Motorola and SPARC, unlike Intel). */
-#if defined AC_APPLE_UNIVERSAL_BUILD
-# if defined __BIG_ENDIAN__
-#  define WORDS_BIGENDIAN 1
-# endif
-#else
-# ifndef WORDS_BIGENDIAN
-/* #  undef WORDS_BIGENDIAN */
-# endif
-#endif
+#cmakedefine WORDS_BIGENDIAN 1
 
 /* Support Deflate compression */
 #define ZIP_SUPPORT 1

3rdparty/libwebp/CMakeLists.txt

@@ -54,6 +54,6 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()
 
 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${WEBP_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
+  ocv_install_target(${WEBP_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()
 

3rdparty/openexr/CMakeLists.txt

@@ -64,7 +64,7 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()
 
 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(IlmImf EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
+  ocv_install_target(IlmImf EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()
 
 set(OPENEXR_INCLUDE_PATHS ${OPENEXR_INCLUDE_PATHS} PARENT_SCOPE)

3rdparty/readme.txt

@@ -1,46 +1,39 @@
 This folder contains libraries and headers of a few very popular still image codecs
-used by highgui module.
+used by imgcodecs module.
 The libraries and headers are preferably to build Win32 and Win64 versions of OpenCV.
 On UNIX systems all the libraries are automatically detected by configure script.
 In order to use these versions of libraries instead of system ones on UNIX systems you
 should use BUILD_<library_name> CMake flags (for example, BUILD_PNG for the libpng library).
 
 ------------------------------------------------------------------------------------
-libjpeg 8d (8.4)  -   The Independent JPEG Group's JPEG software.
+libjpeg               The Independent JPEG Group's JPEG software.
                       Copyright (C) 1991-2012, Thomas G. Lane, Guido Vollbeding.
                       See IGJ home page http://www.ijg.org
                       for details and links to the source code
 
-                      HAVE_JPEG preprocessor flag must be set to make highgui use libjpeg.
-                      On UNIX systems configure script takes care of it.
+                      WITH_JPEG CMake option must be ON to add libjpeg support to imgcodecs.
 ------------------------------------------------------------------------------------
-libpng 1.5.12     -   Portable Network Graphics library.
+libpng                Portable Network Graphics library.
                       Copyright (c) 2004, 2006-2012 Glenn Randers-Pehrson.
                       See libpng home page http://www.libpng.org
                       for details and links to the source code
 
-                      HAVE_PNG preprocessor flag must be set to make highgui use libpng.
-                      On UNIX systems configure script takes care of it.
+                      WITH_PNG CMake option must be ON to add libpng support to imgcodecs.
 ------------------------------------------------------------------------------------
-libtiff 4.0.2     -   Tag Image File Format (TIFF) Software
+libtiff               Tag Image File Format (TIFF) Software
                       Copyright (c) 1988-1997 Sam Leffler
                       Copyright (c) 1991-1997 Silicon Graphics, Inc.
                       See libtiff home page http://www.remotesensing.org/libtiff/
                       for details and links to the source code
 
-                      HAVE_TIFF preprocessor flag must be set to make highgui use libtiff.
-                      On UNIX systems configure script takes care of it.
-                      In this build support for ZIP (LZ77 compression) is turned on.
+                      WITH_TIFF CMake option must be ON to add libtiff & zlib support to imgcodecs.
 ------------------------------------------------------------------------------------
-zlib 1.2.7        -   General purpose LZ77 compression library
+zlib                  General purpose LZ77 compression library
                       Copyright (C) 1995-2012 Jean-loup Gailly and Mark Adler.
                       See zlib home page http://www.zlib.net
                       for details and links to the source code
-
-                      No preprocessor definition is needed to make highgui use this library -
-                      it is included automatically if either libpng or libtiff are used.
 ------------------------------------------------------------------------------------
-jasper-1.900.1    -   JasPer is a collection of software
+jasper                JasPer is a collection of software
                       (i.e., a library and application programs) for the coding
                       and manipulation of images.  This software can handle image data in a
                       variety of formats.  One such format supported by JasPer is the JPEG-2000
@@ -50,14 +43,9 @@ jasper-1.900.1    -   JasPer is a collection of software
                       Copyright (c) 1999-2000 The University of British Columbia
                       Copyright (c) 2001-2003 Michael David Adams
 
-                      The JasPer license can be found in src/libjasper.
-
-                      OpenCV on Windows uses pre-built libjasper library
-                      (lib/libjasper*). To get the latest source code,
-                      please, visit the project homepage:
-                      http://www.ece.uvic.ca/~mdadams/jasper/
+                      The JasPer license can be found in libjasper.
 ------------------------------------------------------------------------------------
-openexr-1.7.1     -   OpenEXR is a high dynamic-range (HDR) image file format developed
+openexr               OpenEXR is a high dynamic-range (HDR) image file format developed
                       by Industrial Light & Magic for use in computer imaging applications.
 
                       Copyright (c) 2006, Industrial Light & Magic, a division of Lucasfilm
@@ -66,11 +54,17 @@ openexr-1.7.1     -   OpenEXR is a high dynamic-range (HDR) image file format de
 
                       The project homepage: http://www.openexr.com
 ------------------------------------------------------------------------------------
-ffmpeg-0.8.0      -   FFmpeg is a complete, cross-platform solution to record,
+ffmpeg                FFmpeg is a complete, cross-platform solution to record,
                       convert and stream audio and video. It includes libavcodec -
                       the leading audio/video codec library, and also libavformat, libavutils and
-                      other helper libraries that are used by OpenCV (in highgui module) to
+                      other helper libraries that are used by OpenCV (in videoio module) to
                       read and write video files.
 
-                      The project homepage: http://ffmpeg.org/
+                      Copyright (c) 2001 Fabrice Bellard
+
+                      The project homepage: http://ffmpeg.org/.
+                      
+                      * On Linux/OSX we link user-installed ffmpeg (or ffmpeg fork libav).
+                      * On Windows we use pre-built ffmpeg binaries,
+                        see opencv/3rdparty/ffmpeg/readme.txt for details and licensing information
 ------------------------------------------------------------------------------------

3rdparty/tbb/CMakeLists.txt

@@ -232,9 +232,9 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()
 
 ocv_install_target(tbb EXPORT OpenCVModules
-    RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT main
-    LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main
-    ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main
+    RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT libs
+    LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT libs
+    ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev
     )
 
 # get TBB version

3rdparty/zlib/CMakeLists.txt

@@ -82,7 +82,7 @@ if(UNIX)
   endif()
 endif()
 
-ocv_warnings_disable(CMAKE_C_FLAGS -Wattributes -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wshorten-64-to-32 -Wattributes -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations)
 
 set_target_properties(${ZLIB_LIBRARY} PROPERTIES
         OUTPUT_NAME ${ZLIB_LIBRARY}
@@ -95,5 +95,5 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()
 
 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${ZLIB_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
+  ocv_install_target(${ZLIB_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

CMakeLists.txt

@@ -6,10 +6,18 @@
 #
 # ----------------------------------------------------------------------------
 
+
+
 include(cmake/OpenCVMinDepVersions.cmake)
 
 if(CMAKE_GENERATOR MATCHES Xcode AND XCODE_VERSION VERSION_GREATER 4.3)
   cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)
+elseif(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+  cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+  #Required to resolve linker error issues due to incompatibility with CMake v3.0+ policies.
+  #CMake fails to find _fseeko() which leads to subsequent linker error.
+  #See details here: http://www.cmake.org/Wiki/CMake/Policies
+  cmake_policy(VERSION 2.8)
 else()
   cmake_minimum_required(VERSION "${MIN_VER_CMAKE}" FATAL_ERROR)
 endif()
@@ -31,11 +39,46 @@ else(NOT CMAKE_TOOLCHAIN_FILE)
   set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory")
 endif(NOT CMAKE_TOOLCHAIN_FILE)
 
+if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+  set(WINRT TRUE)
+endif(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+
+if(WINRT)
+  add_definitions(-DWINRT -DNO_GETENV)
+
+  # Making definitions available to other configurations and
+  # to filter dependency restrictions at compile time.
+  if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone)
+    set(WINRT_PHONE TRUE)
+    add_definitions(-DWINRT_PHONE)
+  elseif(CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+    set(WINRT_STORE TRUE)
+    add_definitions(-DWINRT_STORE)
+  endif()
+
+  if(CMAKE_SYSTEM_VERSION MATCHES 8.1)
+    set(WINRT_8_1 TRUE)
+    add_definitions(-DWINRT_8_1)
+  elseif(CMAKE_SYSTEM_VERSION MATCHES 8.0)
+    set(WINRT_8_0 TRUE)
+    add_definitions(-DWINRT_8_0)
+  endif()
+endif()
 
 if(POLICY CMP0022)
   cmake_policy(SET CMP0022 OLD)
 endif()
 
+if(POLICY CMP0026)
+  # silence cmake 3.0+ warnings about reading LOCATION attribute
+  cmake_policy(SET CMP0026 OLD)
+endif()
+
+if (POLICY CMP0042)
+  # silence cmake 3.0+ warnings about MACOSX_RPATH
+  cmake_policy(SET CMP0042 OLD)
+endif()
+
 # must go before the project command
 set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE)
 if(DEFINED CMAKE_BUILD_TYPE)
@@ -113,67 +156,74 @@ endif()
 
 # Optional 3rd party components
 # ===================================================
-OCV_OPTION(WITH_1394           "Include IEEE1394 support"                    ON   IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_1394           "Include IEEE1394 support"                    ON   IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
 OCV_OPTION(WITH_AVFOUNDATION   "Use AVFoundation for Video I/O"              ON   IF IOS)
 OCV_OPTION(WITH_CARBON         "Use Carbon for UI instead of Cocoa"          OFF  IF APPLE )
-OCV_OPTION(WITH_VTK            "Include VTK library support (and build opencv_viz module eiher)"             OFF IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_CUDA           "Include NVidia Cuda Runtime support"                                         ON  IF (NOT IOS) )
-OCV_OPTION(WITH_CUFFT          "Include NVidia Cuda Fast Fourier Transform (FFT) library support"            ON  IF (NOT IOS) )
-OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (NOT IOS) )
+OCV_OPTION(WITH_VTK            "Include VTK library support (and build opencv_viz module eiher)"             ON  IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_CUDA           "Include NVidia Cuda Runtime support"                                         ON  IF (NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_CUFFT          "Include NVidia Cuda Fast Fourier Transform (FFT) library support"            ON  IF (NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (NOT IOS AND NOT WINRT) )
 OCV_OPTION(WITH_NVCUVID        "Include NVidia Video Decoding library support"                               OFF IF (NOT IOS AND NOT APPLE) )
-OCV_OPTION(WITH_EIGEN          "Include Eigen2/Eigen3 support"               ON)
+OCV_OPTION(WITH_EIGEN          "Include Eigen2/Eigen3 support"               ON   IF (NOT WINRT) )
 OCV_OPTION(WITH_VFW            "Include Video for Windows support"           ON   IF WIN32 )
-OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS))
-OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT ANDROID) )
 OCV_OPTION(WITH_GSTREAMER_0_10 "Enable Gstreamer 0.10 support (instead of 1.x)"                              OFF )
 OCV_OPTION(WITH_GTK            "Include GTK support"                         ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
-OCV_OPTION(WITH_IPP            "Include Intel IPP support"                   OFF  IF (MSVC OR X86 OR X86_64) )
+OCV_OPTION(WITH_GTK_2_X        "Use GTK version 2"                           OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_IPP            "Include Intel IPP support"                   ON   IF (X86_64 OR X86) AND NOT WINRT)
 OCV_OPTION(WITH_JASPER         "Include JPEG2K support"                      ON   IF (NOT IOS) )
 OCV_OPTION(WITH_JPEG           "Include JPEG support"                        ON)
-OCV_OPTION(WITH_WEBP           "Include WebP support"                        ON   IF (NOT IOS) )
-OCV_OPTION(WITH_OPENEXR        "Include ILM support via OpenEXR"             ON   IF (NOT IOS) )
-OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT APPLE) )
-OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_WEBP           "Include WebP support"                        ON   IF (NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_OPENEXR        "Include ILM support via OpenEXR"             ON   IF (NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT WINRT) )
+OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_OPENNI2        "Include OpenNI2 support"                     OFF  IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
 OCV_OPTION(WITH_PNG            "Include PNG support"                         ON)
-OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_GIGEAPI        "Include Smartek GigE support"                ON   IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_QT             "Build with Qt Backend support"               OFF  IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_WIN32UI        "Build with Win32 UI Backend support"         ON   IF WIN32 )
+OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_GIGEAPI        "Include Smartek GigE support"                ON   IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_QT             "Build with Qt Backend support"               OFF  IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_WIN32UI        "Build with Win32 UI Backend support"         ON   IF WIN32 AND NOT WINRT)
 OCV_OPTION(WITH_QUICKTIME      "Use QuickTime for Video I/O insted of QTKit" OFF  IF APPLE )
-OCV_OPTION(WITH_TBB            "Include Intel TBB support"                   OFF  IF (NOT IOS) )
+OCV_OPTION(WITH_TBB            "Include Intel TBB support"                   OFF  IF (NOT IOS AND NOT WINRT) )
 OCV_OPTION(WITH_OPENMP         "Include OpenMP support"                      OFF)
-OCV_OPTION(WITH_CSTRIPES       "Include C= support"                          OFF  IF WIN32 )
+OCV_OPTION(WITH_CSTRIPES       "Include C= support"                          OFF  IF (WIN32 AND NOT WINRT)  )
+OCV_OPTION(WITH_PTHREADS_PF    "Use pthreads-based parallel_for"             OFF  IF (NOT WIN32) )
 OCV_OPTION(WITH_TIFF           "Include TIFF support"                        ON   IF (NOT IOS) )
 OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT ANDROID) )
 OCV_OPTION(WITH_LIBV4L         "Use libv4l for Video 4 Linux support"        ON   IF (UNIX AND NOT ANDROID) )
-OCV_OPTION(WITH_DSHOW          "Build HighGUI with DirectShow support"       ON   IF (WIN32 AND NOT ARM) )
-OCV_OPTION(WITH_MSMF           "Build HighGUI with Media Foundation support" OFF  IF WIN32 )
-OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE) )
+OCV_OPTION(WITH_DSHOW          "Build VideoIO with DirectShow support"       ON   IF (WIN32 AND NOT ARM AND NOT WINRT) )
+OCV_OPTION(WITH_MSMF           "Build VideoIO with Media Foundation support" OFF  IF WIN32 )
+OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT WINRT) )
 OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_CLP            "Include Clp support (EPL)"                   OFF)
-OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              ON   IF (NOT IOS) )
-OCV_OPTION(WITH_OPENCLAMDFFT   "Include AMD OpenCL FFT library support"      ON   IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_OPENCLAMDBLAS  "Include AMD OpenCL BLAS library support"     ON   IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_DIRECTX        "Include DirectX support"                     ON   IF WIN32 )
-OCV_OPTION(WITH_INTELPERC      "Include Intel Perceptual Computing support"  OFF  IF WIN32 )
-
+OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              NOT ANDROID IF (NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_OPENCL_SVM     "Include OpenCL Shared Virtual Memory support" OFF ) # experimental
+OCV_OPTION(WITH_OPENCLAMDFFT   "Include AMD OpenCL FFT library support"      ON   IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_OPENCLAMDBLAS  "Include AMD OpenCL BLAS library support"     ON   IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_DIRECTX        "Include DirectX support"                     ON   IF (WIN32 AND NOT WINRT) )
+OCV_OPTION(WITH_INTELPERC      "Include Intel Perceptual Computing support"  OFF  IF (WIN32 AND NOT WINRT) )
+OCV_OPTION(WITH_IPP_A          "Include Intel IPP_A support"                 OFF  IF (MSVC OR X86 OR X86_64) )
+OCV_OPTION(WITH_GDAL           "Include GDAL Support"                        OFF  IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
+OCV_OPTION(WITH_GPHOTO2        "Include gPhoto2 library support"             ON   IF (UNIX AND NOT ANDROID) )
 
 # OpenCV build components
 # ===================================================
 OCV_OPTION(BUILD_SHARED_LIBS        "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)" NOT (ANDROID OR IOS) )
-OCV_OPTION(BUILD_opencv_apps        "Build utility applications (used for example to train classifiers)" (NOT ANDROID) IF (NOT IOS) )
+OCV_OPTION(BUILD_opencv_apps        "Build utility applications (used for example to train classifiers)" (NOT ANDROID AND NOT WINRT) IF (NOT IOS) )
 OCV_OPTION(BUILD_ANDROID_EXAMPLES   "Build examples for Android platform"         ON  IF ANDROID )
-OCV_OPTION(BUILD_DOCS               "Create build rules for OpenCV Documentation" ON )
+OCV_OPTION(BUILD_DOCS               "Create build rules for OpenCV Documentation" ON  IF NOT WINRT)
 OCV_OPTION(BUILD_EXAMPLES           "Build all examples"                          OFF )
-OCV_OPTION(BUILD_PACKAGE            "Enables 'make package_source' command"       ON )
-OCV_OPTION(BUILD_PERF_TESTS         "Build performance tests"                     ON  IF (NOT IOS) )
-OCV_OPTION(BUILD_TESTS              "Build accuracy & regression tests"           ON  IF (NOT IOS) )
+OCV_OPTION(BUILD_PACKAGE            "Enables 'make package_source' command"       ON  IF NOT WINRT)
+OCV_OPTION(BUILD_PERF_TESTS         "Build performance tests"                     ON  IF (NOT IOS AND NOT WINRT) )
+OCV_OPTION(BUILD_TESTS              "Build accuracy & regression tests"           ON  IF (NOT IOS AND NOT WINRT) )
 OCV_OPTION(BUILD_WITH_DEBUG_INFO    "Include debug info into debug libs (not MSCV only)" ON )
 OCV_OPTION(BUILD_WITH_STATIC_CRT    "Enables use of staticaly linked CRT for staticaly linked OpenCV" ON IF MSVC )
+OCV_OPTION(BUILD_WITH_DYNAMIC_IPP   "Enables dynamic linking of IPP (only for standalone IPP)" OFF )
 OCV_OPTION(BUILD_FAT_JAVA_LIB       "Create fat java wrapper containing the whole OpenCV library" ON IF NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX )
-OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF IF ANDROID AND ANDROID_SOURCE_TREE )
-OCV_OPTION(BUILD_ANDROID_PACKAGE    "Build platform-specific package for Google Play" OFF IF ANDROID )
+OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF IF ANDROID )
+OCV_OPTION(BUILD_CUDA_STUBS         "Build CUDA modules stubs when no CUDA SDK" OFF  IF (NOT IOS) )
 
 # 3rd party libs
 OCV_OPTION(BUILD_ZLIB               "Build zlib from source"             WIN32 OR APPLE )
@@ -181,7 +231,7 @@ OCV_OPTION(BUILD_TIFF               "Build libtiff from source"          WIN32 O
 OCV_OPTION(BUILD_JASPER             "Build libjasper from source"        WIN32 OR ANDROID OR APPLE )
 OCV_OPTION(BUILD_JPEG               "Build libjpeg from source"          WIN32 OR ANDROID OR APPLE )
 OCV_OPTION(BUILD_PNG                "Build libpng from source"           WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_OPENEXR            "Build openexr from source"          WIN32 OR ANDROID OR APPLE )
+OCV_OPTION(BUILD_OPENEXR            "Build openexr from source"          (WIN32 OR ANDROID OR APPLE) AND NOT WINRT)
 OCV_OPTION(BUILD_TBB                "Download and build TBB from source" ANDROID )
 
 # OpenCV installation options
@@ -191,29 +241,38 @@ OCV_OPTION(INSTALL_C_EXAMPLES       "Install C examples"        OFF )
 OCV_OPTION(INSTALL_PYTHON_EXAMPLES  "Install Python examples"   OFF )
 OCV_OPTION(INSTALL_ANDROID_EXAMPLES "Install Android examples"  OFF IF ANDROID )
 OCV_OPTION(INSTALL_TO_MANGLED_PATHS "Enables mangled install paths, that help with side by side installs." OFF IF (UNIX AND NOT ANDROID AND NOT IOS AND BUILD_SHARED_LIBS) )
-
+OCV_OPTION(INSTALL_TESTS            "Install accuracy and performance test binaries and test data" OFF)
 
 # OpenCV build options
 # ===================================================
 OCV_OPTION(ENABLE_PRECOMPILED_HEADERS "Use precompiled headers"                                  ON   IF (NOT IOS) )
 OCV_OPTION(ENABLE_SOLUTION_FOLDERS    "Solution folder in Visual Studio or in other IDEs"        (MSVC_IDE OR CMAKE_GENERATOR MATCHES Xcode) )
 OCV_OPTION(ENABLE_PROFILING           "Enable profiling in the GCC compiler (Add flags: -g -pg)" OFF  IF CMAKE_COMPILER_IS_GNUCXX )
+OCV_OPTION(ENABLE_COVERAGE            "Enable coverage collection with  GCov"                    OFF  IF CMAKE_COMPILER_IS_GNUCXX )
 OCV_OPTION(ENABLE_OMIT_FRAME_POINTER  "Enable -fomit-frame-pointer for GCC"                      ON   IF CMAKE_COMPILER_IS_GNUCXX AND NOT (APPLE AND CMAKE_COMPILER_IS_CLANGCXX) )
 OCV_OPTION(ENABLE_POWERPC             "Enable PowerPC for GCC"                                   ON   IF (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_SYSTEM_PROCESSOR MATCHES powerpc.*) )
 OCV_OPTION(ENABLE_FAST_MATH           "Enable -ffast-math (not recommended for GCC 4.6.x)"       OFF  IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
 OCV_OPTION(ENABLE_SSE                 "Enable SSE instructions"                                  ON   IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
 OCV_OPTION(ENABLE_SSE2                "Enable SSE2 instructions"                                 ON   IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_SSE3                "Enable SSE3 instructions"                                 ON   IF ((CV_ICC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_SSSE3               "Enable SSSE3 instructions"                                OFF  IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_SSE41               "Enable SSE4.1 instructions"                               OFF  IF ((CV_ICC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_SSE42               "Enable SSE4.2 instructions"                               OFF  IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_SSE3                "Enable SSE3 instructions"                                 ON   IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX OR CV_ICC) AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_SSSE3               "Enable SSSE3 instructions"                                OFF  IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_SSE41               "Enable SSE4.1 instructions"                               OFF  IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX OR CV_ICC) AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_SSE42               "Enable SSE4.2 instructions"                               OFF  IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_POPCNT              "Enable POPCNT instructions"                               OFF  IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
 OCV_OPTION(ENABLE_AVX                 "Enable AVX instructions"                                  OFF  IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_NEON                "Enable NEON instructions"                                 OFF  IF CMAKE_COMPILER_IS_GNUCXX AND ARM )
-OCV_OPTION(ENABLE_VFPV3               "Enable VFPv3-D32 instructions"                            OFF  IF CMAKE_COMPILER_IS_GNUCXX AND ARM )
+OCV_OPTION(ENABLE_AVX2                "Enable AVX2 instructions"                                 OFF  IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_FMA3                "Enable FMA3 instructions"                                 OFF  IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_NEON                "Enable NEON instructions"                                 OFF  IF CMAKE_COMPILER_IS_GNUCXX AND (ARM OR AARCH64 OR IOS) )
+OCV_OPTION(ENABLE_VFPV3               "Enable VFPv3-D32 instructions"                            OFF  IF CMAKE_COMPILER_IS_GNUCXX AND (ARM OR AARCH64 OR IOS) )
 OCV_OPTION(ENABLE_NOISY_WARNINGS      "Show all warnings even if they are too noisy"             OFF )
 OCV_OPTION(OPENCV_WARNINGS_ARE_ERRORS "Treat warnings as errors"                                 OFF )
-OCV_OPTION(ENABLE_WINRT_MODE          "Build with Windows Runtime support"                       OFF  IF WIN32 )
-OCV_OPTION(ENABLE_WINRT_MODE_NATIVE   "Build with Windows Runtime native C++ support"            OFF  IF WIN32 )
+OCV_OPTION(ANDROID_EXAMPLES_WITH_LIBS "Build binaries of Android examples with native libraries" OFF  IF ANDROID )
+OCV_OPTION(ENABLE_IMPL_COLLECTION     "Collect implementation data on function call"             OFF )
+OCV_OPTION(GENERATE_ABI_DESCRIPTOR    "Generate XML file for abi_compliance_checker tool" OFF IF UNIX)
+
+if(ENABLE_IMPL_COLLECTION)
+  add_definitions(-DCV_COLLECT_IMPL_DATA)
+endif()
 
 
 # ----------------------------------------------------------------------------
@@ -240,26 +299,52 @@ endif()
 
 if(ANDROID OR WIN32)
   set(OPENCV_DOC_INSTALL_PATH doc)
-elseif(INSTALL_TO_MANGLED_PATHS)
-  set(OPENCV_DOC_INSTALL_PATH share/OpenCV-${OPENCV_VERSION}/doc)
 else()
   set(OPENCV_DOC_INSTALL_PATH share/OpenCV/doc)
 endif()
 
-if(WIN32)
+if(WIN32 AND CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
   if(DEFINED OpenCV_RUNTIME AND DEFINED OpenCV_ARCH)
     set(OpenCV_INSTALL_BINARIES_PREFIX "${OpenCV_ARCH}/${OpenCV_RUNTIME}/")
   else()
     message(STATUS "Can't detect runtime and/or arch")
     set(OpenCV_INSTALL_BINARIES_PREFIX "")
   endif()
+elseif(ANDROID)
+  set(OpenCV_INSTALL_BINARIES_PREFIX "sdk/native/")
 else()
   set(OpenCV_INSTALL_BINARIES_PREFIX "")
 endif()
 
-set(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples")
+if(ANDROID)
+  set(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples/${ANDROID_NDK_ABI_NAME}")
+else()
+  set(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples")
+endif()
 
-set(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin")
+if(ANDROID)
+  set(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin/${ANDROID_NDK_ABI_NAME}")
+else()
+  set(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin")
+endif()
+
+if(NOT OPENCV_TEST_INSTALL_PATH)
+  set(OPENCV_TEST_INSTALL_PATH "${OPENCV_BIN_INSTALL_PATH}")
+endif()
+
+if (OPENCV_TEST_DATA_PATH)
+  get_filename_component(OPENCV_TEST_DATA_PATH ${OPENCV_TEST_DATA_PATH} ABSOLUTE)
+endif()
+
+if(OPENCV_TEST_DATA_PATH AND NOT OPENCV_TEST_DATA_INSTALL_PATH)
+  if(ANDROID)
+    set(OPENCV_TEST_DATA_INSTALL_PATH "sdk/etc/testdata")
+  elseif(WIN32)
+    set(OPENCV_TEST_DATA_INSTALL_PATH "testdata")
+  else()
+    set(OPENCV_TEST_DATA_INSTALL_PATH "share/OpenCV/testdata")
+  endif()
+endif()
 
 if(ANDROID)
   set(LIBRARY_OUTPUT_PATH         "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}")
@@ -268,19 +353,28 @@ if(ANDROID)
   set(OPENCV_3P_LIB_INSTALL_PATH  sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME})
   set(OPENCV_CONFIG_INSTALL_PATH  sdk/native/jni)
   set(OPENCV_INCLUDE_INSTALL_PATH sdk/native/jni/include)
+  set(OPENCV_SAMPLES_SRC_INSTALL_PATH samples/native)
+  set(OPENCV_OTHER_INSTALL_PATH   sdk/etc)
 else()
   set(LIBRARY_OUTPUT_PATH         "${OpenCV_BINARY_DIR}/lib")
   set(3P_LIBRARY_OUTPUT_PATH      "${OpenCV_BINARY_DIR}/3rdparty/lib${LIB_SUFFIX}")
-  if(WIN32)
+
+  if(WIN32 AND CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
     if(OpenCV_STATIC)
       set(OPENCV_LIB_INSTALL_PATH   "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
     else()
       set(OPENCV_LIB_INSTALL_PATH   "${OpenCV_INSTALL_BINARIES_PREFIX}lib${LIB_SUFFIX}")
     endif()
     set(OPENCV_3P_LIB_INSTALL_PATH  "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
+    set(OPENCV_SAMPLES_SRC_INSTALL_PATH    samples/native)
+    set(OPENCV_JAR_INSTALL_PATH java)
+    set(OPENCV_OTHER_INSTALL_PATH   etc)
   else()
     set(OPENCV_LIB_INSTALL_PATH     lib${LIB_SUFFIX})
     set(OPENCV_3P_LIB_INSTALL_PATH  share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH})
+    set(OPENCV_SAMPLES_SRC_INSTALL_PATH    share/OpenCV/samples)
+    set(OPENCV_JAR_INSTALL_PATH share/OpenCV/java)
+    set(OPENCV_OTHER_INSTALL_PATH   share/OpenCV)
   endif()
   set(OPENCV_INCLUDE_INSTALL_PATH "include")
 
@@ -297,8 +391,16 @@ set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
 
 if(INSTALL_TO_MANGLED_PATHS)
   set(OPENCV_INCLUDE_INSTALL_PATH ${OPENCV_INCLUDE_INSTALL_PATH}/opencv-${OPENCV_VERSION})
+  string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_3P_LIB_INSTALL_PATH "${OPENCV_3P_LIB_INSTALL_PATH}")
+  string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_SAMPLES_SRC_INSTALL_PATH "${OPENCV_SAMPLES_SRC_INSTALL_PATH}")
+  string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_CONFIG_INSTALL_PATH "${OPENCV_CONFIG_INSTALL_PATH}")
+  string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_DOC_INSTALL_PATH "${OPENCV_DOC_INSTALL_PATH}")
+  string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_JAR_INSTALL_PATH "${OPENCV_JAR_INSTALL_PATH}")
+  string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_TEST_DATA_INSTALL_PATH "${OPENCV_TEST_DATA_INSTALL_PATH}")
+  string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_OTHER_INSTALL_PATH "${OPENCV_OTHER_INSTALL_PATH}")
 endif()
 
+
 if(WIN32)
   # Postfix of DLLs:
   set(OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}")
@@ -313,6 +415,9 @@ if(DEFINED CMAKE_DEBUG_POSTFIX)
   set(OPENCV_DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
 endif()
 
+if(INSTALL_CREATE_DISTRIB AND BUILD_SHARED_LIBS AND NOT DEFINED BUILD_opencv_world)
+  set(BUILD_opencv_world ON CACHE INTERNAL "")
+endif()
 
 # ----------------------------------------------------------------------------
 #  Path for build/platform -specific headers
@@ -331,7 +436,7 @@ set(OPENCV_EXTRA_MODULES_PATH "" CACHE PATH "Where to look for additional OpenCV
 find_host_package(Git QUIET)
 
 if(GIT_FOUND)
-  execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty --match "2.[0-9].[0-9]*"
+  execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty --match "[0-9].[0-9].[0-9]*"
     WORKING_DIRECTORY "${OpenCV_SOURCE_DIR}"
     OUTPUT_VARIABLE OPENCV_VCSVERSION
     RESULT_VARIABLE GIT_RESULT
@@ -398,6 +503,19 @@ endif()
 include(cmake/OpenCVPCHSupport.cmake)
 include(cmake/OpenCVModule.cmake)
 
+# ----------------------------------------------------------------------------
+#  Detect endianness of build platform
+# ----------------------------------------------------------------------------
+
+if(IOS)
+  # test_big_endian needs try_compile, which doesn't work for iOS
+  # http://public.kitware.com/Bug/view.php?id=12288
+  set(WORDS_BIGENDIAN 0)
+else()
+  include(TestBigEndian)
+  test_big_endian(WORDS_BIGENDIAN)
+endif()
+
 # ----------------------------------------------------------------------------
 #  Detect 3rd-party libraries
 # ----------------------------------------------------------------------------
@@ -407,14 +525,26 @@ include(cmake/OpenCVFindLibsGUI.cmake)
 include(cmake/OpenCVFindLibsVideo.cmake)
 include(cmake/OpenCVFindLibsPerf.cmake)
 
-
 # ----------------------------------------------------------------------------
 #  Detect other 3rd-party libraries/tools
 # ----------------------------------------------------------------------------
 
-# --- LATEX for pdf documentation ---
+# --- Doxygen and PlantUML for documentation ---
+unset(DOXYGEN_FOUND CACHE)
 if(BUILD_DOCS)
-  include(cmake/OpenCVFindLATEX.cmake)
+  find_package(Doxygen)
+  if (PLANTUML_JAR)
+    message(STATUS "Using PlantUML path from command line: ${PLANTUML_JAR}")
+  elseif(DEFINED ENV{PLANTUML_JAR})
+    set(PLANTUML_JAR $ENV{PLANTUML_JAR})
+    message(STATUS "Using PLantUML path from environment: ${PLANTUML_JAR}")
+  else()
+    message(STATUS "To enable PlantUML support, set PLANTUML_JAR environment variable or pass -DPLANTUML_JAR=<filepath> option to cmake")
+  endif()
+  if (PLANTUML_JAR AND DOXYGEN_VERSION VERSION_LESS 1.8.8)
+    message(STATUS "You need Doxygen version 1.8.8 or later to use PlantUML")
+    unset(PLANTUML_JAR)
+  endif()
 endif(BUILD_DOCS)
 
 # --- Python Support ---
@@ -507,18 +637,9 @@ if(ANDROID)
   add_subdirectory(platforms/android/service)
 endif()
 
-if(BUILD_ANDROID_PACKAGE)
-  add_subdirectory(platforms/android/package)
-endif()
-
-if (ANDROID)
-  add_subdirectory(platforms/android/libinfo)
-endif()
-
 # ----------------------------------------------------------------------------
 # Finalization: generate configuration-based files
 # ----------------------------------------------------------------------------
-ocv_track_build_dependencies()
 
 # Generate platform-dependent and configuration-dependent headers
 include(cmake/OpenCVGenHeaders.cmake)
@@ -535,6 +656,52 @@ include(cmake/OpenCVGenConfig.cmake)
 # Generate Info.plist for the IOS framework
 include(cmake/OpenCVGenInfoPlist.cmake)
 
+# Generate ABI descriptor
+include(cmake/OpenCVGenABI.cmake)
+
+# Generate environment setup file
+if(INSTALL_TESTS AND OPENCV_TEST_DATA_PATH)
+  if(ANDROID)
+    get_filename_component(TEST_PATH ${OPENCV_TEST_INSTALL_PATH} DIRECTORY)
+    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/opencv_run_all_tests_android.sh.in"
+                   "${CMAKE_BINARY_DIR}/unix-install/opencv_run_all_tests.sh" @ONLY)
+    install(PROGRAMS "${CMAKE_BINARY_DIR}/unix-install/opencv_run_all_tests.sh"
+            DESTINATION ${CMAKE_INSTALL_PREFIX} COMPONENT tests)
+  elseif(WIN32)
+    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/opencv_run_all_tests_windows.cmd.in"
+                   "${CMAKE_BINARY_DIR}/win-install/opencv_run_all_tests.cmd" @ONLY)
+    install(PROGRAMS "${CMAKE_BINARY_DIR}/win-install/opencv_run_all_tests.cmd"
+            DESTINATION ${OPENCV_TEST_INSTALL_PATH} COMPONENT tests)
+  elseif(UNIX)
+    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/opencv_run_all_tests_unix.sh.in"
+                   "${CMAKE_BINARY_DIR}/unix-install/opencv_run_all_tests.sh" @ONLY)
+    install(PROGRAMS "${CMAKE_BINARY_DIR}/unix-install/opencv_run_all_tests.sh"
+            DESTINATION ${OPENCV_TEST_INSTALL_PATH} COMPONENT tests)
+  endif()
+endif()
+
+if(NOT OPENCV_README_FILE)
+  if(ANDROID)
+    set(OPENCV_README_FILE ${CMAKE_CURRENT_SOURCE_DIR}/platforms/android/README.android)
+  endif()
+endif()
+
+if(NOT OPENCV_LICENSE_FILE)
+  set(OPENCV_LICENSE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/LICENSE)
+endif()
+
+# for UNIX it does not make sense as LICENSE and readme will be part of the package automatically
+if(ANDROID OR NOT UNIX)
+  install(FILES ${OPENCV_LICENSE_FILE}
+        PERMISSIONS OWNER_READ GROUP_READ WORLD_READ
+        DESTINATION ${CMAKE_INSTALL_PREFIX} COMPONENT libs)
+  if(OPENCV_README_FILE)
+    install(FILES ${OPENCV_README_FILE}
+            PERMISSIONS OWNER_READ GROUP_READ WORLD_READ
+            DESTINATION ${CMAKE_INSTALL_PREFIX} COMPONENT libs)
+  endif()
+endif()
+
 # ----------------------------------------------------------------------------
 # Summary:
 # ----------------------------------------------------------------------------
@@ -594,6 +761,11 @@ else()
 endif()
 status("    Precompiled headers:"     PCHSupport_FOUND AND ENABLE_PRECOMPILED_HEADERS THEN YES ELSE NO)
 
+# ========================== Dependencies ============================
+ocv_get_all_libs(deps_modules deps_extra deps_3rdparty)
+status("    Extra dependencies:" ${deps_extra})
+status("    3rdparty dependencies:" ${deps_3rdparty})
+
 # ========================== OpenCV modules ==========================
 status("")
 status("  OpenCV modules:")
@@ -636,18 +808,19 @@ if(ANDROID)
     status("    Android toolchain:" "${ANDROID_STANDALONE_TOOLCHAIN}")
   endif()
   status("    android tool:"  ANDROID_EXECUTABLE  THEN "${ANDROID_EXECUTABLE} (${ANDROID_TOOLS_Pkg_Desc})" ELSE NO)
-  status("    Google Play package:" BUILD_ANDROID_PACKAGE                                         THEN YES ELSE NO)
+  status("    Google Play manager:" BUILD_ANDROID_SERVICE                                         THEN YES ELSE NO)
   status("    Android examples:"    BUILD_ANDROID_EXAMPLES AND CAN_BUILD_ANDROID_PROJECTS         THEN YES ELSE NO)
 endif()
 
 # ================== Windows RT features ==================
 if(WIN32)
 status("")
-    status("  Windows RT support:" HAVE_WINRT THEN YES ELSE NO)
-    if (ENABLE_WINRT_MODE OR ENABLE_WINRT_MODE_NATIVE)
-      status("    Windows SDK v8.0:" ${WINDOWS_SDK_PATH})
-      status("    Visual Studio 2012:" ${VISUAL_STUDIO_PATH})
-    endif()
+status("  Windows RT support:" WINRT THEN YES ELSE NO)
+  if(WINRT)
+    status("    Building for Microsoft platform: " ${CMAKE_SYSTEM_NAME})
+    status("    Building for architectures: " ${CMAKE_VS_EFFECTIVE_PLATFORMS})
+    status("    Building for version: " ${CMAKE_SYSTEM_VERSION})
+  endif()
 endif(WIN32)
 
 # ========================== GUI ==========================
@@ -674,8 +847,14 @@ else()
         status("    Cocoa:"  YES)
       endif()
     else()
-      status("    GTK+ 2.x:" HAVE_GTK      THEN "YES (ver ${ALIASOF_gtk+-2.0_VERSION})"     ELSE NO)
-      status("    GThread :" HAVE_GTHREAD  THEN "YES (ver ${ALIASOF_gthread-2.0_VERSION})"  ELSE NO)
+      if(HAVE_GTK3)
+        status("    GTK+ 3.x:" HAVE_GTK THEN "YES (ver ${ALIASOF_gtk+-3.0_VERSION})" ELSE NO)
+      elseif(HAVE_GTK)
+        status("    GTK+ 2.x:" HAVE_GTK THEN "YES (ver ${ALIASOF_gtk+-2.0_VERSION})" ELSE NO)
+      else()
+        status("    GTK+:" NO)
+      endif()
+      status("    GThread :" HAVE_GTHREAD THEN "YES (ver ${ALIASOF_gthread-2.0_VERSION})" ELSE NO)
       status("    GtkGlExt:" HAVE_GTKGLEXT THEN "YES (ver ${ALIASOF_gtkglext-1.0_VERSION})" ELSE NO)
     endif()
   endif()
@@ -726,6 +905,12 @@ else()
   status("    OpenEXR:"  "NO")
 endif()
 
+if( WITH_GDAL )
+  status("    GDAL:"   GDAL_FOUND THEN "${GDAL_LIBRARY}" ELSE "NO")
+else()
+  status("    GDAL:"     "NO")
+endif()
+
 # ========================== VIDEO IO ==========================
 status("")
 status("  Video I/O:")
@@ -739,15 +924,6 @@ if(DEFINED WITH_1394)
   status("    DC1394 2.x:"     HAVE_DC1394_2       THEN "YES (ver ${ALIASOF_libdc1394-2_VERSION})" ELSE NO)
 endif(DEFINED WITH_1394)
 
-if(ANDROID)
-  if(HAVE_opencv_androidcamera)
-    status("    AndroidNativeCamera:" BUILD_ANDROID_CAMERA_WRAPPER
-                                                   THEN "YES, build for Android${ANDROID_VERSION}" ELSE "YES, use prebuilt libraries")
-  else()
-    status("    AndroidNativeCamera:" "NO (native camera requires Android API level 8 or higher)")
-  endif()
-endif()
-
 if(DEFINED WITH_AVFOUNDATION)
   status("    AVFoundation:"   WITH_AVFOUNDATION   THEN YES                                        ELSE NO)
 endif(DEFINED WITH_AVFOUNDATION)
@@ -762,6 +938,7 @@ if(DEFINED WITH_FFMPEG)
   status("      format:"       HAVE_FFMPEG_FORMAT  THEN "YES (ver ${ALIASOF_libavformat_VERSION})" ELSE NO)
   status("      util:"         HAVE_FFMPEG_UTIL    THEN "YES (ver ${ALIASOF_libavutil_VERSION})"   ELSE NO)
   status("      swscale:"      HAVE_FFMPEG_SWSCALE THEN "YES (ver ${ALIASOF_libswscale_VERSION})"  ELSE NO)
+  status("      resample:"     HAVE_FFMPEG_RESAMPLE THEN "YES (ver ${ALIASOF_libavresample_VERSION})"  ELSE NO)
   status("      gentoo-style:" HAVE_GENTOO_FFMPEG  THEN YES                                        ELSE NO)
 endif(DEFINED WITH_FFMPEG)
 
@@ -783,6 +960,11 @@ if(DEFINED WITH_OPENNI)
                                                    THEN "YES (${OPENNI_PRIME_SENSOR_MODULE})"      ELSE NO)
 endif(DEFINED WITH_OPENNI)
 
+if(DEFINED WITH_OPENNI2)
+  status("    OpenNI2:"		   HAVE_OPENNI2	   THEN "YES (ver ${OPENNI2_VERSION_STRING}, build ${OPENNI2_VERSION_BUILD})"
+                                                                                                   ELSE NO)
+endif(DEFINED WITH_OPENNI2)
+
 if(DEFINED WITH_PVAPI)
   status("    PvAPI:"          HAVE_PVAPI          THEN YES                                        ELSE NO)
 endif(DEFINED WITH_PVAPI)
@@ -814,8 +996,9 @@ if(DEFINED WITH_V4L)
   else()
     set(HAVE_CAMV4L2_STR "NO")
   endif()
-  status("    V4L/V4L2:"       HAVE_LIBV4L         THEN "Using libv4l (ver ${ALIASOF_libv4l1_VERSION})"
-                                                   ELSE "${HAVE_CAMV4L_STR}/${HAVE_CAMV4L2_STR}")
+  status("    V4L/V4L2:"       HAVE_LIBV4L
+             THEN "Using libv4l1 (ver ${ALIASOF_libv4l1_VERSION}) / libv4l2 (ver ${ALIASOF_libv4l2_VERSION})"
+             ELSE "${HAVE_CAMV4L_STR}/${HAVE_CAMV4L2_STR}")
 endif(DEFINED WITH_V4L)
 
 if(DEFINED WITH_DSHOW)
@@ -838,24 +1021,36 @@ if(DEFINED WITH_INTELPERC)
   status("    Intel PerC:"     HAVE_INTELPERC      THEN "YES"                                 ELSE NO)
 endif(DEFINED WITH_INTELPERC)
 
+if(DEFINED WITH_GPHOTO2)
+  status("    gPhoto2:"        HAVE_GPHOTO2        THEN "YES"                                 ELSE NO)
+endif(DEFINED WITH_GPHOTO2)
+
 
 # ========================== Other third-party libraries ==========================
 status("")
 status("  Other third-party libraries:")
 
-if(WITH_IPP AND IPP_FOUND)
-  status("    Use IPP:" "${IPP_LATEST_VERSION_STR} [${IPP_LATEST_VERSION_MAJOR}.${IPP_LATEST_VERSION_MINOR}.${IPP_LATEST_VERSION_BUILD}]")
+if(WITH_IPP AND HAVE_IPP)
+  status("    Use IPP:" "${IPP_VERSION_STR} [${IPP_VERSION_MAJOR}.${IPP_VERSION_MINOR}.${IPP_VERSION_BUILD}]")
   status("         at:" "${IPP_ROOT_DIR}")
+  if(NOT HAVE_IPP_ICV_ONLY)
+    status("     linked:" BUILD_WITH_DYNAMIC_IPP THEN "dynamic" ELSE "static")
+  endif()
 else()
-  status("    Use IPP:"   WITH_IPP AND NOT IPP_FOUND THEN "IPP not found" ELSE NO)
+  status("    Use IPP:"   WITH_IPP AND NOT HAVE_IPP THEN "IPP not found or implicitly disabled" ELSE NO)
 endif()
 
+if(DEFINED WITH_IPP_A)
+status("    Use IPP Async:"  HAVE_IPP_A       THEN "YES" ELSE NO)
+endif(DEFINED WITH_IPP_A)
+
 status("    Use Eigen:"      HAVE_EIGEN       THEN "YES (ver ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION})" ELSE NO)
 status("    Use TBB:"        HAVE_TBB         THEN "YES (ver ${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR} interface ${TBB_INTERFACE_VERSION})" ELSE NO)
 status("    Use OpenMP:"     HAVE_OPENMP      THEN YES ELSE NO)
 status("    Use GCD"         HAVE_GCD         THEN YES ELSE NO)
 status("    Use Concurrency" HAVE_CONCURRENCY THEN YES ELSE NO)
 status("    Use C=:"         HAVE_CSTRIPES    THEN YES ELSE NO)
+status("    Use pthreads for parallel for:"   HAVE_PTHREADS_PF THEN YES ELSE NO)
 status("    Use Cuda:"       HAVE_CUDA        THEN "YES (ver ${CUDA_VERSION_STRING})" ELSE NO)
 status("    Use OpenCL:"     HAVE_OPENCL      THEN YES ELSE NO)
 
@@ -905,18 +1100,34 @@ endif()
 
 # ========================== python ==========================
 status("")
-status("  Python:")
-status("    Interpreter:"     PYTHONINTERP_FOUND  THEN "${PYTHON_EXECUTABLE} (ver ${PYTHON_VERSION_STRING})"       ELSE NO)
-if(BUILD_opencv_python)
-  if(PYTHONLIBS_VERSION_STRING)
-    status("    Libraries:"   HAVE_opencv_python  THEN  "${PYTHON_LIBRARIES} (ver ${PYTHONLIBS_VERSION_STRING})"   ELSE NO)
+status("  Python 2:")
+status("    Interpreter:"     PYTHON2INTERP_FOUND  THEN "${PYTHON2_EXECUTABLE} (ver ${PYTHON2_VERSION_STRING})"       ELSE NO)
+if(BUILD_opencv_python2)
+  if(PYTHON2LIBS_VERSION_STRING)
+    status("    Libraries:"   HAVE_opencv_python2  THEN  "${PYTHON2_LIBRARIES} (ver ${PYTHON2LIBS_VERSION_STRING})"   ELSE NO)
   else()
-    status("    Libraries:"   HAVE_opencv_python  THEN  "${PYTHON_LIBRARIES}"                                      ELSE NO)
+    status("    Libraries:"   HAVE_opencv_python2  THEN  "${PYTHON2_LIBRARIES}"                                      ELSE NO)
   endif()
-  status("    numpy:"         PYTHON_NUMPY_INCLUDE_DIRS THEN "${PYTHON_NUMPY_INCLUDE_DIRS} (ver ${PYTHON_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
-  status("    packages path:" PYTHON_EXECUTABLE         THEN "${PYTHON_PACKAGES_PATH}"                                    ELSE "-")
+  status("    numpy:"         PYTHON2_NUMPY_INCLUDE_DIRS THEN "${PYTHON2_NUMPY_INCLUDE_DIRS} (ver ${PYTHON2_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
+  status("    packages path:" PYTHON2_EXECUTABLE         THEN "${PYTHON2_PACKAGES_PATH}"                                    ELSE "-")
 endif()
 
+status("")
+status("  Python 3:")
+status("    Interpreter:"     PYTHON3INTERP_FOUND  THEN "${PYTHON3_EXECUTABLE} (ver ${PYTHON3_VERSION_STRING})"       ELSE NO)
+if(BUILD_opencv_python3)
+  if(PYTHON3LIBS_VERSION_STRING)
+    status("    Libraries:"   HAVE_opencv_python3  THEN  "${PYTHON3_LIBRARIES} (ver ${PYTHON3LIBS_VERSION_STRING})"   ELSE NO)
+  else()
+    status("    Libraries:"   HAVE_opencv_python3  THEN  "${PYTHON3_LIBRARIES}"                                      ELSE NO)
+  endif()
+  status("    numpy:"         PYTHON3_NUMPY_INCLUDE_DIRS THEN "${PYTHON3_NUMPY_INCLUDE_DIRS} (ver ${PYTHON3_NUMPY_VERSION})" ELSE "NO (Python3 wrappers can not be generated)")
+  status("    packages path:" PYTHON3_EXECUTABLE         THEN "${PYTHON3_PACKAGES_PATH}"                                    ELSE "-")
+endif()
+
+status("")
+status("  Python (for build):"  PYTHON_DEFAULT_AVAILABLE THEN "${PYTHON_DEFAULT_EXECUTABLE}" ELSE NO)
+
 # ========================== java ==========================
 status("")
 status("  Java:")
@@ -924,7 +1135,8 @@ status("    ant:"           ANT_EXECUTABLE      THEN "${ANT_EXECUTABLE} (ver ${A
 if(NOT ANDROID)
   status("    JNI:"         JNI_INCLUDE_DIRS    THEN "${JNI_INCLUDE_DIRS}"                                       ELSE NO)
 endif()
-status("    Java tests:"    BUILD_TESTS AND (CAN_BUILD_ANDROID_PROJECTS OR HAVE_opencv_java)            THEN YES ELSE NO)
+status("    Java wrappers:" HAVE_opencv_java                                                            THEN YES ELSE NO)
+status("    Java tests:"    BUILD_TESTS AND opencv_test_java_BINARY_DIR                                 THEN YES ELSE NO)
 
 # ========================= matlab =========================
 status("")
@@ -938,14 +1150,8 @@ endif()
 if(BUILD_DOCS)
   status("")
   status("  Documentation:")
-  if(HAVE_SPHINX)
-    status("    Build Documentation:" PDFLATEX_COMPILER      THEN YES ELSE "YES (only HTML and without math expressions)")
-  else()
-    status("    Build Documentation:" NO)
-  endif()
-  status("    Sphinx:"              HAVE_SPHINX              THEN "${SPHINX_BUILD} (ver ${SPHINX_VERSION})" ELSE NO)
-  status("    PdfLaTeX compiler:"   PDFLATEX_COMPILER        THEN "${PDFLATEX_COMPILER}" ELSE NO)
-  status("    PlantUML:"            PLANTUML                 THEN "${PLANTUML}" ELSE NO)
+  status("    Doxygen:"             DOXYGEN_FOUND             THEN "${DOXYGEN_EXECUTABLE} (ver ${DOXYGEN_VERSION})" ELSE NO)
+  status("    PlantUML:"            PLANTUML_JAR              THEN "${PLANTUML_JAR}" ELSE NO)
 endif()
 
 # ========================== samples and tests ==========================
@@ -971,3 +1177,9 @@ ocv_finalize_status()
 if("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
   message(WARNING "The source directory is the same as binary directory. \"make clean\" may damage the source tree")
 endif()
+
+# ----------------------------------------------------------------------------
+# CPack stuff
+# ----------------------------------------------------------------------------
+
+include(cmake/OpenCVPackaging.cmake)

LICENSE

@@ -7,6 +7,14 @@ copy or use the software.
                For Open Source Computer Vision Library
                        (3-clause BSD License)
 
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:
 

README.md

@@ -1,5 +1,7 @@
 ### OpenCV: Open Source Computer Vision Library
 
+[![Gittip](http://img.shields.io/gittip/OpenCV.png)](https://www.gittip.com/OpenCV/)
+
 #### Resources
 
 * Homepage: <http://opencv.org>
@@ -18,6 +20,3 @@ Summary of guidelines:
 * Include tests and documentation;
 * Clean up "oops" commits before submitting;
 * Follow the coding style guide.
-
-[![Donate OpenCV project](http://opencv.org/wp-content/uploads/2013/07/gittip1.png)](https://www.gittip.com/OpenCV/)
-[![Donate OpenCV project](http://opencv.org/wp-content/uploads/2013/07/paypal-donate-button.png)](https://www.paypal.com/cgi-bin/webscr?item_name=Donation+to+OpenCV&cmd=_donations&business=accountant%40opencv.org)

apps/CMakeLists.txt

@@ -1,6 +1,6 @@
 add_definitions(-D__OPENCV_BUILD=1)
 link_libraries(${OPENCV_LINKER_LIBS})
 
-add_subdirectory(haartraining)
 add_subdirectory(traincascade)
-add_subdirectory(sft)
+add_subdirectory(createsamples)
+add_subdirectory(annotation)

apps/annotation/CMakeLists.txt

@@ -0,0 +1,37 @@
+SET(OPENCV_ANNOTATION_DEPS opencv_core opencv_highgui opencv_imgproc opencv_imgcodecs opencv_videoio)
+ocv_check_dependencies(${OPENCV_ANNOTATION_DEPS})
+
+if(NOT OCV_DEPENDENCIES_FOUND)
+   return()
+endif()
+
+project(annotation)
+set(the_target opencv_annotation)
+
+ocv_target_include_directories(${the_target} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
+ocv_target_include_modules_recurse(${the_target} ${OPENCV_ANNOTATION_DEPS})
+
+file(GLOB SRCS *.cpp)
+
+set(annotation_files ${SRCS})
+ocv_add_executable(${the_target} ${annotation_files})
+ocv_target_link_libraries(${the_target} ${OPENCV_ANNOTATION_DEPS})
+
+set_target_properties(${the_target} PROPERTIES
+                      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+                      ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+                      RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+                      INSTALL_NAME_DIR lib
+                      OUTPUT_NAME "opencv_annotation")
+
+if(ENABLE_SOLUTION_FOLDERS)
+   set_target_properties(${the_target} PROPERTIES FOLDER "applications")
+endif()
+
+if(INSTALL_CREATE_DISTRIB)
+   if(BUILD_SHARED_LIBS)
+      install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} CONFIGURATIONS Release COMPONENT dev)
+   endif()
+else()
+   install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT dev)
+endif()

apps/annotation/opencv_annotation.cpp

@@ -0,0 +1,207 @@
+/*****************************************************************************************************
+USAGE:
+./opencv_annotation -images <folder location> -annotations <ouput file>
+
+Created by: Puttemans Steven
+*****************************************************************************************************/
+
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include <fstream>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+// Function prototypes
+void on_mouse(int, int, int, int, void*);
+string int2string(int);
+void get_annotations(Mat, stringstream*);
+
+// Public parameters
+Mat image;
+int roi_x0 = 0, roi_y0 = 0, roi_x1 = 0, roi_y1 = 0, num_of_rec = 0;
+bool start_draw = false;
+
+// Window name for visualisation purposes
+const string window_name="OpenCV Based Annotation Tool";
+
+// FUNCTION : Mouse response for selecting objects in images
+// If left button is clicked, start drawing a rectangle as long as mouse moves
+// Stop drawing once a new left click is detected by the on_mouse function
+void on_mouse(int event, int x, int y, int , void * )
+{
+    // Action when left button is clicked
+    if(event == EVENT_LBUTTONDOWN)
+    {
+        if(!start_draw)
+        {
+            roi_x0 = x;
+            roi_y0 = y;
+            start_draw = true;
+        } else {
+            roi_x1 = x;
+            roi_y1 = y;
+            start_draw = false;
+        }
+    }
+    // Action when mouse is moving
+    if((event == EVENT_MOUSEMOVE) && start_draw)
+    {
+        // Redraw bounding box for annotation
+        Mat current_view;
+        image.copyTo(current_view);
+        rectangle(current_view, Point(roi_x0,roi_y0), Point(x,y), Scalar(0,0,255));
+        imshow(window_name, current_view);
+    }
+}
+
+// FUNCTION : snippet to convert an integer value to a string using a clean function
+// instead of creating a stringstream each time inside the main code
+string int2string(int num)
+{
+    stringstream temp_stream;
+    temp_stream << num;
+    return temp_stream.str();
+}
+
+// FUNCTION : given an image containing positive object instances, add all the object
+// annotations to a known stringstream
+void get_annotations(Mat input_image, stringstream* output_stream)
+{
+    // Make it possible to exit the annotation
+    bool stop = false;
+
+    // Reset the num_of_rec element at each iteration
+    // Make sure the global image is set to the current image
+    num_of_rec = 0;
+    image = input_image;
+
+    // Init window interface and couple mouse actions
+    namedWindow(window_name, WINDOW_AUTOSIZE);
+    setMouseCallback(window_name, on_mouse);
+
+    imshow(window_name, image);
+    stringstream temp_stream;
+    int key_pressed = 0;
+
+    do
+    {
+        // Keys for processing
+        // You need to select one for confirming a selection and one to continue to the next image
+        // Based on the universal ASCII code of the keystroke: http://www.asciitable.com/
+        //      c = 99		    add rectangle to current image
+        //	    n = 110		    save added rectangles and show next image
+        //	    <ESC> = 27      exit program
+        key_pressed = 0xFF & waitKey(0);
+        switch( key_pressed )
+        {
+        case 27:
+                destroyWindow(window_name);
+                stop = true;
+        case 99:
+                // Add a rectangle to the list
+                num_of_rec++;
+                // Draw initiated from top left corner
+                if(roi_x0<roi_x1 && roi_y0<roi_y1)
+                {
+                    temp_stream << " " << int2string(roi_x0) << " " << int2string(roi_y0) << " " << int2string(roi_x1-roi_x0) << " " << int2string(roi_y1-roi_y0);
+                }
+                // Draw initiated from bottom right corner
+                if(roi_x0>roi_x1 && roi_y0>roi_y1)
+                {
+                    temp_stream << " " << int2string(roi_x1) << " " << int2string(roi_y1) << " " << int2string(roi_x0-roi_x1) << " " << int2string(roi_y0-roi_y1);
+                }
+                // Draw initiated from top right corner
+                if(roi_x0>roi_x1 && roi_y0<roi_y1)
+                {
+                    temp_stream << " " << int2string(roi_x1) << " " << int2string(roi_y0) << " " << int2string(roi_x0-roi_x1) << " " << int2string(roi_y1-roi_y0);
+                }
+                // Draw initiated from bottom left corner
+                if(roi_x0<roi_x1 && roi_y0>roi_y1)
+                {
+                    temp_stream << " " << int2string(roi_x0) << " " << int2string(roi_y1) << " " << int2string(roi_x1-roi_x0) << " " << int2string(roi_y0-roi_y1);
+                }
+
+                rectangle(input_image, Point(roi_x0,roi_y0), Point(roi_x1,roi_y1), Scalar(0,255,0), 1);
+
+                break;
+        }
+
+        // Check if escape has been pressed
+        if(stop)
+        {
+            break;
+        }
+    }
+    // Continue as long as the next image key has not been pressed
+    while(key_pressed != 110);
+
+    // If there are annotations AND the next image key is pressed
+    // Write the image annotations to the file
+    if(num_of_rec>0 && key_pressed==110)
+    {
+        *output_stream << " " << num_of_rec << temp_stream.str() << endl;
+    }
+
+    // Close down the window
+    destroyWindow(window_name);
+}
+
+int main( int argc, const char** argv )
+{
+    // If no arguments are given, then supply some information on how this tool works
+    if( argc == 1 ){
+        cout << "Usage: " << argv[0] << endl;
+        cout << " -images <folder_location> [example - /data/testimages/]" << endl;
+        cout << " -annotations <ouput_file> [example - /data/annotations.txt]" << endl;
+
+        return -1;
+    }
+
+    // Read in the input arguments
+    string image_folder;
+    string annotations;
+    for(int i = 1; i < argc; ++i )
+    {
+        if( !strcmp( argv[i], "-images" ) )
+        {
+            image_folder = argv[++i];
+        }
+        else if( !strcmp( argv[i], "-annotations" ) )
+        {
+            annotations = argv[++i];
+        }
+    }
+
+    // Create the outputfilestream
+    ofstream output(annotations.c_str());
+
+    // Return the image filenames inside the image folder
+    vector<String> filenames;
+    String folder(image_folder);
+    glob(folder, filenames);
+
+    // Loop through each image stored in the images folder
+    // Create and temporarily store the annotations
+    // At the end write everything to the annotations file
+    for (size_t i = 0; i < filenames.size(); i++){
+        // Read in an image
+        Mat current_image = imread(filenames[i]);
+
+        // Perform annotations & generate corresponding output
+        stringstream output_stream;
+        get_annotations(current_image, &output_stream);
+
+        // Store the annotations, write to the output file
+        if (output_stream.str() != ""){
+            output << filenames[i] << output_stream.str();
+        }
+    }
+
+    return 0;
+}

apps/createsamples/CMakeLists.txt

@@ -0,0 +1,39 @@
+set(OPENCV_CREATESAMPLES_DEPS opencv_core opencv_imgproc opencv_objdetect opencv_imgcodecs opencv_highgui opencv_calib3d opencv_features2d opencv_videoio)
+ocv_check_dependencies(${OPENCV_CREATESAMPLES_DEPS})
+
+if(NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+project(createsamples)
+set(the_target opencv_createsamples)
+
+ocv_target_include_directories(${the_target} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
+ocv_target_include_modules_recurse(${the_target} ${OPENCV_CREATESAMPLES_DEPS})
+
+file(GLOB SRCS *.cpp)
+file(GLOB HDRS *.h*)
+
+set(createsamples_files ${SRCS} ${HDRS})
+
+ocv_add_executable(${the_target} ${createsamples_files})
+ocv_target_link_libraries(${the_target} ${OPENCV_CREATESAMPLES_DEPS})
+
+set_target_properties(${the_target} PROPERTIES
+                      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+                      ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+                      RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+                      INSTALL_NAME_DIR lib
+                      OUTPUT_NAME "opencv_createsamples")
+
+if(ENABLE_SOLUTION_FOLDERS)
+  set_target_properties(${the_target} PROPERTIES FOLDER "applications")
+endif()
+
+if(INSTALL_CREATE_DISTRIB)
+  if(BUILD_SHARED_LIBS)
+    install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} CONFIGURATIONS Release COMPONENT dev)
+  endif()
+else()
+  install(TARGETS ${the_target} OPTIONAL RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT dev)
+endif()

apps/createsamples/createsamples.cpp

@@ -53,7 +53,7 @@
 
 using namespace std;
 
-#include "cvhaartraining.h"
+#include "utility.hpp"
 
 int main( int argc, char* argv[] )
 {

apps/createsamples/utility.hpp

@@ -0,0 +1,124 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __CREATESAMPLES_UTILITY_HPP__
+#define __CREATESAMPLES_UTILITY_HPP__
+
+#define CV_VERBOSE  1
+
+/*
+ * cvCreateTrainingSamples
+ *
+ * Create training samples applying random distortions to sample image and
+ * store them in .vec file
+ *
+ * filename        - .vec file name
+ * imgfilename     - sample image file name
+ * bgcolor         - background color for sample image
+ * bgthreshold     - background color threshold. Pixels those colors are in range
+ *   [bgcolor-bgthreshold, bgcolor+bgthreshold] are considered as transparent
+ * bgfilename      - background description file name. If not NULL samples
+ *   will be put on arbitrary background
+ * count           - desired number of samples
+ * invert          - if not 0 sample foreground pixels will be inverted
+ *   if invert == CV_RANDOM_INVERT then samples will be inverted randomly
+ * maxintensitydev - desired max intensity deviation of foreground samples pixels
+ * maxxangle       - max rotation angles
+ * maxyangle
+ * maxzangle
+ * showsamples     - if not 0 samples will be shown
+ * winwidth        - desired samples width
+ * winheight       - desired samples height
+ */
+#define CV_RANDOM_INVERT 0x7FFFFFFF
+
+void cvCreateTrainingSamples( const char* filename,
+                              const char* imgfilename, int bgcolor, int bgthreshold,
+                              const char* bgfilename, int count,
+                              int invert = 0, int maxintensitydev = 40,
+                              double maxxangle = 1.1,
+                              double maxyangle = 1.1,
+                              double maxzangle = 0.5,
+                              int showsamples = 0,
+                              int winwidth = 24, int winheight = 24 );
+
+void cvCreateTestSamples( const char* infoname,
+                          const char* imgfilename, int bgcolor, int bgthreshold,
+                          const char* bgfilename, int count,
+                          int invert, int maxintensitydev,
+                          double maxxangle, double maxyangle, double maxzangle,
+                          int showsamples,
+                          int winwidth, int winheight );
+
+/*
+ * cvCreateTrainingSamplesFromInfo
+ *
+ * Create training samples from a set of marked up images and store them into .vec file
+ * infoname    - file in which marked up image descriptions are stored
+ * num         - desired number of samples
+ * showsamples - if not 0 samples will be shown
+ * winwidth    - sample width
+ * winheight   - sample height
+ *
+ * Return number of successfully created samples
+ */
+int cvCreateTrainingSamplesFromInfo( const char* infoname, const char* vecfilename,
+                                     int num,
+                                     int showsamples,
+                                     int winwidth, int winheight );
+
+/*
+ * cvShowVecSamples
+ *
+ * Shows samples stored in .vec file
+ *
+ * filename
+ *   .vec file name
+ * winwidth
+ *   sample width
+ * winheight
+ *   sample height
+ * scale
+ *   the scale each sample is adjusted to
+ */
+void cvShowVecSamples( const char* filename, int winwidth, int winheight, double scale );
+
+#endif //__CREATESAMPLES_UTILITY_HPP__

apps/haartraining/CMakeLists.txt

@@ -1,89 +0,0 @@
-SET(OPENCV_HAARTRAINING_DEPS opencv_core opencv_imgproc opencv_photo opencv_ml opencv_highgui opencv_objdetect opencv_calib3d opencv_video opencv_features2d opencv_flann opencv_legacy)
-ocv_check_dependencies(${OPENCV_HAARTRAINING_DEPS})
-
-if(NOT OCV_DEPENDENCIES_FOUND)
-  return()
-endif()
-
-project(haartraining)
-
-ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
-ocv_include_modules(${OPENCV_HAARTRAINING_DEPS})
-
-if(WIN32)
-  link_directories(${CMAKE_CURRENT_BINARY_DIR})
-endif()
-
-link_libraries(${OPENCV_HAARTRAINING_DEPS} opencv_haartraining_engine)
-
-# -----------------------------------------------------------
-#  Library
-# -----------------------------------------------------------
-set(cvhaartraining_lib_src
-  _cvcommon.h
-  cvclassifier.h
-  _cvhaartraining.h
-  cvhaartraining.h
-  cvboost.cpp
-  cvcommon.cpp
-  cvhaarclassifier.cpp
-  cvhaartraining.cpp
-  cvsamples.cpp
-  )
-
-add_library(opencv_haartraining_engine STATIC ${cvhaartraining_lib_src})
-set_target_properties(opencv_haartraining_engine PROPERTIES
-                      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-                      ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
-                      RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
-                      INSTALL_NAME_DIR lib
-                     )
-
-# -----------------------------------------------------------
-#  haartraining
-# -----------------------------------------------------------
-
-add_executable(opencv_haartraining cvhaartraining.h haartraining.cpp)
-set_target_properties(opencv_haartraining PROPERTIES
-                      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-                      OUTPUT_NAME "opencv_haartraining")
-
-# -----------------------------------------------------------
-#  createsamples
-# -----------------------------------------------------------
-
-add_executable(opencv_createsamples cvhaartraining.h createsamples.cpp)
-set_target_properties(opencv_createsamples PROPERTIES
-                      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-                      OUTPUT_NAME "opencv_createsamples")
-
-# -----------------------------------------------------------
-#  performance
-# -----------------------------------------------------------
-add_executable(opencv_performance performance.cpp)
-set_target_properties(opencv_performance PROPERTIES
-                      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-                      OUTPUT_NAME "opencv_performance")
-
-# -----------------------------------------------------------
-#  Install part
-# -----------------------------------------------------------
-
-if(INSTALL_CREATE_DISTRIB)
-  if(BUILD_SHARED_LIBS)
-    install(TARGETS opencv_haartraining RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} CONFIGURATIONS Release COMPONENT main)
-    install(TARGETS opencv_createsamples RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} CONFIGURATIONS Release COMPONENT main)
-    install(TARGETS opencv_performance RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} CONFIGURATIONS Release COMPONENT main)
-  endif()
-else()
-  install(TARGETS opencv_haartraining RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT main)
-  install(TARGETS opencv_createsamples RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT main)
-  install(TARGETS opencv_performance RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT main)
-endif()
-
-if(ENABLE_SOLUTION_FOLDERS)
-  set_target_properties(opencv_performance PROPERTIES FOLDER "applications")
-  set_target_properties(opencv_createsamples PROPERTIES FOLDER "applications")
-  set_target_properties(opencv_haartraining PROPERTIES FOLDER "applications")
-  set_target_properties(opencv_haartraining_engine PROPERTIES FOLDER "applications")
-endif()

apps/haartraining/_cvcommon.h

@@ -1,92 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef __CVCOMMON_H_
-#define __CVCOMMON_H_
-
-#include "opencv2/core.hpp"
-
-#include "cxcore.h"
-#include "cv.h"
-#include "cxmisc.h"
-
-#define __BEGIN__ __CV_BEGIN__
-#define __END__  __CV_END__
-#define EXIT __CV_EXIT__
-
-#ifndef PATH_MAX
-#define PATH_MAX 512
-#endif /* PATH_MAX */
-
-int icvMkDir( const char* filename );
-
-/* returns index at specified position from index matrix of any type.
-   if matrix is NULL, then specified position is returned */
-CV_INLINE
-int icvGetIdxAt( CvMat* idx, int pos );
-
-CV_INLINE
-int icvGetIdxAt( CvMat* idx, int pos )
-{
-    if( idx == NULL )
-    {
-        return pos;
-    }
-    else
-    {
-        CvScalar sc;
-        int type;
-
-        type = CV_MAT_TYPE( idx->type );
-        cvRawDataToScalar( idx->data.ptr + pos *
-            ( (idx->rows == 1) ? CV_ELEM_SIZE( type ) : idx->step ), type, &sc );
-
-        return (int) sc.val[0];
-    }
-}
-
-/* debug functions */
-
-#define CV_DEBUG_SAVE( ptr ) icvSave( ptr, __FILE__, __LINE__ );
-
-void icvSave( const CvArr* ptr, const char* filename, int line );
-
-#endif /* __CVCOMMON_H_ */

apps/haartraining/_cvhaartraining.h

@@ -1,414 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-/*
- * _cvhaartraining.h
- *
- * training of cascade of boosted classifiers based on haar features
- */
-
-#ifndef __CVHAARTRAINING_H_
-#define __CVHAARTRAINING_H_
-
-#include "_cvcommon.h"
-#include "cvclassifier.h"
-#include <cstring>
-#include <cstdio>
-
-/* parameters for tree cascade classifier training */
-
-/* max number of clusters */
-#define CV_MAX_CLUSTERS 3
-
-/* term criteria for K-Means */
-#define CV_TERM_CRITERIA() cvTermCriteria( CV_TERMCRIT_EPS, 1000, 1E-5 )
-
-/* print statistic info */
-#define CV_VERBOSE 1
-
-#define CV_STAGE_CART_FILE_NAME "AdaBoostCARTHaarClassifier.txt"
-
-#define CV_HAAR_FEATURE_MAX      3
-#define CV_HAAR_FEATURE_DESC_MAX 20
-
-typedef int    sum_type;
-typedef double sqsum_type;
-typedef short  idx_type;
-
-#define CV_SUM_MAT_TYPE CV_32SC1
-#define CV_SQSUM_MAT_TYPE CV_64FC1
-#define CV_IDX_MAT_TYPE CV_16SC1
-
-#define CV_STUMP_TRAIN_PORTION 100
-
-#define CV_THRESHOLD_EPS (0.00001F)
-
-typedef struct CvTHaarFeature
-{
-    char desc[CV_HAAR_FEATURE_DESC_MAX];
-    int  tilted;
-    struct
-    {
-        CvRect r;
-        float weight;
-    } rect[CV_HAAR_FEATURE_MAX];
-} CvTHaarFeature;
-
-typedef struct CvFastHaarFeature
-{
-    int tilted;
-    struct
-    {
-        int p0, p1, p2, p3;
-        float weight;
-    } rect[CV_HAAR_FEATURE_MAX];
-} CvFastHaarFeature;
-
-typedef struct CvIntHaarFeatures
-{
-    CvSize winsize;
-    int count;
-    CvTHaarFeature* feature;
-    CvFastHaarFeature* fastfeature;
-} CvIntHaarFeatures;
-
-CV_INLINE CvTHaarFeature cvHaarFeature( const char* desc,
-                            int x0, int y0, int w0, int h0, float wt0,
-                            int x1, int y1, int w1, int h1, float wt1,
-                            int x2 CV_DEFAULT( 0 ), int y2 CV_DEFAULT( 0 ),
-                            int w2 CV_DEFAULT( 0 ), int h2 CV_DEFAULT( 0 ),
-                            float wt2 CV_DEFAULT( 0.0F ) );
-
-CV_INLINE CvTHaarFeature cvHaarFeature( const char* desc,
-                            int x0, int y0, int w0, int h0, float wt0,
-                            int x1, int y1, int w1, int h1, float wt1,
-                            int x2, int y2, int w2, int h2, float wt2 )
-{
-    CvTHaarFeature hf;
-
-    assert( CV_HAAR_FEATURE_MAX >= 3 );
-    assert( strlen( desc ) < CV_HAAR_FEATURE_DESC_MAX );
-
-    strcpy( &(hf.desc[0]), desc );
-    hf.tilted = ( hf.desc[0] == 't' );
-
-    hf.rect[0].r.x = x0;
-    hf.rect[0].r.y = y0;
-    hf.rect[0].r.width  = w0;
-    hf.rect[0].r.height = h0;
-    hf.rect[0].weight   = wt0;
-
-    hf.rect[1].r.x = x1;
-    hf.rect[1].r.y = y1;
-    hf.rect[1].r.width  = w1;
-    hf.rect[1].r.height = h1;
-    hf.rect[1].weight   = wt1;
-
-    hf.rect[2].r.x = x2;
-    hf.rect[2].r.y = y2;
-    hf.rect[2].r.width  = w2;
-    hf.rect[2].r.height = h2;
-    hf.rect[2].weight   = wt2;
-
-    return hf;
-}
-
-/* Prepared for training samples */
-typedef struct CvHaarTrainingData
-{
-    CvSize winsize;     /* training image size */
-    int    maxnum;      /* maximum number of samples */
-    CvMat  sum;         /* sum images (each row represents image) */
-    CvMat  tilted;      /* tilted sum images (each row represents image) */
-    CvMat  normfactor;  /* normalization factor */
-    CvMat  cls;         /* classes. 1.0 - object, 0.0 - background */
-    CvMat  weights;     /* weights */
-
-    CvMat* valcache;    /* precalculated feature values (CV_32FC1) */
-    CvMat* idxcache;    /* presorted indices (CV_IDX_MAT_TYPE) */
-} CvHaarTrainigData;
-
-
-/* Passed to callback functions */
-typedef struct CvUserdata
-{
-    CvHaarTrainingData* trainingData;
-    CvIntHaarFeatures* haarFeatures;
-} CvUserdata;
-
-CV_INLINE
-CvUserdata cvUserdata( CvHaarTrainingData* trainingData,
-                       CvIntHaarFeatures* haarFeatures );
-
-CV_INLINE
-CvUserdata cvUserdata( CvHaarTrainingData* trainingData,
-                       CvIntHaarFeatures* haarFeatures )
-{
-    CvUserdata userdata;
-
-    userdata.trainingData = trainingData;
-    userdata.haarFeatures = haarFeatures;
-
-    return userdata;
-}
-
-
-#define CV_INT_HAAR_CLASSIFIER_FIELDS()                                 \
-    float (*eval)( CvIntHaarClassifier*, sum_type*, sum_type*, float ); \
-    void  (*save)( CvIntHaarClassifier*, FILE* file );                  \
-    void  (*release)( CvIntHaarClassifier** );
-
-/* internal weak classifier*/
-typedef struct CvIntHaarClassifier
-{
-    CV_INT_HAAR_CLASSIFIER_FIELDS()
-} CvIntHaarClassifier;
-
-/*
- * CART classifier
- */
-typedef struct CvCARTHaarClassifier
-{
-    CV_INT_HAAR_CLASSIFIER_FIELDS()
-
-    int count;
-    int* compidx;
-    CvTHaarFeature* feature;
-    CvFastHaarFeature* fastfeature;
-    float* threshold;
-    int* left;
-    int* right;
-    float* val;
-} CvCARTHaarClassifier;
-
-/* internal stage classifier */
-typedef struct CvStageHaarClassifier
-{
-    CV_INT_HAAR_CLASSIFIER_FIELDS()
-
-    int count;
-    float threshold;
-    CvIntHaarClassifier** classifier;
-} CvStageHaarClassifier;
-
-/* internal cascade classifier */
-typedef struct CvCascadeHaarClassifier
-{
-    CV_INT_HAAR_CLASSIFIER_FIELDS()
-
-    int count;
-    CvIntHaarClassifier** classifier;
-} CvCascadeHaarClassifier;
-
-
-/* internal tree cascade classifier node */
-typedef struct CvTreeCascadeNode
-{
-    CvStageHaarClassifier* stage;
-
-    struct CvTreeCascadeNode* next;
-    struct CvTreeCascadeNode* child;
-    struct CvTreeCascadeNode* parent;
-
-    struct CvTreeCascadeNode* next_same_level;
-    struct CvTreeCascadeNode* child_eval;
-    int idx;
-    int leaf;
-} CvTreeCascadeNode;
-
-/* internal tree cascade classifier */
-typedef struct CvTreeCascadeClassifier
-{
-    CV_INT_HAAR_CLASSIFIER_FIELDS()
-
-    CvTreeCascadeNode* root;      /* root of the tree */
-    CvTreeCascadeNode* root_eval; /* root node for the filtering */
-
-    int next_idx;
-} CvTreeCascadeClassifier;
-
-
-CV_INLINE float cvEvalFastHaarFeature( const CvFastHaarFeature* feature,
-                                       const sum_type* sum, const sum_type* tilted )
-{
-    const sum_type* img = feature->tilted ? tilted : sum;
-    float ret = feature->rect[0].weight*
-        (img[feature->rect[0].p0] - img[feature->rect[0].p1] -
-         img[feature->rect[0].p2] + img[feature->rect[0].p3]) +
-         feature->rect[1].weight*
-        (img[feature->rect[1].p0] - img[feature->rect[1].p1] -
-         img[feature->rect[1].p2] + img[feature->rect[1].p3]);
-
-    if( feature->rect[2].weight != 0.0f )
-        ret += feature->rect[2].weight *
-            ( img[feature->rect[2].p0] - img[feature->rect[2].p1] -
-              img[feature->rect[2].p2] + img[feature->rect[2].p3] );
-    return ret;
-}
-
-
-typedef struct CvSampleDistortionData
-{
-    IplImage* src;
-    IplImage* erode;
-    IplImage* dilate;
-    IplImage* mask;
-    IplImage* img;
-    IplImage* maskimg;
-    int dx;
-    int dy;
-    int bgcolor;
-} CvSampleDistortionData;
-
-/*
- * icvConvertToFastHaarFeature
- *
- * Convert to fast representation of haar features
- *
- * haarFeature     - input array
- * fastHaarFeature - output array
- * size            - size of arrays
- * step            - row step for the integral image
- */
-void icvConvertToFastHaarFeature( CvTHaarFeature* haarFeature,
-                                  CvFastHaarFeature* fastHaarFeature,
-                                  int size, int step );
-
-
-void icvWriteVecHeader( FILE* file, int count, int width, int height );
-void icvWriteVecSample( FILE* file, CvArr* sample );
-void icvPlaceDistortedSample( CvArr* background,
-                              int inverse, int maxintensitydev,
-                              double maxxangle, double maxyangle, double maxzangle,
-                              int inscribe, double maxshiftf, double maxscalef,
-                              CvSampleDistortionData* data );
-void icvEndSampleDistortion( CvSampleDistortionData* data );
-
-int icvStartSampleDistortion( const char* imgfilename, int bgcolor, int bgthreshold,
-                              CvSampleDistortionData* data );
-
-typedef int (*CvGetHaarTrainingDataCallback)( CvMat* img, void* userdata );
-
-typedef struct CvVecFile
-{
-    FILE*  input;
-    int    count;
-    int    vecsize;
-    int    last;
-    short* vector;
-} CvVecFile;
-
-int icvGetHaarTraininDataFromVecCallback( CvMat* img, void* userdata );
-
-/*
- * icvGetHaarTrainingDataFromVec
- *
- * Fill <data> with samples from .vec file, passed <cascade>
-int icvGetHaarTrainingDataFromVec( CvHaarTrainingData* data, int first, int count,
-                                   CvIntHaarClassifier* cascade,
-                                   const char* filename,
-                                   int* consumed );
- */
-
-CvIntHaarClassifier* icvCreateCARTHaarClassifier( int count );
-
-void icvReleaseHaarClassifier( CvIntHaarClassifier** classifier );
-
-void icvInitCARTHaarClassifier( CvCARTHaarClassifier* carthaar, CvCARTClassifier* cart,
-                                CvIntHaarFeatures* intHaarFeatures );
-
-float icvEvalCARTHaarClassifier( CvIntHaarClassifier* classifier,
-                                 sum_type* sum, sum_type* tilted, float normfactor );
-
-CvIntHaarClassifier* icvCreateStageHaarClassifier( int count, float threshold );
-
-void icvReleaseStageHaarClassifier( CvIntHaarClassifier** classifier );
-
-float icvEvalStageHaarClassifier( CvIntHaarClassifier* classifier,
-                                  sum_type* sum, sum_type* tilted, float normfactor );
-
-CvIntHaarClassifier* icvCreateCascadeHaarClassifier( int count );
-
-void icvReleaseCascadeHaarClassifier( CvIntHaarClassifier** classifier );
-
-float icvEvalCascadeHaarClassifier( CvIntHaarClassifier* classifier,
-                                    sum_type* sum, sum_type* tilted, float normfactor );
-
-void icvSaveHaarFeature( CvTHaarFeature* feature, FILE* file );
-
-void icvLoadHaarFeature( CvTHaarFeature* feature, FILE* file );
-
-void icvSaveCARTHaarClassifier( CvIntHaarClassifier* classifier, FILE* file );
-
-CvIntHaarClassifier* icvLoadCARTHaarClassifier( FILE* file, int step );
-
-void icvSaveStageHaarClassifier( CvIntHaarClassifier* classifier, FILE* file );
-
-CvIntHaarClassifier* icvLoadCARTStageHaarClassifier( const char* filename, int step );
-
-
-/* tree cascade classifier */
-
-float icvEvalTreeCascadeClassifier( CvIntHaarClassifier* classifier,
-                                    sum_type* sum, sum_type* tilted, float normfactor );
-
-void icvSetLeafNode( CvTreeCascadeClassifier* tree, CvTreeCascadeNode* leaf );
-
-float icvEvalTreeCascadeClassifierFilter( CvIntHaarClassifier* classifier, sum_type* sum,
-                                          sum_type* tilted, float normfactor );
-
-CvTreeCascadeNode* icvCreateTreeCascadeNode();
-
-void icvReleaseTreeCascadeNodes( CvTreeCascadeNode** node );
-
-void icvReleaseTreeCascadeClassifier( CvIntHaarClassifier** classifier );
-
-/* Prints out current tree structure to <stdout> */
-void icvPrintTreeCascade( CvTreeCascadeNode* root );
-
-/* Loads tree cascade classifier */
-CvIntHaarClassifier* icvLoadTreeCascadeClassifier( const char* filename, int step,
-                                                   int* splits );
-
-/* Finds leaves belonging to maximal level and connects them via leaf->next_same_level */
-CvTreeCascadeNode* icvFindDeepestLeaves( CvTreeCascadeClassifier* tree );
-
-#endif /* __CVHAARTRAINING_H_ */

apps/haartraining/cvclassifier.h

@@ -1,729 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-/*
- * File cvclassifier.h
- *
- * Classifier types
- */
-
-#ifndef _CVCLASSIFIER_H_
-#define _CVCLASSIFIER_H_
-
-#include <cmath>
-#include "cxcore.h"
-
-#define CV_BOOST_API
-
-/* Convert matrix to vector */
-#define CV_MAT2VEC( mat, vdata, vstep, num )       \
-    assert( (mat).rows == 1 || (mat).cols == 1 );  \
-    (vdata) = ((mat).data.ptr);                    \
-    if( (mat).rows == 1 )                          \
-    {                                              \
-        (vstep) = CV_ELEM_SIZE( (mat).type );      \
-        (num) = (mat).cols;                        \
-    }                                              \
-    else                                           \
-    {                                              \
-        (vstep) = (mat).step;                      \
-        (num) = (mat).rows;                        \
-    }
-
-/* Set up <sample> matrix header to be <num> sample of <trainData> samples matrix */
-#define CV_GET_SAMPLE( trainData, tdflags, num, sample )                                 \
-if( CV_IS_ROW_SAMPLE( tdflags ) )                                                        \
-{                                                                                        \
-    cvInitMatHeader( &(sample), 1, (trainData).cols,                                     \
-                     CV_MAT_TYPE( (trainData).type ),                                    \
-                     ((trainData).data.ptr + (num) * (trainData).step),                  \
-                     (trainData).step );                                                 \
-}                                                                                        \
-else                                                                                     \
-{                                                                                        \
-    cvInitMatHeader( &(sample), (trainData).rows, 1,                                     \
-                     CV_MAT_TYPE( (trainData).type ),                                    \
-                     ((trainData).data.ptr + (num) * CV_ELEM_SIZE( (trainData).type )),  \
-                     (trainData).step );                                                 \
-}
-
-#define CV_GET_SAMPLE_STEP( trainData, tdflags, sstep )                                  \
-(sstep) = ( ( CV_IS_ROW_SAMPLE( tdflags ) )                                              \
-           ? (trainData).step : CV_ELEM_SIZE( (trainData).type ) );
-
-
-#define CV_LOGRATIO_THRESHOLD 0.00001F
-
-/* log( val / (1 - val ) ) */
-CV_INLINE float cvLogRatio( float val );
-
-CV_INLINE float cvLogRatio( float val )
-{
-    float tval;
-
-    tval = MAX(CV_LOGRATIO_THRESHOLD, MIN( 1.0F - CV_LOGRATIO_THRESHOLD, (val) ));
-    return logf( tval / (1.0F - tval) );
-}
-
-
-/* flags values for classifier consturctor flags parameter */
-
-/* each trainData matrix column is a sample */
-#define CV_COL_SAMPLE 0
-
-/* each trainData matrix row is a sample */
-#define CV_ROW_SAMPLE 1
-
-#ifndef CV_IS_ROW_SAMPLE
-#  define CV_IS_ROW_SAMPLE( flags ) ( ( flags ) & CV_ROW_SAMPLE )
-#endif
-
-/* Classifier supports tune function */
-#define CV_TUNABLE    (1 << 1)
-
-#define CV_IS_TUNABLE( flags ) ( (flags) & CV_TUNABLE )
-
-
-/* classifier fields common to all classifiers */
-#define CV_CLASSIFIER_FIELDS()                                                           \
-    int flags;                                                                           \
-    float(*eval)( struct CvClassifier*, CvMat* );                                        \
-    void (*tune)( struct CvClassifier*, CvMat*, int flags, CvMat*, CvMat*, CvMat*,       \
-                  CvMat*, CvMat* );                                                      \
-    int  (*save)( struct CvClassifier*, const char* file_name );                         \
-    void (*release)( struct CvClassifier** );
-
-typedef struct CvClassifier
-{
-    CV_CLASSIFIER_FIELDS()
-} CvClassifier;
-
-#define CV_CLASSIFIER_TRAIN_PARAM_FIELDS()
-typedef struct CvClassifierTrainParams
-{
-    CV_CLASSIFIER_TRAIN_PARAM_FIELDS()
-} CvClassifierTrainParams;
-
-
-/*
- Common classifier constructor:
- CvClassifier* cvCreateMyClassifier( CvMat* trainData,
-                     int flags,
-                     CvMat* trainClasses,
-                     CvMat* typeMask,
-                      CvMat* missedMeasurementsMask CV_DEFAULT(0),
-                      CvCompIdx* compIdx CV_DEFAULT(0),
-                      CvMat* sampleIdx CV_DEFAULT(0),
-                      CvMat* weights CV_DEFAULT(0),
-                      CvClassifierTrainParams* trainParams CV_DEFAULT(0)
-                    )
-
- */
-
-typedef CvClassifier* (*CvClassifierConstructor)( CvMat*, int, CvMat*, CvMat*, CvMat*,
-                                                  CvMat*, CvMat*, CvMat*,
-                                                  CvClassifierTrainParams* );
-
-typedef enum CvStumpType
-{
-    CV_CLASSIFICATION       = 0,
-    CV_CLASSIFICATION_CLASS = 1,
-    CV_REGRESSION           = 2
-} CvStumpType;
-
-typedef enum CvStumpError
-{
-    CV_MISCLASSIFICATION = 0,
-    CV_GINI              = 1,
-    CV_ENTROPY           = 2,
-    CV_SQUARE            = 3
-} CvStumpError;
-
-
-typedef struct CvStumpTrainParams
-{
-    CV_CLASSIFIER_TRAIN_PARAM_FIELDS()
-    CvStumpType  type;
-    CvStumpError error;
-} CvStumpTrainParams;
-
-typedef struct CvMTStumpTrainParams
-{
-    CV_CLASSIFIER_TRAIN_PARAM_FIELDS()
-    CvStumpType  type;
-    CvStumpError error;
-    int portion; /* number of components calculated in each thread */
-    int numcomp; /* total number of components */
-
-    /* callback which fills <mat> with components [first, first+num[ */
-    void (*getTrainData)( CvMat* mat, CvMat* sampleIdx, CvMat* compIdx,
-                          int first, int num, void* userdata );
-    CvMat* sortedIdx; /* presorted samples indices */
-    void* userdata; /* passed to callback */
-} CvMTStumpTrainParams;
-
-typedef struct CvStumpClassifier
-{
-    CV_CLASSIFIER_FIELDS()
-    int compidx;
-
-    float lerror; /* impurity of the right node */
-    float rerror; /* impurity of the left  node */
-
-    float threshold;
-    float left;
-    float right;
-} CvStumpClassifier;
-
-typedef struct CvCARTTrainParams
-{
-    CV_CLASSIFIER_TRAIN_PARAM_FIELDS()
-    /* desired number of internal nodes */
-    int count;
-    CvClassifierTrainParams* stumpTrainParams;
-    CvClassifierConstructor  stumpConstructor;
-
-    /*
-     * Split sample indices <idx>
-     * on the "left" indices <left> and "right" indices <right>
-     * according to samples components <compidx> values and <threshold>.
-     *
-     * NOTE: Matrices <left> and <right> must be allocated using cvCreateMat function
-     *   since they are freed using cvReleaseMat function
-     *
-     * If it is NULL then the default implementation which evaluates training
-     * samples from <trainData> passed to classifier constructor is used
-     */
-    void (*splitIdx)( int compidx, float threshold,
-                      CvMat* idx, CvMat** left, CvMat** right,
-                      void* userdata );
-    void* userdata;
-} CvCARTTrainParams;
-
-typedef struct CvCARTClassifier
-{
-    CV_CLASSIFIER_FIELDS()
-    /* number of internal nodes */
-    int count;
-
-    /* internal nodes (each array of <count> elements) */
-    int* compidx;
-    float* threshold;
-    int* left;
-    int* right;
-
-    /* leaves (array of <count>+1 elements) */
-    float* val;
-} CvCARTClassifier;
-
-CV_BOOST_API
-void cvGetSortedIndices( CvMat* val, CvMat* idx, int sortcols CV_DEFAULT( 0 ) );
-
-CV_BOOST_API
-void cvReleaseStumpClassifier( CvClassifier** classifier );
-
-CV_BOOST_API
-float cvEvalStumpClassifier( CvClassifier* classifier, CvMat* sample );
-
-CV_BOOST_API
-CvClassifier* cvCreateStumpClassifier( CvMat* trainData,
-                                       int flags,
-                                       CvMat* trainClasses,
-                                       CvMat* typeMask,
-                                       CvMat* missedMeasurementsMask CV_DEFAULT(0),
-                                       CvMat* compIdx CV_DEFAULT(0),
-                                       CvMat* sampleIdx CV_DEFAULT(0),
-                                       CvMat* weights CV_DEFAULT(0),
-                                       CvClassifierTrainParams* trainParams CV_DEFAULT(0) );
-
-/*
- * cvCreateMTStumpClassifier
- *
- * Multithreaded stump classifier constructor
- * Includes huge train data support through callback function
- */
-CV_BOOST_API
-CvClassifier* cvCreateMTStumpClassifier( CvMat* trainData,
-                                         int flags,
-                                         CvMat* trainClasses,
-                                         CvMat* typeMask,
-                                         CvMat* missedMeasurementsMask,
-                                         CvMat* compIdx,
-                                         CvMat* sampleIdx,
-                                         CvMat* weights,
-                                         CvClassifierTrainParams* trainParams );
-
-/*
- * cvCreateCARTClassifier
- *
- * CART classifier constructor
- */
-CV_BOOST_API
-CvClassifier* cvCreateCARTClassifier( CvMat* trainData,
-                                      int flags,
-                                      CvMat* trainClasses,
-                                      CvMat* typeMask,
-                                      CvMat* missedMeasurementsMask,
-                                      CvMat* compIdx,
-                                      CvMat* sampleIdx,
-                                      CvMat* weights,
-                                      CvClassifierTrainParams* trainParams );
-
-CV_BOOST_API
-void cvReleaseCARTClassifier( CvClassifier** classifier );
-
-CV_BOOST_API
-float cvEvalCARTClassifier( CvClassifier* classifier, CvMat* sample );
-
-/****************************************************************************************\
-*                                        Boosting                                        *
-\****************************************************************************************/
-
-/*
- * CvBoostType
- *
- * The CvBoostType enumeration specifies the boosting type.
- *
- * Remarks
- *   Four different boosting variants for 2 class classification problems are supported:
- *   Discrete AdaBoost, Real AdaBoost, LogitBoost and Gentle AdaBoost.
- *   The L2 (2 class classification problems) and LK (K class classification problems)
- *   algorithms are close to LogitBoost but more numerically stable than last one.
- *   For regression three different loss functions are supported:
- *   Least square, least absolute deviation and huber loss.
- */
-typedef enum CvBoostType
-{
-    CV_DABCLASS = 0, /* 2 class Discrete AdaBoost           */
-    CV_RABCLASS = 1, /* 2 class Real AdaBoost               */
-    CV_LBCLASS  = 2, /* 2 class LogitBoost                  */
-    CV_GABCLASS = 3, /* 2 class Gentle AdaBoost             */
-    CV_L2CLASS  = 4, /* classification (2 class problem)    */
-    CV_LKCLASS  = 5, /* classification (K class problem)    */
-    CV_LSREG    = 6, /* least squares regression            */
-    CV_LADREG   = 7, /* least absolute deviation regression */
-    CV_MREG     = 8, /* M-regression (Huber loss)           */
-} CvBoostType;
-
-/****************************************************************************************\
-*                             Iterative training functions                               *
-\****************************************************************************************/
-
-/*
- * CvBoostTrainer
- *
- * The CvBoostTrainer structure represents internal boosting trainer.
- */
-typedef struct CvBoostTrainer CvBoostTrainer;
-
-/*
- * cvBoostStartTraining
- *
- * The cvBoostStartTraining function starts training process and calculates
- * response values and weights for the first weak classifier training.
- *
- * Parameters
- *   trainClasses
- *     Vector of classes of training samples classes. Each element must be 0 or 1 and
- *     of type CV_32FC1.
- *   weakTrainVals
- *     Vector of response values for the first trained weak classifier.
- *     Must be of type CV_32FC1.
- *   weights
- *     Weight vector of training samples for the first trained weak classifier.
- *     Must be of type CV_32FC1.
- *   type
- *     Boosting type. CV_DABCLASS, CV_RABCLASS, CV_LBCLASS, CV_GABCLASS
- *     types are supported.
- *
- * Return Values
- *   The return value is a pointer to internal trainer structure which is used
- *   to perform next training iterations.
- *
- * Remarks
- *   weakTrainVals and weights must be allocated before calling the function
- *   and of the same size as trainingClasses. Usually weights should be initialized
- *   with 1.0 value.
- *   The function calculates response values and weights for the first weak
- *   classifier training and stores them into weakTrainVals and weights
- *   respectively.
- *   Note, the training of the weak classifier using weakTrainVals, weight,
- *   trainingData is outside of this function.
- */
-CV_BOOST_API
-CvBoostTrainer* cvBoostStartTraining( CvMat* trainClasses,
-                                      CvMat* weakTrainVals,
-                                      CvMat* weights,
-                                      CvMat* sampleIdx,
-                                      CvBoostType type );
-/*
- * cvBoostNextWeakClassifier
- *
- * The cvBoostNextWeakClassifier function performs next training
- * iteration and caluclates response values and weights for the next weak
- * classifier training.
- *
- * Parameters
- *   weakEvalVals
- *     Vector of values obtained by evaluation of each sample with
- *     the last trained weak classifier (iteration i). Must be of CV_32FC1 type.
- *   trainClasses
- *     Vector of classes of training samples. Each element must be 0 or 1,
- *     and of type CV_32FC1.
- *   weakTrainVals
- *     Vector of response values for the next weak classifier training
- *     (iteration i+1). Must be of type CV_32FC1.
- *   weights
- *     Weight vector of training samples for the next weak classifier training
- *     (iteration i+1). Must be of type CV_32FC1.
- *   trainer
- *     A pointer to internal trainer returned by the cvBoostStartTraining
- *     function call.
- *
- * Return Values
- *   The return value is the coefficient for the last trained weak classifier.
- *
- * Remarks
- *   weakTrainVals and weights must be exactly the same vectors as used in
- *   the cvBoostStartTraining function call and should not be modified.
- *   The function calculates response values and weights for the next weak
- *   classifier training and stores them into weakTrainVals and weights
- *   respectively.
- *   Note, the training of the weak classifier of iteration i+1 using
- *   weakTrainVals, weight, trainingData is outside of this function.
- */
-CV_BOOST_API
-float cvBoostNextWeakClassifier( CvMat* weakEvalVals,
-                                 CvMat* trainClasses,
-                                 CvMat* weakTrainVals,
-                                 CvMat* weights,
-                                 CvBoostTrainer* trainer );
-
-/*
- * cvBoostEndTraining
- *
- * The cvBoostEndTraining function finishes training process and releases
- * internally allocated memory.
- *
- * Parameters
- *   trainer
- *     A pointer to a pointer to internal trainer returned by the cvBoostStartTraining
- *     function call.
- */
-CV_BOOST_API
-void cvBoostEndTraining( CvBoostTrainer** trainer );
-
-/****************************************************************************************\
-*                                    Boosted tree models                                 *
-\****************************************************************************************/
-
-/*
- * CvBtClassifier
- *
- * The CvBtClassifier structure represents boosted tree model.
- *
- * Members
- *   flags
- *     Flags. If CV_IS_TUNABLE( flags ) != 0 then the model supports tuning.
- *   eval
- *     Evaluation function. Returns sample predicted class (0, 1, etc.)
- *     for classification or predicted value for regression.
- *   tune
- *     Tune function. If the model supports tuning then tune call performs
- *     one more boosting iteration if passed to the function flags parameter
- *     is CV_TUNABLE otherwise releases internally allocated for tuning memory
- *     and makes the model untunable.
- *     NOTE: Since tuning uses the pointers to parameters,
- *     passed to the cvCreateBtClassifier function, they should not be modified
- *     or released between tune calls.
- *   save
- *     This function stores the model into given file.
- *   release
- *     This function releases the model.
- *   type
- *     Boosted tree model type.
- *   numclasses
- *     Number of classes for CV_LKCLASS type or 1 for all other types.
- *   numiter
- *     Number of iterations. Number of weak classifiers is equal to number
- *     of iterations for all types except CV_LKCLASS. For CV_LKCLASS type
- *     number of weak classifiers is (numiter * numclasses).
- *   numfeatures
- *     Number of features in sample.
- *   trees
- *     Stores weak classifiers when the model does not support tuning.
- *   seq
- *     Stores weak classifiers when the model supports tuning.
- *   trainer
- *     Pointer to internal tuning parameters if the model supports tuning.
- */
-typedef struct CvBtClassifier
-{
-    CV_CLASSIFIER_FIELDS()
-
-    CvBoostType type;
-    int numclasses;
-    int numiter;
-    int numfeatures;
-    union
-    {
-        CvCARTClassifier** trees;
-        CvSeq* seq;
-    };
-    void* trainer;
-} CvBtClassifier;
-
-/*
- * CvBtClassifierTrainParams
- *
- * The CvBtClassifierTrainParams structure stores training parameters for
- * boosted tree model.
- *
- * Members
- *   type
- *     Boosted tree model type.
- *   numiter
- *     Desired number of iterations.
- *   param
- *     Parameter   Model Type    Parameter Meaning
- *     param[0]    Any           Shrinkage factor
- *     param[1]    CV_MREG       alpha. (1-alpha) determines "break-down" point of
- *                               the training procedure, i.e. the fraction of samples
- *                               that can be arbitrary modified without serious
- *                               degrading the quality of the result.
- *                 CV_DABCLASS,  Weight trimming factor.
- *                 CV_RABCLASS,
- *                 CV_LBCLASS,
- *                 CV_GABCLASS,
- *                 CV_L2CLASS,
- *                 CV_LKCLASS
- *   numsplits
- *     Desired number of splits in each tree.
- */
-typedef struct CvBtClassifierTrainParams
-{
-    CV_CLASSIFIER_TRAIN_PARAM_FIELDS()
-
-    CvBoostType type;
-    int numiter;
-    float param[2];
-    int numsplits;
-} CvBtClassifierTrainParams;
-
-/*
- * cvCreateBtClassifier
- *
- * The cvCreateBtClassifier function creates boosted tree model.
- *
- * Parameters
- *   trainData
- *     Matrix of feature values. Must have CV_32FC1 type.
- *   flags
- *     Determines how samples are stored in trainData.
- *     One of CV_ROW_SAMPLE or CV_COL_SAMPLE.
- *     Optionally may be combined with CV_TUNABLE to make tunable model.
- *   trainClasses
- *     Vector of responses for regression or classes (0, 1, 2, etc.) for classification.
- *   typeMask,
- *   missedMeasurementsMask,
- *   compIdx
- *     Not supported. Must be NULL.
- *   sampleIdx
- *     Indices of samples used in training. If NULL then all samples are used.
- *     For CV_DABCLASS, CV_RABCLASS, CV_LBCLASS and CV_GABCLASS must be NULL.
- *   weights
- *     Not supported. Must be NULL.
- *   trainParams
- *     A pointer to CvBtClassifierTrainParams structure. Training parameters.
- *     See CvBtClassifierTrainParams description for details.
- *
- * Return Values
- *   The return value is a pointer to created boosted tree model of type CvBtClassifier.
- *
- * Remarks
- *     The function performs trainParams->numiter training iterations.
- *     If CV_TUNABLE flag is specified then created model supports tuning.
- *     In this case additional training iterations may be performed by
- *     tune function call.
- */
-CV_BOOST_API
-CvClassifier* cvCreateBtClassifier( CvMat* trainData,
-                                    int flags,
-                                    CvMat* trainClasses,
-                                    CvMat* typeMask,
-                                    CvMat* missedMeasurementsMask,
-                                    CvMat* compIdx,
-                                    CvMat* sampleIdx,
-                                    CvMat* weights,
-                                    CvClassifierTrainParams* trainParams );
-
-/*
- * cvCreateBtClassifierFromFile
- *
- * The cvCreateBtClassifierFromFile function restores previously saved
- * boosted tree model from file.
- *
- * Parameters
- *   filename
- *     The name of the file with boosted tree model.
- *
- * Remarks
- *   The restored model does not support tuning.
- */
-CV_BOOST_API
-CvClassifier* cvCreateBtClassifierFromFile( const char* filename );
-
-/****************************************************************************************\
-*                                    Utility functions                                   *
-\****************************************************************************************/
-
-/*
- * cvTrimWeights
- *
- * The cvTrimWeights function performs weight trimming.
- *
- * Parameters
- *   weights
- *     Weights vector.
- *   idx
- *     Indices vector of weights that should be considered.
- *     If it is NULL then all weights are used.
- *   factor
- *     Weight trimming factor. Must be in [0, 1] range.
- *
- * Return Values
- *   The return value is a vector of indices. If all samples should be used then
- *   it is equal to idx. In other case the cvReleaseMat function should be called
- *   to release it.
- *
- * Remarks
- */
-CV_BOOST_API
-CvMat* cvTrimWeights( CvMat* weights, CvMat* idx, float factor );
-
-/*
- * cvReadTrainData
- *
- * The cvReadTrainData function reads feature values and responses from file.
- *
- * Parameters
- *   filename
- *     The name of the file to be read.
- *   flags
- *     One of CV_ROW_SAMPLE or CV_COL_SAMPLE. Determines how feature values
- *     will be stored.
- *   trainData
- *     A pointer to a pointer to created matrix with feature values.
- *     cvReleaseMat function should be used to destroy created matrix.
- *   trainClasses
- *     A pointer to a pointer to created matrix with response values.
- *     cvReleaseMat function should be used to destroy created matrix.
- *
- * Remarks
- *   File format:
- *   ============================================
- *   m n
- *   value_1_1 value_1_2 ... value_1_n response_1
- *   value_2_1 value_2_2 ... value_2_n response_2
- *   ...
- *   value_m_1 value_m_2 ... value_m_n response_m
- *   ============================================
- *   m
- *     Number of samples
- *   n
- *     Number of features in each sample
- *   value_i_j
- *     Value of j-th feature of i-th sample
- *   response_i
- *     Response value of i-th sample
- *     For classification problems responses represent classes (0, 1, etc.)
- *   All values and classes are integer or real numbers.
- */
-CV_BOOST_API
-void cvReadTrainData( const char* filename,
-                      int flags,
-                      CvMat** trainData,
-                      CvMat** trainClasses );
-
-
-/*
- * cvWriteTrainData
- *
- * The cvWriteTrainData function stores feature values and responses into file.
- *
- * Parameters
- *   filename
- *     The name of the file.
- *   flags
- *     One of CV_ROW_SAMPLE or CV_COL_SAMPLE. Determines how feature values
- *     are stored.
- *   trainData
- *     Feature values matrix.
- *   trainClasses
- *     Response values vector.
- *   sampleIdx
- *     Vector of idicies of the samples that should be stored. If it is NULL
- *     then all samples will be stored.
- *
- * Remarks
- *   See the cvReadTrainData function for file format description.
- */
-CV_BOOST_API
-void cvWriteTrainData( const char* filename,
-                       int flags,
-                       CvMat* trainData,
-                       CvMat* trainClasses,
-                       CvMat* sampleIdx );
-
-/*
- * cvRandShuffle
- *
- * The cvRandShuffle function perfroms random shuffling of given vector.
- *
- * Parameters
- *   vector
- *     Vector that should be shuffled.
- *     Must have CV_8UC1, CV_16SC1, CV_32SC1 or CV_32FC1 type.
- */
-CV_BOOST_API
-void cvRandShuffleVec( CvMat* vector );
-
-#endif /* _CVCLASSIFIER_H_ */

apps/haartraining/cvcommon.cpp

@@ -1,125 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include "_cvcommon.h"
-
-#include <cstring>
-#include <ctime>
-
-#include <sys/stat.h>
-#include <sys/types.h>
-#ifdef _WIN32
-#include <direct.h>
-#endif /* _WIN32 */
-
-int icvMkDir( const char* filename )
-{
-    char path[PATH_MAX];
-    char* p;
-    int pos;
-
-#ifdef _WIN32
-    struct _stat st;
-#else /* _WIN32 */
-    struct stat st;
-    mode_t mode;
-
-    mode = 0755;
-#endif /* _WIN32 */
-
-    strcpy( path, filename );
-
-    p = path;
-    for( ; ; )
-    {
-        pos = (int)strcspn( p, "/\\" );
-
-        if( pos == (int) strlen( p ) ) break;
-        if( pos != 0 )
-        {
-            p[pos] = '\0';
-
-#ifdef _WIN32
-            if( p[pos-1] != ':' )
-            {
-                if( _stat( path, &st ) != 0 )
-                {
-                    if( _mkdir( path ) != 0 ) return 0;
-                }
-            }
-#else /* _WIN32 */
-            if( stat( path, &st ) != 0 )
-            {
-                if( mkdir( path, mode ) != 0 ) return 0;
-            }
-#endif /* _WIN32 */
-        }
-
-        p[pos] = '/';
-
-        p += pos + 1;
-    }
-
-    return 1;
-}
-
-#if 0
-/* debug functions */
-void icvSave( const CvArr* ptr, const char* filename, int line )
-{
-    CvFileStorage* fs;
-    char buf[PATH_MAX];
-    const char* name;
-
-    name = strrchr( filename, '\\' );
-    if( !name ) name = strrchr( filename, '/' );
-    if( !name ) name = filename;
-    else name++; /* skip '/' or '\\' */
-
-    sprintf( buf, "%s-%d-%d", name, line, time( NULL ) );
-    fs = cvOpenFileStorage( buf, NULL, CV_STORAGE_WRITE_TEXT );
-    if( !fs ) return;
-    cvWrite( fs, "debug", ptr );
-    cvReleaseFileStorage( &fs );
-}
-#endif // #if 0
-
-/* End of file. */

apps/haartraining/cvhaarclassifier.cpp

@@ -1,835 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-/*
- * cvhaarclassifier.cpp
- *
- * haar classifiers (stump, CART, stage, cascade)
- */
-
-#include "_cvhaartraining.h"
-
-
-CvIntHaarClassifier* icvCreateCARTHaarClassifier( int count )
-{
-    CvCARTHaarClassifier* cart;
-    size_t datasize;
-
-    datasize = sizeof( *cart ) +
-        ( sizeof( int ) +
-          sizeof( CvTHaarFeature ) + sizeof( CvFastHaarFeature ) +
-          sizeof( float ) + sizeof( int ) + sizeof( int ) ) * count +
-        sizeof( float ) * (count + 1);
-
-    cart = (CvCARTHaarClassifier*) cvAlloc( datasize );
-    memset( cart, 0, datasize );
-
-    cart->feature = (CvTHaarFeature*) (cart + 1);
-    cart->fastfeature = (CvFastHaarFeature*) (cart->feature + count);
-    cart->threshold = (float*) (cart->fastfeature + count);
-    cart->left = (int*) (cart->threshold + count);
-    cart->right = (int*) (cart->left + count);
-    cart->val = (float*) (cart->right + count);
-    cart->compidx = (int*) (cart->val + count + 1 );
-    cart->count = count;
-    cart->eval = icvEvalCARTHaarClassifier;
-    cart->save = icvSaveCARTHaarClassifier;
-    cart->release = icvReleaseHaarClassifier;
-
-    return (CvIntHaarClassifier*) cart;
-}
-
-
-void icvReleaseHaarClassifier( CvIntHaarClassifier** classifier )
-{
-    cvFree( classifier );
-    *classifier = NULL;
-}
-
-
-void icvInitCARTHaarClassifier( CvCARTHaarClassifier* carthaar, CvCARTClassifier* cart,
-                                CvIntHaarFeatures* intHaarFeatures )
-{
-    int i;
-
-    for( i = 0; i < cart->count; i++ )
-    {
-        carthaar->feature[i] = intHaarFeatures->feature[cart->compidx[i]];
-        carthaar->fastfeature[i] = intHaarFeatures->fastfeature[cart->compidx[i]];
-        carthaar->threshold[i] = cart->threshold[i];
-        carthaar->left[i] = cart->left[i];
-        carthaar->right[i] = cart->right[i];
-        carthaar->val[i] = cart->val[i];
-        carthaar->compidx[i] = cart->compidx[i];
-    }
-    carthaar->count = cart->count;
-    carthaar->val[cart->count] = cart->val[cart->count];
-}
-
-
-float icvEvalCARTHaarClassifier( CvIntHaarClassifier* classifier,
-                                 sum_type* sum, sum_type* tilted, float normfactor )
-{
-    int idx = 0;
-
-    do
-    {
-        if( cvEvalFastHaarFeature(
-                ((CvCARTHaarClassifier*) classifier)->fastfeature + idx, sum, tilted )
-              < (((CvCARTHaarClassifier*) classifier)->threshold[idx] * normfactor) )
-        {
-            idx = ((CvCARTHaarClassifier*) classifier)->left[idx];
-        }
-        else
-        {
-            idx = ((CvCARTHaarClassifier*) classifier)->right[idx];
-        }
-    } while( idx > 0 );
-
-    return ((CvCARTHaarClassifier*) classifier)->val[-idx];
-}
-
-
-CvIntHaarClassifier* icvCreateStageHaarClassifier( int count, float threshold )
-{
-    CvStageHaarClassifier* stage;
-    size_t datasize;
-
-    datasize = sizeof( *stage ) + sizeof( CvIntHaarClassifier* ) * count;
-    stage = (CvStageHaarClassifier*) cvAlloc( datasize );
-    memset( stage, 0, datasize );
-
-    stage->count = count;
-    stage->threshold = threshold;
-    stage->classifier = (CvIntHaarClassifier**) (stage + 1);
-
-    stage->eval = icvEvalStageHaarClassifier;
-    stage->save = icvSaveStageHaarClassifier;
-    stage->release = icvReleaseStageHaarClassifier;
-
-    return (CvIntHaarClassifier*) stage;
-}
-
-
-void icvReleaseStageHaarClassifier( CvIntHaarClassifier** classifier )
-{
-    int i;
-
-    for( i = 0; i < ((CvStageHaarClassifier*) *classifier)->count; i++ )
-    {
-        if( ((CvStageHaarClassifier*) *classifier)->classifier[i] != NULL )
-        {
-            ((CvStageHaarClassifier*) *classifier)->classifier[i]->release(
-                &(((CvStageHaarClassifier*) *classifier)->classifier[i]) );
-        }
-    }
-
-    cvFree( classifier );
-    *classifier = NULL;
-}
-
-
-float icvEvalStageHaarClassifier( CvIntHaarClassifier* classifier,
-                                  sum_type* sum, sum_type* tilted, float normfactor )
-{
-    int i;
-    float stage_sum;
-
-    stage_sum = 0.0F;
-    for( i = 0; i < ((CvStageHaarClassifier*) classifier)->count; i++ )
-    {
-        stage_sum +=
-            ((CvStageHaarClassifier*) classifier)->classifier[i]->eval(
-                ((CvStageHaarClassifier*) classifier)->classifier[i],
-                sum, tilted, normfactor );
-    }
-
-    return stage_sum;
-}
-
-
-CvIntHaarClassifier* icvCreateCascadeHaarClassifier( int count )
-{
-    CvCascadeHaarClassifier* ptr;
-    size_t datasize;
-
-    datasize = sizeof( *ptr ) + sizeof( CvIntHaarClassifier* ) * count;
-    ptr = (CvCascadeHaarClassifier*) cvAlloc( datasize );
-    memset( ptr, 0, datasize );
-
-    ptr->count = count;
-    ptr->classifier = (CvIntHaarClassifier**) (ptr + 1);
-
-    ptr->eval = icvEvalCascadeHaarClassifier;
-    ptr->save = NULL;
-    ptr->release = icvReleaseCascadeHaarClassifier;
-
-    return (CvIntHaarClassifier*) ptr;
-}
-
-
-void icvReleaseCascadeHaarClassifier( CvIntHaarClassifier** classifier )
-{
-    int i;
-
-    for( i = 0; i < ((CvCascadeHaarClassifier*) *classifier)->count; i++ )
-    {
-        if( ((CvCascadeHaarClassifier*) *classifier)->classifier[i] != NULL )
-        {
-            ((CvCascadeHaarClassifier*) *classifier)->classifier[i]->release(
-                &(((CvCascadeHaarClassifier*) *classifier)->classifier[i]) );
-        }
-    }
-
-    cvFree( classifier );
-    *classifier = NULL;
-}
-
-
-float icvEvalCascadeHaarClassifier( CvIntHaarClassifier* classifier,
-                                    sum_type* sum, sum_type* tilted, float normfactor )
-{
-    int i;
-
-    for( i = 0; i < ((CvCascadeHaarClassifier*) classifier)->count; i++ )
-    {
-        if( ((CvCascadeHaarClassifier*) classifier)->classifier[i]->eval(
-                    ((CvCascadeHaarClassifier*) classifier)->classifier[i],
-                    sum, tilted, normfactor )
-            < ( ((CvStageHaarClassifier*)
-                    ((CvCascadeHaarClassifier*) classifier)->classifier[i])->threshold
-                            - CV_THRESHOLD_EPS) )
-        {
-            return 0.0;
-        }
-    }
-
-    return 1.0;
-}
-
-
-void icvSaveHaarFeature( CvTHaarFeature* feature, FILE* file )
-{
-    fprintf( file, "%d\n", ( ( feature->rect[2].weight == 0.0F ) ? 2 : 3) );
-    fprintf( file, "%d %d %d %d %d %d\n",
-        feature->rect[0].r.x,
-        feature->rect[0].r.y,
-        feature->rect[0].r.width,
-        feature->rect[0].r.height,
-        0,
-        (int) (feature->rect[0].weight) );
-    fprintf( file, "%d %d %d %d %d %d\n",
-        feature->rect[1].r.x,
-        feature->rect[1].r.y,
-        feature->rect[1].r.width,
-        feature->rect[1].r.height,
-        0,
-        (int) (feature->rect[1].weight) );
-    if( feature->rect[2].weight != 0.0F )
-    {
-        fprintf( file, "%d %d %d %d %d %d\n",
-            feature->rect[2].r.x,
-            feature->rect[2].r.y,
-            feature->rect[2].r.width,
-            feature->rect[2].r.height,
-            0,
-            (int) (feature->rect[2].weight) );
-    }
-    fprintf( file, "%s\n", &(feature->desc[0]) );
-}
-
-
-void icvLoadHaarFeature( CvTHaarFeature* feature, FILE* file )
-{
-    int nrect;
-    int j;
-    int tmp;
-    int weight;
-
-    nrect = 0;
-    int values_read = fscanf( file, "%d", &nrect );
-    CV_Assert(values_read == 1);
-
-    assert( nrect <= CV_HAAR_FEATURE_MAX );
-
-    for( j = 0; j < nrect; j++ )
-    {
-        values_read = fscanf( file, "%d %d %d %d %d %d",
-            &(feature->rect[j].r.x),
-            &(feature->rect[j].r.y),
-            &(feature->rect[j].r.width),
-            &(feature->rect[j].r.height),
-            &tmp, &weight );
-        CV_Assert(values_read == 6);
-        feature->rect[j].weight = (float) weight;
-    }
-    for( j = nrect; j < CV_HAAR_FEATURE_MAX; j++ )
-    {
-        feature->rect[j].r.x = 0;
-        feature->rect[j].r.y = 0;
-        feature->rect[j].r.width = 0;
-        feature->rect[j].r.height = 0;
-        feature->rect[j].weight = 0.0f;
-    }
-    values_read = fscanf( file, "%s", &(feature->desc[0]) );
-    CV_Assert(values_read == 1);
-    feature->tilted = ( feature->desc[0] == 't' );
-}
-
-
-void icvSaveCARTHaarClassifier( CvIntHaarClassifier* classifier, FILE* file )
-{
-    int i;
-    int count;
-
-    count = ((CvCARTHaarClassifier*) classifier)->count;
-    fprintf( file, "%d\n", count );
-    for( i = 0; i < count; i++ )
-    {
-        icvSaveHaarFeature( &(((CvCARTHaarClassifier*) classifier)->feature[i]), file );
-        fprintf( file, "%e %d %d\n",
-            ((CvCARTHaarClassifier*) classifier)->threshold[i],
-            ((CvCARTHaarClassifier*) classifier)->left[i],
-            ((CvCARTHaarClassifier*) classifier)->right[i] );
-    }
-    for( i = 0; i <= count; i++ )
-    {
-        fprintf( file, "%e ", ((CvCARTHaarClassifier*) classifier)->val[i] );
-    }
-    fprintf( file, "\n" );
-}
-
-
-CvIntHaarClassifier* icvLoadCARTHaarClassifier( FILE* file, int step )
-{
-    CvCARTHaarClassifier* ptr;
-    int i;
-    int count;
-
-    ptr = NULL;
-    int values_read = fscanf( file, "%d", &count );
-    CV_Assert(values_read == 1);
-
-    if( count > 0 )
-    {
-        ptr = (CvCARTHaarClassifier*) icvCreateCARTHaarClassifier( count );
-        for( i = 0; i < count; i++ )
-        {
-            icvLoadHaarFeature( &(ptr->feature[i]), file );
-            values_read = fscanf( file, "%f %d %d", &(ptr->threshold[i]), &(ptr->left[i]),
-                                      &(ptr->right[i]) );
-            CV_Assert(values_read == 3);
-        }
-        for( i = 0; i <= count; i++ )
-        {
-            values_read = fscanf( file, "%f", &(ptr->val[i]) );
-            CV_Assert(values_read == 1);
-        }
-        icvConvertToFastHaarFeature( ptr->feature, ptr->fastfeature, ptr->count, step );
-    }
-
-    return (CvIntHaarClassifier*) ptr;
-}
-
-
-void icvSaveStageHaarClassifier( CvIntHaarClassifier* classifier, FILE* file )
-{
-    int count;
-    int i;
-    float threshold;
-
-    count = ((CvStageHaarClassifier*) classifier)->count;
-    fprintf( file, "%d\n", count );
-    for( i = 0; i < count; i++ )
-    {
-        ((CvStageHaarClassifier*) classifier)->classifier[i]->save(
-            ((CvStageHaarClassifier*) classifier)->classifier[i], file );
-    }
-
-    threshold = ((CvStageHaarClassifier*) classifier)->threshold;
-
-    /* to be compatible with the previous implementation */
-    /* threshold = 2.0F * ((CvStageHaarClassifier*) classifier)->threshold - count; */
-
-    fprintf( file, "%e\n", threshold );
-}
-
-
-
-static CvIntHaarClassifier* icvLoadCARTStageHaarClassifierF( FILE* file, int step )
-{
-    CvStageHaarClassifier* ptr = NULL;
-
-    //CV_FUNCNAME( "icvLoadCARTStageHaarClassifierF" );
-
-    __BEGIN__;
-
-    if( file != NULL )
-    {
-        int count;
-        int i;
-        float threshold;
-
-        count = 0;
-        int values_read = fscanf( file, "%d", &count );
-        CV_Assert(values_read == 1);
-        if( count > 0 )
-        {
-            ptr = (CvStageHaarClassifier*) icvCreateStageHaarClassifier( count, 0.0F );
-            for( i = 0; i < count; i++ )
-            {
-                ptr->classifier[i] = icvLoadCARTHaarClassifier( file, step );
-            }
-
-            values_read = fscanf( file, "%f", &threshold );
-            CV_Assert(values_read == 1);
-
-            ptr->threshold = threshold;
-            /* to be compatible with the previous implementation */
-            /* ptr->threshold = 0.5F * (threshold + count); */
-        }
-        if( feof( file ) )
-        {
-            ptr->release( (CvIntHaarClassifier**) &ptr );
-            ptr = NULL;
-        }
-    }
-
-    __END__;
-
-    return (CvIntHaarClassifier*) ptr;
-}
-
-
-CvIntHaarClassifier* icvLoadCARTStageHaarClassifier( const char* filename, int step )
-{
-    CvIntHaarClassifier* ptr = NULL;
-
-    CV_FUNCNAME( "icvLoadCARTStageHaarClassifier" );
-
-    __BEGIN__;
-
-    FILE* file;
-
-    file = fopen( filename, "r" );
-    if( file )
-    {
-        CV_CALL( ptr = icvLoadCARTStageHaarClassifierF( file, step ) );
-        fclose( file );
-    }
-
-    __END__;
-
-    return ptr;
-}
-
-/* tree cascade classifier */
-
-/* evaluates a tree cascade classifier */
-
-float icvEvalTreeCascadeClassifier( CvIntHaarClassifier* classifier,
-                                    sum_type* sum, sum_type* tilted, float normfactor )
-{
-    CvTreeCascadeNode* ptr;
-
-    ptr = ((CvTreeCascadeClassifier*) classifier)->root;
-
-    while( ptr )
-    {
-        if( ptr->stage->eval( (CvIntHaarClassifier*) ptr->stage,
-                              sum, tilted, normfactor )
-                >= ptr->stage->threshold - CV_THRESHOLD_EPS )
-        {
-            ptr = ptr->child;
-        }
-        else
-        {
-            while( ptr && ptr->next == NULL ) ptr = ptr->parent;
-            if( ptr == NULL ) return 0.0F;
-            ptr = ptr->next;
-        }
-    }
-
-    return 1.0F;
-}
-
-/* sets path int the tree form the root to the leaf node */
-
-void icvSetLeafNode( CvTreeCascadeClassifier* tcc, CvTreeCascadeNode* leaf )
-{
-    CV_FUNCNAME( "icvSetLeafNode" );
-
-    __BEGIN__;
-
-    CvTreeCascadeNode* ptr;
-
-    ptr = NULL;
-    while( leaf )
-    {
-        leaf->child_eval = ptr;
-        ptr = leaf;
-        leaf = leaf->parent;
-    }
-
-    leaf = tcc->root;
-    while( leaf && leaf != ptr ) leaf = leaf->next;
-    if( leaf != ptr )
-        CV_ERROR( CV_StsError, "Invalid tcc or leaf node." );
-
-    tcc->root_eval = ptr;
-
-    __END__;
-}
-
-/* evaluates a tree cascade classifier. used in filtering */
-
-float icvEvalTreeCascadeClassifierFilter( CvIntHaarClassifier* classifier, sum_type* sum,
-                                          sum_type* tilted, float normfactor )
-{
-    CvTreeCascadeNode* ptr;
-    //CvTreeCascadeClassifier* tree;
-
-    //tree = (CvTreeCascadeClassifier*) classifier;
-
-
-
-    ptr = ((CvTreeCascadeClassifier*) classifier)->root_eval;
-    while( ptr )
-    {
-        if( ptr->stage->eval( (CvIntHaarClassifier*) ptr->stage,
-                              sum, tilted, normfactor )
-                < ptr->stage->threshold - CV_THRESHOLD_EPS )
-        {
-            return 0.0F;
-        }
-        ptr = ptr->child_eval;
-    }
-
-    return 1.0F;
-}
-
-/* creates tree cascade node */
-
-CvTreeCascadeNode* icvCreateTreeCascadeNode()
-{
-    CvTreeCascadeNode* ptr = NULL;
-
-    CV_FUNCNAME( "icvCreateTreeCascadeNode" );
-
-    __BEGIN__;
-    size_t data_size;
-
-    data_size = sizeof( *ptr );
-    CV_CALL( ptr = (CvTreeCascadeNode*) cvAlloc( data_size ) );
-    memset( ptr, 0, data_size );
-
-    __END__;
-
-    return ptr;
-}
-
-/* releases all tree cascade nodes accessible via links */
-
-void icvReleaseTreeCascadeNodes( CvTreeCascadeNode** node )
-{
-    //CV_FUNCNAME( "icvReleaseTreeCascadeNodes" );
-
-    __BEGIN__;
-
-    if( node && *node )
-    {
-        CvTreeCascadeNode* ptr;
-        CvTreeCascadeNode* ptr_;
-
-        ptr = *node;
-
-        while( ptr )
-        {
-            while( ptr->child ) ptr = ptr->child;
-
-            if( ptr->stage ) ptr->stage->release( (CvIntHaarClassifier**) &ptr->stage );
-            ptr_ = ptr;
-
-            while( ptr && ptr->next == NULL ) ptr = ptr->parent;
-            if( ptr ) ptr = ptr->next;
-
-            cvFree( &ptr_ );
-        }
-    }
-
-    __END__;
-}
-
-
-/* releases tree cascade classifier */
-
-void icvReleaseTreeCascadeClassifier( CvIntHaarClassifier** classifier )
-{
-    if( classifier && *classifier )
-    {
-        icvReleaseTreeCascadeNodes( &((CvTreeCascadeClassifier*) *classifier)->root );
-        cvFree( classifier );
-        *classifier = NULL;
-    }
-}
-
-
-void icvPrintTreeCascade( CvTreeCascadeNode* root )
-{
-    //CV_FUNCNAME( "icvPrintTreeCascade" );
-
-    __BEGIN__;
-
-    CvTreeCascadeNode* node;
-    CvTreeCascadeNode* n;
-    char buf0[256];
-    char buf[256];
-    int level;
-    int i;
-    int max_level;
-
-    node = root;
-    level = max_level = 0;
-    while( node )
-    {
-        while( node->child ) { node = node->child; level++; }
-        if( level > max_level ) { max_level = level; }
-        while( node && !node->next ) { node = node->parent; level--; }
-        if( node ) node = node->next;
-    }
-
-    printf( "\nTree Classifier\n" );
-    printf( "Stage\n" );
-    for( i = 0; i <= max_level; i++ ) printf( "+---" );
-    printf( "+\n" );
-    for( i = 0; i <= max_level; i++ ) printf( "|%3d", i );
-    printf( "|\n" );
-    for( i = 0; i <= max_level; i++ ) printf( "+---" );
-    printf( "+\n\n" );
-
-    node = root;
-
-    buf[0] = 0;
-    while( node )
-    {
-        sprintf( buf + strlen( buf ), "%3d", node->idx );
-        while( node->child )
-        {
-            node = node->child;
-            sprintf( buf + strlen( buf ),
-                ((node->idx < 10) ? "---%d" : ((node->idx < 100) ? "--%d" : "-%d")),
-                node->idx );
-        }
-        printf( " %s\n", buf );
-
-        while( node && !node->next ) { node = node->parent; }
-        if( node )
-        {
-            node = node->next;
-
-            n = node->parent;
-            buf[0] = 0;
-            while( n )
-            {
-                if( n->next )
-                    sprintf( buf0, "  | %s", buf );
-                else
-                    sprintf( buf0, "    %s", buf );
-                strcpy( buf, buf0 );
-                n = n->parent;
-            }
-            printf( " %s  |\n", buf );
-        }
-    }
-    printf( "\n" );
-    fflush( stdout );
-
-    __END__;
-}
-
-
-
-CvIntHaarClassifier* icvLoadTreeCascadeClassifier( const char* filename, int step,
-                                                   int* splits )
-{
-    CvTreeCascadeClassifier* ptr = NULL;
-    CvTreeCascadeNode** nodes = NULL;
-
-    CV_FUNCNAME( "icvLoadTreeCascadeClassifier" );
-
-    __BEGIN__;
-
-    size_t data_size;
-    CvStageHaarClassifier* stage;
-    char stage_name[PATH_MAX];
-    char* suffix;
-    int i, num;
-    FILE* f;
-    int result, parent=0, next=0;
-    int stub;
-
-    if( !splits ) splits = &stub;
-
-    *splits = 0;
-
-    data_size = sizeof( *ptr );
-
-    CV_CALL( ptr = (CvTreeCascadeClassifier*) cvAlloc( data_size ) );
-    memset( ptr, 0, data_size );
-
-    ptr->eval = icvEvalTreeCascadeClassifier;
-    ptr->release = icvReleaseTreeCascadeClassifier;
-
-    sprintf( stage_name, "%s/", filename );
-    suffix = stage_name + strlen( stage_name );
-
-    for( i = 0; ; i++ )
-    {
-        sprintf( suffix, "%d/%s", i, CV_STAGE_CART_FILE_NAME );
-        f = fopen( stage_name, "r" );
-        if( !f ) break;
-        fclose( f );
-    }
-    num = i;
-
-    if( num < 1 ) EXIT;
-
-    data_size = sizeof( *nodes ) * num;
-    CV_CALL( nodes = (CvTreeCascadeNode**) cvAlloc( data_size ) );
-
-    for( i = 0; i < num; i++ )
-    {
-        sprintf( suffix, "%d/%s", i, CV_STAGE_CART_FILE_NAME );
-        f = fopen( stage_name, "r" );
-        CV_CALL( stage = (CvStageHaarClassifier*)
-            icvLoadCARTStageHaarClassifierF( f, step ) );
-
-        result = ( f && stage ) ? fscanf( f, "%d%d", &parent, &next ) : 0;
-        if( f ) fclose( f );
-
-        if( result != 2 )
-        {
-            num = i;
-            break;
-        }
-
-        printf( "Stage %d loaded\n", i );
-
-        if( parent >= i || (next != -1 && next != i + 1) )
-            CV_ERROR( CV_StsError, "Invalid tree links" );
-
-        CV_CALL( nodes[i] = icvCreateTreeCascadeNode() );
-        nodes[i]->stage = stage;
-        nodes[i]->idx = i;
-        nodes[i]->parent = (parent != -1 ) ? nodes[parent] : NULL;
-        nodes[i]->next = ( next != -1 ) ? nodes[i] : NULL;
-        nodes[i]->child = NULL;
-    }
-    for( i = 0; i < num; i++ )
-    {
-        if( nodes[i]->next )
-        {
-            (*splits)++;
-            nodes[i]->next = nodes[i+1];
-        }
-        if( nodes[i]->parent && nodes[i]->parent->child == NULL )
-        {
-            nodes[i]->parent->child = nodes[i];
-        }
-    }
-    ptr->root = nodes[0];
-    ptr->next_idx = num;
-
-    __END__;
-
-    cvFree( &nodes );
-
-    return (CvIntHaarClassifier*) ptr;
-}
-
-
-CvTreeCascadeNode* icvFindDeepestLeaves( CvTreeCascadeClassifier* tcc )
-{
-    CvTreeCascadeNode* leaves;
-
-    //CV_FUNCNAME( "icvFindDeepestLeaves" );
-
-    __BEGIN__;
-
-    int level, cur_level;
-    CvTreeCascadeNode* ptr;
-    CvTreeCascadeNode* last;
-
-    leaves = last = NULL;
-
-    ptr = tcc->root;
-    level = -1;
-    cur_level = 0;
-
-    /* find leaves with maximal level */
-    while( ptr )
-    {
-        if( ptr->child ) { ptr = ptr->child; cur_level++; }
-        else
-        {
-            if( cur_level == level )
-            {
-                last->next_same_level = ptr;
-                ptr->next_same_level = NULL;
-                last = ptr;
-            }
-            if( cur_level > level )
-            {
-                level = cur_level;
-                leaves = last = ptr;
-                ptr->next_same_level = NULL;
-            }
-            while( ptr && ptr->next == NULL ) { ptr = ptr->parent; cur_level--; }
-            if( ptr ) ptr = ptr->next;
-        }
-    }
-
-    __END__;
-
-    return leaves;
-}
-
-/* End of file. */

apps/haartraining/cvhaartraining.h

@@ -1,192 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-/*
- * cvhaartraining.h
- *
- * haar training functions
- */
-
-#ifndef _CVHAARTRAINING_H_
-#define _CVHAARTRAINING_H_
-
-/*
- * cvCreateTrainingSamples
- *
- * Create training samples applying random distortions to sample image and
- * store them in .vec file
- *
- * filename        - .vec file name
- * imgfilename     - sample image file name
- * bgcolor         - background color for sample image
- * bgthreshold     - background color threshold. Pixels those colors are in range
- *   [bgcolor-bgthreshold, bgcolor+bgthreshold] are considered as transparent
- * bgfilename      - background description file name. If not NULL samples
- *   will be put on arbitrary background
- * count           - desired number of samples
- * invert          - if not 0 sample foreground pixels will be inverted
- *   if invert == CV_RANDOM_INVERT then samples will be inverted randomly
- * maxintensitydev - desired max intensity deviation of foreground samples pixels
- * maxxangle       - max rotation angles
- * maxyangle
- * maxzangle
- * showsamples     - if not 0 samples will be shown
- * winwidth        - desired samples width
- * winheight       - desired samples height
- */
-#define CV_RANDOM_INVERT 0x7FFFFFFF
-
-void cvCreateTrainingSamples( const char* filename,
-                              const char* imgfilename, int bgcolor, int bgthreshold,
-                              const char* bgfilename, int count,
-                              int invert = 0, int maxintensitydev = 40,
-                              double maxxangle = 1.1,
-                              double maxyangle = 1.1,
-                              double maxzangle = 0.5,
-                              int showsamples = 0,
-                              int winwidth = 24, int winheight = 24 );
-
-void cvCreateTestSamples( const char* infoname,
-                          const char* imgfilename, int bgcolor, int bgthreshold,
-                          const char* bgfilename, int count,
-                          int invert, int maxintensitydev,
-                          double maxxangle, double maxyangle, double maxzangle,
-                          int showsamples,
-                          int winwidth, int winheight );
-
-/*
- * cvCreateTrainingSamplesFromInfo
- *
- * Create training samples from a set of marked up images and store them into .vec file
- * infoname    - file in which marked up image descriptions are stored
- * num         - desired number of samples
- * showsamples - if not 0 samples will be shown
- * winwidth    - sample width
- * winheight   - sample height
- *
- * Return number of successfully created samples
- */
-int cvCreateTrainingSamplesFromInfo( const char* infoname, const char* vecfilename,
-                                     int num,
-                                     int showsamples,
-                                     int winwidth, int winheight );
-
-/*
- * cvShowVecSamples
- *
- * Shows samples stored in .vec file
- *
- * filename
- *   .vec file name
- * winwidth
- *   sample width
- * winheight
- *   sample height
- * scale
- *   the scale each sample is adjusted to
- */
-void cvShowVecSamples( const char* filename, int winwidth, int winheight, double scale );
-
-
-/*
- * cvCreateCascadeClassifier
- *
- * Create cascade classifier
- * dirname          - directory name in which cascade classifier will be created.
- *   It must exist and contain subdirectories 0, 1, 2, ... (nstages-1).
- * vecfilename      - name of .vec file with object's images
- * bgfilename       - name of background description file
- * bg_vecfile       - true if bgfilename represents a vec file with discrete negatives
- * npos             - number of positive samples used in training of each stage
- * nneg             - number of negative samples used in training of each stage
- * nstages          - number of stages
- * numprecalculated - number of features being precalculated. Each precalculated feature
- *   requires (number_of_samples*(sizeof( float ) + sizeof( short ))) bytes of memory
- * numsplits        - number of binary splits in each weak classifier
- *   1 - stumps, 2 and more - trees.
- * minhitrate       - desired min hit rate of each stage
- * maxfalsealarm    - desired max false alarm of each stage
- * weightfraction   - weight trimming parameter
- * mode             - 0 - BASIC = Viola
- *                    1 - CORE  = All upright
- *                    2 - ALL   = All features
- * symmetric        - if not 0 vertical symmetry is assumed
- * equalweights     - if not 0 initial weights of all samples will be equal
- * winwidth         - sample width
- * winheight        - sample height
- * boosttype        - type of applied boosting algorithm
- *   0 - Discrete AdaBoost
- *   1 - Real AdaBoost
- *   2 - LogitBoost
- *   3 - Gentle AdaBoost
- * stumperror       - type of used error if Discrete AdaBoost algorithm is applied
- *   0 - misclassification error
- *   1 - gini error
- *   2 - entropy error
- */
-void cvCreateCascadeClassifier( const char* dirname,
-                                const char* vecfilename,
-                                const char* bgfilename,
-                                int npos, int nneg, int nstages,
-                                int numprecalculated,
-                                int numsplits,
-                                float minhitrate = 0.995F, float maxfalsealarm = 0.5F,
-                                float weightfraction = 0.95F,
-                                int mode = 0, int symmetric = 1,
-                                int equalweights = 1,
-                                int winwidth = 24, int winheight = 24,
-                                int boosttype = 3, int stumperror = 0 );
-
-void cvCreateTreeCascadeClassifier( const char* dirname,
-                                    const char* vecfilename,
-                                    const char* bgfilename,
-                                    int npos, int nneg, int nstages,
-                                    int numprecalculated,
-                                    int numsplits,
-                                    float minhitrate, float maxfalsealarm,
-                                    float weightfraction,
-                                    int mode, int symmetric,
-                                    int equalweights,
-                                    int winwidth, int winheight,
-                                    int boosttype, int stumperror,
-                                    int maxtreesplits, int minpos, bool bg_vecfile = false );
-
-#endif /* _CVHAARTRAINING_H_ */

apps/haartraining/cvsamples.cpp

@@ -1,953 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-/*
- * cvsamples.cpp
- *
- * support functions for training and test samples creation.
- */
-
-#include "cvhaartraining.h"
-#include "_cvhaartraining.h"
-
-/* if ipl.h file is included then iplWarpPerspectiveQ function
-   is used for image transformation during samples creation;
-   otherwise internal cvWarpPerspective function is used */
-
-//#include <ipl.h>
-
-#include "cv.h"
-#include "highgui.h"
-
-/* Calculates coefficients of perspective transformation
- * which maps <quad> into rectangle ((0,0), (w,0), (w,h), (h,0)):
- *
- *      c00*xi + c01*yi + c02
- * ui = ---------------------
- *      c20*xi + c21*yi + c22
- *
- *      c10*xi + c11*yi + c12
- * vi = ---------------------
- *      c20*xi + c21*yi + c22
- *
- * Coefficients are calculated by solving linear system:
- * / x0 y0  1  0  0  0 -x0*u0 -y0*u0 \ /c00\ /u0\
- * | x1 y1  1  0  0  0 -x1*u1 -y1*u1 | |c01| |u1|
- * | x2 y2  1  0  0  0 -x2*u2 -y2*u2 | |c02| |u2|
- * | x3 y3  1  0  0  0 -x3*u3 -y3*u3 |.|c10|=|u3|,
- * |  0  0  0 x0 y0  1 -x0*v0 -y0*v0 | |c11| |v0|
- * |  0  0  0 x1 y1  1 -x1*v1 -y1*v1 | |c12| |v1|
- * |  0  0  0 x2 y2  1 -x2*v2 -y2*v2 | |c20| |v2|
- * \  0  0  0 x3 y3  1 -x3*v3 -y3*v3 / \c21/ \v3/
- *
- * where:
- *   (xi, yi) = (quad[i][0], quad[i][1])
- *        cij - coeffs[i][j], coeffs[2][2] = 1
- *   (ui, vi) - rectangle vertices
- */
-static void cvGetPerspectiveTransform( CvSize src_size, double quad[4][2],
-                                double coeffs[3][3] )
-{
-    //CV_FUNCNAME( "cvWarpPerspective" );
-
-    __BEGIN__;
-
-    double a[8][8];
-    double b[8];
-
-    CvMat A = cvMat( 8, 8, CV_64FC1, a );
-    CvMat B = cvMat( 8, 1, CV_64FC1, b );
-    CvMat X = cvMat( 8, 1, CV_64FC1, coeffs );
-
-    int i;
-    for( i = 0; i < 4; ++i )
-    {
-        a[i][0] = quad[i][0]; a[i][1] = quad[i][1]; a[i][2] = 1;
-        a[i][3] = a[i][4] = a[i][5] = a[i][6] = a[i][7] = 0;
-        b[i] = 0;
-    }
-    for( i = 4; i < 8; ++i )
-    {
-        a[i][3] = quad[i-4][0]; a[i][4] = quad[i-4][1]; a[i][5] = 1;
-        a[i][0] = a[i][1] = a[i][2] = a[i][6] = a[i][7] = 0;
-        b[i] = 0;
-    }
-
-    int u = src_size.width - 1;
-    int v = src_size.height - 1;
-
-    a[1][6] = -quad[1][0] * u; a[1][7] = -quad[1][1] * u;
-    a[2][6] = -quad[2][0] * u; a[2][7] = -quad[2][1] * u;
-    b[1] = b[2] = u;
-
-    a[6][6] = -quad[2][0] * v; a[6][7] = -quad[2][1] * v;
-    a[7][6] = -quad[3][0] * v; a[7][7] = -quad[3][1] * v;
-    b[6] = b[7] = v;
-
-    cvSolve( &A, &B, &X );
-
-    coeffs[2][2] = 1;
-
-    __END__;
-}
-
-/* Warps source into destination by a perspective transform */
-static void cvWarpPerspective( CvArr* src, CvArr* dst, double quad[4][2] )
-{
-    CV_FUNCNAME( "cvWarpPerspective" );
-
-    __BEGIN__;
-
-#ifdef __IPL_H__
-    IplImage src_stub, dst_stub;
-    IplImage* src_img;
-    IplImage* dst_img;
-    CV_CALL( src_img = cvGetImage( src, &src_stub ) );
-    CV_CALL( dst_img = cvGetImage( dst, &dst_stub ) );
-    iplWarpPerspectiveQ( src_img, dst_img, quad, IPL_WARP_R_TO_Q,
-                         IPL_INTER_CUBIC | IPL_SMOOTH_EDGE );
-#else
-
-    int fill_value = 0;
-
-    double c[3][3]; /* transformation coefficients */
-    double q[4][2]; /* rearranged quad */
-
-    int left = 0;
-    int right = 0;
-    int next_right = 0;
-    int next_left = 0;
-    double y_min = 0;
-    double y_max = 0;
-    double k_left, b_left, k_right, b_right;
-
-    uchar* src_data;
-    int src_step;
-    CvSize src_size;
-
-    uchar* dst_data;
-    int dst_step;
-    CvSize dst_size;
-
-    double d = 0;
-    int direction = 0;
-    int i;
-
-    if( !src || (!CV_IS_IMAGE( src ) && !CV_IS_MAT( src )) ||
-        cvGetElemType( src ) != CV_8UC1 ||
-        cvGetDims( src ) != 2 )
-    {
-        CV_ERROR( CV_StsBadArg,
-            "Source must be two-dimensional array of CV_8UC1 type." );
-    }
-    if( !dst || (!CV_IS_IMAGE( dst ) && !CV_IS_MAT( dst )) ||
-        cvGetElemType( dst ) != CV_8UC1 ||
-        cvGetDims( dst ) != 2 )
-    {
-        CV_ERROR( CV_StsBadArg,
-            "Destination must be two-dimensional array of CV_8UC1 type." );
-    }
-
-    CV_CALL( cvGetRawData( src, &src_data, &src_step, &src_size ) );
-    CV_CALL( cvGetRawData( dst, &dst_data, &dst_step, &dst_size ) );
-
-    CV_CALL( cvGetPerspectiveTransform( src_size, quad, c ) );
-
-    /* if direction > 0 then vertices in quad follow in a CW direction,
-       otherwise they follow in a CCW direction */
-    direction = 0;
-    for( i = 0; i < 4; ++i )
-    {
-        int ni = i + 1; if( ni == 4 ) ni = 0;
-        int pi = i - 1; if( pi == -1 ) pi = 3;
-
-        d = (quad[i][0] - quad[pi][0])*(quad[ni][1] - quad[i][1]) -
-            (quad[i][1] - quad[pi][1])*(quad[ni][0] - quad[i][0]);
-        int cur_direction = CV_SIGN(d);
-        if( direction == 0 )
-        {
-            direction = cur_direction;
-        }
-        else if( direction * cur_direction < 0 )
-        {
-            direction = 0;
-            break;
-        }
-    }
-    if( direction == 0 )
-    {
-        CV_ERROR( CV_StsBadArg, "Quadrangle is nonconvex or degenerated." );
-    }
-
-    /* <left> is the index of the topmost quad vertice
-       if there are two such vertices <left> is the leftmost one */
-    left = 0;
-    for( i = 1; i < 4; ++i )
-    {
-        if( (quad[i][1] < quad[left][1]) ||
-            ((quad[i][1] == quad[left][1]) && (quad[i][0] < quad[left][0])) )
-        {
-            left = i;
-        }
-    }
-    /* rearrange <quad> vertices in such way that they follow in a CW
-       direction and the first vertice is the topmost one and put them
-       into <q> */
-    if( direction > 0 )
-    {
-        for( i = left; i < 4; ++i )
-        {
-            q[i-left][0] = quad[i][0];
-            q[i-left][1] = quad[i][1];
-        }
-        for( i = 0; i < left; ++i )
-        {
-            q[4-left+i][0] = quad[i][0];
-            q[4-left+i][1] = quad[i][1];
-        }
-    }
-    else
-    {
-        for( i = left; i >= 0; --i )
-        {
-            q[left-i][0] = quad[i][0];
-            q[left-i][1] = quad[i][1];
-        }
-        for( i = 3; i > left; --i )
-        {
-            q[4+left-i][0] = quad[i][0];
-            q[4+left-i][1] = quad[i][1];
-        }
-    }
-
-    left = right = 0;
-    /* if there are two topmost points, <right> is the index of the rightmost one
-       otherwise <right> */
-    if( q[left][1] == q[left+1][1] )
-    {
-        right = 1;
-    }
-
-    /* <next_left> follows <left> in a CCW direction */
-    next_left = 3;
-    /* <next_right> follows <right> in a CW direction */
-    next_right = right + 1;
-
-    /* subtraction of 1 prevents skipping of the first row */
-    y_min = q[left][1] - 1;
-
-    /* left edge equation: y = k_left * x + b_left */
-    k_left = (q[left][0] - q[next_left][0]) /
-               (q[left][1] - q[next_left][1]);
-    b_left = (q[left][1] * q[next_left][0] -
-               q[left][0] * q[next_left][1]) /
-                 (q[left][1] - q[next_left][1]);
-
-    /* right edge equation: y = k_right * x + b_right */
-    k_right = (q[right][0] - q[next_right][0]) /
-               (q[right][1] - q[next_right][1]);
-    b_right = (q[right][1] * q[next_right][0] -
-               q[right][0] * q[next_right][1]) /
-                 (q[right][1] - q[next_right][1]);
-
-    for(;;)
-    {
-        int x, y;
-
-        y_max = MIN( q[next_left][1], q[next_right][1] );
-
-        int iy_min = MAX( cvRound(y_min), 0 ) + 1;
-        int iy_max = MIN( cvRound(y_max), dst_size.height - 1 );
-
-        double x_min = k_left * iy_min + b_left;
-        double x_max = k_right * iy_min + b_right;
-
-        /* walk through the destination quadrangle row by row */
-        for( y = iy_min; y <= iy_max; ++y )
-        {
-            int ix_min = MAX( cvRound( x_min ), 0 );
-            int ix_max = MIN( cvRound( x_max ), dst_size.width - 1 );
-
-            for( x = ix_min; x <= ix_max; ++x )
-            {
-                /* calculate coordinates of the corresponding source array point */
-                double div = (c[2][0] * x + c[2][1] * y + c[2][2]);
-                double src_x = (c[0][0] * x + c[0][1] * y + c[0][2]) / div;
-                double src_y = (c[1][0] * x + c[1][1] * y + c[1][2]) / div;
-
-                int isrc_x = cvFloor( src_x );
-                int isrc_y = cvFloor( src_y );
-                double delta_x = src_x - isrc_x;
-                double delta_y = src_y - isrc_y;
-
-                uchar* s = src_data + isrc_y * src_step + isrc_x;
-
-                int i00, i10, i01, i11;
-                i00 = i10 = i01 = i11 = (int) fill_value;
-
-                /* linear interpolation using 2x2 neighborhood */
-                if( isrc_x >= 0 && isrc_x <= src_size.width &&
-                    isrc_y >= 0 && isrc_y <= src_size.height )
-                {
-                    i00 = s[0];
-                }
-                if( isrc_x >= -1 && isrc_x < src_size.width &&
-                    isrc_y >= 0 && isrc_y <= src_size.height )
-                {
-                    i10 = s[1];
-                }
-                if( isrc_x >= 0 && isrc_x <= src_size.width &&
-                    isrc_y >= -1 && isrc_y < src_size.height )
-                {
-                    i01 = s[src_step];
-                }
-                if( isrc_x >= -1 && isrc_x < src_size.width &&
-                    isrc_y >= -1 && isrc_y < src_size.height )
-                {
-                    i11 = s[src_step+1];
-                }
-
-                double i0 = i00 + (i10 - i00)*delta_x;
-                double i1 = i01 + (i11 - i01)*delta_x;
-
-                ((uchar*)(dst_data + y * dst_step))[x] = (uchar) (i0 + (i1 - i0)*delta_y);
-            }
-            x_min += k_left;
-            x_max += k_right;
-        }
-
-        if( (next_left == next_right) ||
-            (next_left+1 == next_right && q[next_left][1] == q[next_right][1]) )
-        {
-            break;
-        }
-
-        if( y_max == q[next_left][1] )
-        {
-            left = next_left;
-            next_left = left - 1;
-
-            k_left = (q[left][0] - q[next_left][0]) /
-                       (q[left][1] - q[next_left][1]);
-            b_left = (q[left][1] * q[next_left][0] -
-                       q[left][0] * q[next_left][1]) /
-                         (q[left][1] - q[next_left][1]);
-        }
-        if( y_max == q[next_right][1] )
-        {
-            right = next_right;
-            next_right = right + 1;
-
-            k_right = (q[right][0] - q[next_right][0]) /
-                       (q[right][1] - q[next_right][1]);
-            b_right = (q[right][1] * q[next_right][0] -
-                       q[right][0] * q[next_right][1]) /
-                         (q[right][1] - q[next_right][1]);
-        }
-        y_min = y_max;
-    }
-#endif /* #ifndef __IPL_H__ */
-
-    __END__;
-}
-
-static
-void icvRandomQuad( int width, int height, double quad[4][2],
-                    double maxxangle,
-                    double maxyangle,
-                    double maxzangle )
-{
-    double distfactor = 3.0;
-    double distfactor2 = 1.0;
-
-    double halfw, halfh;
-    int i;
-
-    double rotVectData[3];
-    double vectData[3];
-    double rotMatData[9];
-
-    CvMat rotVect;
-    CvMat rotMat;
-    CvMat vect;
-
-    double d;
-
-    rotVect = cvMat( 3, 1, CV_64FC1, &rotVectData[0] );
-    rotMat = cvMat( 3, 3, CV_64FC1, &rotMatData[0] );
-    vect = cvMat( 3, 1, CV_64FC1, &vectData[0] );
-
-    rotVectData[0] = maxxangle * (2.0 * rand() / RAND_MAX - 1.0);
-    rotVectData[1] = ( maxyangle - fabs( rotVectData[0] ) )
-        * (2.0 * rand() / RAND_MAX - 1.0);
-    rotVectData[2] = maxzangle * (2.0 * rand() / RAND_MAX - 1.0);
-    d = (distfactor + distfactor2 * (2.0 * rand() / RAND_MAX - 1.0)) * width;
-
-/*
-    rotVectData[0] = maxxangle;
-    rotVectData[1] = maxyangle;
-    rotVectData[2] = maxzangle;
-
-    d = distfactor * width;
-*/
-
-    cvRodrigues2( &rotVect, &rotMat );
-
-    halfw = 0.5 * width;
-    halfh = 0.5 * height;
-
-    quad[0][0] = -halfw;
-    quad[0][1] = -halfh;
-    quad[1][0] =  halfw;
-    quad[1][1] = -halfh;
-    quad[2][0] =  halfw;
-    quad[2][1] =  halfh;
-    quad[3][0] = -halfw;
-    quad[3][1] =  halfh;
-
-    for( i = 0; i < 4; i++ )
-    {
-        rotVectData[0] = quad[i][0];
-        rotVectData[1] = quad[i][1];
-        rotVectData[2] = 0.0;
-        cvMatMulAdd( &rotMat, &rotVect, 0, &vect );
-        quad[i][0] = vectData[0] * d / (d + vectData[2]) + halfw;
-        quad[i][1] = vectData[1] * d / (d + vectData[2]) + halfh;
-
-        /*
-        quad[i][0] += halfw;
-        quad[i][1] += halfh;
-        */
-    }
-}
-
-
-int icvStartSampleDistortion( const char* imgfilename, int bgcolor, int bgthreshold,
-                              CvSampleDistortionData* data )
-{
-    memset( data, 0, sizeof( *data ) );
-    data->src = cvLoadImage( imgfilename, 0 );
-    if( data->src != NULL && data->src->nChannels == 1
-        && data->src->depth == IPL_DEPTH_8U )
-    {
-        int r, c;
-        uchar* pmask;
-        uchar* psrc;
-        uchar* perode;
-        uchar* pdilate;
-        uchar dd, de;
-
-        data->dx = data->src->width / 2;
-        data->dy = data->src->height / 2;
-        data->bgcolor = bgcolor;
-
-        data->mask = cvCloneImage( data->src );
-        data->erode = cvCloneImage( data->src );
-        data->dilate = cvCloneImage( data->src );
-
-        /* make mask image */
-        for( r = 0; r < data->mask->height; r++ )
-        {
-            for( c = 0; c < data->mask->width; c++ )
-            {
-                pmask = ( (uchar*) (data->mask->imageData + r * data->mask->widthStep)
-                        + c );
-                if( bgcolor - bgthreshold <= (int) (*pmask) &&
-                    (int) (*pmask) <= bgcolor + bgthreshold )
-                {
-                    *pmask = (uchar) 0;
-                }
-                else
-                {
-                    *pmask = (uchar) 255;
-                }
-            }
-        }
-
-        /* extend borders of source image */
-        cvErode( data->src, data->erode, 0, 1 );
-        cvDilate( data->src, data->dilate, 0, 1 );
-        for( r = 0; r < data->mask->height; r++ )
-        {
-            for( c = 0; c < data->mask->width; c++ )
-            {
-                pmask = ( (uchar*) (data->mask->imageData + r * data->mask->widthStep)
-                        + c );
-                if( (*pmask) == 0 )
-                {
-                    psrc = ( (uchar*) (data->src->imageData + r * data->src->widthStep)
-                           + c );
-                    perode =
-                        ( (uchar*) (data->erode->imageData + r * data->erode->widthStep)
-                                + c );
-                    pdilate =
-                        ( (uchar*)(data->dilate->imageData + r * data->dilate->widthStep)
-                                + c );
-                    de = (uchar)(bgcolor - (*perode));
-                    dd = (uchar)((*pdilate) - bgcolor);
-                    if( de >= dd && de > bgthreshold )
-                    {
-                        (*psrc) = (*perode);
-                    }
-                    if( dd > de && dd > bgthreshold )
-                    {
-                        (*psrc) = (*pdilate);
-                    }
-                }
-            }
-        }
-
-        data->img = cvCreateImage( cvSize( data->src->width + 2 * data->dx,
-                                           data->src->height + 2 * data->dy ),
-                                   IPL_DEPTH_8U, 1 );
-        data->maskimg = cvCloneImage( data->img );
-
-        return 1;
-    }
-
-    return 0;
-}
-
-void icvPlaceDistortedSample( CvArr* background,
-                              int inverse, int maxintensitydev,
-                              double maxxangle, double maxyangle, double maxzangle,
-                              int inscribe, double maxshiftf, double maxscalef,
-                              CvSampleDistortionData* data )
-{
-    double quad[4][2];
-    int r, c;
-    uchar* pimg;
-    uchar* pbg;
-    uchar* palpha;
-    uchar chartmp;
-    int forecolordev;
-    float scale;
-    IplImage* img;
-    IplImage* maskimg;
-    CvMat  stub;
-    CvMat* bgimg;
-
-    CvRect cr;
-    CvRect roi;
-
-    double xshift, yshift, randscale;
-
-    icvRandomQuad( data->src->width, data->src->height, quad,
-                   maxxangle, maxyangle, maxzangle );
-    quad[0][0] += (double) data->dx;
-    quad[0][1] += (double) data->dy;
-    quad[1][0] += (double) data->dx;
-    quad[1][1] += (double) data->dy;
-    quad[2][0] += (double) data->dx;
-    quad[2][1] += (double) data->dy;
-    quad[3][0] += (double) data->dx;
-    quad[3][1] += (double) data->dy;
-
-    cvSet( data->img, cvScalar( data->bgcolor ) );
-    cvSet( data->maskimg, cvScalar( 0.0 ) );
-
-    cvWarpPerspective( data->src, data->img, quad );
-    cvWarpPerspective( data->mask, data->maskimg, quad );
-
-    cvSmooth( data->maskimg, data->maskimg, CV_GAUSSIAN, 3, 3 );
-
-    bgimg = cvGetMat( background, &stub );
-
-    cr.x = data->dx;
-    cr.y = data->dy;
-    cr.width = data->src->width;
-    cr.height = data->src->height;
-
-    if( inscribe )
-    {
-        /* quad's circumscribing rectangle */
-        cr.x = (int) MIN( quad[0][0], quad[3][0] );
-        cr.y = (int) MIN( quad[0][1], quad[1][1] );
-        cr.width  = (int) (MAX( quad[1][0], quad[2][0] ) + 0.5F ) - cr.x;
-        cr.height = (int) (MAX( quad[2][1], quad[3][1] ) + 0.5F ) - cr.y;
-    }
-
-    xshift = maxshiftf * rand() / RAND_MAX;
-    yshift = maxshiftf * rand() / RAND_MAX;
-
-    cr.x -= (int) ( xshift * cr.width  );
-    cr.y -= (int) ( yshift * cr.height );
-    cr.width  = (int) ((1.0 + maxshiftf) * cr.width );
-    cr.height = (int) ((1.0 + maxshiftf) * cr.height);
-
-    randscale = maxscalef * rand() / RAND_MAX;
-    cr.x -= (int) ( 0.5 * randscale * cr.width  );
-    cr.y -= (int) ( 0.5 * randscale * cr.height );
-    cr.width  = (int) ((1.0 + randscale) * cr.width );
-    cr.height = (int) ((1.0 + randscale) * cr.height);
-
-    scale = MAX( ((float) cr.width) / bgimg->cols, ((float) cr.height) / bgimg->rows );
-
-    roi.x = (int) (-0.5F * (scale * bgimg->cols - cr.width) + cr.x);
-    roi.y = (int) (-0.5F * (scale * bgimg->rows - cr.height) + cr.y);
-    roi.width  = (int) (scale * bgimg->cols);
-    roi.height = (int) (scale * bgimg->rows);
-
-    img = cvCreateImage( cvSize( bgimg->cols, bgimg->rows ), IPL_DEPTH_8U, 1 );
-    maskimg = cvCreateImage( cvSize( bgimg->cols, bgimg->rows ), IPL_DEPTH_8U, 1 );
-
-    cvSetImageROI( data->img, roi );
-    cvResize( data->img, img );
-    cvResetImageROI( data->img );
-    cvSetImageROI( data->maskimg, roi );
-    cvResize( data->maskimg, maskimg );
-    cvResetImageROI( data->maskimg );
-
-    forecolordev = (int) (maxintensitydev * (2.0 * rand() / RAND_MAX - 1.0));
-
-    for( r = 0; r < img->height; r++ )
-    {
-        for( c = 0; c < img->width; c++ )
-        {
-            pimg = (uchar*) img->imageData + r * img->widthStep + c;
-            pbg = (uchar*) bgimg->data.ptr + r * bgimg->step + c;
-            palpha = (uchar*) maskimg->imageData + r * maskimg->widthStep + c;
-            chartmp = (uchar) MAX( 0, MIN( 255, forecolordev + (*pimg) ) );
-            if( inverse )
-            {
-                chartmp ^= 0xFF;
-            }
-            *pbg = (uchar) (( chartmp*(*palpha )+(255 - (*palpha) )*(*pbg) ) / 255);
-        }
-    }
-
-    cvReleaseImage( &img );
-    cvReleaseImage( &maskimg );
-}
-
-void icvEndSampleDistortion( CvSampleDistortionData* data )
-{
-    if( data->src )
-    {
-        cvReleaseImage( &data->src );
-    }
-    if( data->mask )
-    {
-        cvReleaseImage( &data->mask );
-    }
-    if( data->erode )
-    {
-        cvReleaseImage( &data->erode );
-    }
-    if( data->dilate )
-    {
-        cvReleaseImage( &data->dilate );
-    }
-    if( data->img )
-    {
-        cvReleaseImage( &data->img );
-    }
-    if( data->maskimg )
-    {
-        cvReleaseImage( &data->maskimg );
-    }
-}
-
-void icvWriteVecHeader( FILE* file, int count, int width, int height )
-{
-    int vecsize;
-    short tmp;
-
-    /* number of samples */
-    fwrite( &count, sizeof( count ), 1, file );
-    /* vector size */
-    vecsize = width * height;
-    fwrite( &vecsize, sizeof( vecsize ), 1, file );
-    /* min/max values */
-    tmp = 0;
-    fwrite( &tmp, sizeof( tmp ), 1, file );
-    fwrite( &tmp, sizeof( tmp ), 1, file );
-}
-
-void icvWriteVecSample( FILE* file, CvArr* sample )
-{
-    CvMat* mat, stub;
-    int r, c;
-    short tmp;
-    uchar chartmp;
-
-    mat = cvGetMat( sample, &stub );
-    chartmp = 0;
-    fwrite( &chartmp, sizeof( chartmp ), 1, file );
-    for( r = 0; r < mat->rows; r++ )
-    {
-        for( c = 0; c < mat->cols; c++ )
-        {
-            tmp = (short) (CV_MAT_ELEM( *mat, uchar, r, c ));
-            fwrite( &tmp, sizeof( tmp ), 1, file );
-        }
-    }
-}
-
-
-int cvCreateTrainingSamplesFromInfo( const char* infoname, const char* vecfilename,
-                                     int num,
-                                     int showsamples,
-                                     int winwidth, int winheight )
-{
-    char fullname[PATH_MAX];
-    char* filename;
-
-    FILE* info;
-    FILE* vec;
-    IplImage* src=0;
-    IplImage* sample;
-    int line;
-    int error;
-    int i;
-    int x, y, width, height;
-    int total;
-
-    assert( infoname != NULL );
-    assert( vecfilename != NULL );
-
-    total = 0;
-    if( !icvMkDir( vecfilename ) )
-    {
-
-#if CV_VERBOSE
-        fprintf( stderr, "Unable to create directory hierarchy: %s\n", vecfilename );
-#endif /* CV_VERBOSE */
-
-        return total;
-    }
-
-    info = fopen( infoname, "r" );
-    if( info == NULL )
-    {
-
-#if CV_VERBOSE
-        fprintf( stderr, "Unable to open file: %s\n", infoname );
-#endif /* CV_VERBOSE */
-
-        return total;
-    }
-
-    vec = fopen( vecfilename, "wb" );
-    if( vec == NULL )
-    {
-
-#if CV_VERBOSE
-        fprintf( stderr, "Unable to open file: %s\n", vecfilename );
-#endif /* CV_VERBOSE */
-
-        fclose( info );
-
-        return total;
-    }
-
-    sample = cvCreateImage( cvSize( winwidth, winheight ), IPL_DEPTH_8U, 1 );
-
-    icvWriteVecHeader( vec, num, sample->width, sample->height );
-
-    if( showsamples )
-    {
-        cvNamedWindow( "Sample", CV_WINDOW_AUTOSIZE );
-    }
-
-    strcpy( fullname, infoname );
-    filename = strrchr( fullname, '\\' );
-    if( filename == NULL )
-    {
-        filename = strrchr( fullname, '/' );
-    }
-    if( filename == NULL )
-    {
-        filename = fullname;
-    }
-    else
-    {
-        filename++;
-    }
-
-    for( line = 1, error = 0, total = 0; total < num ;line++ )
-    {
-        int count;
-
-        error = ( fscanf( info, "%s %d", filename, &count ) != 2 );
-        if( !error )
-        {
-            src = cvLoadImage( fullname, 0 );
-            error = ( src == NULL );
-            if( error )
-            {
-
-#if CV_VERBOSE
-                fprintf( stderr, "Unable to open image: %s\n", fullname );
-#endif /* CV_VERBOSE */
-
-            }
-        }
-        for( i = 0; (i < count) && (total < num); i++, total++ )
-        {
-            error = ( fscanf( info, "%d %d %d %d", &x, &y, &width, &height ) != 4 );
-            if( error ) break;
-            cvSetImageROI( src, cvRect( x, y, width, height ) );
-            cvResize( src, sample, width >= sample->width &&
-                      height >= sample->height ? CV_INTER_AREA : CV_INTER_LINEAR );
-
-            if( showsamples )
-            {
-                cvShowImage( "Sample", sample );
-                if( cvWaitKey( 0 ) == 27 )
-                {
-                    showsamples = 0;
-                }
-            }
-            icvWriteVecSample( vec, sample );
-        }
-
-        if( src )
-        {
-            cvReleaseImage( &src );
-        }
-
-        if( error )
-        {
-
-#if CV_VERBOSE
-            fprintf( stderr, "%s(%d) : parse error", infoname, line );
-#endif /* CV_VERBOSE */
-
-            break;
-        }
-    }
-
-    if( sample )
-    {
-        cvReleaseImage( &sample );
-    }
-
-    fclose( vec );
-    fclose( info );
-
-    return total;
-}
-
-
-void cvShowVecSamples( const char* filename, int winwidth, int winheight,
-                       double scale )
-{
-    CvVecFile file;
-    short tmp;
-    int i;
-    CvMat* sample;
-
-    tmp = 0;
-    file.input = fopen( filename, "rb" );
-
-    if( file.input != NULL )
-    {
-        size_t elements_read1 = fread( &file.count, sizeof( file.count ), 1, file.input );
-        size_t elements_read2 = fread( &file.vecsize, sizeof( file.vecsize ), 1, file.input );
-        size_t elements_read3 = fread( &tmp, sizeof( tmp ), 1, file.input );
-        size_t elements_read4 = fread( &tmp, sizeof( tmp ), 1, file.input );
-        CV_Assert(elements_read1 == 1 && elements_read2 == 1 && elements_read3 == 1 && elements_read4 == 1);
-
-        if( file.vecsize != winwidth * winheight )
-        {
-            int guessed_w = 0;
-            int guessed_h = 0;
-
-            fprintf( stderr, "Warning: specified sample width=%d and height=%d "
-                "does not correspond to .vec file vector size=%d.\n",
-                winwidth, winheight, file.vecsize );
-            if( file.vecsize > 0 )
-            {
-                guessed_w = cvFloor( sqrt( (float) file.vecsize ) );
-                if( guessed_w > 0 )
-                {
-                    guessed_h = file.vecsize / guessed_w;
-                }
-            }
-
-            if( guessed_w <= 0 || guessed_h <= 0 || guessed_w * guessed_h != file.vecsize)
-            {
-                fprintf( stderr, "Error: failed to guess sample width and height\n" );
-                fclose( file.input );
-
-                return;
-            }
-            else
-            {
-                winwidth = guessed_w;
-                winheight = guessed_h;
-                fprintf( stderr, "Guessed width=%d, guessed height=%d\n",
-                    winwidth, winheight );
-            }
-        }
-
-        if( !feof( file.input ) && scale > 0 )
-        {
-            CvMat* scaled_sample = 0;
-
-            file.last = 0;
-            file.vector = (short*) cvAlloc( sizeof( *file.vector ) * file.vecsize );
-            sample = scaled_sample = cvCreateMat( winheight, winwidth, CV_8UC1 );
-            if( scale != 1.0 )
-            {
-                scaled_sample = cvCreateMat( MAX( 1, cvCeil( scale * winheight ) ),
-                                             MAX( 1, cvCeil( scale * winwidth ) ),
-                                             CV_8UC1 );
-            }
-            cvNamedWindow( "Sample", CV_WINDOW_AUTOSIZE );
-            for( i = 0; i < file.count; i++ )
-            {
-                icvGetHaarTraininDataFromVecCallback( sample, &file );
-                if( scale != 1.0 ) cvResize( sample, scaled_sample, CV_INTER_LINEAR);
-                cvShowImage( "Sample", scaled_sample );
-                if( cvWaitKey( 0 ) == 27 ) break;
-            }
-            if( scaled_sample && scaled_sample != sample ) cvReleaseMat( &scaled_sample );
-            cvReleaseMat( &sample );
-            cvFree( &file.vector );
-        }
-        fclose( file.input );
-    }
-}
-
-
-/* End of file. */

apps/haartraining/haartraining.cpp

@@ -1,284 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-/*
- * haartraining.cpp
- *
- * Train cascade classifier
- */
-
-#include <cstdio>
-#include <cstring>
-#include <cstdlib>
-
-using namespace std;
-
-#include "cvhaartraining.h"
-
-int main( int argc, char* argv[] )
-{
-    int i = 0;
-    char* nullname = (char*)"(NULL)";
-
-    char* vecname = NULL;
-    char* dirname = NULL;
-    char* bgname  = NULL;
-
-    bool bg_vecfile = false;
-    int npos    = 2000;
-    int nneg    = 2000;
-    int nstages = 14;
-    int mem     = 200;
-    int nsplits = 1;
-    float minhitrate     = 0.995F;
-    float maxfalsealarm  = 0.5F;
-    float weightfraction = 0.95F;
-    int mode         = 0;
-    int symmetric    = 1;
-    int equalweights = 0;
-    int width  = 24;
-    int height = 24;
-    const char* boosttypes[] = { "DAB", "RAB", "LB", "GAB" };
-    int boosttype = 3;
-    const char* stumperrors[] = { "misclass", "gini", "entropy" };
-    int stumperror = 0;
-    int maxtreesplits = 0;
-    int minpos = 500;
-
-    if( argc == 1 )
-    {
-        printf( "Usage: %s\n  -data <dir_name>\n"
-                "  -vec <vec_file_name>\n"
-                "  -bg <background_file_name>\n"
-                "  [-bg-vecfile]\n"
-                "  [-npos <number_of_positive_samples = %d>]\n"
-                "  [-nneg <number_of_negative_samples = %d>]\n"
-                "  [-nstages <number_of_stages = %d>]\n"
-                "  [-nsplits <number_of_splits = %d>]\n"
-                "  [-mem <memory_in_MB = %d>]\n"
-                "  [-sym (default)] [-nonsym]\n"
-                "  [-minhitrate <min_hit_rate = %f>]\n"
-                "  [-maxfalsealarm <max_false_alarm_rate = %f>]\n"
-                "  [-weighttrimming <weight_trimming = %f>]\n"
-                "  [-eqw]\n"
-                "  [-mode <BASIC (default) | CORE | ALL>]\n"
-                "  [-w <sample_width = %d>]\n"
-                "  [-h <sample_height = %d>]\n"
-                "  [-bt <DAB | RAB | LB | GAB (default)>]\n"
-                "  [-err <misclass (default) | gini | entropy>]\n"
-                "  [-maxtreesplits <max_number_of_splits_in_tree_cascade = %d>]\n"
-                "  [-minpos <min_number_of_positive_samples_per_cluster = %d>]\n",
-                argv[0], npos, nneg, nstages, nsplits, mem,
-                minhitrate, maxfalsealarm, weightfraction, width, height,
-                maxtreesplits, minpos );
-
-        return 0;
-    }
-
-    for( i = 1; i < argc; i++ )
-    {
-        if( !strcmp( argv[i], "-data" ) )
-        {
-            dirname = argv[++i];
-        }
-        else if( !strcmp( argv[i], "-vec" ) )
-        {
-            vecname = argv[++i];
-        }
-        else if( !strcmp( argv[i], "-bg" ) )
-        {
-            bgname = argv[++i];
-        }
-        else if( !strcmp( argv[i], "-bg-vecfile" ) )
-        {
-            bg_vecfile = true;
-        }
-        else if( !strcmp( argv[i], "-npos" ) )
-        {
-            npos = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-nneg" ) )
-        {
-            nneg = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-nstages" ) )
-        {
-            nstages = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-nsplits" ) )
-        {
-            nsplits = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-mem" ) )
-        {
-            mem = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-sym" ) )
-        {
-            symmetric = 1;
-        }
-        else if( !strcmp( argv[i], "-nonsym" ) )
-        {
-            symmetric = 0;
-        }
-        else if( !strcmp( argv[i], "-minhitrate" ) )
-        {
-            minhitrate = (float) atof( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-maxfalsealarm" ) )
-        {
-            maxfalsealarm = (float) atof( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-weighttrimming" ) )
-        {
-            weightfraction = (float) atof( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-eqw" ) )
-        {
-            equalweights = 1;
-        }
-        else if( !strcmp( argv[i], "-mode" ) )
-        {
-            char* tmp = argv[++i];
-
-            if( !strcmp( tmp, "CORE" ) )
-            {
-                mode = 1;
-            }
-            else if( !strcmp( tmp, "ALL" ) )
-            {
-                mode = 2;
-            }
-            else
-            {
-                mode = 0;
-            }
-        }
-        else if( !strcmp( argv[i], "-w" ) )
-        {
-            width = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-h" ) )
-        {
-            height = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-bt" ) )
-        {
-            i++;
-            if( !strcmp( argv[i], boosttypes[0] ) )
-            {
-                boosttype = 0;
-            }
-            else if( !strcmp( argv[i], boosttypes[1] ) )
-            {
-                boosttype = 1;
-            }
-            else if( !strcmp( argv[i], boosttypes[2] ) )
-            {
-                boosttype = 2;
-            }
-            else
-            {
-                boosttype = 3;
-            }
-        }
-        else if( !strcmp( argv[i], "-err" ) )
-        {
-            i++;
-            if( !strcmp( argv[i], stumperrors[0] ) )
-            {
-                stumperror = 0;
-            }
-            else if( !strcmp( argv[i], stumperrors[1] ) )
-            {
-                stumperror = 1;
-            }
-            else
-            {
-                stumperror = 2;
-            }
-        }
-        else if( !strcmp( argv[i], "-maxtreesplits" ) )
-        {
-            maxtreesplits = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-minpos" ) )
-        {
-            minpos = atoi( argv[++i] );
-        }
-    }
-
-    printf( "Data dir name: %s\n", ((dirname == NULL) ? nullname : dirname ) );
-    printf( "Vec file name: %s\n", ((vecname == NULL) ? nullname : vecname ) );
-    printf( "BG  file name: %s, is a vecfile: %s\n", ((bgname == NULL) ? nullname : bgname ), bg_vecfile ? "yes" : "no" );
-    printf( "Num pos: %d\n", npos );
-    printf( "Num neg: %d\n", nneg );
-    printf( "Num stages: %d\n", nstages );
-    printf( "Num splits: %d (%s as weak classifier)\n", nsplits,
-        (nsplits == 1) ? "stump" : "tree" );
-    printf( "Mem: %d MB\n", mem );
-    printf( "Symmetric: %s\n", (symmetric) ? "TRUE" : "FALSE" );
-    printf( "Min hit rate: %f\n", minhitrate );
-    printf( "Max false alarm rate: %f\n", maxfalsealarm );
-    printf( "Weight trimming: %f\n", weightfraction );
-    printf( "Equal weights: %s\n", (equalweights) ? "TRUE" : "FALSE" );
-    printf( "Mode: %s\n", ( (mode == 0) ? "BASIC" : ( (mode == 1) ? "CORE" : "ALL") ) );
-    printf( "Width: %d\n", width );
-    printf( "Height: %d\n", height );
-    //printf( "Max num of precalculated features: %d\n", numprecalculated );
-    printf( "Applied boosting algorithm: %s\n", boosttypes[boosttype] );
-    printf( "Error (valid only for Discrete and Real AdaBoost): %s\n",
-            stumperrors[stumperror] );
-
-    printf( "Max number of splits in tree cascade: %d\n", maxtreesplits );
-    printf( "Min number of positive samples per cluster: %d\n", minpos );
-
-    cvCreateTreeCascadeClassifier( dirname, vecname, bgname,
-                               npos, nneg, nstages, mem,
-                               nsplits,
-                               minhitrate, maxfalsealarm, weightfraction,
-                               mode, symmetric,
-                               equalweights, width, height,
-                               boosttype, stumperror,
-                               maxtreesplits, minpos, bg_vecfile );
-
-    return 0;
-}

apps/haartraining/performance.cpp

@@ -1,377 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-/*
- * performance.cpp
- *
- * Measure performance of classifier
- */
-#include "opencv2/core.hpp"
-
-#include "cv.h"
-#include "highgui.h"
-
-#include <cstdio>
-#include <cmath>
-#include <ctime>
-
-#ifdef _WIN32
-/* use clock() function insted of time() */
-#define time( arg ) (((double) clock()) / CLOCKS_PER_SEC)
-#endif /* _WIN32 */
-
-#ifndef PATH_MAX
-#define PATH_MAX 512
-#endif /* PATH_MAX */
-
-typedef struct HidCascade
-{
-    int size;
-    int count;
-} HidCascade;
-
-typedef struct ObjectPos
-{
-    float x;
-    float y;
-    float width;
-    int found;    /* for reference */
-    int neghbors;
-} ObjectPos;
-
-int main( int argc, char* argv[] )
-{
-    int i, j;
-    char* classifierdir = NULL;
-    //char* samplesdir    = NULL;
-
-    int saveDetected = 1;
-    double scale_factor = 1.2;
-    float maxSizeDiff = 1.5F;
-    float maxPosDiff  = 0.3F;
-
-    /* number of stages. if <=0 all stages are used */
-    int nos = -1, nos0;
-
-    int width  = 24;
-    int height = 24;
-
-    int rocsize;
-
-    FILE* info;
-    char* infoname;
-    char fullname[PATH_MAX];
-    char detfilename[PATH_MAX];
-    char* filename;
-    char detname[] = "det-";
-
-    CvHaarClassifierCascade* cascade;
-    CvMemStorage* storage;
-    CvSeq* objects;
-
-    double totaltime;
-
-    infoname = (char*)"";
-    rocsize = 40;
-    if( argc == 1 )
-    {
-        printf( "Usage: %s\n  -data <classifier_directory_name>\n"
-                "  -info <collection_file_name>\n"
-                "  [-maxSizeDiff <max_size_difference = %f>]\n"
-                "  [-maxPosDiff <max_position_difference = %f>]\n"
-                "  [-sf <scale_factor = %f>]\n"
-                "  [-ni]\n"
-                "  [-nos <number_of_stages = %d>]\n"
-                "  [-rs <roc_size = %d>]\n"
-                "  [-w <sample_width = %d>]\n"
-                "  [-h <sample_height = %d>]\n",
-                argv[0], maxSizeDiff, maxPosDiff, scale_factor, nos, rocsize,
-                width, height );
-
-        return 0;
-    }
-
-    for( i = 1; i < argc; i++ )
-    {
-        if( !strcmp( argv[i], "-data" ) )
-        {
-            classifierdir = argv[++i];
-        }
-        else if( !strcmp( argv[i], "-info" ) )
-        {
-            infoname = argv[++i];
-        }
-        else if( !strcmp( argv[i], "-maxSizeDiff" ) )
-        {
-            maxSizeDiff = (float) atof( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-maxPosDiff" ) )
-        {
-            maxPosDiff = (float) atof( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-sf" ) )
-        {
-            scale_factor = atof( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-ni" ) )
-        {
-            saveDetected = 0;
-        }
-        else if( !strcmp( argv[i], "-nos" ) )
-        {
-            nos = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-rs" ) )
-        {
-            rocsize = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-w" ) )
-        {
-            width = atoi( argv[++i] );
-        }
-        else if( !strcmp( argv[i], "-h" ) )
-        {
-            height = atoi( argv[++i] );
-        }
-    }
-
-    cascade = cvLoadHaarClassifierCascade( classifierdir, cvSize( width, height ) );
-    if( cascade == NULL )
-    {
-        printf( "Unable to load classifier from %s\n", classifierdir );
-
-        return 1;
-    }
-
-    int* numclassifiers = new int[cascade->count];
-    numclassifiers[0] = cascade->stage_classifier[0].count;
-    for( i = 1; i < cascade->count; i++ )
-    {
-        numclassifiers[i] = numclassifiers[i-1] + cascade->stage_classifier[i].count;
-    }
-
-    storage = cvCreateMemStorage();
-
-    nos0 = cascade->count;
-    if( nos <= 0 )
-        nos = nos0;
-
-    strcpy( fullname, infoname );
-    filename = strrchr( fullname, '\\' );
-    if( filename == NULL )
-    {
-        filename = strrchr( fullname, '/' );
-    }
-    if( filename == NULL )
-    {
-        filename = fullname;
-    }
-    else
-    {
-        filename++;
-    }
-
-    info = fopen( infoname, "r" );
-    totaltime = 0.0;
-    if( info != NULL )
-    {
-        int x, y;
-        IplImage* img;
-        int hits, missed, falseAlarms;
-        int totalHits, totalMissed, totalFalseAlarms;
-        int found;
-        float distance;
-
-        int refcount;
-        ObjectPos* ref;
-        int detcount;
-        ObjectPos* det;
-        int error=0;
-
-        int* pos;
-        int* neg;
-
-        pos = (int*) cvAlloc( rocsize * sizeof( *pos ) );
-        neg = (int*) cvAlloc( rocsize * sizeof( *neg ) );
-        for( i = 0; i < rocsize; i++ ) { pos[i] = neg[i] = 0; }
-
-        printf( "+================================+======+======+======+\n" );
-        printf( "|            File Name           | Hits |Missed| False|\n" );
-        printf( "+================================+======+======+======+\n" );
-
-        totalHits = totalMissed = totalFalseAlarms = 0;
-        while( !feof( info ) )
-        {
-            if( fscanf( info, "%s %d", filename, &refcount ) != 2 || refcount <= 0 ) break;
-
-            img = cvLoadImage( fullname );
-            if( !img ) continue;
-
-            ref = (ObjectPos*) cvAlloc( refcount * sizeof( *ref ) );
-            for( i = 0; i < refcount; i++ )
-            {
-                int w, h;
-                error = (fscanf( info, "%d %d %d %d", &x, &y, &w, &h ) != 4);
-                if( error ) break;
-                ref[i].x = 0.5F * w  + x;
-                ref[i].y = 0.5F * h + y;
-                ref[i].width = sqrtf( 0.5F * (w * w + h * h) );
-                ref[i].found = 0;
-                ref[i].neghbors = 0;
-            }
-            if( !error )
-            {
-                cvClearMemStorage( storage );
-
-                cascade->count = nos;
-                totaltime -= time( 0 );
-                objects = cvHaarDetectObjects( img, cascade, storage, scale_factor, 1 );
-                totaltime += time( 0 );
-                cascade->count = nos0;
-
-                detcount = ( objects ? objects->total : 0);
-                det = (detcount > 0) ?
-                    ( (ObjectPos*)cvAlloc( detcount * sizeof( *det )) ) : NULL;
-                hits = missed = falseAlarms = 0;
-                for( i = 0; i < detcount; i++ )
-                {
-                    CvAvgComp r = *((CvAvgComp*) cvGetSeqElem( objects, i ));
-                    det[i].x = 0.5F * r.rect.width  + r.rect.x;
-                    det[i].y = 0.5F * r.rect.height + r.rect.y;
-                    det[i].width = sqrtf( 0.5F * (r.rect.width * r.rect.width +
-                                                  r.rect.height * r.rect.height) );
-                    det[i].neghbors = r.neighbors;
-
-                    if( saveDetected )
-                    {
-                        cvRectangle( img, cvPoint( r.rect.x, r.rect.y ),
-                            cvPoint( r.rect.x + r.rect.width, r.rect.y + r.rect.height ),
-                            CV_RGB( 255, 0, 0 ), 3 );
-                    }
-
-                    found = 0;
-                    for( j = 0; j < refcount; j++ )
-                    {
-                        distance = sqrtf( (det[i].x - ref[j].x) * (det[i].x - ref[j].x) +
-                                          (det[i].y - ref[j].y) * (det[i].y - ref[j].y) );
-                        if( (distance < ref[j].width * maxPosDiff) &&
-                            (det[i].width > ref[j].width / maxSizeDiff) &&
-                            (det[i].width < ref[j].width * maxSizeDiff) )
-                        {
-                            ref[j].found = 1;
-                            ref[j].neghbors = MAX( ref[j].neghbors, det[i].neghbors );
-                            found = 1;
-                        }
-                    }
-                    if( !found )
-                    {
-                        falseAlarms++;
-                        neg[MIN(det[i].neghbors, rocsize - 1)]++;
-                    }
-                }
-                for( j = 0; j < refcount; j++ )
-                {
-                    if( ref[j].found )
-                    {
-                        hits++;
-                        pos[MIN(ref[j].neghbors, rocsize - 1)]++;
-                    }
-                    else
-                    {
-                        missed++;
-                    }
-                }
-
-                totalHits += hits;
-                totalMissed += missed;
-                totalFalseAlarms += falseAlarms;
-                printf( "|%32.32s|%6d|%6d|%6d|\n", filename, hits, missed, falseAlarms );
-                printf( "+--------------------------------+------+------+------+\n" );
-                fflush( stdout );
-
-                if( saveDetected )
-                {
-                    strcpy( detfilename, detname );
-                    strcat( detfilename, filename );
-                    strcpy( filename, detfilename );
-                    cvvSaveImage( fullname, img );
-                }
-
-                if( det ) { cvFree( &det ); det = NULL; }
-            } /* if( !error ) */
-
-            cvReleaseImage( &img );
-            cvFree( &ref );
-        }
-        fclose( info );
-
-        printf( "|%32.32s|%6d|%6d|%6d|\n", "Total",
-                totalHits, totalMissed, totalFalseAlarms );
-        printf( "+================================+======+======+======+\n" );
-        printf( "Number of stages: %d\n", nos );
-        printf( "Number of weak classifiers: %d\n", numclassifiers[nos - 1] );
-        printf( "Total time: %f\n", totaltime );
-
-        /* print ROC to stdout */
-        for( i = rocsize - 1; i > 0; i-- )
-        {
-            pos[i-1] += pos[i];
-            neg[i-1] += neg[i];
-        }
-        fprintf( stderr, "%d\n", nos );
-        for( i = 0; i < rocsize; i++ )
-        {
-            fprintf( stderr, "\t%d\t%d\t%f\t%f\n", pos[i], neg[i],
-                ((float)pos[i]) / (totalHits + totalMissed),
-                ((float)neg[i]) / (totalHits + totalMissed) );
-        }
-
-        cvFree( &pos );
-        cvFree( &neg );
-    }
-
-    delete[] numclassifiers;
-
-    cvReleaseHaarClassifierCascade( &cascade );
-    cvReleaseMemStorage( &storage );
-
-    return 0;
-}

apps/sft/CMakeLists.txt

@@ -1,33 +0,0 @@
-set(name sft)
-set(the_target opencv_${name})
-
-set(OPENCV_${the_target}_DEPS opencv_core opencv_softcascade opencv_highgui opencv_imgproc opencv_ml)
-ocv_check_dependencies(${OPENCV_${the_target}_DEPS})
-
-if(NOT OCV_DEPENDENCIES_FOUND)
-  return()
-endif()
-
-project(${the_target})
-
-ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include" "${OpenCV_SOURCE_DIR}/include/opencv")
-ocv_include_modules(${OPENCV_${the_target}_DEPS})
-
-file(GLOB ${the_target}_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
-
-add_executable(${the_target} ${${the_target}_SOURCES})
-
-target_link_libraries(${the_target} ${OPENCV_${the_target}_DEPS})
-
-set_target_properties(${the_target} PROPERTIES
-                      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-                      ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
-                      RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
-                      INSTALL_NAME_DIR lib
-                      OUTPUT_NAME "opencv_trainsoftcascade")
-
-if(ENABLE_SOLUTION_FOLDERS)
-  set_target_properties(${the_target} PROPERTIES FOLDER "applications")
-endif()
-
-install(TARGETS ${the_target} RUNTIME DESTINATION bin COMPONENT main)

apps/sft/config.cpp

@@ -1,162 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include <sft/config.hpp>
-#include <iomanip>
-
-sft::Config::Config(): seed(0) {}
-
-void sft::Config::write(cv::FileStorage& fs) const
-{
-    fs << "{"
-       << "trainPath"    << trainPath
-       << "testPath"     << testPath
-
-       << "modelWinSize" << modelWinSize
-       << "offset"       << offset
-       << "octaves"      << octaves
-
-       << "positives"    << positives
-       << "negatives"    << negatives
-       << "btpNegatives" << btpNegatives
-
-       << "shrinkage"    << shrinkage
-
-       << "treeDepth"    << treeDepth
-       << "weaks"        << weaks
-       << "poolSize"     << poolSize
-
-       << "cascadeName"  << cascadeName
-       << "outXmlPath"   << outXmlPath
-
-       << "seed"         << seed
-       << "featureType"  << featureType
-       << "}";
-}
-
-void sft::Config::read(const cv::FileNode& node)
-{
-    trainPath = (string)node["trainPath"];
-    testPath  = (string)node["testPath"];
-
-    cv::FileNodeIterator  nIt = node["modelWinSize"].end();
-    modelWinSize = cv::Size((int)*(--nIt), (int)*(--nIt));
-
-    nIt = node["offset"].end();
-    offset = cv::Point2i((int)*(--nIt), (int)*(--nIt));
-
-    node["octaves"] >> octaves;
-
-    positives =    (int)node["positives"];
-    negatives =    (int)node["negatives"];
-    btpNegatives = (int)node["btpNegatives"];
-
-    shrinkage = (int)node["shrinkage"];
-
-    treeDepth = (int)node["treeDepth"];
-    weaks =     (int)node["weaks"];
-    poolSize =  (int)node["poolSize"];
-
-    cascadeName = (std::string)node["cascadeName"];
-    outXmlPath =  (std::string)node["outXmlPath"];
-
-    seed = (int)node["seed"];
-    featureType = (std::string)node["featureType"];
-}
-
-void sft::write(cv::FileStorage& fs, const string&, const Config& x)
-{
-    x.write(fs);
-}
-
-void sft::read(const cv::FileNode& node, Config& x, const Config& default_value)
-{
-    x = default_value;
-
-    if(!node.empty())
-        x.read(node);
-}
-
-namespace {
-
-struct Out
-{
-    Out(std::ostream& _out): out(_out) {}
-    template<typename T>
-    void operator ()(const T a) const {out << a << " ";}
-
-    std::ostream& out;
-private:
-    Out& operator=(Out const& other);
-};
-}
-
-std::ostream& sft::operator<<(std::ostream& out, const Config& m)
-{
-    out << std::setw(14) << std::left << "trainPath"    << m.trainPath     << std::endl
-        << std::setw(14) << std::left << "testPath"     << m.testPath      << std::endl
-
-        << std::setw(14) << std::left << "modelWinSize" << m.modelWinSize  << std::endl
-        << std::setw(14) << std::left << "offset"       << m.offset        << std::endl
-        << std::setw(14) << std::left << "octaves";
-
-    Out o(out);
-    for_each(m.octaves.begin(), m.octaves.end(), o);
-
-    out << std::endl
-        << std::setw(14) << std::left  << "positives"    << m.positives    << std::endl
-        << std::setw(14) << std::left  << "negatives"    << m.negatives    << std::endl
-        << std::setw(14) << std::left  << "btpNegatives" << m.btpNegatives << std::endl
-
-        << std::setw(14) << std::left  << "shrinkage"    << m.shrinkage    << std::endl
-
-        << std::setw(14) << std::left  << "treeDepth"    << m.treeDepth    << std::endl
-        << std::setw(14) << std::left  << "weaks"        << m.weaks        << std::endl
-        << std::setw(14) << std::left  << "poolSize"     << m.poolSize     << std::endl
-
-        << std::setw(14) << std::left  << "cascadeName"  << m.cascadeName  << std::endl
-        << std::setw(14) << std::left  << "outXmlPath"   << m.outXmlPath   << std::endl
-        << std::setw(14) << std::left  << "seed"         << m.seed         << std::endl
-        << std::setw(14) << std::left  << "featureType"  << m.featureType  << std::endl;
-
-    return out;
-}

apps/sft/dataset.cpp

@@ -1,77 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include <sft/dataset.hpp>
-#include <opencv2/highgui.hpp>
-
-#include <iostream>
-#include <queue>
-
-// in the default case data folders should be aligned as following:
-// 1. positives: <train or test path>/octave_<octave number>/pos/*.png
-// 2. negatives: <train or test path>/octave_<octave number>/neg/*.png
-sft::ScaledDataset::ScaledDataset(const string& path, const int oct)
-{
-    dprintf("%s\n", "get dataset file names...");
-    dprintf("%s\n", "Positives globing...");
-    cv::glob(path + "/pos/octave_" + cv::format("%d", oct) + "/*.png", pos);
-
-    dprintf("%s\n", "Negatives globing...");
-    cv::glob(path + "/neg/octave_" + cv::format("%d", oct) + "/*.png", neg);
-
-    // Check: files not empty
-    CV_Assert(pos.size() != size_t(0));
-    CV_Assert(neg.size() != size_t(0));
-}
-
-cv::Mat sft::ScaledDataset::get(SampleType type, int idx) const
-{
-    const std::string& src = (type == POSITIVE)? pos[idx]: neg[idx];
-    return cv::imread(src);
-}
-
-int sft::ScaledDataset::available(SampleType type) const
-{
-    return (int)((type == POSITIVE)? pos.size():neg.size());
-}
-
-sft::ScaledDataset::~ScaledDataset(){}

apps/sft/include/sft/common.hpp

@@ -1,74 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef __SFT_COMMON_HPP__
-#define __SFT_COMMON_HPP__
-
-#include <opencv2/core.hpp>
-#include <opencv2/core/utility.hpp>
-#include <opencv2/softcascade.hpp>
-
-namespace cv {using namespace softcascade;}
-namespace sft
-{
-
-    using cv::Mat;
-    struct ICF;
-
-    typedef cv::String   string;
-
-    typedef std::vector<ICF>           Icfvector;
-    typedef std::vector<sft::string>   svector;
-    typedef std::vector<int>           ivector;
-}
-
-// used for noisy printfs
-//#define WITH_DEBUG_OUT
-
-#if defined WITH_DEBUG_OUT
-# include <stdio.h>
-# define dprintf(format, ...)  printf(format, ##__VA_ARGS__)
-#else
-# define dprintf(format, ...)
-#endif
-
-#endif

apps/sft/include/sft/config.hpp

@@ -1,138 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef __SFT_CONFIG_HPP__
-#define __SFT_CONFIG_HPP__
-
-#include <sft/common.hpp>
-
-#include <ostream>
-
-namespace sft {
-
-struct Config
-{
-    Config();
-
-    void write(cv::FileStorage& fs) const;
-
-    void read(const cv::FileNode& node);
-
-    // Scaled and shrunk model size.
-    cv::Size model(ivector::const_iterator it) const
-    {
-        float octave = powf(2.f, (float)(*it));
-        return cv::Size( cvRound(modelWinSize.width  * octave) / shrinkage,
-                         cvRound(modelWinSize.height * octave) / shrinkage );
-    }
-
-    // Scaled but, not shrunk bounding box for object in sample image.
-    cv::Rect bbox(ivector::const_iterator it) const
-    {
-        float octave = powf(2.f, (float)(*it));
-        return cv::Rect( cvRound(offset.x * octave), cvRound(offset.y * octave),
-            cvRound(modelWinSize.width  * octave), cvRound(modelWinSize.height * octave));
-    }
-
-    string resPath(ivector::const_iterator it) const
-    {
-        return cv::format("%s%d.xml",cascadeName.c_str(), *it);
-    }
-
-    // Paths to a rescaled data
-    string trainPath;
-    string testPath;
-
-    // Original model size.
-    cv::Size modelWinSize;
-
-    // example offset into positive image
-    cv::Point2i offset;
-
-    // List of octaves for which have to be trained cascades (a list of powers of two)
-    ivector octaves;
-
-    // Maximum number of positives that should be used during training
-    int positives;
-
-    // Initial number of negatives used during training.
-    int negatives;
-
-    // Number of weak negatives to add each bootstrapping step.
-    int btpNegatives;
-
-    // Inverse of scale for feature resizing
-    int shrinkage;
-
-    // Depth on weak classifier's decision tree
-    int treeDepth;
-
-    // Weak classifiers number in resulted cascade
-    int weaks;
-
-    // Feature random pool size
-    int poolSize;
-
-    // file name to store cascade
-    string cascadeName;
-
-    // path to resulting cascade
-    string outXmlPath;
-
-    // seed for random generation
-    int seed;
-
-    // channel feature type
-    string featureType;
-
-    // // bounding rectangle for actual example into example window
-    // cv::Rect exampleWindow;
-};
-
-// required for cv::FileStorage serialization
-void write(cv::FileStorage& fs, const string&, const Config& x);
-void read(const cv::FileNode& node, Config& x, const Config& default_value);
-std::ostream& operator<<(std::ostream& out, const Config& m);
-
-}
-
-#endif

apps/sft/include/sft/dataset.hpp

@@ -1,67 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef __SFT_OCTAVE_HPP__
-#define __SFT_OCTAVE_HPP__
-
-#include <sft/common.hpp>
-namespace sft
-{
-
-using cv::softcascade::Dataset;
-
-class ScaledDataset : public Dataset
-{
-public:
-    ScaledDataset(const sft::string& path, const int octave);
-
-    virtual cv::Mat get(SampleType type, int idx) const;
-    virtual int available(SampleType type) const;
-    virtual ~ScaledDataset();
-
-private:
-    svector pos;
-    svector neg;
-};
-}
-
-#endif

apps/sft/sft.cpp

@@ -1,168 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-// Training application for Soft Cascades.
-
-#include <sft/common.hpp>
-#include <iostream>
-#include <sft/dataset.hpp>
-#include <sft/config.hpp>
-
-#include <opencv2/core/core_c.h>
-
-int main(int argc, char** argv)
-{
-    using namespace sft;
-
-    const string keys =
-        "{help h usage ? |      | print this message              }"
-        "{config c       |      | path to configuration xml       }"
-    ;
-
-    cv::CommandLineParser parser(argc, argv, keys);
-    parser.about("Soft cascade training application.");
-
-    if (parser.has("help"))
-    {
-        parser.printMessage();
-        return 0;
-    }
-
-    if (!parser.check())
-    {
-        parser.printErrors();
-        return 1;
-    }
-
-    string configPath = parser.get<string>("config");
-    if (configPath.empty())
-    {
-        std::cout << "Configuration file is missing or empty. Could not start training." << std::endl;
-        return 0;
-    }
-
-    std::cout << "Read configuration from file " << configPath << std::endl;
-    cv::FileStorage fs(configPath, cv::FileStorage::READ);
-    if(!fs.isOpened())
-    {
-        std::cout << "Configuration file " << configPath << " can't be opened." << std::endl;
-        return 1;
-    }
-
-    // 1. load config
-    sft::Config cfg;
-    fs["config"] >> cfg;
-    std::cout << std::endl << "Training will be executed for configuration:" << std::endl << cfg << std::endl;
-
-    // 2. check and open output file
-    cv::FileStorage fso(cfg.outXmlPath, cv::FileStorage::WRITE);
-    if(!fso.isOpened())
-    {
-        std::cout << "Training stopped. Output classifier Xml file " << cfg.outXmlPath << " can't be opened." << std::endl;
-        return 1;
-    }
-
-    fso << cfg.cascadeName
-        << "{"
-        << "stageType"   << "BOOST"
-        << "featureType" << cfg.featureType
-        << "octavesNum"  << (int)cfg.octaves.size()
-        << "width"       << cfg.modelWinSize.width
-        << "height"      << cfg.modelWinSize.height
-        << "shrinkage"   << cfg.shrinkage
-        << "octaves"     << "[";
-
-    // 3. Train all octaves
-    for (ivector::const_iterator it = cfg.octaves.begin(); it != cfg.octaves.end(); ++it)
-    {
-        // a. create random feature pool
-        int nfeatures  = cfg.poolSize;
-        cv::Size model = cfg.model(it);
-        std::cout << "Model " << model << std::endl;
-
-        int nchannels = (cfg.featureType == "HOG6MagLuv") ? 10: 8;
-
-        std::cout << "number of feature channels is " << nchannels << std::endl;
-
-        cv::Ptr<cv::FeaturePool> pool = cv::FeaturePool::create(model, nfeatures, nchannels);
-        nfeatures = pool->size();
-
-
-        int npositives = cfg.positives;
-        int nnegatives = cfg.negatives;
-        int shrinkage  = cfg.shrinkage;
-        cv::Rect boundingBox = cfg.bbox(it);
-        std::cout << "Object bounding box" << boundingBox << std::endl;
-
-        typedef cv::Octave Octave;
-
-        cv::Ptr<cv::ChannelFeatureBuilder> builder = cv::ChannelFeatureBuilder::create(cfg.featureType);
-        std::cout << "Channel builder " << builder->info()->name() << std::endl;
-        cv::Ptr<Octave> boost = Octave::create(boundingBox, npositives, nnegatives, *it, shrinkage, builder);
-
-        std::string path = cfg.trainPath;
-        sft::ScaledDataset dataset(path, *it);
-
-        if (boost->train(&dataset, pool, cfg.weaks, cfg.treeDepth))
-        {
-            CvFileStorage* fout = cvOpenFileStorage(cfg.resPath(it).c_str(), 0, CV_STORAGE_WRITE);
-            boost->write(fout, cfg.cascadeName);
-
-            cvReleaseFileStorage( &fout);
-
-            cv::Mat thresholds;
-            boost->setRejectThresholds(thresholds);
-
-            boost->write(fso, pool, thresholds);
-
-            cv::FileStorage tfs(("thresholds." + cfg.resPath(it)).c_str(), cv::FileStorage::WRITE);
-            tfs << "thresholds" << thresholds;
-
-            std::cout << "Octave " << *it << " was successfully trained..." << std::endl;
-        }
-    }
-
-    fso << "]" << "}";
-    fso.release();
-    std::cout << "Training complete..." << std::endl;
-    return 0;
-}

apps/traincascade/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_ml opencv_imgproc opencv_photo opencv_objdetect opencv_highgui opencv_calib3d opencv_video opencv_features2d opencv_flann opencv_legacy)
+set(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_imgproc opencv_objdetect opencv_imgcodecs opencv_highgui opencv_calib3d opencv_features2d)
 ocv_check_dependencies(${OPENCV_TRAINCASCADE_DEPS})
 
 if(NOT OCV_DEPENDENCIES_FOUND)
@@ -6,21 +6,18 @@ if(NOT OCV_DEPENDENCIES_FOUND)
 endif()
 
 project(traincascade)
-
-ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
-ocv_include_modules(${OPENCV_TRAINCASCADE_DEPS})
-
-set(traincascade_files traincascade.cpp
-  cascadeclassifier.cpp cascadeclassifier.h
-  boost.cpp boost.h features.cpp traincascade_features.h
-  haarfeatures.cpp haarfeatures.h
-  lbpfeatures.cpp lbpfeatures.h
-  HOGfeatures.cpp HOGfeatures.h
-  imagestorage.cpp imagestorage.h)
-
 set(the_target opencv_traincascade)
-add_executable(${the_target} ${traincascade_files})
-target_link_libraries(${the_target} ${OPENCV_TRAINCASCADE_DEPS} opencv_haartraining_engine)
+
+ocv_target_include_directories(${the_target} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
+ocv_target_include_modules_recurse(${the_target} ${OPENCV_TRAINCASCADE_DEPS})
+
+file(GLOB SRCS *.cpp)
+file(GLOB HDRS *.h*)
+
+set(traincascade_files ${SRCS} ${HDRS})
+
+ocv_add_executable(${the_target} ${traincascade_files})
+ocv_target_link_libraries(${the_target} ${OPENCV_TRAINCASCADE_DEPS})
 
 set_target_properties(${the_target} PROPERTIES
                       DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
@@ -35,8 +32,8 @@ endif()
 
 if(INSTALL_CREATE_DISTRIB)
   if(BUILD_SHARED_LIBS)
-    install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} CONFIGURATIONS Release COMPONENT main)
+    install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} CONFIGURATIONS Release COMPONENT dev)
   endif()
 else()
-  install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT main)
+  install(TARGETS ${the_target} OPTIONAL RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT dev)
 endif()

apps/traincascade/HOGfeatures.cpp

@@ -187,11 +187,11 @@ void CvHOGEvaluator::integralHistogram(const Mat &img, vector<Mat> &histogram, M
 
     for( y = 0; y < gradSize.height; y++ )
     {
-        const uchar* currPtr = img.data + img.step*ymap[y];
-        const uchar* prevPtr = img.data + img.step*ymap[y-1];
-        const uchar* nextPtr = img.data + img.step*ymap[y+1];
-        float* gradPtr = (float*)grad.ptr(y);
-        uchar* qanglePtr = (uchar*)qangle.ptr(y);
+        const uchar* currPtr = img.ptr(ymap[y]);
+        const uchar* prevPtr = img.ptr(ymap[y-1]);
+        const uchar* nextPtr = img.ptr(ymap[y+1]);
+        float* gradPtr = grad.ptr<float>(y);
+        uchar* qanglePtr = qangle.ptr(y);
 
         for( x = 0; x < width; x++ )
         {
@@ -226,9 +226,9 @@ void CvHOGEvaluator::integralHistogram(const Mat &img, vector<Mat> &histogram, M
     int magStep = (int)( grad.step / sizeof(float) );
     for( binIdx = 0; binIdx < nbins; binIdx++ )
     {
-        histBuf = (float*)histogram[binIdx].data;
-        magBuf = (const float*)grad.data;
-        binsBuf = (const uchar*)qangle.data;
+        histBuf = histogram[binIdx].ptr<float>();
+        magBuf = grad.ptr<float>();
+        binsBuf = qangle.ptr();
 
         memset( histBuf, 0, histSize.width * sizeof(histBuf[0]) );
         histBuf += histStep + 1;

apps/traincascade/boost.cpp

@@ -437,7 +437,7 @@ CvDTreeNode* CvCascadeBoostTrainData::subsample_data( const CvMat* _subsample_id
             if (is_buf_16u)
             {
                 unsigned short* udst_idx = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
-                    vi*sample_count + data_root->offset);
+                    (size_t)vi*sample_count + data_root->offset);
                 for( int i = 0; i < num_valid; i++ )
                 {
                     idx = src_idx[i];
@@ -450,7 +450,7 @@ CvDTreeNode* CvCascadeBoostTrainData::subsample_data( const CvMat* _subsample_id
             else
             {
                 int* idst_idx = buf->data.i + root->buf_idx*get_length_subbuf() +
-                    vi*sample_count + root->offset;
+                    (size_t)vi*sample_count + root->offset;
                 for( int i = 0; i < num_valid; i++ )
                 {
                     idx = src_idx[i];
@@ -467,14 +467,14 @@ CvDTreeNode* CvCascadeBoostTrainData::subsample_data( const CvMat* _subsample_id
         if (is_buf_16u)
         {
             unsigned short* udst = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
-                (workVarCount-1)*sample_count + root->offset);
+                (size_t)(workVarCount-1)*sample_count + root->offset);
             for( int i = 0; i < count; i++ )
                 udst[i] = (unsigned short)src_lbls[sidx[i]];
         }
         else
         {
             int* idst = buf->data.i + root->buf_idx*get_length_subbuf() +
-                (workVarCount-1)*sample_count + root->offset;
+                (size_t)(workVarCount-1)*sample_count + root->offset;
             for( int i = 0; i < count; i++ )
                 idst[i] = src_lbls[sidx[i]];
         }
@@ -484,14 +484,14 @@ CvDTreeNode* CvCascadeBoostTrainData::subsample_data( const CvMat* _subsample_id
         if (is_buf_16u)
         {
             unsigned short* sample_idx_dst = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
-                workVarCount*sample_count + root->offset);
+                (size_t)workVarCount*sample_count + root->offset);
             for( int i = 0; i < count; i++ )
                 sample_idx_dst[i] = (unsigned short)sample_idx_src[sidx[i]];
         }
         else
         {
             int* sample_idx_dst = buf->data.i + root->buf_idx*get_length_subbuf() +
-                workVarCount*sample_count + root->offset;
+                (size_t)workVarCount*sample_count + root->offset;
             for( int i = 0; i < count; i++ )
                 sample_idx_dst[i] = sample_idx_src[sidx[i]];
         }
@@ -677,9 +677,9 @@ void CvCascadeBoostTrainData::setData( const CvFeatureEvaluator* _featureEvaluat
 
     // set sample labels
     if (is_buf_16u)
-        udst = (unsigned short*)(buf->data.s + work_var_count*sample_count);
+        udst = (unsigned short*)(buf->data.s + (size_t)work_var_count*sample_count);
     else
-        idst = buf->data.i + work_var_count*sample_count;
+        idst = buf->data.i + (size_t)work_var_count*sample_count;
 
     for (int si = 0; si < sample_count; si++)
     {
@@ -747,11 +747,11 @@ void CvCascadeBoostTrainData::get_ord_var_data( CvDTreeNode* n, int vi, float* o
     if ( vi < numPrecalcIdx )
     {
         if( !is_buf_16u )
-            *sortedIndices = buf->data.i + n->buf_idx*get_length_subbuf() + vi*sample_count + n->offset;
+            *sortedIndices = buf->data.i + n->buf_idx*get_length_subbuf() + (size_t)vi*sample_count + n->offset;
         else
         {
             const unsigned short* shortIndices = (const unsigned short*)(buf->data.s + n->buf_idx*get_length_subbuf() +
-                                                    vi*sample_count + n->offset );
+                                                    (size_t)vi*sample_count + n->offset );
             for( int i = 0; i < nodeSampleCount; i++ )
                 sortedIndicesBuf[i] = shortIndices[i];
 
@@ -862,14 +862,14 @@ struct FeatureIdxOnlyPrecalc : ParallelLoopBody
             {
                 valCachePtr[si] = (*featureEvaluator)( fi, si );
                 if ( is_buf_16u )
-                    *(udst + fi*sample_count + si) = (unsigned short)si;
+                    *(udst + (size_t)fi*sample_count + si) = (unsigned short)si;
                 else
-                    *(idst + fi*sample_count + si) = si;
+                    *(idst + (size_t)fi*sample_count + si) = si;
             }
             if ( is_buf_16u )
-                std::sort(udst + fi*sample_count, udst + (fi + 1)*sample_count, LessThanIdx<float, unsigned short>(valCachePtr) );
+                std::sort(udst + (size_t)fi*sample_count, udst + (size_t)(fi + 1)*sample_count, LessThanIdx<float, unsigned short>(valCachePtr) );
             else
-                std::sort(idst + fi*sample_count, idst + (fi + 1)*sample_count, LessThanIdx<float, int>(valCachePtr) );
+                std::sort(idst + (size_t)fi*sample_count, idst + (size_t)(fi + 1)*sample_count, LessThanIdx<float, int>(valCachePtr) );
         }
     }
     const CvFeatureEvaluator* featureEvaluator;
@@ -898,14 +898,14 @@ struct FeatureValAndIdxPrecalc : ParallelLoopBody
             {
                 valCache->at<float>(fi,si) = (*featureEvaluator)( fi, si );
                 if ( is_buf_16u )
-                    *(udst + fi*sample_count + si) = (unsigned short)si;
+                    *(udst + (size_t)fi*sample_count + si) = (unsigned short)si;
                 else
-                    *(idst + fi*sample_count + si) = si;
+                    *(idst + (size_t)fi*sample_count + si) = si;
             }
             if ( is_buf_16u )
-                std::sort(idst + fi*sample_count, idst + (fi + 1)*sample_count, LessThanIdx<float, unsigned short>(valCache->ptr<float>(fi)) );
+                std::sort(udst + (size_t)fi*sample_count, udst + (size_t)(fi + 1)*sample_count, LessThanIdx<float, unsigned short>(valCache->ptr<float>(fi)) );
             else
-                std::sort(idst + fi*sample_count, idst + (fi + 1)*sample_count, LessThanIdx<float, int>(valCache->ptr<float>(fi)) );
+                std::sort(idst + (size_t)fi*sample_count, idst + (size_t)(fi + 1)*sample_count, LessThanIdx<float, int>(valCache->ptr<float>(fi)) );
         }
     }
     const CvFeatureEvaluator* featureEvaluator;
@@ -1228,9 +1228,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
     if (data->is_buf_16u)
     {
         unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*length_buf_row +
-            (workVarCount-1)*scount + left->offset);
+            (size_t)(workVarCount-1)*scount + left->offset);
         unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*length_buf_row +
-            (workVarCount-1)*scount + right->offset);
+            (size_t)(workVarCount-1)*scount + right->offset);
 
         for( int i = 0; i < n; i++ )
         {
@@ -1251,9 +1251,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
     else
     {
         int *ldst = buf->data.i + left->buf_idx*length_buf_row +
-            (workVarCount-1)*scount + left->offset;
+            (size_t)(workVarCount-1)*scount + left->offset;
         int *rdst = buf->data.i + right->buf_idx*length_buf_row +
-            (workVarCount-1)*scount + right->offset;
+            (size_t)(workVarCount-1)*scount + right->offset;
 
         for( int i = 0; i < n; i++ )
         {
@@ -1281,9 +1281,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
     if (data->is_buf_16u)
     {
         unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*length_buf_row +
-            workVarCount*scount + left->offset);
+            (size_t)workVarCount*scount + left->offset);
         unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*length_buf_row +
-            workVarCount*scount + right->offset);
+            (size_t)workVarCount*scount + right->offset);
         for (int i = 0; i < n; i++)
         {
             unsigned short idx = (unsigned short)tempBuf[i];
@@ -1302,9 +1302,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
     else
     {
         int* ldst = buf->data.i + left->buf_idx*length_buf_row +
-            workVarCount*scount + left->offset;
+            (size_t)workVarCount*scount + left->offset;
         int* rdst = buf->data.i + right->buf_idx*length_buf_row +
-            workVarCount*scount + right->offset;
+            (size_t)workVarCount*scount + right->offset;
         for (int i = 0; i < n; i++)
         {
             int idx = tempBuf[i];
@@ -1473,7 +1473,7 @@ void CvCascadeBoost::update_weights( CvBoostTree* tree )
         if (data->is_buf_16u)
         {
             unsigned short* labels = (unsigned short*)(buf->data.s + data->data_root->buf_idx*length_buf_row +
-                data->data_root->offset + (data->work_var_count-1)*data->sample_count);
+                data->data_root->offset + (size_t)(data->work_var_count-1)*data->sample_count);
             for( int i = 0; i < n; i++ )
             {
                 // save original categorical responses {0,1}, convert them to {-1,1}
@@ -1491,7 +1491,7 @@ void CvCascadeBoost::update_weights( CvBoostTree* tree )
         else
         {
             int* labels = buf->data.i + data->data_root->buf_idx*length_buf_row +
-                data->data_root->offset + (data->work_var_count-1)*data->sample_count;
+                data->data_root->offset + (size_t)(data->work_var_count-1)*data->sample_count;
 
             for( int i = 0; i < n; i++ )
             {

apps/traincascade/boost.h

@@ -2,7 +2,7 @@
 #define _OPENCV_BOOST_H_
 
 #include "traincascade_features.h"
-#include "ml.h"
+#include "old_ml.hpp"
 
 struct CvCascadeBoostParams : CvBoostParams
 {

apps/traincascade/cascadeclassifier.cpp

@@ -135,7 +135,8 @@ bool CvCascadeClassifier::train( const string _cascadeDirName,
                                 const CvCascadeParams& _cascadeParams,
                                 const CvFeatureParams& _featureParams,
                                 const CvCascadeBoostParams& _stageParams,
-                                bool baseFormatSave )
+                                bool baseFormatSave,
+                                double acceptanceRatioBreakValue )
 {
     // Start recording clock ticks for training time output
     const clock_t begin_time = clock();
@@ -168,6 +169,13 @@ bool CvCascadeClassifier::train( const string _cascadeDirName,
         featureEvaluator = CvFeatureEvaluator::create(cascadeParams.featureType);
         featureEvaluator->init( featureParams, numPos + numNeg, cascadeParams.winSize );
         stageClassifiers.reserve( numStages );
+    }else{
+        // Make sure that if model parameters are preloaded, that people are aware of this,
+        // even when passing other parameters to the training command
+        cout << "---------------------------------------------------------------------------------" << endl;
+        cout << "Training parameters are pre-loaded from the parameter file in data folder!" << endl;
+        cout << "Please empty this folder if you want to use a NEW set of training parameters." << endl;
+        cout << "---------------------------------------------------------------------------------" << endl;
     }
     cout << "PARAMETERS:" << endl;
     cout << "cascadeDirName: " << _cascadeDirName << endl;
@@ -178,6 +186,7 @@ bool CvCascadeClassifier::train( const string _cascadeDirName,
     cout << "numStages: " << numStages << endl;
     cout << "precalcValBufSize[Mb] : " << _precalcValBufSize << endl;
     cout << "precalcIdxBufSize[Mb] : " << _precalcIdxBufSize << endl;
+    cout << "acceptanceRatioBreakValue : " << acceptanceRatioBreakValue << endl;
     cascadeParams.printAttrs();
     stageParams->printAttrs();
     featureParams->printAttrs();
@@ -200,13 +209,18 @@ bool CvCascadeClassifier::train( const string _cascadeDirName,
         if ( !updateTrainingSet( tempLeafFARate ) )
         {
             cout << "Train dataset for temp stage can not be filled. "
-                "Branch training terminated." << endl;
+                    "Branch training terminated." << endl;
             break;
         }
         if( tempLeafFARate <= requiredLeafFARate )
         {
             cout << "Required leaf false alarm rate achieved. "
-                 "Branch training terminated." << endl;
+                    "Branch training terminated." << endl;
+            break;
+        }
+        if( (tempLeafFARate <= acceptanceRatioBreakValue) && (acceptanceRatioBreakValue >= 0) ){
+            cout << "The required acceptanceRatio for the model has been reached to avoid overfitting of trainingdata. "
+                    "Branch training terminated." << endl;
             break;
         }
 

apps/traincascade/cascadeclassifier.h

@@ -7,8 +7,6 @@
 #include "lbpfeatures.h"
 #include "HOGfeatures.h" //new
 #include "boost.h"
-#include "cv.h"
-#include "cxcore.h"
 
 #define CC_CASCADE_FILENAME "cascade.xml"
 #define CC_PARAMS_FILENAME "params.xml"
@@ -96,7 +94,8 @@ public:
                 const CvCascadeParams& _cascadeParams,
                 const CvFeatureParams& _featureParams,
                 const CvCascadeBoostParams& _stageParams,
-                bool baseFormatSave = false );
+                bool baseFormatSave = false,
+                double acceptanceRatioBreakValue = -1.0 );
 private:
     int predict( int sampleIdx );
     void save( const std::string cascadeDirName, bool baseFormat = false );

apps/traincascade/features.cpp

@@ -13,9 +13,9 @@ float calcNormFactor( const Mat& sum, const Mat& sqSum )
     size_t p0, p1, p2, p3;
     CV_SUM_OFFSETS( p0, p1, p2, p3, normrect, sum.step1() )
     double area = normrect.width * normrect.height;
-    const int *sp = (const int*)sum.data;
+    const int *sp = sum.ptr<int>();
     int valSum = sp[p0] - sp[p1] - sp[p2] + sp[p3];
-    const double *sqp = (const double *)sqSum.data;
+    const double *sqp = sqSum.ptr<double>();
     double valSqSum = sqp[p0] - sqp[p1] - sqp[p2] + sqp[p3];
     return (float) sqrt( (double) (area * valSqSum - (double)valSum * valSum) );
 }

apps/traincascade/imagestorage.cpp

@@ -1,6 +1,7 @@
 #include "opencv2/core.hpp"
+#include "opencv2/core/core_c.h"
 #include "opencv2/imgproc.hpp"
-#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
 
 #include "imagestorage.h"
 #include <stdio.h>
@@ -32,20 +33,12 @@ bool CvCascadeImageReader::NegReader::create( const string _filename, Size _winS
     if ( !file.is_open() )
         return false;
 
-    size_t pos = _filename.rfind('\\');
-    char dlmrt = '\\';
-    if (pos == string::npos)
-    {
-        pos = _filename.rfind('/');
-        dlmrt = '/';
-    }
-    dirname = pos == string::npos ? "" : _filename.substr(0, pos) + dlmrt;
     while( !file.eof() )
     {
         std::getline(file, str);
         if (str.empty()) break;
         if (str.at(0) == '#' ) continue; /* comment */
-        imgFilenames.push_back(dirname + str);
+        imgFilenames.push_back(str);
     }
     file.close();
 
@@ -61,8 +54,10 @@ bool CvCascadeImageReader::NegReader::nextImg()
     for( size_t i = 0; i < count; i++ )
     {
         src = imread( imgFilenames[last++], 0 );
-        if( src.empty() )
+        if( src.empty() ){
+            last %= count;
             continue;
+        }
         round += last / count;
         round = round % (winSize.width * winSize.height);
         last %= count;
@@ -97,7 +92,7 @@ bool CvCascadeImageReader::NegReader::get( Mat& _img )
             return false;
 
     Mat mat( winSize.height, winSize.width, CV_8UC1,
-        (void*)(img.data + point.y * img.step + point.x * img.elemSize()), img.step );
+        (void*)(img.ptr(point.y) + point.x * img.elemSize()), img.step );
     mat.copyTo(_img);
 
     if( (int)( point.x + (1.0F + stepFactor ) * winSize.width ) < img.cols )

apps/traincascade/imagestorage.h

@@ -1,9 +1,6 @@
 #ifndef _OPENCV_IMAGESTORAGE_H_
 #define _OPENCV_IMAGESTORAGE_H_
 
-#include "highgui.h"
-
-
 
 class CvCascadeImageReader
 {

apps/traincascade/old_ml_data.cpp

@@ -0,0 +1,792 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "old_ml_precomp.hpp"
+#include <ctype.h>
+
+#define MISS_VAL    FLT_MAX
+#define CV_VAR_MISS    0
+
+CvTrainTestSplit::CvTrainTestSplit()
+{
+    train_sample_part_mode = CV_COUNT;
+    train_sample_part.count = -1;
+    mix = false;
+}
+
+CvTrainTestSplit::CvTrainTestSplit( int _train_sample_count, bool _mix )
+{
+    train_sample_part_mode = CV_COUNT;
+    train_sample_part.count = _train_sample_count;
+    mix = _mix;
+}
+
+CvTrainTestSplit::CvTrainTestSplit( float _train_sample_portion, bool _mix )
+{
+    train_sample_part_mode = CV_PORTION;
+    train_sample_part.portion = _train_sample_portion;
+    mix = _mix;
+}
+
+////////////////
+
+CvMLData::CvMLData()
+{
+    values = missing = var_types = var_idx_mask = response_out = var_idx_out = var_types_out = 0;
+    train_sample_idx = test_sample_idx = 0;
+    header_lines_number = 0;
+    sample_idx = 0;
+    response_idx = -1;
+
+    train_sample_count = -1;
+
+    delimiter = ',';
+    miss_ch = '?';
+    //flt_separator = '.';
+
+    rng = &cv::theRNG();
+}
+
+CvMLData::~CvMLData()
+{
+    clear();
+}
+
+void CvMLData::free_train_test_idx()
+{
+    cvReleaseMat( &train_sample_idx );
+    cvReleaseMat( &test_sample_idx );
+    sample_idx = 0;
+}
+
+void CvMLData::clear()
+{
+    class_map.clear();
+
+    cvReleaseMat( &values );
+    cvReleaseMat( &missing );
+    cvReleaseMat( &var_types );
+    cvReleaseMat( &var_idx_mask );
+
+    cvReleaseMat( &response_out );
+    cvReleaseMat( &var_idx_out );
+    cvReleaseMat( &var_types_out );
+
+    free_train_test_idx();
+
+    total_class_count = 0;
+
+    response_idx = -1;
+
+    train_sample_count = -1;
+}
+
+
+void CvMLData::set_header_lines_number( int idx )
+{
+    header_lines_number = std::max(0, idx);
+}
+
+int CvMLData::get_header_lines_number() const
+{
+    return header_lines_number;
+}
+
+static char *fgets_chomp(char *str, int n, FILE *stream)
+{
+    char *head = fgets(str, n, stream);
+    if( head )
+    {
+        for(char *tail = head + strlen(head) - 1; tail >= head; --tail)
+        {
+            if( *tail != '\r'  && *tail != '\n' )
+                break;
+            *tail = '\0';
+        }
+    }
+    return head;
+}
+
+
+int CvMLData::read_csv(const char* filename)
+{
+    const int M = 1000000;
+    const char str_delimiter[3] = { ' ', delimiter, '\0' };
+    FILE* file = 0;
+    CvMemStorage* storage;
+    CvSeq* seq;
+    char *ptr;
+    float* el_ptr;
+    CvSeqReader reader;
+    int cols_count = 0;
+    uchar *var_types_ptr = 0;
+
+    clear();
+
+    file = fopen( filename, "rt" );
+
+    if( !file )
+        return -1;
+
+    std::vector<char> _buf(M);
+    char* buf = &_buf[0];
+
+    // skip header lines
+    for( int i = 0; i < header_lines_number; i++ )
+    {
+        if( fgets( buf, M, file ) == 0 )
+        {
+            fclose(file);
+            return -1;
+        }
+    }
+
+    // read the first data line and determine the number of variables
+    if( !fgets_chomp( buf, M, file ))
+    {
+        fclose(file);
+        return -1;
+    }
+
+    ptr = buf;
+    while( *ptr == ' ' )
+        ptr++;
+    for( ; *ptr != '\0'; )
+    {
+        if(*ptr == delimiter || *ptr == ' ')
+        {
+            cols_count++;
+            ptr++;
+            while( *ptr == ' ' ) ptr++;
+        }
+        else
+            ptr++;
+    }
+
+    cols_count++;
+
+    if ( cols_count == 0)
+    {
+        fclose(file);
+        return -1;
+    }
+
+    // create temporary memory storage to store the whole database
+    el_ptr = new float[cols_count];
+    storage = cvCreateMemStorage();
+    seq = cvCreateSeq( 0, sizeof(*seq), cols_count*sizeof(float), storage );
+
+    var_types = cvCreateMat( 1, cols_count, CV_8U );
+    cvZero( var_types );
+    var_types_ptr = var_types->data.ptr;
+
+    for(;;)
+    {
+        char *token = NULL;
+        int type;
+        token = strtok(buf, str_delimiter);
+        if (!token)
+            break;
+        for (int i = 0; i < cols_count-1; i++)
+        {
+            str_to_flt_elem( token, el_ptr[i], type);
+            var_types_ptr[i] |= type;
+            token = strtok(NULL, str_delimiter);
+            if (!token)
+            {
+                fclose(file);
+                delete [] el_ptr;
+                return -1;
+            }
+        }
+        str_to_flt_elem( token, el_ptr[cols_count-1], type);
+        var_types_ptr[cols_count-1] |= type;
+        cvSeqPush( seq, el_ptr );
+        if( !fgets_chomp( buf, M, file ) )
+            break;
+    }
+    fclose(file);
+
+    values = cvCreateMat( seq->total, cols_count, CV_32FC1 );
+    missing = cvCreateMat( seq->total, cols_count, CV_8U );
+    var_idx_mask = cvCreateMat( 1, values->cols, CV_8UC1 );
+    cvSet( var_idx_mask, cvRealScalar(1) );
+    train_sample_count = seq->total;
+
+    cvStartReadSeq( seq, &reader );
+    for(int i = 0; i < seq->total; i++ )
+    {
+        const float* sdata = (float*)reader.ptr;
+        float* ddata = values->data.fl + cols_count*i;
+        uchar* dm = missing->data.ptr + cols_count*i;
+
+        for( int j = 0; j < cols_count; j++ )
+        {
+            ddata[j] = sdata[j];
+            dm[j] = ( fabs( MISS_VAL - sdata[j] ) <= FLT_EPSILON );
+        }
+        CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
+    }
+
+    if ( cvNorm( missing, 0, CV_L1 ) <= FLT_EPSILON )
+        cvReleaseMat( &missing );
+
+    cvReleaseMemStorage( &storage );
+    delete []el_ptr;
+    return 0;
+}
+
+const CvMat* CvMLData::get_values() const
+{
+    return values;
+}
+
+const CvMat* CvMLData::get_missing() const
+{
+    CV_FUNCNAME( "CvMLData::get_missing" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    __END__;
+
+    return missing;
+}
+
+const std::map<cv::String, int>& CvMLData::get_class_labels_map() const
+{
+    return class_map;
+}
+
+void CvMLData::str_to_flt_elem( const char* token, float& flt_elem, int& type)
+{
+
+    char* stopstring = NULL;
+    flt_elem = (float)strtod( token, &stopstring );
+    assert( stopstring );
+    type = CV_VAR_ORDERED;
+    if ( *stopstring == miss_ch && strlen(stopstring) == 1 ) // missed value
+    {
+        flt_elem = MISS_VAL;
+        type = CV_VAR_MISS;
+    }
+    else
+    {
+        if ( (*stopstring != 0) && (*stopstring != '\n') && (strcmp(stopstring, "\r\n") != 0) ) // class label
+        {
+            int idx = class_map[token];
+            if ( idx == 0)
+            {
+                total_class_count++;
+                idx = total_class_count;
+                class_map[token] = idx;
+            }
+            flt_elem = (float)idx;
+            type = CV_VAR_CATEGORICAL;
+        }
+    }
+}
+
+void CvMLData::set_delimiter(char ch)
+{
+    CV_FUNCNAME( "CvMLData::set_delimited" );
+    __BEGIN__;
+
+    if (ch == miss_ch /*|| ch == flt_separator*/)
+        CV_ERROR(CV_StsBadArg, "delimited, miss_character and flt_separator must be different");
+
+    delimiter = ch;
+
+    __END__;
+}
+
+char CvMLData::get_delimiter() const
+{
+    return delimiter;
+}
+
+void CvMLData::set_miss_ch(char ch)
+{
+    CV_FUNCNAME( "CvMLData::set_miss_ch" );
+    __BEGIN__;
+
+    if (ch == delimiter/* || ch == flt_separator*/)
+        CV_ERROR(CV_StsBadArg, "delimited, miss_character and flt_separator must be different");
+
+    miss_ch = ch;
+
+    __END__;
+}
+
+char CvMLData::get_miss_ch() const
+{
+    return miss_ch;
+}
+
+void CvMLData::set_response_idx( int idx )
+{
+    CV_FUNCNAME( "CvMLData::set_response_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    if ( idx >= values->cols)
+        CV_ERROR( CV_StsBadArg, "idx value is not correct" );
+
+    if ( response_idx >= 0 )
+        chahge_var_idx( response_idx, true );
+    if ( idx >= 0 )
+        chahge_var_idx( idx, false );
+    response_idx = idx;
+
+    __END__;
+}
+
+int CvMLData::get_response_idx() const
+{
+    CV_FUNCNAME( "CvMLData::get_response_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+     __END__;
+    return response_idx;
+}
+
+void CvMLData::change_var_type( int var_idx, int type )
+{
+    CV_FUNCNAME( "CvMLData::change_var_type" );
+    __BEGIN__;
+
+    int var_count = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+     var_count = values->cols;
+
+    if ( var_idx < 0 || var_idx >= var_count)
+        CV_ERROR( CV_StsBadArg, "var_idx is not correct" );
+
+    if ( type != CV_VAR_ORDERED && type != CV_VAR_CATEGORICAL)
+         CV_ERROR( CV_StsBadArg, "type is not correct" );
+
+    assert( var_types );
+    if ( var_types->data.ptr[var_idx] == CV_VAR_CATEGORICAL && type == CV_VAR_ORDERED)
+        CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
+    var_types->data.ptr[var_idx] = (uchar)type;
+
+    __END__;
+
+    return;
+}
+
+void CvMLData::set_var_types( const char* str )
+{
+    CV_FUNCNAME( "CvMLData::set_var_types" );
+    __BEGIN__;
+
+    const char* ord = 0, *cat = 0;
+    int var_count = 0, set_var_type_count = 0;
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    var_count = values->cols;
+
+    assert( var_types );
+
+    ord = strstr( str, "ord" );
+    cat = strstr( str, "cat" );
+    if ( !ord && !cat )
+        CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+    if ( !ord && strlen(cat) == 3 ) // str == "cat"
+    {
+        cvSet( var_types, cvScalarAll(CV_VAR_CATEGORICAL) );
+        return;
+    }
+
+    if ( !cat && strlen(ord) == 3 ) // str == "ord"
+    {
+        cvSet( var_types, cvScalarAll(CV_VAR_ORDERED) );
+        return;
+    }
+
+    if ( ord ) // parse ord str
+    {
+        char* stopstring = NULL;
+        if ( ord[3] != '[')
+            CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+        ord += 4; // pass "ord["
+        do
+        {
+            int b1 = (int)strtod( ord, &stopstring );
+            if ( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
+                CV_ERROR( CV_StsBadArg, "types string is not correct" );
+            ord = stopstring + 1;
+            if ( (stopstring[0] == ',') || (stopstring[0] == ']'))
+            {
+                if ( var_types->data.ptr[b1] == CV_VAR_CATEGORICAL)
+                    CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
+                var_types->data.ptr[b1] = CV_VAR_ORDERED;
+                set_var_type_count++;
+            }
+            else
+            {
+                if ( stopstring[0] == '-')
+                {
+                    int b2 = (int)strtod( ord, &stopstring);
+                    if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
+                        CV_ERROR( CV_StsBadArg, "types string is not correct" );
+                    ord = stopstring + 1;
+                    for (int i = b1; i <= b2; i++)
+                    {
+                        if ( var_types->data.ptr[i] == CV_VAR_CATEGORICAL)
+                            CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
+                        var_types->data.ptr[i] = CV_VAR_ORDERED;
+                    }
+                    set_var_type_count += b2 - b1 + 1;
+                }
+                else
+                    CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+            }
+        }
+        while (*stopstring != ']');
+
+        if ( stopstring[1] != '\0' && stopstring[1] != ',')
+            CV_ERROR( CV_StsBadArg, "types string is not correct" );
+    }
+
+    if ( cat ) // parse cat str
+    {
+        char* stopstring = NULL;
+        if ( cat[3] != '[')
+            CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+        cat += 4; // pass "cat["
+        do
+        {
+            int b1 = (int)strtod( cat, &stopstring );
+            if ( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
+                CV_ERROR( CV_StsBadArg, "types string is not correct" );
+            cat = stopstring + 1;
+            if ( (stopstring[0] == ',') || (stopstring[0] == ']'))
+            {
+                var_types->data.ptr[b1] = CV_VAR_CATEGORICAL;
+                set_var_type_count++;
+            }
+            else
+            {
+                if ( stopstring[0] == '-')
+                {
+                    int b2 = (int)strtod( cat, &stopstring);
+                    if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
+                        CV_ERROR( CV_StsBadArg, "types string is not correct" );
+                    cat = stopstring + 1;
+                    for (int i = b1; i <= b2; i++)
+                        var_types->data.ptr[i] = CV_VAR_CATEGORICAL;
+                    set_var_type_count += b2 - b1 + 1;
+                }
+                else
+                    CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+            }
+        }
+        while (*stopstring != ']');
+
+        if ( stopstring[1] != '\0' && stopstring[1] != ',')
+            CV_ERROR( CV_StsBadArg, "types string is not correct" );
+    }
+
+    if (set_var_type_count != var_count)
+        CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+     __END__;
+}
+
+const CvMat* CvMLData::get_var_types()
+{
+    CV_FUNCNAME( "CvMLData::get_var_types" );
+    __BEGIN__;
+
+    uchar *var_types_out_ptr = 0;
+    int avcount, vt_size;
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    assert( var_idx_mask );
+
+    avcount = cvFloor( cvNorm( var_idx_mask, 0, CV_L1 ) );
+    vt_size = avcount + (response_idx >= 0);
+
+    if ( avcount == values->cols || (avcount == values->cols-1 && response_idx == values->cols-1) )
+        return var_types;
+
+    if ( !var_types_out || ( var_types_out && var_types_out->cols != vt_size ) )
+    {
+        cvReleaseMat( &var_types_out );
+        var_types_out = cvCreateMat( 1, vt_size, CV_8UC1 );
+    }
+
+    var_types_out_ptr = var_types_out->data.ptr;
+    for( int i = 0; i < var_types->cols; i++)
+    {
+        if (i == response_idx || !var_idx_mask->data.ptr[i]) continue;
+        *var_types_out_ptr = var_types->data.ptr[i];
+        var_types_out_ptr++;
+    }
+    if ( response_idx >= 0 )
+        *var_types_out_ptr = var_types->data.ptr[response_idx];
+
+    __END__;
+
+    return var_types_out;
+}
+
+int CvMLData::get_var_type( int var_idx ) const
+{
+    return var_types->data.ptr[var_idx];
+}
+
+const CvMat* CvMLData::get_responses()
+{
+    CV_FUNCNAME( "CvMLData::get_responses_ptr" );
+    __BEGIN__;
+
+    int var_count = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+    var_count = values->cols;
+
+    if ( response_idx < 0 || response_idx >= var_count )
+       return 0;
+    if ( !response_out )
+        response_out = cvCreateMatHeader( values->rows, 1, CV_32FC1 );
+    else
+        cvInitMatHeader( response_out, values->rows, 1, CV_32FC1);
+    cvGetCol( values, response_out, response_idx );
+
+    __END__;
+
+    return response_out;
+}
+
+void CvMLData::set_train_test_split( const CvTrainTestSplit * spl)
+{
+    CV_FUNCNAME( "CvMLData::set_division" );
+    __BEGIN__;
+
+    int sample_count = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    sample_count = values->rows;
+
+    float train_sample_portion;
+
+    if (spl->train_sample_part_mode == CV_COUNT)
+    {
+        train_sample_count = spl->train_sample_part.count;
+        if (train_sample_count > sample_count)
+            CV_ERROR( CV_StsBadArg, "train samples count is not correct" );
+        train_sample_count = train_sample_count<=0 ? sample_count : train_sample_count;
+    }
+    else // dtype.train_sample_part_mode == CV_PORTION
+    {
+        train_sample_portion = spl->train_sample_part.portion;
+        if ( train_sample_portion > 1)
+            CV_ERROR( CV_StsBadArg, "train samples count is not correct" );
+        train_sample_portion = train_sample_portion <= FLT_EPSILON ||
+            1 - train_sample_portion <= FLT_EPSILON ? 1 : train_sample_portion;
+        train_sample_count = std::max(1, cvFloor( train_sample_portion * sample_count ));
+    }
+
+    if ( train_sample_count == sample_count )
+    {
+        free_train_test_idx();
+        return;
+    }
+
+    if ( train_sample_idx && train_sample_idx->cols != train_sample_count )
+        free_train_test_idx();
+
+    if ( !sample_idx)
+    {
+        int test_sample_count = sample_count- train_sample_count;
+        sample_idx = (int*)cvAlloc( sample_count * sizeof(sample_idx[0]) );
+        for (int i = 0; i < sample_count; i++ )
+            sample_idx[i] = i;
+        train_sample_idx = cvCreateMatHeader( 1, train_sample_count, CV_32SC1 );
+        *train_sample_idx = cvMat( 1, train_sample_count, CV_32SC1, &sample_idx[0] );
+
+        CV_Assert(test_sample_count > 0);
+        test_sample_idx = cvCreateMatHeader( 1, test_sample_count, CV_32SC1 );
+        *test_sample_idx = cvMat( 1, test_sample_count, CV_32SC1, &sample_idx[train_sample_count] );
+    }
+
+    mix = spl->mix;
+    if ( mix )
+        mix_train_and_test_idx();
+
+    __END__;
+}
+
+const CvMat* CvMLData::get_train_sample_idx() const
+{
+    CV_FUNCNAME( "CvMLData::get_train_sample_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+    __END__;
+
+    return train_sample_idx;
+}
+
+const CvMat* CvMLData::get_test_sample_idx() const
+{
+    CV_FUNCNAME( "CvMLData::get_test_sample_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+    __END__;
+
+    return test_sample_idx;
+}
+
+void CvMLData::mix_train_and_test_idx()
+{
+    CV_FUNCNAME( "CvMLData::mix_train_and_test_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+    __END__;
+
+    if ( !sample_idx)
+        return;
+
+    if ( train_sample_count > 0 && train_sample_count < values->rows )
+    {
+        int n = values->rows;
+        for (int i = 0; i < n; i++)
+        {
+            int a = (*rng)(n);
+            int b = (*rng)(n);
+            int t;
+            CV_SWAP( sample_idx[a], sample_idx[b], t );
+        }
+    }
+}
+
+const CvMat* CvMLData::get_var_idx()
+{
+     CV_FUNCNAME( "CvMLData::get_var_idx" );
+    __BEGIN__;
+
+    int avcount = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    assert( var_idx_mask );
+
+    avcount = cvFloor( cvNorm( var_idx_mask, 0, CV_L1 ) );
+    int* vidx;
+
+    if ( avcount == values->cols )
+        return 0;
+
+    if ( !var_idx_out || ( var_idx_out && var_idx_out->cols != avcount ) )
+    {
+        cvReleaseMat( &var_idx_out );
+        var_idx_out = cvCreateMat( 1, avcount, CV_32SC1);
+        if ( response_idx >=0 )
+            var_idx_mask->data.ptr[response_idx] = 0;
+    }
+
+    vidx = var_idx_out->data.i;
+
+    for(int i = 0; i < var_idx_mask->cols; i++)
+        if ( var_idx_mask->data.ptr[i] )
+        {
+            *vidx = i;
+            vidx++;
+        }
+
+    __END__;
+
+    return var_idx_out;
+}
+
+void CvMLData::chahge_var_idx( int vi, bool state )
+{
+    change_var_idx( vi, state );
+}
+
+void CvMLData::change_var_idx( int vi, bool state )
+{
+     CV_FUNCNAME( "CvMLData::change_var_idx" );
+    __BEGIN__;
+
+    int var_count = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    var_count = values->cols;
+
+    if ( vi < 0 || vi >= var_count)
+        CV_ERROR( CV_StsBadArg, "variable index is not correct" );
+
+    assert( var_idx_mask );
+    var_idx_mask->data.ptr[vi] = state;
+
+    __END__;
+}
+
+/* End of file. */

apps/traincascade/old_ml_precomp.hpp

@@ -0,0 +1,376 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/core.hpp"
+#include "old_ml.hpp"
+#include "opencv2/core/core_c.h"
+#include "opencv2/core/utility.hpp"
+
+#include "opencv2/core/private.hpp"
+
+#include <assert.h>
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#define ML_IMPL CV_IMPL
+#define __BEGIN__ __CV_BEGIN__
+#define __END__ __CV_END__
+#define EXIT __CV_EXIT__
+
+#define CV_MAT_ELEM_FLAG( mat, type, comp, vect, tflag )    \
+    (( tflag == CV_ROW_SAMPLE )                             \
+    ? (CV_MAT_ELEM( mat, type, comp, vect ))                \
+    : (CV_MAT_ELEM( mat, type, vect, comp )))
+
+/* Convert matrix to vector */
+#define ICV_MAT2VEC( mat, vdata, vstep, num )      \
+    if( MIN( (mat).rows, (mat).cols ) != 1 )       \
+        CV_ERROR( CV_StsBadArg, "" );              \
+    (vdata) = ((mat).data.ptr);                    \
+    if( (mat).rows == 1 )                          \
+    {                                              \
+        (vstep) = CV_ELEM_SIZE( (mat).type );      \
+        (num) = (mat).cols;                        \
+    }                                              \
+    else                                           \
+    {                                              \
+        (vstep) = (mat).step;                      \
+        (num) = (mat).rows;                        \
+    }
+
+/* get raw data */
+#define ICV_RAWDATA( mat, flags, rdata, sstep, cstep, m, n )         \
+    (rdata) = (mat).data.ptr;                                        \
+    if( CV_IS_ROW_SAMPLE( flags ) )                                  \
+    {                                                                \
+        (sstep) = (mat).step;                                        \
+        (cstep) = CV_ELEM_SIZE( (mat).type );                        \
+        (m) = (mat).rows;                                            \
+        (n) = (mat).cols;                                            \
+    }                                                                \
+    else                                                             \
+    {                                                                \
+        (cstep) = (mat).step;                                        \
+        (sstep) = CV_ELEM_SIZE( (mat).type );                        \
+        (n) = (mat).rows;                                            \
+        (m) = (mat).cols;                                            \
+    }
+
+#define ICV_IS_MAT_OF_TYPE( mat, mat_type) \
+    (CV_IS_MAT( mat ) && CV_MAT_TYPE( mat->type ) == (mat_type) &&   \
+    (mat)->cols > 0 && (mat)->rows > 0)
+
+/*
+    uchar* data; int sstep, cstep;      - trainData->data
+    uchar* classes; int clstep; int ncl;- trainClasses
+    uchar* tmask; int tmstep; int ntm;  - typeMask
+    uchar* missed;int msstep, mcstep;   -missedMeasurements...
+    int mm, mn;                         == m,n == size,dim
+    uchar* sidx;int sistep;             - sampleIdx
+    uchar* cidx;int cistep;             - compIdx
+    int k, l;                           == n,m == dim,size (length of cidx, sidx)
+    int m, n;                           == size,dim
+*/
+#define ICV_DECLARE_TRAIN_ARGS()                                                    \
+    uchar* data;                                                                    \
+    int sstep, cstep;                                                               \
+    uchar* classes;                                                                 \
+    int clstep;                                                                     \
+    int ncl;                                                                        \
+    uchar* tmask;                                                                   \
+    int tmstep;                                                                     \
+    int ntm;                                                                        \
+    uchar* missed;                                                                  \
+    int msstep, mcstep;                                                             \
+    int mm, mn;                                                                     \
+    uchar* sidx;                                                                    \
+    int sistep;                                                                     \
+    uchar* cidx;                                                                    \
+    int cistep;                                                                     \
+    int k, l;                                                                       \
+    int m, n;                                                                       \
+                                                                                    \
+    data = classes = tmask = missed = sidx = cidx = NULL;                           \
+    sstep = cstep = clstep = ncl = tmstep = ntm = msstep = mcstep = mm = mn = 0;    \
+    sistep = cistep = k = l = m = n = 0;
+
+#define ICV_TRAIN_DATA_REQUIRED( param, flags )                                     \
+    if( !ICV_IS_MAT_OF_TYPE( (param), CV_32FC1 ) )                                  \
+    {                                                                               \
+        CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );                   \
+    }                                                                               \
+    else                                                                            \
+    {                                                                               \
+        ICV_RAWDATA( *(param), (flags), data, sstep, cstep, m, n );                 \
+        k = n;                                                                      \
+        l = m;                                                                      \
+    }
+
+#define ICV_TRAIN_CLASSES_REQUIRED( param )                                         \
+    if( !ICV_IS_MAT_OF_TYPE( (param), CV_32FC1 ) )                                  \
+    {                                                                               \
+        CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );                   \
+    }                                                                               \
+    else                                                                            \
+    {                                                                               \
+        ICV_MAT2VEC( *(param), classes, clstep, ncl );                              \
+        if( m != ncl )                                                              \
+        {                                                                           \
+            CV_ERROR( CV_StsBadArg, "Unmatched sizes" );                            \
+        }                                                                           \
+    }
+
+#define ICV_ARG_NULL( param )                                                       \
+    if( (param) != NULL )                                                           \
+    {                                                                               \
+        CV_ERROR( CV_StsBadArg, #param " parameter must be NULL" );                 \
+    }
+
+#define ICV_MISSED_MEASUREMENTS_OPTIONAL( param, flags )                            \
+    if( param )                                                                     \
+    {                                                                               \
+        if( !ICV_IS_MAT_OF_TYPE( param, CV_8UC1 ) )                                 \
+        {                                                                           \
+            CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );               \
+        }                                                                           \
+        else                                                                        \
+        {                                                                           \
+            ICV_RAWDATA( *(param), (flags), missed, msstep, mcstep, mm, mn );       \
+            if( mm != m || mn != n )                                                \
+            {                                                                       \
+                CV_ERROR( CV_StsBadArg, "Unmatched sizes" );                        \
+            }                                                                       \
+        }                                                                           \
+    }
+
+#define ICV_COMP_IDX_OPTIONAL( param )                                              \
+    if( param )                                                                     \
+    {                                                                               \
+        if( !ICV_IS_MAT_OF_TYPE( param, CV_32SC1 ) )                                \
+        {                                                                           \
+            CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );               \
+        }                                                                           \
+        else                                                                        \
+        {                                                                           \
+            ICV_MAT2VEC( *(param), cidx, cistep, k );                               \
+            if( k > n )                                                             \
+                CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );           \
+        }                                                                           \
+    }
+
+#define ICV_SAMPLE_IDX_OPTIONAL( param )                                            \
+    if( param )                                                                     \
+    {                                                                               \
+        if( !ICV_IS_MAT_OF_TYPE( param, CV_32SC1 ) )                                \
+        {                                                                           \
+            CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );               \
+        }                                                                           \
+        else                                                                        \
+        {                                                                           \
+            ICV_MAT2VEC( *sampleIdx, sidx, sistep, l );                             \
+            if( l > m )                                                             \
+                CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );           \
+        }                                                                           \
+    }
+
+/****************************************************************************************/
+#define ICV_CONVERT_FLOAT_ARRAY_TO_MATRICE( array, matrice )        \
+{                                                                   \
+    CvMat a, b;                                                     \
+    int dims = (matrice)->cols;                                     \
+    int nsamples = (matrice)->rows;                                 \
+    int type = CV_MAT_TYPE((matrice)->type);                        \
+    int i, offset = dims;                                           \
+                                                                    \
+    CV_ASSERT( type == CV_32FC1 || type == CV_64FC1 );              \
+    offset *= ((type == CV_32FC1) ? sizeof(float) : sizeof(double));\
+                                                                    \
+    b = cvMat( 1, dims, CV_32FC1 );                                 \
+    cvGetRow( matrice, &a, 0 );                                     \
+    for( i = 0; i < nsamples; i++, a.data.ptr += offset )           \
+    {                                                               \
+        b.data.fl = (float*)array[i];                               \
+        CV_CALL( cvConvert( &b, &a ) );                             \
+    }                                                               \
+}
+
+/****************************************************************************************\
+*                       Auxiliary functions declarations                                 *
+\****************************************************************************************/
+
+/* Generates a set of classes centers in quantity <num_of_clusters> that are generated as
+   uniform random vectors in parallelepiped, where <data> is concentrated. Vectors in
+   <data> should have horizontal orientation. If <centers> != NULL, the function doesn't
+   allocate any memory and stores generated centers in <centers>, returns <centers>.
+   If <centers> == NULL, the function allocates memory and creates the matrice. Centers
+   are supposed to be oriented horizontally. */
+CvMat* icvGenerateRandomClusterCenters( int seed,
+                                        const CvMat* data,
+                                        int num_of_clusters,
+                                        CvMat* centers CV_DEFAULT(0));
+
+/* Fills the <labels> using <probs> by choosing the maximal probability. Outliers are
+   fixed by <oulier_tresh> and have cluster label (-1). Function also controls that there
+   weren't "empty" clusters by filling empty clusters with the maximal probability vector.
+   If probs_sums != NULL, filles it with the sums of probabilities for each sample (it is
+   useful for normalizing probabilities' matrice of FCM) */
+void icvFindClusterLabels( const CvMat* probs, float outlier_thresh, float r,
+                           const CvMat* labels );
+
+typedef struct CvSparseVecElem32f
+{
+    int idx;
+    float val;
+}
+CvSparseVecElem32f;
+
+/* Prepare training data and related parameters */
+#define CV_TRAIN_STATMODEL_DEFRAGMENT_TRAIN_DATA    1
+#define CV_TRAIN_STATMODEL_SAMPLES_AS_ROWS          2
+#define CV_TRAIN_STATMODEL_SAMPLES_AS_COLUMNS       4
+#define CV_TRAIN_STATMODEL_CATEGORICAL_RESPONSE     8
+#define CV_TRAIN_STATMODEL_ORDERED_RESPONSE         16
+#define CV_TRAIN_STATMODEL_RESPONSES_ON_OUTPUT      32
+#define CV_TRAIN_STATMODEL_ALWAYS_COPY_TRAIN_DATA   64
+#define CV_TRAIN_STATMODEL_SPARSE_AS_SPARSE         128
+
+int
+cvPrepareTrainData( const char* /*funcname*/,
+                    const CvMat* train_data, int tflag,
+                    const CvMat* responses, int response_type,
+                    const CvMat* var_idx,
+                    const CvMat* sample_idx,
+                    bool always_copy_data,
+                    const float*** out_train_samples,
+                    int* _sample_count,
+                    int* _var_count,
+                    int* _var_all,
+                    CvMat** out_responses,
+                    CvMat** out_response_map,
+                    CvMat** out_var_idx,
+                    CvMat** out_sample_idx=0 );
+
+void
+cvSortSamplesByClasses( const float** samples, const CvMat* classes,
+                        int* class_ranges, const uchar** mask CV_DEFAULT(0) );
+
+void
+cvCombineResponseMaps (CvMat*  _responses,
+                 const CvMat*  old_response_map,
+                       CvMat*  new_response_map,
+                       CvMat** out_response_map);
+
+void
+cvPreparePredictData( const CvArr* sample, int dims_all, const CvMat* comp_idx,
+                      int class_count, const CvMat* prob, float** row_sample,
+                      int as_sparse CV_DEFAULT(0) );
+
+/* copies clustering [or batch "predict"] results
+   (labels and/or centers and/or probs) back to the output arrays */
+void
+cvWritebackLabels( const CvMat* labels, CvMat* dst_labels,
+                   const CvMat* centers, CvMat* dst_centers,
+                   const CvMat* probs, CvMat* dst_probs,
+                   const CvMat* sample_idx, int samples_all,
+                   const CvMat* comp_idx, int dims_all );
+#define cvWritebackResponses cvWritebackLabels
+
+#define XML_FIELD_NAME "_name"
+CvFileNode* icvFileNodeGetChild(CvFileNode* father, const char* name);
+CvFileNode* icvFileNodeGetChildArrayElem(CvFileNode* father, const char* name,int index);
+CvFileNode* icvFileNodeGetNext(CvFileNode* n, const char* name);
+
+
+void cvCheckTrainData( const CvMat* train_data, int tflag,
+                       const CvMat* missing_mask,
+                       int* var_all, int* sample_all );
+
+CvMat* cvPreprocessIndexArray( const CvMat* idx_arr, int data_arr_size, bool check_for_duplicates=false );
+
+CvMat* cvPreprocessVarType( const CvMat* type_mask, const CvMat* var_idx,
+                            int var_all, int* response_type );
+
+CvMat* cvPreprocessOrderedResponses( const CvMat* responses,
+                const CvMat* sample_idx, int sample_all );
+
+CvMat* cvPreprocessCategoricalResponses( const CvMat* responses,
+                const CvMat* sample_idx, int sample_all,
+                CvMat** out_response_map, CvMat** class_counts=0 );
+
+const float** cvGetTrainSamples( const CvMat* train_data, int tflag,
+                   const CvMat* var_idx, const CvMat* sample_idx,
+                   int* _var_count, int* _sample_count,
+                   bool always_copy_data=false );
+
+namespace cv
+{
+    struct DTreeBestSplitFinder
+    {
+        DTreeBestSplitFinder(){ splitSize = 0, tree = 0; node = 0; }
+        DTreeBestSplitFinder( CvDTree* _tree, CvDTreeNode* _node);
+        DTreeBestSplitFinder( const DTreeBestSplitFinder& finder, Split );
+        virtual ~DTreeBestSplitFinder() {}
+        virtual void operator()(const BlockedRange& range);
+        void join( DTreeBestSplitFinder& rhs );
+        Ptr<CvDTreeSplit> bestSplit;
+        Ptr<CvDTreeSplit> split;
+        int splitSize;
+        CvDTree* tree;
+        CvDTreeNode* node;
+    };
+
+    struct ForestTreeBestSplitFinder : DTreeBestSplitFinder
+    {
+        ForestTreeBestSplitFinder() : DTreeBestSplitFinder() {}
+        ForestTreeBestSplitFinder( CvForestTree* _tree, CvDTreeNode* _node );
+        ForestTreeBestSplitFinder( const ForestTreeBestSplitFinder& finder, Split );
+        virtual void operator()(const BlockedRange& range);
+    };
+}
+
+#endif /* __ML_H__ */