OpenCV version++

2.4.13.3
Merge pull request #9266 from alalek:backport_9238
2026-07-21 19:33:03 +04:00 · 2017-07-31 15:57:29 +03:00 · 2017-07-30 14:38:06 +00:00 · 2017-07-30 14:14:08 +03:00 · 2017-07-30 14:11:10 +03:00 · 2017-07-24 11:40:51 +00:00
34 changed files with 640 additions and 305 deletions
@@ -7,3 +7,4 @@
 .sw[a-z]
 tags
 tegra/
+.cache
@@ -4,11 +4,16 @@
 #    From the off-tree build directory, invoke:
 #      $ cmake <PATH_TO_OPENCV_ROOT>
 #
-#
-#   - OCT-2008: Initial version <joseluisblancoc@gmail.com>
-#
 # ----------------------------------------------------------------------------

+# Disable in-source builds to prevent source tree corruption.
+if(" ${CMAKE_SOURCE_DIR}" STREQUAL " ${CMAKE_BINARY_DIR}")
+  message(FATAL_ERROR "
+FATAL: In-source builds are not allowed.
+       You should create separate directory for build files.
+")
+endif()
+
 set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)

 # Following block can broke build in case of cross-compilng
@@ -1094,13 +1099,6 @@ status("")

 ocv_finalize_status()

-# ----------------------------------------------------------------------------
-# Warn in the case of in-source build
-# ----------------------------------------------------------------------------
-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
 # ----------------------------------------------------------------------------
@@ -140,7 +140,7 @@ bool CvCascadeClassifier::train( const string _cascadeDirName,
                                double acceptanceRatioBreakValue)
 {
    // Start recording clock ticks for training time output
-    const clock_t begin_time = clock();
+    double time = (double)getTickCount();

    if( _cascadeDirName.empty() || _posFilename.empty() || _negFilename.empty() )
        CV_Error( CV_StsBadArg, "_cascadeDirName or _bgfileName or _vecFileName is NULL" );
@@ -268,7 +268,7 @@ bool CvCascadeClassifier::train( const string _cascadeDirName,
        fs << "}";

        // Output training time up till now
-        float seconds = float( clock () - begin_time ) / CLOCKS_PER_SEC;
+        double seconds = ( (double)getTickCount() - time)/ getTickFrequency();
        int days = int(seconds) / 60 / 60 / 24;
        int hours = (int(seconds) / 60 / 60) % 24;
        int minutes = (int(seconds) / 60) % 60;
@@ -246,7 +246,10 @@ if(CMAKE_COMPILER_IS_GNUCXX)
  endif()

  set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} -DNDEBUG")
-  set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -O0 -DDEBUG -D_DEBUG")
+  if(NOT " ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG} " MATCHES "-O")
+    set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -O0")
+  endif()
+  set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -DDEBUG -D_DEBUG")
 endif()

 if(MSVC)
@@ -81,7 +81,7 @@ if(MSVC)
    set(OpenCV_RUNTIME vc12)
  elseif(MSVC_VERSION EQUAL 1900)
    set(OpenCV_RUNTIME vc14)
-  elseif(MSVC_VERSION EQUAL 1910)
+  elseif(MSVC_VERSION EQUAL 1910 OR MSVC_VERSION EQUAL 1911)
    set(OpenCV_RUNTIME vc15)
  endif()
 elseif(MINGW)
@@ -138,7 +138,7 @@ if(MSVC)
    set(OpenCV_RUNTIME vc12)
  elseif(MSVC_VERSION EQUAL 1900)
    set(OpenCV_RUNTIME vc14)
-  elseif(MSVC_VERSION EQUAL 1910)
+  elseif(MSVC_VERSION EQUAL 1910 OR MSVC_VERSION EQUAL 1911)
    set(OpenCV_RUNTIME vc15)
  endif()
 elseif(MINGW)
@@ -213,6 +213,7 @@ if(WITH_FFMPEG)
      if(NOT __VALID_FFMPEG)
        #message(FATAL_ERROR "FFMPEG: test check build log:\n${TRY_OUT}")
        message(STATUS "WARNING: Can't build ffmpeg test code")
+        set(HAVE_FFMPEG FALSE)
      else()
        ocv_append_build_options(HIGHGUI FFMPEG)
      endif()
@@ -74,8 +74,8 @@ if(OpenCV_EXTRA_COMPONENTS)
      list(APPEND OpenCV_LIB_COMPONENTS_ "${extra_component}")
    elseif(extra_component MATCHES "[\\/]")
      get_filename_component(libdir "${extra_component}" PATH)
-      get_filename_component(libname "${extra_component}" NAME_WE)
-      string(REGEX REPLACE "^lib" "" libname "${libname}")
+      get_filename_component(libname "${extra_component}" NAME)
+      ocv_get_libname(libname "${libname}")
      list(APPEND OpenCV_LIB_COMPONENTS_ "-L${libdir}" "-l${libname}")
    else()
      list(APPEND OpenCV_LIB_COMPONENTS_ "-l${extra_component}")
@@ -170,6 +170,10 @@ macro(ocv_add_module _name)
      return() # extra protection from redefinition
    endif()
    project(${the_module})
+    add_definitions(
+        -D_USE_MATH_DEFINES  # M_PI constant in MSVS
+        -D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS  # to use C libraries from C++ code (ffmpeg)
+    )
  endif(OPENCV_INITIAL_PASS)
 endmacro()

@@ -69,6 +69,9 @@ MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
    FOREACH(item ${DIRINC})
        if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")
          LIST(APPEND ${_out_compile_flags} "${_PCH_include_prefix}\"${item}\"")
+        elseif(CMAKE_COMPILER_IS_GNUCXX AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0" AND
+               item MATCHES "/usr/include$")
+          # workaround for GCC 6.x bug
        else()
          LIST(APPEND ${_out_compile_flags} "${_PCH_isystem_prefix}\"${item}\"")
        endif()
@@ -78,6 +81,9 @@ MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
    FOREACH(item ${DIRINC})
        if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")
          LIST(APPEND ${_out_compile_flags} "${_PCH_include_prefix}\"${item}\"")
+        elseif(CMAKE_COMPILER_IS_GNUCXX AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0" AND
+               item MATCHES "/usr/include$")
+          # workaround for GCC 6.x bug
        else()
          LIST(APPEND ${_out_compile_flags} "${_PCH_isystem_prefix}\"${item}\"")
        endif()
@@ -749,6 +749,12 @@ function(ocv_source_group group)
  source_group(${group} FILES ${srcs})
 endfunction()

+macro(ocv_get_libname var_name)
+  get_filename_component(__libname "${ARGN}" NAME)
+  string(REGEX REPLACE "^lib(.+).(a|so)(.[.0-9]+)?$" "\\1" __libname "${__libname}")
+  set(${var_name} "${__libname}")
+endmacro()
+
 # build the list of simple dependencies, that links via "-l"
 #  _all_libs - name of variable with input list
 #  _simple - name of variable with output list of simple libs
@@ -1,3 +1,5 @@
+#define __STDC_CONSTANT_MACROS
+
 #include <stdlib.h>

 extern "C" {
@@ -81,4 +81,6 @@ Building OpenCV from Source Using CMake, Using the Command Line

 .. note::

+   Use ``cmake -DCMAKE_BUILD_TYPE=RELEASE -DCMAKE_INSTALL_PREFIX=/usr/local ..`` , without spaces after -D if step 2 do not work.
+
   If the size of the created library is a critical issue (like in case of an Android build) you can use the ``install/strip`` command to get the smallest size as possible. The *stripped* version appears to be twice as small. However, we do not recommend using this unless those extra megabytes do really matter.
@@ -483,11 +483,11 @@ Finds the positions of internal corners of the chessboard.

    :param flags: Various operation flags that can be zero or a combination of the following values:

-            * **CV_CALIB_CB_ADAPTIVE_THRESH** Use adaptive thresholding to convert the image to black and white, rather than a fixed threshold level (computed from the average image brightness).
+            * **CALIB_CB_ADAPTIVE_THRESH** Use adaptive thresholding to convert the image to black and white, rather than a fixed threshold level (computed from the average image brightness).

-            * **CV_CALIB_CB_NORMALIZE_IMAGE** Normalize the image gamma with  :ocv:func:`equalizeHist`  before applying fixed or adaptive thresholding.
+            * **CALIB_CB_NORMALIZE_IMAGE** Normalize the image gamma with  :ocv:func:`equalizeHist`  before applying fixed or adaptive thresholding.

-            * **CV_CALIB_CB_FILTER_QUADS** Use additional criteria (like contour area, perimeter, square-like shape) to filter out false quads extracted at the contour retrieval stage.
+            * **CALIB_CB_FILTER_QUADS** Use additional criteria (like contour area, perimeter, square-like shape) to filter out false quads extracted at the contour retrieval stage.

            * **CALIB_CB_FAST_CHECK** Run a fast check on the image that looks for chessboard corners, and shortcut the call if none is found. This can drastically speed up the call in the degenerate condition when no chessboard is observed.

@@ -329,7 +329,7 @@ TEST_F(fisheyeTest, Homography)
    EXPECT_MAT_NEAR(std_err, correct_std_err, 1e-12);
 }

-TEST_F(fisheyeTest, EtimateUncertainties)
+TEST_F(fisheyeTest, EstimateUncertainties)
 {
    const int n_images = 34;

@@ -203,11 +203,13 @@ cv::Affine3<T>::Affine3(const cv::Mat& data, const Vec3& t)
    {
        rotation(data(Rect(0, 0, 3, 3)));
        translation(data(Rect(3, 0, 1, 3)));
-        return;
+    }
+    else
+    {
+        rotation(data);
+        translation(t);
    }

-    rotation(data);
-    translation(t);
    matrix.val[12] = matrix.val[13] = matrix.val[14] = 0;
    matrix.val[15] = 1;
 }
@@ -407,7 +407,7 @@ public:
  The class is specialized for each fundamental numerical data type supported by OpenCV.
  It provides DataDepth<T>::value constant.
 */
-template<typename _Tp> class DataDepth {};
+template<typename _Tp> class DataDepth { public: enum { value = -1, fmt = 0 }; };

 template<> class DataDepth<bool> { public: enum { value = CV_8U, fmt=(int)'u' }; };
 template<> class DataDepth<uchar> { public: enum { value = CV_8U, fmt=(int)'u' }; };
@@ -880,8 +880,10 @@ public:


 typedef Point_<int> Point2i;
+typedef Point_<int64> Point2l;
 typedef Point2i Point;
 typedef Size_<int> Size2i;
+typedef Size_<int64> Size2l;
 typedef Size_<double> Size2d;
 typedef Size2i Size;
 typedef Rect_<int> Rect;
@@ -2711,6 +2713,7 @@ CV_EXPORTS_W void polylines(InputOutputArray img, InputArrayOfArrays pts,

 //! clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
 CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
+CV_EXPORTS bool clipLine(Size2l imgSize, CV_IN_OUT Point2l& pt1, CV_IN_OUT Point2l& pt2);

 //! clips the line segment by the rectangle imgRect
 CV_EXPORTS_W bool clipLine(Rect imgRect, CV_OUT CV_IN_OUT Point& pt1, CV_OUT CV_IN_OUT Point& pt2);
@@ -2748,6 +2751,9 @@ public:
 CV_EXPORTS_W void ellipse2Poly( Point center, Size axes, int angle,
                                int arcStart, int arcEnd, int delta,
                                CV_OUT vector<Point>& pts );
+CV_EXPORTS void ellipse2Poly( Point2d center, Size2d axes, int angle,
+                              int arcStart, int arcEnd, int delta,
+                              CV_OUT vector<Point2d>& pts );

 enum
 {
@@ -50,7 +50,7 @@
 #define CV_VERSION_EPOCH    2
 #define CV_VERSION_MAJOR    4
 #define CV_VERSION_MINOR    13
-#define CV_VERSION_REVISION 1
+#define CV_VERSION_REVISION 3

 #define CVAUX_STR_EXP(__A)  #__A
 #define CVAUX_STR(__A)      CVAUX_STR_EXP(__A)
@@ -51,12 +51,12 @@ struct PolyEdge
    //PolyEdge(int _y0, int _y1, int _x, int _dx) : y0(_y0), y1(_y1), x(_x), dx(_dx) {}

    int y0, y1;
-    int x, dx;
+    int64 x, dx;
    PolyEdge *next;
 };

 static void
-CollectPolyEdges( Mat& img, const Point* v, int npts,
+CollectPolyEdges( Mat& img, const Point2l* v, int npts,
                  vector<PolyEdge>& edges, const void* color, int line_type,
                  int shift, Point offset=Point() );

@@ -64,11 +64,11 @@ static void
 FillEdgeCollection( Mat& img, vector<PolyEdge>& edges, const void* color );

 static void
-PolyLine( Mat& img, const Point* v, int npts, bool closed,
+PolyLine( Mat& img, const Point2l* v, int npts, bool closed,
          const void* color, int thickness, int line_type, int shift );

 static void
-FillConvexPoly( Mat& img, const Point* v, int npts,
+FillConvexPoly( Mat& img, const Point2l* v, int npts,
                const void* color, int line_type, int shift );

 /****************************************************************************************\
@@ -77,14 +77,25 @@ FillConvexPoly( Mat& img, const Point* v, int npts,

 bool clipLine( Size img_size, Point& pt1, Point& pt2 )
 {
-    int64 x1, y1, x2, y2;
+    Point2l p1(pt1.x, pt1.y);
+    Point2l p2(pt2.x, pt2.y);
+    bool inside = clipLine(Size2l(img_size.width, img_size.height), p1, p2);
+    pt1.x = (int)p1.x;
+    pt1.y = (int)p1.y;
+    pt2.x = (int)p2.x;
+    pt2.y = (int)p2.y;
+    return inside;
+}
+
+bool clipLine( Size2l img_size, Point2l& pt1, Point2l& pt2 )
+{
    int c1, c2;
    int64 right = img_size.width-1, bottom = img_size.height-1;

    if( img_size.width <= 0 || img_size.height <= 0 )
        return false;

-    x1 = pt1.x; y1 = pt1.y; x2 = pt2.x; y2 = pt2.y;
+    int64 &x1 = pt1.x, &y1 = pt1.y, &x2 = pt2.x, &y2 = pt2.y;
    c1 = (x1 < 0) + (x1 > right) * 2 + (y1 < 0) * 4 + (y1 > bottom) * 8;
    c2 = (x2 < 0) + (x2 > right) * 2 + (y2 < 0) * 4 + (y2 > bottom) * 8;

@@ -124,11 +135,6 @@ bool clipLine( Size img_size, Point& pt1, Point& pt2 )
        }

        assert( (c1 & c2) != 0 || (x1 | y1 | x2 | y2) >= 0 );
-
-        pt1.x = (int)x1;
-        pt1.y = (int)y1;
-        pt2.x = (int)x2;
-        pt2.y = (int)y2;
    }

    return (c1 | c2) == 0;
@@ -279,25 +285,25 @@ static const int FilterTable[] = {
 };

 static void
-LineAA( Mat& img, Point pt1, Point pt2, const void* color )
+LineAA( Mat& img, Point2l pt1, Point2l pt2, const void* color )
 {
-    int dx, dy;
+    int64 dx, dy;
    int ecount, scount = 0;
    int slope;
-    int ax, ay;
-    int x_step, y_step;
-    int i, j;
+    int64 ax, ay;
+    int64 x_step, y_step;
+    int64 i, j;
    int ep_table[9];
    int cb = ((uchar*)color)[0], cg = ((uchar*)color)[1], cr = ((uchar*)color)[2], ca = ((uchar*)color)[3];
    int _cb, _cg, _cr, _ca;
    int nch = img.channels();
    uchar* ptr = img.data;
    size_t step = img.step;
-    Size size = img.size();
+    Size2l size(img.cols, img.rows);

    if( !((nch == 1 || nch == 3 || nch == 4) && img.depth() == CV_8U) )
    {
-        Line(img, pt1, pt2, color);
+        Line(img, Point((int)(pt1.x<<XY_SHIFT), (int)(pt1.y<<XY_SHIFT)), Point((int)(pt2.x<<XY_SHIFT), (int)(pt2.y<<XY_SHIFT)), color);
        return;
    }

@@ -333,11 +339,11 @@ LineAA( Mat& img, Point pt1, Point pt2, const void* color )
        pt1.y ^= pt2.y & j;

        x_step = XY_ONE;
-        y_step = (int) (((int64) dy << XY_SHIFT) / (ax | 1));
+        y_step = (dy << XY_SHIFT) / (ax | 1);
        pt2.x += XY_ONE;
-        ecount = (pt2.x >> XY_SHIFT) - (pt1.x >> XY_SHIFT);
+        ecount = (int)((pt2.x >> XY_SHIFT) - (pt1.x >> XY_SHIFT));
        j = -(pt1.x & (XY_ONE - 1));
-        pt1.y += (int) ((((int64) y_step) * j) >> XY_SHIFT) + (XY_ONE >> 1);
+        pt1.y += ((y_step * j) >> XY_SHIFT) + (XY_ONE >> 1);
        slope = (y_step >> (XY_SHIFT - 5)) & 0x3f;
        slope ^= (y_step < 0 ? 0x3f : 0);

@@ -356,12 +362,12 @@ LineAA( Mat& img, Point pt1, Point pt2, const void* color )
        pt2.y ^= pt1.y & i;
        pt1.y ^= pt2.y & i;

-        x_step = (int) (((int64) dx << XY_SHIFT) / (ay | 1));
+        x_step = (dx << XY_SHIFT) / (ay | 1);
        y_step = XY_ONE;
        pt2.y += XY_ONE;
-        ecount = (pt2.y >> XY_SHIFT) - (pt1.y >> XY_SHIFT);
+        ecount = (int)((pt2.y >> XY_SHIFT) - (pt1.y >> XY_SHIFT));
        j = -(pt1.y & (XY_ONE - 1));
-        pt1.x += (int) ((((int64) x_step) * j) >> XY_SHIFT) + (XY_ONE >> 1);
+        pt1.x += ((x_step * j) >> XY_SHIFT) + (XY_ONE >> 1);
        slope = (x_step >> (XY_SHIFT - 5)) & 0x3f;
        slope ^= (x_step < 0 ? 0x3f : 0);

@@ -375,8 +381,8 @@ LineAA( Mat& img, Point pt1, Point pt2, const void* color )
    /* Calc end point correction table */
    {
        int t0 = slope << 7;
-        int t1 = ((0x78 - i) | 4) * slope;
-        int t2 = (j | 4) * slope;
+        int t1 = ((0x78 - (int)i) | 4) * slope;
+        int t2 = ((int)j | 4) * slope;

        ep_table[0] = 0;
        ep_table[8] = slope;
@@ -630,23 +636,25 @@ LineAA( Mat& img, Point pt1, Point pt2, const void* color )


 static void
-Line2( Mat& img, Point pt1, Point pt2, const void* color )
+Line2( Mat& img, Point2l pt1, Point2l pt2, const void* color)
 {
-    int dx, dy;
+    int64 dx, dy;
    int ecount;
-    int ax, ay;
-    int i, j, x, y;
-    int x_step, y_step;
+    int64 ax, ay;
+    int64 i, j;
+    int x, y;
+    int64 x_step, y_step;
    int cb = ((uchar*)color)[0];
    int cg = ((uchar*)color)[1];
    int cr = ((uchar*)color)[2];
    int pix_size = (int)img.elemSize();
    uchar *ptr = img.data, *tptr;
    size_t step = img.step;
-    Size size = img.size(), sizeScaled(size.width*XY_ONE, size.height*XY_ONE);
+    Size size = img.size();

    //assert( img && (nch == 1 || nch == 3) && img.depth() == CV_8U );

+    Size2l sizeScaled(((int64)size.width) << XY_SHIFT, ((int64)size.height) << XY_SHIFT);
    if( !clipLine( sizeScaled, pt1, pt2 ))
        return;

@@ -670,8 +678,8 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
        pt1.y ^= pt2.y & j;

        x_step = XY_ONE;
-        y_step = (int) (((int64) dy << XY_SHIFT) / (ax | 1));
-        ecount = (pt2.x - pt1.x) >> XY_SHIFT;
+        y_step = (dy << XY_SHIFT) / (ax | 1);
+        ecount = (int)((pt2.x - pt1.x) >> XY_SHIFT);
    }
    else
    {
@@ -684,9 +692,9 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
        pt2.y ^= pt1.y & i;
        pt1.y ^= pt2.y & i;

-        x_step = (int) (((int64) dx << XY_SHIFT) / (ay | 1));
+        x_step = (dx << XY_SHIFT) / (ay | 1);
        y_step = XY_ONE;
-        ecount = (pt2.y - pt1.y) >> XY_SHIFT;
+        ecount = (int)((pt2.y - pt1.y) >> XY_SHIFT);
    }

    pt1.x += (XY_ONE >> 1);
@@ -705,8 +713,8 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
            tptr[2] = (uchar)cr;        \
        }

-        ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT,
-                      (pt2.y + (XY_ONE >> 1)) >> XY_SHIFT);
+        ICV_PUT_POINT((int)((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT),
+                      (int)((pt2.y + (XY_ONE >> 1)) >> XY_SHIFT));

        if( ax > ay )
        {
@@ -714,7 +722,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )

            while( ecount >= 0 )
            {
-                ICV_PUT_POINT(pt1.x, pt1.y >> XY_SHIFT);
+                ICV_PUT_POINT((int)(pt1.x), (int)(pt1.y >> XY_SHIFT));
                pt1.x++;
                pt1.y += y_step;
                ecount--;
@@ -726,7 +734,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )

            while( ecount >= 0 )
            {
-                ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y);
+                ICV_PUT_POINT((int)(pt1.x >> XY_SHIFT), (int)(pt1.y));
                pt1.x += x_step;
                pt1.y++;
                ecount--;
@@ -746,8 +754,8 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
            tptr[0] = (uchar)cb;    \
        }

-        ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT,
-                      (pt2.y + (XY_ONE >> 1)) >> XY_SHIFT);
+        ICV_PUT_POINT((int)((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT),
+                      (int)((pt2.y + (XY_ONE >> 1)) >> XY_SHIFT));

        if( ax > ay )
        {
@@ -755,7 +763,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )

            while( ecount >= 0 )
            {
-                ICV_PUT_POINT(pt1.x, pt1.y >> XY_SHIFT);
+                ICV_PUT_POINT((int)(pt1.x), (int)(pt1.y >> XY_SHIFT));
                pt1.x++;
                pt1.y += y_step;
                ecount--;
@@ -767,7 +775,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )

            while( ecount >= 0 )
            {
-                ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y);
+                ICV_PUT_POINT((int)(pt1.x >> XY_SHIFT), (int)(pt1.y));
                pt1.x += x_step;
                pt1.y++;
                ecount--;
@@ -788,8 +796,8 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
                tptr[j] = ((uchar*)color)[j]; \
        }

-        ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT,
-                      (pt2.y + (XY_ONE >> 1)) >> XY_SHIFT);
+        ICV_PUT_POINT((int)((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT),
+                      (int)((pt2.y + (XY_ONE >> 1)) >> XY_SHIFT));

        if( ax > ay )
        {
@@ -797,7 +805,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )

            while( ecount >= 0 )
            {
-                ICV_PUT_POINT(pt1.x, pt1.y >> XY_SHIFT);
+                ICV_PUT_POINT((int)(pt1.x), (int)(pt1.y >> XY_SHIFT));
                pt1.x++;
                pt1.y += y_step;
                ecount--;
@@ -809,7 +817,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )

            while( ecount >= 0 )
            {
-                ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y);
+                ICV_PUT_POINT((int)(pt1.x >> XY_SHIFT), (int)(pt1.y));
                pt1.x += x_step;
                pt1.y++;
                ecount--;
@@ -917,13 +925,35 @@ sincos( int angle, float& cosval, float& sinval )
   constructs polygon that represents elliptic arc.
 */
 void ellipse2Poly( Point center, Size axes, int angle,
+                   int arcStart, int arcEnd,
+                   int delta, CV_OUT std::vector<Point>& pts )
+{
+    vector<Point2d> _pts;
+    ellipse2Poly(Point2d(center.x, center.y), Size2d(axes.width, axes.height), angle,
+                 arcStart, arcEnd, delta, _pts);
+    Point prevPt(INT_MIN, INT_MIN);
+    pts.resize(0);
+    for (unsigned int i = 0; i < _pts.size(); ++i)
+    {
+        Point pt;
+        pt.x = cvRound(_pts[i].x);
+        pt.y = cvRound(_pts[i].y);
+        if (pt != prevPt) {
+            pts.push_back(pt);
+            prevPt = pt;
+        }
+    }
+
+    // If there are no points, it's a zero-size polygon
+    if( pts.size() == 1 )
+        pts.push_back(pts[0]);
+}
+
+void ellipse2Poly( Point2d center, Size2d axes, int angle,
                   int arc_start, int arc_end,
-                   int delta, vector<Point>& pts )
+                   int delta, vector<Point2d>& pts )
 {
    float alpha, beta;
-    double size_a = axes.width, size_b = axes.height;
-    double cx = center.x, cy = center.y;
-    Point prevPt(INT_MIN,INT_MIN);
    int i;

    while( angle < 0 )
@@ -964,15 +994,12 @@ void ellipse2Poly( Point center, Size axes, int angle,
        if( angle < 0 )
            angle += 360;

-        x = size_a * SinTable[450-angle];
-        y = size_b * SinTable[angle];
-        Point pt;
-        pt.x = cvRound( cx + x * alpha - y * beta );
-        pt.y = cvRound( cy + x * beta + y * alpha );
-        if( pt != prevPt ){
-            pts.push_back(pt);
-            prevPt = pt;
-        }
+        x = axes.width * SinTable[450-angle];
+        y = axes.height * SinTable[angle];
+        Point2d pt;
+        pt.x = center.x + x * alpha - y * beta;
+        pt.y = center.y + x * beta + y * alpha;
+        pts.push_back(pt);
    }

    if( pts.size() == 1 )
@@ -981,16 +1008,37 @@ void ellipse2Poly( Point center, Size axes, int angle,


 static void
-EllipseEx( Mat& img, Point center, Size axes,
+EllipseEx( Mat& img, Point2l center, Size2l axes,
           int angle, int arc_start, int arc_end,
           const void* color, int thickness, int line_type )
 {
    axes.width = std::abs(axes.width), axes.height = std::abs(axes.height);
-    int delta = (std::max(axes.width,axes.height)+(XY_ONE>>1))>>XY_SHIFT;
+    int delta = (int)((std::max(axes.width,axes.height)+(XY_ONE>>1))>>XY_SHIFT);
    delta = delta < 3 ? 90 : delta < 10 ? 30 : delta < 15 ? 18 : 5;

-    vector<Point> v;
-    ellipse2Poly( center, axes, angle, arc_start, arc_end, delta, v );
+    vector<Point2d> _v;
+    ellipse2Poly( Point2d((double)center.x, (double)center.y), Size2d((double)axes.width, (double)axes.height), angle, arc_start, arc_end, delta, _v );
+
+    vector<Point2l> v;
+    Point2l prevPt(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
+    v.resize(0);
+    for (unsigned int i = 0; i < _v.size(); ++i)
+    {
+        Point2l pt;
+        pt.x = (int64)cvRound(_v[i].x / XY_ONE) << XY_SHIFT;
+        pt.y = (int64)cvRound(_v[i].y / XY_ONE) << XY_SHIFT;
+        pt.x += cvRound(_v[i].x - pt.x);
+        pt.y += cvRound(_v[i].y - pt.y);
+        if (pt != prevPt) {
+            v.push_back(pt);
+            prevPt = pt;
+        }
+    }
+
+    // If there are no points, it's a zero-size polygon
+    if (v.size() == 1) {
+        v.assign(2, center);
+    }

    if( thickness >= 0 )
        PolyLine( img, &v[0], (int)v.size(), false, color, thickness, line_type, XY_SHIFT );
@@ -1029,23 +1077,24 @@ EllipseEx( Mat& img, Point center, Size axes,

 /* filling convex polygon. v - array of vertices, ntps - number of points */
 static void
-FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_type, int shift )
+FillConvexPoly( Mat& img, const Point2l* v, int npts, const void* color, int line_type, int shift )
 {
    struct
    {
        int idx, di;
-        int x, dx, ye;
+        int64 x, dx;
+        int ye;
    }
    edge[2];

-    int delta = shift ? 1 << (shift - 1) : 0;
-    int i, y, imin = 0, left = 0, right = 1, x1, x2;
+    int delta = 1 << shift >> 1;
+    int i, y, imin = 0, left = 0, right = 1;
    int edges = npts;
-    int xmin, xmax, ymin, ymax;
+    int64 xmin, xmax, ymin, ymax;
    uchar* ptr = img.data;
    Size size = img.size();
    int pix_size = (int)img.elemSize();
-    Point p0;
+    Point2l p0;
    int delta1, delta2;

    if( line_type < CV_AA )
@@ -1063,7 +1112,7 @@ FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_

    for( i = 0; i < npts; i++ )
    {
-        Point p = v[i];
+        Point2l p = v[i];
        if( p.y < ymin )
        {
            ymin = p.y;
@@ -1082,10 +1131,10 @@ FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_
            if( shift == 0 )
            {
                Point pt0, pt1;
-                pt0.x = p0.x >> XY_SHIFT;
-                pt0.y = p0.y >> XY_SHIFT;
-                pt1.x = p.x >> XY_SHIFT;
-                pt1.y = p.y >> XY_SHIFT;
+                pt0.x = (int)(p0.x >> XY_SHIFT);
+                pt0.y = (int)(p0.y >> XY_SHIFT);
+                pt1.x = (int)(p.x >> XY_SHIFT);
+                pt1.y = (int)(p.y >> XY_SHIFT);
                Line( img, pt0, pt1, color, line_type );
            }
            else
@@ -1101,13 +1150,13 @@ FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_
    ymin = (ymin + delta) >> shift;
    ymax = (ymax + delta) >> shift;

-    if( npts < 3 || xmax < 0 || ymax < 0 || xmin >= size.width || ymin >= size.height )
+    if( npts < 3 || (int)xmax < 0 || (int)ymax < 0 || (int)xmin >= size.width || (int)ymin >= size.height )
        return;

    ymax = MIN( ymax, size.height - 1 );
    edge[0].idx = edge[1].idx = imin;

-    edge[0].ye = edge[1].ye = y = ymin;
+    edge[0].ye = edge[1].ye = y = (int)ymin;
    edge[0].di = 1;
    edge[1].di = npts - 1;

@@ -1115,18 +1164,19 @@ FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_

    do
    {
-        if( line_type < CV_AA || y < ymax || y == ymin )
+        if( line_type < CV_AA || y < (int)ymax || y == (int)ymin )
        {
            for( i = 0; i < 2; i++ )
            {
                if( y >= edge[i].ye )
                {
                    int idx = edge[i].idx, di = edge[i].di;
-                    int xs = 0, xe, ye, ty = 0;
+                    int64 xs = 0, xe;
+                    int ty = 0;

                    for(;;)
                    {
-                        ty = (v[idx].y + delta) >> shift;
+                        ty = (int)((v[idx].y + delta) >> shift);
                        if( ty > y || edges == 0 )
                            break;
                        xs = v[idx].x;
@@ -1135,16 +1185,19 @@ FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_
                        edges--;
                    }

-                    ye = ty;
-                    xs <<= XY_SHIFT - shift;
-                    xe = v[idx].x << (XY_SHIFT - shift);
+                    xe = v[idx].x;
+                    if (XY_SHIFT - shift != 0)
+                    {
+                        xs <<= XY_SHIFT - shift;
+                        xe <<= XY_SHIFT - shift;
+                    }

                    /* no more edges */
-                    if( y >= ye )
+                    if( y >= ty)
                        return;

-                    edge[i].ye = ye;
-                    edge[i].dx = ((xe - xs)*2 + (ye - y)) / (2 * (ye - y));
+                    edge[i].ye = ty;
+                    edge[i].dx = ((xe - xs)*2 + (ty - y)) / (2 * (ty - y));
                    edge[i].x = xs;
                    edge[i].idx = idx;
                }
@@ -1157,13 +1210,10 @@ FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_
            right ^= 1;
        }

-        x1 = edge[left].x;
-        x2 = edge[right].x;
-
        if( y >= 0 )
        {
-            int xx1 = (x1 + delta1) >> XY_SHIFT;
-            int xx2 = (x2 + delta2) >> XY_SHIFT;
+            int xx1 = (int)((edge[left].x + delta1) >> XY_SHIFT);
+            int xx2 = (int)((edge[right].x + delta2) >> XY_SHIFT);

            if( xx2 >= 0 && xx1 < size.width )
            {
@@ -1175,25 +1225,22 @@ FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_
            }
        }

-        x1 += edge[left].dx;
-        x2 += edge[right].dx;
-
-        edge[left].x = x1;
-        edge[right].x = x2;
+        edge[left].x += edge[left].dx;
+        edge[right].x += edge[right].dx;
        ptr += img.step;
    }
-    while( ++y <= ymax );
+    while( ++y <= (int)ymax );
 }


 /******** Arbitrary polygon **********/

 static void
-CollectPolyEdges( Mat& img, const Point* v, int count, vector<PolyEdge>& edges,
+CollectPolyEdges( Mat& img, const Point2l* v, int count, vector<PolyEdge>& edges,
                  const void* color, int line_type, int shift, Point offset )
 {
-    int i, delta = offset.y + (shift ? 1 << (shift - 1) : 0);
-    Point pt0 = v[count-1], pt1;
+    int i, delta = offset.y + ((1 << shift) >> 1);
+    Point2l pt0 = v[count-1], pt1;
    pt0.x = (pt0.x + offset.x) << (XY_SHIFT - shift);
    pt0.y = (pt0.y + delta) >> shift;

@@ -1201,7 +1248,7 @@ CollectPolyEdges( Mat& img, const Point* v, int count, vector<PolyEdge>& edges,

    for( i = 0; i < count; i++, pt0 = pt1 )
    {
-        Point t0, t1;
+        Point2l t0, t1;
        PolyEdge edge;

        pt1 = v[i];
@@ -1213,7 +1260,7 @@ CollectPolyEdges( Mat& img, const Point* v, int count, vector<PolyEdge>& edges,
            t0.y = pt0.y; t1.y = pt1.y;
            t0.x = (pt0.x + (XY_ONE >> 1)) >> XY_SHIFT;
            t1.x = (pt1.x + (XY_ONE >> 1)) >> XY_SHIFT;
-            Line( img, t0, t1, color, line_type );
+            Line( img, Point((int)(t0.x), (int)(t0.y)), Point((int)(t1.x), (int)(t1.y)), color, line_type );
        }
        else
        {
@@ -1228,14 +1275,14 @@ CollectPolyEdges( Mat& img, const Point* v, int count, vector<PolyEdge>& edges,

        if( pt0.y < pt1.y )
        {
-            edge.y0 = pt0.y;
-            edge.y1 = pt1.y;
+            edge.y0 = (int)(pt0.y);
+            edge.y1 = (int)(pt1.y);
            edge.x = pt0.x;
        }
        else
        {
-            edge.y0 = pt1.y;
-            edge.y1 = pt0.y;
+            edge.y0 = (int)(pt1.y);
+            edge.y1 = (int)(pt0.y);
            edge.x = pt1.x;
        }
        edge.dx = (pt1.x - pt0.x) / (pt1.y - pt0.y);
@@ -1261,7 +1308,8 @@ FillEdgeCollection( Mat& img, vector<PolyEdge>& edges, const void* color )
    int i, y, total = (int)edges.size();
    Size size = img.size();
    PolyEdge* e;
-    int y_max = INT_MIN, x_max = INT_MIN, y_min = INT_MAX, x_min = INT_MAX;
+    int y_max = INT_MIN, y_min = INT_MAX;
+    int64 x_max = 0xFFFFFFFFFFFFFFFF, x_min = 0x7FFFFFFFFFFFFFFF;
    int pix_size = (int)img.elemSize();

    if( total < 2 )
@@ -1273,7 +1321,7 @@ FillEdgeCollection( Mat& img, vector<PolyEdge>& edges, const void* color )
        assert( e1.y0 < e1.y1 );
        // Determine x-coordinate of the end of the edge.
        // (This is not necessary x-coordinate of any vertex in the array.)
-        int x1 = e1.x + (e1.y1 - e1.y0) * e1.dx;
+        int64 x1 = e1.x + (e1.y1 - e1.y0) * e1.dx;
        y_min = std::min( y_min, e1.y0 );
        y_max = std::max( y_max, e1.y1 );
        x_min = std::min( x_min, e1.x );
@@ -1282,7 +1330,7 @@ FillEdgeCollection( Mat& img, vector<PolyEdge>& edges, const void* color )
        x_max = std::max( x_max, x1 );
    }

-    if( y_max < 0 || y_min >= size.height || x_max < 0 || x_min >= (size.width<<XY_SHIFT) )
+    if( y_max < 0 || y_min >= size.height || x_max < 0 || x_min >= ((int64)size.width<<XY_SHIFT) )
        return;

    std::sort( edges.begin(), edges.end(), CmpEdges() );
@@ -1338,19 +1386,18 @@ FillEdgeCollection( Mat& img, vector<PolyEdge>& edges, const void* color )
                {
                    // convert x's from fixed-point to image coordinates
                    uchar *timg = img.data + y * img.step;
-                    int x1 = keep_prelast->x;
-                    int x2 = prelast->x;
+                    int x1, x2;

-                    if( x1 > x2 )
+                    if (keep_prelast->x > prelast->x)
                    {
-                        int t = x1;
-
-                        x1 = x2;
-                        x2 = t;
+                        x1 = (int)((prelast->x + XY_ONE - 1) >> XY_SHIFT);
+                        x2 = (int)(keep_prelast->x >> XY_SHIFT);
+                    }
+                    else
+                    {
+                        x1 = (int)((keep_prelast->x + XY_ONE - 1) >> XY_SHIFT);
+                        x2 = (int)(prelast->x >> XY_SHIFT);
                    }
-
-                    x1 = (x1 + XY_ONE - 1) >> XY_SHIFT;
-                    x2 = x2 >> XY_SHIFT;

                    // clip and draw the line
                    if( x1 < size.width && x2 >= 0 )
@@ -1550,7 +1597,7 @@ Circle( Mat& img, Point center, int radius, const void* color, int fill )


 static void
-ThickLine( Mat& img, Point p0, Point p1, const void* color,
+ThickLine( Mat& img, Point2l p0, Point2l p1, const void* color,
           int thickness, int line_type, int flags, int shift )
 {
    static const double INV_XY_ONE = 1./XY_ONE;
@@ -1570,7 +1617,7 @@ ThickLine( Mat& img, Point p0, Point p1, const void* color,
                p0.y = (p0.y + (XY_ONE>>1)) >> XY_SHIFT;
                p1.x = (p1.x + (XY_ONE>>1)) >> XY_SHIFT;
                p1.y = (p1.y + (XY_ONE>>1)) >> XY_SHIFT;
-                Line( img, p0, p1, color, line_type );
+                Line( img, Point((int)(p0.x), (int)(p0.y)), Point((int)(p1.x), (int)(p1.y)), color, line_type );
            }
            else
                Line2( img, p0, p1, color );
@@ -1580,7 +1627,7 @@ ThickLine( Mat& img, Point p0, Point p1, const void* color,
    }
    else
    {
-        Point pt[4], dp = Point(0,0);
+        Point2l pt[4], dp = Point2l(0,0);
        double dx = (p0.x - p1.x)*INV_XY_ONE, dy = (p1.y - p0.y)*INV_XY_ONE;
        double r = dx * dx + dy * dy;
        int i, oddThickness = thickness & 1;
@@ -1611,13 +1658,13 @@ ThickLine( Mat& img, Point p0, Point p1, const void* color,
                if( line_type < CV_AA )
                {
                    Point center;
-                    center.x = (p0.x + (XY_ONE>>1)) >> XY_SHIFT;
-                    center.y = (p0.y + (XY_ONE>>1)) >> XY_SHIFT;
+                    center.x = (int)((p0.x + (XY_ONE>>1)) >> XY_SHIFT);
+                    center.y = (int)((p0.y + (XY_ONE>>1)) >> XY_SHIFT);
                    Circle( img, center, (thickness + (XY_ONE>>1)) >> XY_SHIFT, color, 1 );
                }
                else
                {
-                    EllipseEx( img, p0, cvSize(thickness, thickness),
+                    EllipseEx( img, p0, Size2l(thickness, thickness),
                               0, 0, 360, color, -1, line_type );
                }
            }
@@ -1628,7 +1675,7 @@ ThickLine( Mat& img, Point p0, Point p1, const void* color,


 static void
-PolyLine( Mat& img, const Point* v, int count, bool is_closed,
+PolyLine( Mat& img, const Point2l* v, int count, bool is_closed,
          const void* color, int thickness,
          int line_type, int shift )
 {
@@ -1637,13 +1684,13 @@ PolyLine( Mat& img, const Point* v, int count, bool is_closed,

    int i = is_closed ? count - 1 : 0;
    int flags = 2 + !is_closed;
-    Point p0;
+    Point2l p0;
    CV_Assert( 0 <= shift && shift <= XY_SHIFT && thickness >= 0 );

    p0 = v[i];
    for( i = !is_closed; i < count; i++ )
    {
-        Point p = v[i];
+        Point2l p = v[i];
        ThickLine( img, p0, p, color, thickness, line_type, flags, shift );
        p0 = p;
        flags = 2;
@@ -1700,7 +1747,7 @@ void rectangle( Mat& img, Point pt1, Point pt2,
    double buf[4];
    scalarToRawData(color, buf, img.type(), 0);

-    Point pt[4];
+    Point2l pt[4];

    pt[0] = pt1;
    pt[1].x = pt2.x;
@@ -1741,10 +1788,12 @@ void circle( Mat& img, Point center, int radius,

    if( thickness > 1 || line_type >= CV_AA || shift > 0 )
    {
-        center.x <<= XY_SHIFT - shift;
-        center.y <<= XY_SHIFT - shift;
-        radius <<= XY_SHIFT - shift;
-        EllipseEx( img, center, Size(radius, radius),
+        Point2l _center(center.x, center.y);
+        int64 _radius(radius);
+        _center.x <<= XY_SHIFT - shift;
+        _center.y <<= XY_SHIFT - shift;
+        _radius <<= XY_SHIFT - shift;
+        EllipseEx( img, _center, Size2l(_radius, _radius),
                   0, 0, 360, buf, thickness, line_type );
    }
    else
@@ -1768,12 +1817,14 @@ void ellipse( Mat& img, Point center, Size axes,
    int _angle = cvRound(angle);
    int _start_angle = cvRound(start_angle);
    int _end_angle = cvRound(end_angle);
-    center.x <<= XY_SHIFT - shift;
-    center.y <<= XY_SHIFT - shift;
-    axes.width <<= XY_SHIFT - shift;
-    axes.height <<= XY_SHIFT - shift;
+    Point2l _center(center.x, center.y);
+    Size2l _axes(axes.width, axes.height);
+    _center.x <<= XY_SHIFT - shift;
+    _center.y <<= XY_SHIFT - shift;
+    _axes.width <<= XY_SHIFT - shift;
+    _axes.height <<= XY_SHIFT - shift;

-    EllipseEx( img, center, axes, _angle, _start_angle,
+    EllipseEx( img, _center, _axes, _angle, _start_angle,
               _end_angle, buf, thickness, line_type );
 }

@@ -1790,10 +1841,14 @@ void ellipse(Mat& img, const RotatedRect& box, const Scalar& color,
    scalarToRawData(color, buf, img.type(), 0);

    int _angle = cvRound(box.angle);
-    Point center(cvRound(box.center.x*(1 << XY_SHIFT)),
-                 cvRound(box.center.y*(1 << XY_SHIFT)));
-    Size axes(cvRound(box.size.width*(1 << (XY_SHIFT - 1))),
-              cvRound(box.size.height*(1 << (XY_SHIFT - 1))));
+    Point2l center(cvRound(box.center.x),
+                 cvRound(box.center.y));
+    center.x = (center.x << XY_SHIFT) + cvRound((box.center.x - center.x)*XY_ONE);
+    center.y = (center.y << XY_SHIFT) + cvRound((box.center.y - center.y)*XY_ONE);
+    Size2l axes(cvRound(box.size.width),
+              cvRound(box.size.height));
+    axes.width  = (axes.width  << (XY_SHIFT - 1)) + cvRound((box.size.width - axes.width)*(XY_ONE>>1));
+    axes.height = (axes.height << (XY_SHIFT - 1)) + cvRound((box.size.height - axes.height)*(XY_ONE>>1));
    EllipseEx( img, center, axes, _angle, 0, 360, buf, thickness, lineType );
 }

@@ -1876,7 +1931,10 @@ void fillConvexPoly( Mat& img, const Point* pts, int npts,
    double buf[4];
    CV_Assert( 0 <= shift && shift <=  XY_SHIFT );
    scalarToRawData(color, buf, img.type(), 0);
-    FillConvexPoly( img, pts, npts, buf, line_type, shift );
+    vector<Point2l> _pts;
+    for( int n = 0; n < npts; n++ )
+        _pts.push_back(Point2l(pts[n].x, pts[n].y));
+    FillConvexPoly( img, _pts.data(), npts, buf, line_type, shift );
 }


@@ -1900,7 +1958,12 @@ void fillPoly( Mat& img, const Point** pts, const int* npts, int ncontours,

    edges.reserve( total + 1 );
    for( i = 0; i < ncontours; i++ )
-        CollectPolyEdges( img, pts[i], npts[i], edges, buf, line_type, shift, offset );
+    {
+        vector<Point2l> _pts;
+        for( int n = 0; n < npts[i]; n++ )
+            _pts.push_back(Point2l(pts[i][n].x, pts[i][n].y));
+        CollectPolyEdges( img, _pts.data(), npts[i], edges, buf, line_type, shift, offset );
+    }

    FillEdgeCollection(img, edges, buf);
 }
@@ -1920,7 +1983,12 @@ void polylines( Mat& img, const Point** pts, const int* npts, int ncontours, boo
    scalarToRawData( color, buf, img.type(), 0 );

    for( int i = 0; i < ncontours; i++ )
-        PolyLine( img, pts[i], npts[i], isClosed, buf, thickness, line_type, shift );
+    {
+        vector<Point2l> _pts;
+        for( int n = 0; n < npts[i]; n++ )
+            _pts.push_back(Point2l(pts[i][n].x, pts[i][n].y));
+        PolyLine( img, _pts.data(), npts[i], isClosed, buf, thickness, line_type, shift );
+    }
 }


@@ -2156,23 +2224,23 @@ void putText( Mat& img, const string& text, Point org,
    if( bottomLeftOrigin )
        vscale = -vscale;

-    int view_x = org.x << XY_SHIFT;
-    int view_y = (org.y << XY_SHIFT) + base_line*vscale;
-    vector<Point> pts;
+    int64 view_x = (int64)org.x << XY_SHIFT;
+    int64 view_y = ((int64)org.y << XY_SHIFT) + base_line*vscale;
+    vector<Point2l> pts;
    pts.reserve(1 << 10);
    const char **faces = cv::g_HersheyGlyphs;

    for( int i = 0; i < (int)text.size(); i++ )
    {
        int c = (uchar)text[i];
-        Point p;
+        Point2l p;

        readCheck(c, i, text, fontFace);

        const char* ptr = faces[ascii[(c-' ')+1]];
        p.x = (uchar)ptr[0] - 'R';
        p.y = (uchar)ptr[1] - 'R';
-        int dx = p.y*hscale;
+        int64 dx = p.y*hscale;
        view_x -= p.x*hscale;
        pts.resize(0);

@@ -2191,7 +2259,7 @@ void putText( Mat& img, const string& text, Point org,
                p.x = (uchar)ptr[0] - 'R';
                p.y = (uchar)ptr[1] - 'R';
                ptr += 2;
-                pts.push_back(Point(p.x*hscale + view_x, p.y*vscale + view_y));
+                pts.push_back(Point2l(p.x*hscale + view_x, p.y*vscale + view_y));
            }
        }
        view_x += dx;
@@ -2310,7 +2378,7 @@ cvDrawContours( void* _img, CvSeq* contour,
    CvSeq *contour0 = contour, *h_next = 0;
    CvTreeNodeIterator iterator;
    cv::vector<cv::PolyEdge> edges;
-    cv::vector<cv::Point> pts;
+    cv::vector<cv::Point2l> pts;
    cv::Scalar externalColor = _externalColor, holeColor = _holeColor;
    cv::Mat img = cv::cvarrToMat(_img);
    cv::Point offset = _offset;
@@ -2434,7 +2502,7 @@ cvEllipse2Poly( CvPoint center, CvSize axes, int angle,
                int arc_start, int arc_end, CvPoint* _pts, int delta )
 {
    cv::vector<cv::Point> pts;
-    cv::ellipse2Poly( center, axes, angle, arc_start, arc_end, delta, pts );
+    cv::ellipse2Poly( cv::Point(center), cv::Size(axes), angle, arc_start, arc_end, delta, pts );
    memcpy( _pts, &pts[0], pts.size()*sizeof(_pts[0]) );
    return (int)pts.size();
 }
@@ -56,7 +56,7 @@
    #include <sys/types.h>
    #if defined ANDROID
        #include <sys/sysconf.h>
-    #else
+    #elif defined __APPLE__
        #include <sys/sysctl.h>
    #endif
 #endif
@@ -163,8 +163,6 @@ std::wstring GetTempFileNameWinRT(std::wstring prefix)
 #include <sys/types.h>
 #if defined ANDROID
 #include <sys/sysconf.h>
-#else
-#include <sys/sysctl.h>
 #endif
 #endif

@@ -146,6 +146,7 @@ public:
     */
    LshTable()
    {
+        feature_size_ = 0;
    }

    /** Default constructor
@@ -156,7 +157,7 @@ public:
     */
    LshTable(unsigned int feature_size, unsigned int key_size, std::vector<size_t> & indices)
    {
-        (void)feature_size;
+        feature_size_ = feature_size;
        (void)key_size;
        (void)indices;
        std::cerr << "LSH is not implemented for that type" << std::endl;
@@ -335,6 +336,8 @@ private:
     */
    unsigned int key_size_;

+    unsigned int feature_size_;
+
    // Members only used for the unsigned char specialization
    /** The mask to apply to a feature to get the hash key
     * Only used in the unsigned char case
@@ -350,9 +353,10 @@ inline LshTable<unsigned char>::LshTable( unsigned int feature_size,
                                          unsigned int subsignature_size,
                                          std::vector<size_t> & indices  )
 {
+    feature_size_ = feature_size;
    initialize(subsignature_size);
    // Allocate the mask
-    mask_ = std::vector<size_t>((size_t)ceil((float)(feature_size * sizeof(char)) / (float)sizeof(size_t)), 0);
+    mask_ = std::vector<size_t>((feature_size * sizeof(char) + sizeof(size_t) - 1) / sizeof(size_t), 0);

    // Generate a random set of order of subsignature_size_ bits
    for (unsigned int i = 0; i < key_size_; ++i) {
@@ -391,6 +395,7 @@ inline size_t LshTable<unsigned char>::getKey(const unsigned char* feature) cons
 {
    // no need to check if T is dividable by sizeof(size_t) like in the Hamming
    // distance computation as we have a mask
+    // FIXIT: This is bad assumption, because we reading tail bytes after of the allocated features buffer
    const size_t* feature_block_ptr = reinterpret_cast<const size_t*> ((const void*)feature);

    // Figure out the subsignature of the feature
@@ -399,10 +404,20 @@ inline size_t LshTable<unsigned char>::getKey(const unsigned char* feature) cons
    size_t subsignature = 0;
    size_t bit_index = 1;

-    for (std::vector<size_t>::const_iterator pmask_block = mask_.begin(); pmask_block != mask_.end(); ++pmask_block) {
+    for (unsigned i = 0; i < feature_size_; i += sizeof(size_t)) {
        // get the mask and signature blocks
-        size_t feature_block = *feature_block_ptr;
-        size_t mask_block = *pmask_block;
+        size_t feature_block;
+        if (i <= feature_size_ - sizeof(size_t))
+        {
+            feature_block = *feature_block_ptr;
+        }
+        else
+        {
+            size_t tmp = 0;
+            memcpy(&tmp, feature_block_ptr, feature_size_ - i); // preserve bytes order
+            feature_block = tmp;
+        }
+        size_t mask_block = mask_[i / sizeof(size_t)];
        while (mask_block) {
            // Get the lowest set bit in the mask block
            size_t lowest_bit = mask_block & (-(ptrdiff_t)mask_block);
@@ -186,9 +186,9 @@ Reduces a matrix to a vector.

    :param mtx: Source 2D matrix.

-    :param vec: Destination vector. Its size and type is defined by  ``dim``  and  ``dtype``  parameters.
+    :param vec: Destination row vector. Its type is defined by ``dtype`` parameter.

-    :param dim: Dimension index along which the matrix is reduced. 0 means that the matrix is reduced to a single row. 1 means that the matrix is reduced to a single column.
+    :param dim: Dimension index along which the matrix is reduced. 0 means that the matrix is reduced to a single row(of length equal to number of matrix columns). 1 means that the matrix is reduced to a single column(of length equal to the number of matrix rows). In either case, the output is always stored as a row vector of appropriate length.

    :param reduceOp: Reduction operation that could be one of the following:

@@ -202,6 +202,6 @@ Reduces a matrix to a vector.

    :param dtype: When it is negative, the destination vector will have the same type as the source matrix. Otherwise, its type will be  ``CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), mtx.channels())`` .

-The function ``reduce`` reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of ``CV_REDUCE_SUM`` and ``CV_REDUCE_AVG`` , the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes.
+The function ``reduce`` reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single column/row is obtained. However, the result is always stored as a row vector. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of ``CV_REDUCE_SUM`` and ``CV_REDUCE_AVG`` , the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes.

 .. seealso:: :ocv:func:`reduce`
@@ -435,13 +435,13 @@ CV_EXPORTS void LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stre
 CV_EXPORTS void merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream = Stream::Null());

 //! makes multi-channel array out of several single-channel arrays
-CV_EXPORTS void merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null());
+CV_EXPORTS void merge(const std::vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null());

 //! copies each plane of a multi-channel array to a dedicated array
 CV_EXPORTS void split(const GpuMat& src, GpuMat* dst, Stream& stream = Stream::Null());

 //! copies each plane of a multi-channel array to a dedicated array
-CV_EXPORTS void split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream = Stream::Null());
+CV_EXPORTS void split(const GpuMat& src, std::vector<GpuMat>& dst, Stream& stream = Stream::Null());

 //! computes magnitude of complex (x(i).re, x(i).im) vector
 //! supports only CV_32FC2 type
@@ -1268,9 +1268,9 @@ private:
 struct CV_EXPORTS HOGConfidence
 {
   double scale;
-   vector<Point> locations;
-   vector<double> confidences;
-   vector<double> part_scores[4];
+   std::vector<Point> locations;
+   std::vector<double> confidences;
+   std::vector<double> part_scores[4];
 };

 struct CV_EXPORTS HOGDescriptor
@@ -1288,27 +1288,27 @@ struct CV_EXPORTS HOGDescriptor
    size_t getDescriptorSize() const;
    size_t getBlockHistogramSize() const;

-    void setSVMDetector(const vector<float>& detector);
+    void setSVMDetector(const std::vector<float>& detector);

-    static vector<float> getDefaultPeopleDetector();
-    static vector<float> getPeopleDetector48x96();
-    static vector<float> getPeopleDetector64x128();
+    static std::vector<float> getDefaultPeopleDetector();
+    static std::vector<float> getPeopleDetector48x96();
+    static std::vector<float> getPeopleDetector64x128();

-    void detect(const GpuMat& img, vector<Point>& found_locations,
+    void detect(const GpuMat& img, std::vector<Point>& found_locations,
                double hit_threshold=0, Size win_stride=Size(),
                Size padding=Size());

-    void detectMultiScale(const GpuMat& img, vector<Rect>& found_locations,
+    void detectMultiScale(const GpuMat& img, std::vector<Rect>& found_locations,
                          double hit_threshold=0, Size win_stride=Size(),
                          Size padding=Size(), double scale0=1.05,
                          int group_threshold=2);

-    void computeConfidence(const GpuMat& img, vector<Point>& hits, double hit_threshold,
-                                                Size win_stride, Size padding, vector<Point>& locations, vector<double>& confidences);
+    void computeConfidence(const GpuMat& img, std::vector<Point>& hits, double hit_threshold,
+                                                Size win_stride, Size padding, std::vector<Point>& locations, std::vector<double>& confidences);

-    void computeConfidenceMultiScale(const GpuMat& img, vector<Rect>& found_locations,
+    void computeConfidenceMultiScale(const GpuMat& img, std::vector<Rect>& found_locations,
                                                                    double hit_threshold, Size win_stride, Size padding,
-                                                                    vector<HOGConfidence> &conf_out, int group_threshold);
+                                                                    std::vector<HOGConfidence> &conf_out, int group_threshold);

    void getDescriptors(const GpuMat& img, Size win_stride,
                        GpuMat& descriptors,
@@ -1838,11 +1838,11 @@ public:

 private:
    GpuMat uPyr_[2];
-    vector<GpuMat> prevPyr_;
-    vector<GpuMat> nextPyr_;
+    std::vector<GpuMat> prevPyr_;
+    std::vector<GpuMat> nextPyr_;
    GpuMat vPyr_[2];
-    vector<GpuMat> buf_;
-    vector<GpuMat> unused;
+    std::vector<GpuMat> buf_;
+    std::vector<GpuMat> unused;
    bool isDeviceArch11_;
 };

@@ -220,7 +220,7 @@ if(HAVE_AVFOUNDATION)
    list(APPEND HIGHGUI_LIBRARIES "-framework AVFoundation" "-framework QuartzCore")
  else()
    list(APPEND highgui_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_avfoundation_mac.mm)
-    list(APPEND HIGHGUI_LIBRARIES "-framework Cocoa" "-framework Accelerate" "-framework AVFoundation" "-framework CoreGraphics" "-framework CoreImage" "-framework CoreMedia" "-framework CoreVideo" "-framework QuartzCore")
+    list(APPEND HIGHGUI_LIBRARIES "-framework Cocoa" "-framework Accelerate" "-framework AVFoundation" "-framework CoreGraphics" "-framework CoreMedia" "-framework CoreVideo" "-framework QuartzCore")
  endif()
 endif()

@@ -241,7 +241,7 @@ endif(HAVE_INTELPERC)
 if(IOS)
  add_definitions(-DHAVE_IOS=1)
  list(APPEND highgui_srcs src/ios_conversions.mm src/cap_ios_abstract_camera.mm src/cap_ios_photo_camera.mm src/cap_ios_video_camera.mm)
-  list(APPEND HIGHGUI_LIBRARIES "-framework Accelerate" "-framework AVFoundation" "-framework CoreGraphics" "-framework CoreImage" "-framework CoreMedia" "-framework CoreVideo" "-framework QuartzCore" "-framework AssetsLibrary")
+  list(APPEND HIGHGUI_LIBRARIES "-framework Accelerate" "-framework AVFoundation" "-framework CoreGraphics" "-framework CoreMedia" "-framework CoreVideo" "-framework QuartzCore" "-framework AssetsLibrary")
 endif()

 if(WIN32)
@@ -697,7 +697,15 @@ CvCaptureFile::CvCaptureFile(const char* filename) {
        return;
    }

-    mAssetTrack = [[mAsset tracksWithMediaType: AVMediaTypeVideo][0] retain];
+    NSArray *tracks = [mAsset tracksWithMediaType:AVMediaTypeVideo];
+    if ([tracks count] == 0) {
+        fprintf(stderr, "OpenCV: Couldn't read video stream from file \"%s\"\n", filename);
+        [localpool drain];
+        started = 0;
+        return;
+    }
+
+    mAssetTrack = [tracks[0] retain];

    if ( ! setupReadingAt(kCMTimeZero) ) {
        fprintf(stderr, "OpenCV: Couldn't read movie file \"%s\"\n", filename);
@@ -129,9 +129,9 @@ extern "C" {
    #include <unistd.h>
    #include <stdio.h>
    #include <sys/types.h>
-    #include <sys/sysctl.h>
    #include <sys/time.h>
 #if defined __APPLE__
+    #include <sys/sysctl.h>
    #include <mach/clock.h>
    #include <mach/mach.h>
 #endif
@@ -1164,12 +1164,12 @@ static int read_frame_v4l2(CvCaptureCAM_V4L* capture) {
   //printf("got data in buff %d, len=%d, flags=0x%X, seq=%d, used=%d)\n",
   //	  buf.index, buf.length, buf.flags, buf.sequence, buf.bytesused);

-   if (-1 == ioctl (capture->deviceHandle, VIDIOC_QBUF, &buf))
-       perror ("VIDIOC_QBUF");
-
   //set timestamp in capture struct to be timestamp of most recent frame
   capture->timestamp = buf.timestamp;

+   if (-1 == ioctl (capture->deviceHandle, VIDIOC_QBUF, &buf))
+       perror ("VIDIOC_QBUF");
+
   return 1;
 }

@@ -409,9 +409,143 @@ int CV_DrawingTest_C::checkLineIterator( Mat& _img )
    return 0;
 }

+class CV_DrawingTest_Far : public CV_DrawingTest_CPP
+{
+public:
+    CV_DrawingTest_Far() {}
+protected:
+    virtual void draw(Mat& img);
+};
+
+void CV_DrawingTest_Far::draw(Mat& img)
+{
+    Size imgSize(32768 + 600, 400);
+    img.create(imgSize, CV_8UC3);
+
+    vector<Point> polyline(4);
+    polyline[0] = Point(32768 + 0, 0);
+    polyline[1] = Point(imgSize.width, 0);
+    polyline[2] = Point(imgSize.width, imgSize.height);
+    polyline[3] = Point(32768 + 0, imgSize.height);
+    const Point* pts = &polyline[0];
+    int n = (int)polyline.size();
+    fillPoly(img, &pts, &n, 1, Scalar::all(255));
+
+    Point p1(32768 + 1, 1), p2(32768 + 3, 3);
+    if (clipLine(Rect(32768 + 0, 0, imgSize.width, imgSize.height), p1, p2) && clipLine(imgSize, p1, p2))
+        circle(img, Point(32768 + 300, 100), 40, Scalar(0, 0, 255), 3); // draw
+
+    p2 = Point(32768 + 3, imgSize.height + 1000);
+    if (clipLine(Rect(32768 + 0, 0, imgSize.width, imgSize.height), p1, p2) && clipLine(imgSize, p1, p2))
+        circle(img, Point(65536 + 500, 300), 50, cvColorToScalar(255, CV_8UC3), 5, 8, 1); // draw
+
+    p1 = Point(imgSize.width, 1), p2 = Point(imgSize.width, 3);
+    if (clipLine(Rect(32768 + 0, 0, imgSize.width, imgSize.height), p1, p2) && clipLine(imgSize, p1, p2))
+        circle(img, Point(32768 + 390, 100), 10, Scalar(0, 0, 255), 3); // not draw
+
+    p1 = Point(imgSize.width - 1, 1), p2 = Point(imgSize.width, 3);
+    if (clipLine(Rect(32768 + 0, 0, imgSize.width, imgSize.height), p1, p2) && clipLine(imgSize, p1, p2))
+        ellipse(img, Point(32768 + 390, 100), Size(20, 30), 60, 0, 220.0, Scalar(0, 200, 0), 4); //draw
+
+    ellipse(img, RotatedRect(Point(32768 + 100, 200), Size(200, 100), 160), Scalar(200, 200, 255), 5);
+
+    polyline.clear();
+    ellipse2Poly(Point(32768 + 430, 180), Size(100, 150), 30, 0, 150, 20, polyline);
+    pts = &polyline[0];
+    n = (int)polyline.size();
+    polylines(img, &pts, &n, 1, false, Scalar(0, 0, 150), 4, CV_AA);
+    n = 0;
+    for (vector<Point>::const_iterator it = polyline.begin(); n < (int)polyline.size() - 1; ++it, n++)
+    {
+        line(img, *it, *(it + 1), Scalar(50, 250, 100));
+    }
+
+    polyline.clear();
+    ellipse2Poly(Point(32768 + 500, 300), Size(50, 80), 0, 0, 180, 10, polyline);
+    pts = &polyline[0];
+    n = (int)polyline.size();
+    polylines(img, &pts, &n, 1, true, Scalar(100, 200, 100), 20);
+    fillConvexPoly(img, pts, n, Scalar(0, 80, 0));
+
+    polyline.resize(8);
+    // external rectengular
+    polyline[0] = Point(32768 + 0, 0);
+    polyline[1] = Point(32768 + 80, 0);
+    polyline[2] = Point(32768 + 80, 80);
+    polyline[3] = Point(32768 + 0, 80);
+    // internal rectangular
+    polyline[4] = Point(32768 + 20, 20);
+    polyline[5] = Point(32768 + 60, 20);
+    polyline[6] = Point(32768 + 60, 60);
+    polyline[7] = Point(32768 + 20, 60);
+    const Point* ppts[] = { &polyline[0], &polyline[0] + 4 };
+    int pn[] = { 4, 4 };
+    fillPoly(img, ppts, pn, 2, Scalar(100, 100, 0), 8, 0, Point(500, 20));
+
+    rectangle(img, Point(32768 + 0, 300), Point(32768 + 50, 398), Scalar(0, 0, 255));
+
+    string text1 = "OpenCV";
+    int baseline = 0, thickness = 3, fontFace = FONT_HERSHEY_SCRIPT_SIMPLEX;
+    float fontScale = 2;
+    Size textSize = getTextSize(text1, fontFace, fontScale, thickness, &baseline);
+    baseline += thickness;
+    Point textOrg((32768 + img.cols - textSize.width) / 2, (img.rows + textSize.height) / 2);
+    rectangle(img, textOrg + Point(0, baseline), textOrg + Point(textSize.width, -textSize.height), Scalar(0, 0, 255));
+    line(img, textOrg + Point(0, thickness), textOrg + Point(textSize.width, thickness), Scalar(0, 0, 255));
+    putText(img, text1, textOrg, fontFace, fontScale, Scalar(150, 0, 150), thickness, 8);
+
+    string text2 = "abcdefghijklmnopqrstuvwxyz1234567890";
+    Scalar color(200, 0, 0);
+    fontScale = 0.5, thickness = 1;
+    int dist = 5;
+
+    textSize = getTextSize(text2, FONT_HERSHEY_SIMPLEX, fontScale, thickness, &baseline);
+    textOrg = Point(32768 + 5, 5) + Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_HERSHEY_SIMPLEX, fontScale, color, thickness, CV_AA);
+
+    fontScale = 1;
+    textSize = getTextSize(text2, FONT_HERSHEY_PLAIN, fontScale, thickness, &baseline);
+    textOrg += Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_HERSHEY_PLAIN, fontScale, color, thickness, CV_AA);
+
+    fontScale = 0.5;
+    textSize = getTextSize(text2, FONT_HERSHEY_DUPLEX, fontScale, thickness, &baseline);
+    textOrg += Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_HERSHEY_DUPLEX, fontScale, color, thickness, CV_AA);
+
+    textSize = getTextSize(text2, FONT_HERSHEY_COMPLEX, fontScale, thickness, &baseline);
+    textOrg += Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_HERSHEY_COMPLEX, fontScale, color, thickness, CV_AA);
+
+    textSize = getTextSize(text2, FONT_HERSHEY_TRIPLEX, fontScale, thickness, &baseline);
+    textOrg += Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_HERSHEY_TRIPLEX, fontScale, color, thickness, CV_AA);
+
+    fontScale = 1;
+    textSize = getTextSize(text2, FONT_HERSHEY_COMPLEX_SMALL, fontScale, thickness, &baseline);
+    textOrg += Point(0, 180) + Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_HERSHEY_COMPLEX_SMALL, fontScale, color, thickness, CV_AA);
+
+    textSize = getTextSize(text2, FONT_HERSHEY_SCRIPT_SIMPLEX, fontScale, thickness, &baseline);
+    textOrg += Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_HERSHEY_SCRIPT_SIMPLEX, fontScale, color, thickness, CV_AA);
+
+    textSize = getTextSize(text2, FONT_HERSHEY_SCRIPT_COMPLEX, fontScale, thickness, &baseline);
+    textOrg += Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_HERSHEY_SCRIPT_COMPLEX, fontScale, color, thickness, CV_AA);
+
+    dist = 15, fontScale = 0.5;
+    textSize = getTextSize(text2, FONT_ITALIC, fontScale, thickness, &baseline);
+    textOrg += Point(0, textSize.height + dist);
+    putText(img, text2, textOrg, FONT_ITALIC, fontScale, color, thickness, CV_AA);
+
+    img = img(Rect(32768, 0, 600, 400)).clone();
+}
+
 #ifdef HAVE_JPEG
 TEST(Highgui_Drawing,    cpp_regression) { CV_DrawingTest_CPP test; test.safe_run(); }
 TEST(Highgui_Drawing,      c_regression) { CV_DrawingTest_C   test; test.safe_run(); }
+TEST(Highgui_Drawing,    far_regression) { CV_DrawingTest_Far test; test.safe_run(); }
 #endif

 class CV_FillConvexPolyTest : public cvtest::BaseTest
@@ -102,6 +102,38 @@ static IppStatus sts = ippInit();

 namespace cv
 {
+//constants for conversion from/to RGB and Gray, YUV, YCrCb according to BT.601
+const float B2YF = 0.114f;
+const float G2YF = 0.587f;
+const float R2YF = 0.299f;
+//to YCbCr
+const float YCBF = 0.564f; // == 1/2/(1-B2YF)
+const float YCRF = 0.713f; // == 1/2/(1-R2YF)
+const int YCBI = 9241;  // == YCBF*16384
+const int YCRI = 11682; // == YCRF*16384
+//to YUV
+const float B2UF = 0.492f;
+const float R2VF = 0.877f;
+const int B2UI = 8061;  // == B2UF*16384
+const int R2VI = 14369; // == R2VF*16384
+//from YUV
+const float U2BF = 2.032f;
+const float U2GF = -0.395f;
+const float V2GF = -0.581f;
+const float V2RF = 1.140f;
+const int U2BI = 33292;
+const int U2GI = -6472;
+const int V2GI = -9519;
+const int V2RI = 18678;
+//from YCrCb
+const float CR2RF = 1.403f;
+const float CB2GF = -0.344f;
+const float CR2GF = -0.714f;
+const float CB2BF = 1.773f;
+const int CR2RI = 22987;
+const int CB2GI = -5636;
+const int CR2GI = -11698;
+const int CB2BI = 29049;

 // computes cubic spline coefficients for a function: (xi=i, yi=f[i]), i=0..n
 template<typename _Tp> static void splineBuild(const _Tp* f, int n, _Tp* tab)
@@ -402,9 +434,9 @@ struct IPPColor2GrayFunctor
 {
    IPPColor2GrayFunctor(ippiColor2GrayFunc _func) : func(_func)
    {
-        coeffs[0] = 0.114f;
-        coeffs[1] = 0.587f;
-        coeffs[2] = 0.299f;
+        coeffs[0] = B2YF;
+        coeffs[1] = G2YF;
+        coeffs[2] = R2YF;
    }
    bool operator()(const void *src, int srcStep, void *dst, int dstStep, int cols, int rows) const
    {
@@ -668,9 +700,9 @@ enum
 {
    yuv_shift = 14,
    xyz_shift = 12,
-    R2Y = 4899,
-    G2Y = 9617,
-    B2Y = 1868,
+    R2Y = 4899, // B2YF*16384
+    G2Y = 9617, // G2YF*16384
+    B2Y = 1868, // B2YF*16384
    BLOCK_SIZE = 256
 };

@@ -709,7 +741,7 @@ template<typename _Tp> struct RGB2Gray

    RGB2Gray(int _srccn, int blueIdx, const float* _coeffs) : srccn(_srccn)
    {
-        static const float coeffs0[] = { 0.299f, 0.587f, 0.114f };
+        static const float coeffs0[] = { R2YF, G2YF, B2YF };
        memcpy( coeffs, _coeffs ? _coeffs : coeffs0, 3*sizeof(coeffs[0]) );
        if(blueIdx == 0)
            std::swap(coeffs[0], coeffs[2]);
@@ -787,16 +819,18 @@ template<typename _Tp> struct RGB2YCrCb_f
 {
    typedef _Tp channel_type;

-    RGB2YCrCb_f(int _srccn, int _blueIdx, const float* _coeffs) : srccn(_srccn), blueIdx(_blueIdx)
+    RGB2YCrCb_f(int _srccn, int _blueIdx, bool _isCrCb) : srccn(_srccn), blueIdx(_blueIdx), isCrCb(_isCrCb)
    {
-        static const float coeffs0[] = {0.299f, 0.587f, 0.114f, 0.713f, 0.564f};
-        memcpy(coeffs, _coeffs ? _coeffs : coeffs0, 5*sizeof(coeffs[0]));
+        static const float coeffs_crb[] = { R2YF, G2YF, B2YF, YCRF, YCBF };
+        static const float coeffs_yuv[] = { R2YF, G2YF, B2YF, R2VF, B2UF };
+        memcpy(coeffs, isCrCb ? coeffs_crb : coeffs_yuv, 5*sizeof(coeffs[0]));
        if(blueIdx==0) std::swap(coeffs[0], coeffs[2]);
    }

    void operator()(const _Tp* src, _Tp* dst, int n) const
    {
        int scn = srccn, bidx = blueIdx;
+        int yuvOrder = !isCrCb; //1 if YUV, 0 if YCrCb
        const _Tp delta = ColorChannel<_Tp>::half();
        float C0 = coeffs[0], C1 = coeffs[1], C2 = coeffs[2], C3 = coeffs[3], C4 = coeffs[4];
        n *= 3;
@@ -805,10 +839,11 @@ template<typename _Tp> struct RGB2YCrCb_f
            _Tp Y = saturate_cast<_Tp>(src[0]*C0 + src[1]*C1 + src[2]*C2);
            _Tp Cr = saturate_cast<_Tp>((src[bidx^2] - Y)*C3 + delta);
            _Tp Cb = saturate_cast<_Tp>((src[bidx] - Y)*C4 + delta);
-            dst[i] = Y; dst[i+1] = Cr; dst[i+2] = Cb;
+            dst[i] = Y; dst[i+1+yuvOrder] = Cr; dst[i+2-yuvOrder] = Cb;
        }
    }
    int srccn, blueIdx;
+    bool isCrCb;
    float coeffs[5];
 };

@@ -817,16 +852,18 @@ template<typename _Tp> struct RGB2YCrCb_i
 {
    typedef _Tp channel_type;

-    RGB2YCrCb_i(int _srccn, int _blueIdx, const int* _coeffs)
-        : srccn(_srccn), blueIdx(_blueIdx)
+    RGB2YCrCb_i(int _srccn, int _blueIdx, bool _isCrCb)
+        : srccn(_srccn), blueIdx(_blueIdx), isCrCb(_isCrCb)
    {
-        static const int coeffs0[] = {R2Y, G2Y, B2Y, 11682, 9241};
-        memcpy(coeffs, _coeffs ? _coeffs : coeffs0, 5*sizeof(coeffs[0]));
+        static const int coeffs_crb[] = { R2Y, G2Y, B2Y, YCRI, YCBI };
+        static const int coeffs_yuv[] = { R2Y, G2Y, B2Y, R2VI, B2UI };
+        memcpy(coeffs, isCrCb ? coeffs_crb : coeffs_yuv, 5*sizeof(coeffs[0]));
        if(blueIdx==0) std::swap(coeffs[0], coeffs[2]);
    }
    void operator()(const _Tp* src, _Tp* dst, int n) const
    {
        int scn = srccn, bidx = blueIdx;
+        int yuvOrder = !isCrCb; //1 if YUV, 0 if YCrCb
        int C0 = coeffs[0], C1 = coeffs[1], C2 = coeffs[2], C3 = coeffs[3], C4 = coeffs[4];
        int delta = ColorChannel<_Tp>::half()*(1 << yuv_shift);
        n *= 3;
@@ -836,11 +873,12 @@ template<typename _Tp> struct RGB2YCrCb_i
            int Cr = CV_DESCALE((src[bidx^2] - Y)*C3 + delta, yuv_shift);
            int Cb = CV_DESCALE((src[bidx] - Y)*C4 + delta, yuv_shift);
            dst[i] = saturate_cast<_Tp>(Y);
-            dst[i+1] = saturate_cast<_Tp>(Cr);
-            dst[i+2] = saturate_cast<_Tp>(Cb);
+            dst[i+1+yuvOrder] = saturate_cast<_Tp>(Cr);
+            dst[i+2-yuvOrder] = saturate_cast<_Tp>(Cb);
        }
    }
    int srccn, blueIdx;
+    bool isCrCb;
    int coeffs[5];
 };

@@ -849,23 +887,25 @@ template<typename _Tp> struct YCrCb2RGB_f
 {
    typedef _Tp channel_type;

-    YCrCb2RGB_f(int _dstcn, int _blueIdx, const float* _coeffs)
-        : dstcn(_dstcn), blueIdx(_blueIdx)
+    YCrCb2RGB_f(int _dstcn, int _blueIdx, bool _isCrCb)
+        : dstcn(_dstcn), blueIdx(_blueIdx), isCrCb(_isCrCb)
    {
-        static const float coeffs0[] = {1.403f, -0.714f, -0.344f, 1.773f};
-        memcpy(coeffs, _coeffs ? _coeffs : coeffs0, 4*sizeof(coeffs[0]));
+        static const float coeffs_cbr[] = {CR2RF, CR2GF, CB2GF, CB2BF};
+        static const float coeffs_yuv[] = { V2RF,  V2GF,  U2GF,  U2BF};
+        memcpy(coeffs, isCrCb ? coeffs_cbr : coeffs_yuv, 4*sizeof(coeffs[0]));
    }
    void operator()(const _Tp* src, _Tp* dst, int n) const
    {
        int dcn = dstcn, bidx = blueIdx;
+        int yuvOrder = !isCrCb; //1 if YUV, 0 if YCrCb
        const _Tp delta = ColorChannel<_Tp>::half(), alpha = ColorChannel<_Tp>::max();
        float C0 = coeffs[0], C1 = coeffs[1], C2 = coeffs[2], C3 = coeffs[3];
        n *= 3;
        for(int i = 0; i < n; i += 3, dst += dcn)
        {
            _Tp Y = src[i];
-            _Tp Cr = src[i+1];
-            _Tp Cb = src[i+2];
+            _Tp Cr = src[i+1+yuvOrder];
+            _Tp Cb = src[i+2-yuvOrder];

            _Tp b = saturate_cast<_Tp>(Y + (Cb - delta)*C3);
            _Tp g = saturate_cast<_Tp>(Y + (Cb - delta)*C2 + (Cr - delta)*C1);
@@ -877,6 +917,7 @@ template<typename _Tp> struct YCrCb2RGB_f
        }
    }
    int dstcn, blueIdx;
+    bool isCrCb;
    float coeffs[4];
 };

@@ -885,24 +926,26 @@ template<typename _Tp> struct YCrCb2RGB_i
 {
    typedef _Tp channel_type;

-    YCrCb2RGB_i(int _dstcn, int _blueIdx, const int* _coeffs)
-        : dstcn(_dstcn), blueIdx(_blueIdx)
+    YCrCb2RGB_i(int _dstcn, int _blueIdx, bool _isCrCb)
+        : dstcn(_dstcn), blueIdx(_blueIdx), isCrCb(_isCrCb)
    {
-        static const int coeffs0[] = {22987, -11698, -5636, 29049};
-        memcpy(coeffs, _coeffs ? _coeffs : coeffs0, 4*sizeof(coeffs[0]));
+        static const int coeffs_crb[] = { CR2RI, CR2GI, CB2GI, CB2BI};
+        static const int coeffs_yuv[] = {  V2RI,  V2GI,  U2GI, U2BI };
+        memcpy(coeffs, isCrCb ? coeffs_crb : coeffs_yuv, 4*sizeof(coeffs[0]));
    }

    void operator()(const _Tp* src, _Tp* dst, int n) const
    {
        int dcn = dstcn, bidx = blueIdx;
+        int yuvOrder = !isCrCb; //1 if YUV, 0 if YCrCb
        const _Tp delta = ColorChannel<_Tp>::half(), alpha = ColorChannel<_Tp>::max();
        int C0 = coeffs[0], C1 = coeffs[1], C2 = coeffs[2], C3 = coeffs[3];
        n *= 3;
        for(int i = 0; i < n; i += 3, dst += dcn)
        {
            _Tp Y = src[i];
-            _Tp Cr = src[i+1];
-            _Tp Cb = src[i+2];
+            _Tp Cr = src[i+1+yuvOrder];
+            _Tp Cb = src[i+2-yuvOrder];

            int b = Y + CV_DESCALE((Cb - delta)*C3, yuv_shift);
            int g = Y + CV_DESCALE((Cb - delta)*C2 + (Cr - delta)*C1, yuv_shift);
@@ -916,6 +959,7 @@ template<typename _Tp> struct YCrCb2RGB_i
        }
    }
    int dstcn, blueIdx;
+    bool isCrCb;
    int coeffs[4];
 };

@@ -3832,10 +3876,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
            {
            CV_Assert( scn == 3 || scn == 4 );
            bidx = code == CV_BGR2YCrCb || code == CV_BGR2YUV ? 0 : 2;
-            static const float yuv_f[] = { 0.114f, 0.587f, 0.299f, 0.492f, 0.877f };
-            static const int yuv_i[] = { B2Y, G2Y, R2Y, 8061, 14369 };
-            const float* coeffs_f = code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? 0 : yuv_f;
-            const int* coeffs_i = code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? 0 : yuv_i;
+            const bool isCrCb = (code == CV_BGR2YCrCb || code == CV_RGB2YCrCb);

            _dst.create(sz, CV_MAKETYPE(depth, 3));
            dst = _dst.getMat();
@@ -3846,12 +3887,12 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
                if((code == CV_RGB2YCrCb || code == CV_BGR2YCrCb) && tegra::cvtRGB2YCrCb(src, dst, bidx))
                    break;
 #endif
-                CvtColorLoop(src, dst, RGB2YCrCb_i<uchar>(scn, bidx, coeffs_i));
+                CvtColorLoop(src, dst, RGB2YCrCb_i<uchar>(scn, bidx, isCrCb));
            }
            else if( depth == CV_16U )
-                CvtColorLoop(src, dst, RGB2YCrCb_i<ushort>(scn, bidx, coeffs_i));
+                CvtColorLoop(src, dst, RGB2YCrCb_i<ushort>(scn, bidx, isCrCb));
            else
-                CvtColorLoop(src, dst, RGB2YCrCb_f<float>(scn, bidx, coeffs_f));
+                CvtColorLoop(src, dst, RGB2YCrCb_f<float>(scn, bidx, isCrCb));
            }
            break;

@@ -3861,20 +3902,17 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
            if( dcn <= 0 ) dcn = 3;
            CV_Assert( scn == 3 && (dcn == 3 || dcn == 4) );
            bidx = code == CV_YCrCb2BGR || code == CV_YUV2BGR ? 0 : 2;
-            static const float yuv_f[] = { 2.032f, -0.395f, -0.581f, 1.140f };
-            static const int yuv_i[] = { 33292, -6472, -9519, 18678 };
-            const float* coeffs_f = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? 0 : yuv_f;
-            const int* coeffs_i = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? 0 : yuv_i;
+            const bool isCrCb = (code == CV_YCrCb2BGR || code == CV_YCrCb2RGB);

            _dst.create(sz, CV_MAKETYPE(depth, dcn));
            dst = _dst.getMat();

            if( depth == CV_8U )
-                CvtColorLoop(src, dst, YCrCb2RGB_i<uchar>(dcn, bidx, coeffs_i));
+                CvtColorLoop(src, dst, YCrCb2RGB_i<uchar>(dcn, bidx, isCrCb));
            else if( depth == CV_16U )
-                CvtColorLoop(src, dst, YCrCb2RGB_i<ushort>(dcn, bidx, coeffs_i));
+                CvtColorLoop(src, dst, YCrCb2RGB_i<ushort>(dcn, bidx, isCrCb));
            else
-                CvtColorLoop(src, dst, YCrCb2RGB_f<float>(dcn, bidx, coeffs_f));
+                CvtColorLoop(src, dst, YCrCb2RGB_f<float>(dcn, bidx, isCrCb));
            }
            break;

@@ -170,10 +170,12 @@ static Mat createInitialImage( const Mat& img, bool doubleImageSize, float sigma
 {
    Mat gray, gray_fpt;
    if( img.channels() == 3 || img.channels() == 4 )
+    {
        cvtColor(img, gray, COLOR_BGR2GRAY);
+        gray.convertTo(gray_fpt, DataType<sift_wt>::type, SIFT_FIXPT_SCALE, 0);
+    }
    else
-        img.copyTo(gray);
-    gray.convertTo(gray_fpt, DataType<sift_wt>::type, SIFT_FIXPT_SCALE, 0);
+        img.convertTo(gray_fpt, DataType<sift_wt>::type, SIFT_FIXPT_SCALE, 0);

    float sig_diff;

@@ -181,7 +183,7 @@ static Mat createInitialImage( const Mat& img, bool doubleImageSize, float sigma
    {
        sig_diff = sqrtf( std::max(sigma * sigma - SIFT_INIT_SIGMA * SIFT_INIT_SIGMA * 4, 0.01f) );
        Mat dbl;
-        resize(gray_fpt, dbl, Size(gray.cols*2, gray.rows*2), 0, 0, INTER_LINEAR);
+        resize(gray_fpt, dbl, Size(gray_fpt.cols*2, gray_fpt.rows*2), 0, 0, INTER_LINEAR);
        GaussianBlur(dbl, dbl, Size(), sig_diff, sig_diff);
        return dbl;
    }
@@ -115,9 +115,42 @@ enum
    BLOCK_SIZE = 256
 };

+//constants for conversion from/to RGB and Gray, YUV, YCrCb according to BT.601
+#define B2YF 0.114f
+#define G2YF 0.587f
+#define R2YF 0.299f
+//to YCbCr
+#define YCBF 0.564f
+#define YCRF 0.713f
+#define YCBI 9241
+#define YCRI 11682
+//to YUV
+#define B2UF 0.492f
+#define R2VF 0.877f
+#define B2UI 8061
+#define R2VI 14369
+//from YUV
+#define U2BF 2.032f
+#define U2GF -0.395f
+#define V2GF -0.581f
+#define V2RF 1.140f
+#define U2BI 33292
+#define U2GI -6472
+#define V2GI -9519
+#define V2RI 18678
+//from YCrCb
+#define CR2RF 1.403f
+#define CB2GF -0.344f
+#define CR2GF -0.714f
+#define CB2BF 1.773f
+#define CR2RI 22987
+#define CB2GI -5636
+#define CR2GI -11698
+#define CB2BI 29049
+
 ///////////////////////////////////// RGB <-> GRAY //////////////////////////////////////

-__constant float c_RGB2GrayCoeffs_f[3]  = { 0.114f, 0.587f, 0.299f };
+__constant float c_RGB2GrayCoeffs_f[3]  = { B2YF, G2YF, R2YF };
 __constant int   c_RGB2GrayCoeffs_i[3]  = { B2Y, G2Y, R2Y };

 __kernel void RGB2Gray(int cols, int rows, int src_step, int dst_step,
@@ -135,7 +168,7 @@ __kernel void RGB2Gray(int cols, int rows, int src_step, int dst_step,
 #ifndef INTEL_DEVICE

 #ifdef DEPTH_5
-        dst[dst_idx] = src[src_idx + bidx] * 0.114f + src[src_idx + 1] * 0.587f + src[src_idx + (bidx^2)] * 0.299f;
+        dst[dst_idx] = src[src_idx + bidx] * B2YF + src[src_idx + 1] * G2YF + src[src_idx + (bidx^2)] * R2YF;
 #else
        dst[dst_idx] = (DATA_TYPE)CV_DESCALE((src[src_idx + bidx] * B2Y + src[src_idx + 1] * G2Y + src[src_idx + (bidx^2)] * R2Y), yuv_shift);
 #endif
@@ -221,8 +254,8 @@ __kernel void Gray2RGB(int cols, int rows, int src_step, int dst_step,

 ///////////////////////////////////// RGB <-> YUV //////////////////////////////////////

-__constant float c_RGB2YUVCoeffs_f[5]  = { 0.114f, 0.587f, 0.299f, 0.492f, 0.877f };
-__constant int   c_RGB2YUVCoeffs_i[5]  = { B2Y, G2Y, R2Y, 8061, 14369 };
+__constant float c_RGB2YUVCoeffs_f[5]  = { B2YF, G2YF, R2YF, B2UF, R2VF };
+__constant int   c_RGB2YUVCoeffs_i[5]  = { B2Y, G2Y, R2Y, B2UI, R2VI };

 __kernel void RGB2YUV(int cols, int rows, int src_step, int dst_step,
                      __global const DATA_TYPE* src, __global DATA_TYPE* dst,
@@ -252,13 +285,13 @@ __kernel void RGB2YUV(int cols, int rows, int src_step, int dst_step,
            const DATA_TYPE rgb[] = {src_ptr[0], src_ptr[1], src_ptr[2]};

 #ifdef DEPTH_5
-            float Y = rgb[0] * coeffs[bidx^2] + rgb[1] * coeffs[1] + rgb[2] * coeffs[bidx];
-            float U = (rgb[bidx^2] - Y) * coeffs[3] + HALF_MAX;
-            float V = (rgb[bidx] - Y) * coeffs[4] + HALF_MAX;
+            float Y = rgb[0] * coeffs[bidx] + rgb[1] * coeffs[1] + rgb[2] * coeffs[bidx^2];
+            float U = (rgb[bidx] - Y) * coeffs[3] + HALF_MAX;
+            float V = (rgb[bidx^2] - Y) * coeffs[4] + HALF_MAX;
 #else
-            int Y = CV_DESCALE(rgb[0] * coeffs[bidx^2] + rgb[1] * coeffs[1] + rgb[2] * coeffs[bidx], yuv_shift);
-            int U = CV_DESCALE((rgb[bidx^2] - Y) * coeffs[3] + delta, yuv_shift);
-            int V = CV_DESCALE((rgb[bidx] - Y) * coeffs[4] + delta, yuv_shift);
+            int Y = CV_DESCALE(rgb[0] * coeffs[bidx] + rgb[1] * coeffs[1] + rgb[2] * coeffs[bidx^2], yuv_shift);
+            int U = CV_DESCALE((rgb[bidx] - Y) * coeffs[3] + delta, yuv_shift);
+            int V = CV_DESCALE((rgb[bidx^2] - Y) * coeffs[4] + delta, yuv_shift);
 #endif

            dst_ptr[0] = SAT_CAST( Y );
@@ -274,23 +307,22 @@ __kernel void RGB2YUV(int cols, int rows, int src_step, int dst_step,
            const float2 c1 = r0.s15;
            const float2 c2 = r0.s26;

-            const float2 Y = (bidx == 0) ? (c0 * coeffs[2] + c1 * coeffs[1] + c2 * coeffs[0]) : (c0 * coeffs[0] + c1 * coeffs[1] + c2 * coeffs[2]);
-            const float2 U = (bidx == 0) ? ((c2 - Y) * coeffs[3] + HALF_MAX) : ((c0 - Y) * coeffs[3] + HALF_MAX);
-            const float2 V = (bidx == 0) ? ((c0 - Y) * coeffs[4] + HALF_MAX) : ((c2 - Y) * coeffs[4] + HALF_MAX);
+            const float2 Y = (bidx == 0) ? (c0 * coeffs[0] + c1 * coeffs[1] + c2 * coeffs[2]) : (c0 * coeffs[2] + c1 * coeffs[1] + c2 * coeffs[0]);
+            const float2 U = (bidx == 0) ? ((c0 - Y) * coeffs[3] + HALF_MAX) : ((c2 - Y) * coeffs[3] + HALF_MAX);
+            const float2 V = (bidx == 0) ? ((c2 - Y) * coeffs[4] + HALF_MAX) : ((c0 - Y) * coeffs[4] + HALF_MAX);
 #else
            const int2 c0 = convert_int2(r0.s04);
            const int2 c1 = convert_int2(r0.s15);
            const int2 c2 = convert_int2(r0.s26);

-            const int2 yi = (bidx == 0) ? CV_DESCALE(c0 * coeffs[2] + c1 * coeffs[1] + c2 * coeffs[0], yuv_shift) : CV_DESCALE(c0 * coeffs[0] + c1 * coeffs[1] + c2 * coeffs[2], yuv_shift);
-            const int2 ui = (bidx == 0) ? CV_DESCALE((c2 - yi) * coeffs[3] + delta, yuv_shift) : CV_DESCALE((c0 - yi) * coeffs[3] + delta, yuv_shift);
-            const int2 vi = (bidx == 0) ? CV_DESCALE((c0 - yi) * coeffs[4] + delta, yuv_shift) : CV_DESCALE((c2 - yi) * coeffs[4] + delta, yuv_shift);
+            const int2 yi = (bidx == 0) ? CV_DESCALE(c0 * coeffs[0] + c1 * coeffs[1] + c2 * coeffs[2], yuv_shift) : CV_DESCALE(c0 * coeffs[2] + c1 * coeffs[1] + c2 * coeffs[0], yuv_shift);
+            const int2 ui = (bidx == 0) ? CV_DESCALE((c0 - yi) * coeffs[3] + delta, yuv_shift) : CV_DESCALE((c2 - yi) * coeffs[3] + delta, yuv_shift);
+            const int2 vi = (bidx == 0) ? CV_DESCALE((c2 - yi) * coeffs[4] + delta, yuv_shift) : CV_DESCALE((c0 - yi) * coeffs[4] + delta, yuv_shift);

            const VECTOR2 Y = SAT_CAST2(yi);
            const VECTOR2 U = SAT_CAST2(ui);
            const VECTOR2 V = SAT_CAST2(vi);
 #endif
-
            vstore8((VECTOR8)(Y.s0, U.s0, V.s0, 0, Y.s1, U.s1, V.s1, 0), 0, dst_ptr);
        }
 #elif (4 == pixels_per_work_item)
@@ -302,14 +334,13 @@ __kernel void RGB2YUV(int cols, int rows, int src_step, int dst_step,
            const int4 c1 = convert_int4(r0.s159d);
            const int4 c2 = convert_int4(r0.s26ae);

-            const int4 yi = (bidx == 0) ? CV_DESCALE(c0 * coeffs[2] + c1 * coeffs[1] + c2 * coeffs[0], yuv_shift) : CV_DESCALE(c0 * coeffs[0] + c1 * coeffs[1] + c2 * coeffs[2], yuv_shift);
-            const int4 ui = (bidx == 0) ? CV_DESCALE((c2 - yi) * coeffs[3] + delta, yuv_shift) : CV_DESCALE((c0 - yi) * coeffs[3] + delta, yuv_shift);
-            const int4 vi = (bidx == 0) ? CV_DESCALE((c0 - yi) * coeffs[4] + delta, yuv_shift) : CV_DESCALE((c2 - yi) * coeffs[4] + delta, yuv_shift);
+            const int4 yi = (bidx == 0) ? CV_DESCALE(c0 * coeffs[0] + c1 * coeffs[1] + c2 * coeffs[2], yuv_shift) : CV_DESCALE(c0 * coeffs[2] + c1 * coeffs[1] + c2 * coeffs[0], yuv_shift);
+            const int4 ui = (bidx == 0) ? CV_DESCALE((c0 - yi) * coeffs[3] + delta, yuv_shift) : CV_DESCALE((c2 - yi) * coeffs[3] + delta, yuv_shift);
+            const int4 vi = (bidx == 0) ? CV_DESCALE((c2 - yi) * coeffs[4] + delta, yuv_shift) : CV_DESCALE((c0 - yi) * coeffs[4] + delta, yuv_shift);

            const VECTOR4 Y = SAT_CAST4(yi);
            const VECTOR4 U = SAT_CAST4(ui);
            const VECTOR4 V = SAT_CAST4(vi);
-
            vstore16((VECTOR16)(Y.s0, U.s0, V.s0, 0, Y.s1, U.s1, V.s1, 0, Y.s2, U.s2, V.s2, 0, Y.s3, U.s3, V.s3, 0), 0, dst_ptr);
 #endif
        }
@@ -317,8 +348,8 @@ __kernel void RGB2YUV(int cols, int rows, int src_step, int dst_step,
    }
 }

-__constant float c_YUV2RGBCoeffs_f[5] = { 2.032f, -0.395f, -0.581f, 1.140f };
-__constant int   c_YUV2RGBCoeffs_i[5] = { 33292, -6472, -9519, 18678 };
+__constant float c_YUV2RGBCoeffs_f[5] = { U2BF, U2GF, V2GF, V2RF };
+__constant int   c_YUV2RGBCoeffs_i[5] = { U2BI, U2GI, V2GI, V2RI };

 __kernel void YUV2RGB(int cols, int rows, int src_step, int dst_step,
                      __global const DATA_TYPE* src, __global DATA_TYPE* dst,
@@ -347,13 +378,13 @@ __kernel void YUV2RGB(int cols, int rows, int src_step, int dst_step,
            const DATA_TYPE yuv[] = {src_ptr[0], src_ptr[1], src_ptr[2]};

 #ifdef DEPTH_5
-            float B = yuv[0] + (yuv[2] - HALF_MAX) * coeffs[3];
-            float G = yuv[0] + (yuv[2] - HALF_MAX) * coeffs[2] + (yuv[1] - HALF_MAX) * coeffs[1];
-            float R = yuv[0] + (yuv[1] - HALF_MAX) * coeffs[0];
+            float B = yuv[0] + (yuv[1] - HALF_MAX) * coeffs[0];
+            float G = yuv[0] + (yuv[1] - HALF_MAX) * coeffs[1] + (yuv[2] - HALF_MAX) * coeffs[2];
+            float R = yuv[0] + (yuv[2] - HALF_MAX) * coeffs[3];
 #else
-            int B = yuv[0] + CV_DESCALE((yuv[2] - HALF_MAX) * coeffs[3], yuv_shift);
-            int G = yuv[0] + CV_DESCALE((yuv[2] - HALF_MAX) * coeffs[2] + (yuv[1] - HALF_MAX) * coeffs[1], yuv_shift);
-            int R = yuv[0] + CV_DESCALE((yuv[1] - HALF_MAX) * coeffs[0], yuv_shift);
+            int B = yuv[0] + CV_DESCALE((yuv[1] - HALF_MAX) * coeffs[0], yuv_shift);
+            int G = yuv[0] + CV_DESCALE((yuv[1] - HALF_MAX) * coeffs[1] + (yuv[2] - HALF_MAX) * coeffs[2], yuv_shift);
+            int R = yuv[0] + CV_DESCALE((yuv[2] - HALF_MAX) * coeffs[3], yuv_shift);
 #endif

            dst_ptr[bidx]     = SAT_CAST( B );
@@ -372,17 +403,17 @@ __kernel void YUV2RGB(int cols, int rows, int src_step, int dst_step,
            const float2 U = r0.s15;
            const float2 V = r0.s26;

-            const float2 c0 = (bidx == 0) ? (Y + (V - HALF_MAX) * coeffs[3]) : (Y + (U - HALF_MAX) * coeffs[0]);
+            const float2 c0 = (bidx != 0) ? (Y + (V - HALF_MAX) * coeffs[3]) : (Y + (U - HALF_MAX) * coeffs[0]);
            const float2 c1 = Y + (V - HALF_MAX) * coeffs[2] + (U - HALF_MAX) * coeffs[1];
-            const float2 c2 = (bidx == 0) ? (Y + (U - HALF_MAX) * coeffs[0]) : (Y + (V - HALF_MAX) * coeffs[3]);
+            const float2 c2 = (bidx != 0) ? (Y + (U - HALF_MAX) * coeffs[0]) : (Y + (V - HALF_MAX) * coeffs[3]);
 #else
            const int2 Y = convert_int2(r0.s04);
            const int2 U = convert_int2(r0.s15);
            const int2 V = convert_int2(r0.s26);

-            const int2 c0i = (bidx == 0) ? (Y + CV_DESCALE((V - HALF_MAX) * coeffs[3], yuv_shift)) : (Y + CV_DESCALE((U - HALF_MAX) * coeffs[0], yuv_shift));
+            const int2 c0i = (bidx != 0) ? (Y + CV_DESCALE((V - HALF_MAX) * coeffs[3], yuv_shift)) : (Y + CV_DESCALE((U - HALF_MAX) * coeffs[0], yuv_shift));
            const int2 c1i = Y + CV_DESCALE((V - HALF_MAX) * coeffs[2] + (U - HALF_MAX) * coeffs[1], yuv_shift);
-            const int2 c2i = (bidx == 0) ? (Y + CV_DESCALE((U - HALF_MAX) * coeffs[0], yuv_shift)) : (Y + CV_DESCALE((V - HALF_MAX) * coeffs[3], yuv_shift));
+            const int2 c2i = (bidx != 0) ? (Y + CV_DESCALE((U - HALF_MAX) * coeffs[0], yuv_shift)) : (Y + CV_DESCALE((V - HALF_MAX) * coeffs[3], yuv_shift));

            const VECTOR2 c0 = SAT_CAST2(c0i);
            const VECTOR2 c1 = SAT_CAST2(c1i);
@@ -404,9 +435,9 @@ __kernel void YUV2RGB(int cols, int rows, int src_step, int dst_step,
            const int4 U = convert_int4(r0.s159d);
            const int4 V = convert_int4(r0.s26ae);

-            const int4 c0i = (bidx == 0) ? (Y + CV_DESCALE((V - HALF_MAX) * coeffs[3], yuv_shift)) : (Y + CV_DESCALE((U - HALF_MAX) * coeffs[0], yuv_shift));
+            const int4 c0i = (bidx != 0) ? (Y + CV_DESCALE((V - HALF_MAX) * coeffs[3], yuv_shift)) : (Y + CV_DESCALE((U - HALF_MAX) * coeffs[0], yuv_shift));
            const int4 c1i = Y + CV_DESCALE((V - HALF_MAX) * coeffs[2] + (U - HALF_MAX) * coeffs[1], yuv_shift);
-            const int4 c2i = (bidx == 0) ? (Y + CV_DESCALE((U - HALF_MAX) * coeffs[0], yuv_shift)) : (Y + CV_DESCALE((V - HALF_MAX) * coeffs[3], yuv_shift));
+            const int4 c2i = (bidx != 0) ? (Y + CV_DESCALE((U - HALF_MAX) * coeffs[0], yuv_shift)) : (Y + CV_DESCALE((V - HALF_MAX) * coeffs[3], yuv_shift));

            const VECTOR4 c0 = SAT_CAST4(c0i);
            const VECTOR4 c1 = SAT_CAST4(c1i);
@@ -484,8 +515,8 @@ __kernel void YUV2RGBA_NV12(int cols, int rows, int src_step, int dst_step,

 ///////////////////////////////////// RGB <-> YCrCb //////////////////////////////////////

-__constant float c_RGB2YCrCbCoeffs_f[5] = {0.299f, 0.587f, 0.114f, 0.713f, 0.564f};
-__constant int   c_RGB2YCrCbCoeffs_i[5] = {R2Y, G2Y, B2Y, 11682, 9241};
+__constant float c_RGB2YCrCbCoeffs_f[5] = {R2YF, G2YF, B2YF, YCRF, YCBF};
+__constant int   c_RGB2YCrCbCoeffs_i[5] = {R2Y, G2Y, B2Y, YCRI, YCBI};

 __kernel void RGB2YCrCb(int cols, int rows, int src_step, int dst_step,
                      __global const DATA_TYPE* src, __global DATA_TYPE* dst,
@@ -579,8 +610,8 @@ __kernel void RGB2YCrCb(int cols, int rows, int src_step, int dst_step,
    }
 }

-__constant float c_YCrCb2RGBCoeffs_f[4] = { 1.403f, -0.714f, -0.344f, 1.773f };
-__constant int   c_YCrCb2RGBCoeffs_i[4] = { 22987, -11698, -5636, 29049 };
+__constant float c_YCrCb2RGBCoeffs_f[4] = { CR2RF, CR2GF, CB2GF, CB2BF };
+__constant int   c_YCrCb2RGBCoeffs_i[4] = { CR2RI, CR2GI, CB2GI, CB2BI };

 __kernel void YCrCb2RGB(int cols, int rows, int src_step, int dst_step,
                      __global const DATA_TYPE* src, __global DATA_TYPE* dst,
@@ -40,7 +40,7 @@ Modification of ``fastNlMeansDenoising`` function for colored images

    :param h: Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

-    :param hForColorComponents: The same as h but for color components. For most images value equals 10 will be enought to remove colored noise and do not distort colors
+    :param hColor: The same as h but for color components. For most images value equals 10 will be enought to remove colored noise and do not distort colors

 The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using ``fastNlMeansDenoising`` function.

@@ -85,6 +85,6 @@ Modification of ``fastNlMeansDenoisingMulti`` function for colored images sequen

    :param h: Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise.

-    :param hForColorComponents: The same as h but for color components.
+    :param hColor: The same as h but for color components.

 The function converts images to CIELAB colorspace and then separately denoise L and AB components with given h parameters using ``fastNlMeansDenoisingMulti`` function.
@@ -101,7 +101,7 @@ public:
            }
            else
            {
-                if (readStringList(input, imageList))
+                if (isListOfImages(input) && readStringList(input, imageList))
                    {
                        inputType = IMAGE_LIST;
                        nrFrames = (nrFrames < (int)imageList.size()) ? nrFrames : (int)imageList.size();
@@ -169,6 +169,16 @@ public:
            l.push_back((string)*it);
        return true;
    }
+
+    static bool isListOfImages( const string& filename)
+    {
+        string s(filename);
+        // Look for file extension
+        if( s.find(".xml") == string::npos && s.find(".yaml") == string::npos && s.find(".yml") == string::npos )
+            return false;
+        else
+            return true;
+    }
 public:
    Size boardSize;            // The size of the board -> Number of items by width and height
    Pattern calibrationPattern;// One of the Chessboard, circles, or asymmetric circle pattern
Author	SHA1	Message	Date
Alexander Alekhin	b398b572cc	OpenCV version++ 2.4.13.3	2017-07-31 15:57:29 +03:00
Alexander Alekhin	a0520bef42	Merge pull request #9266 from alalek:backport_9238 (2.4) backport #9238	2017-07-30 14:38:06 +00:00
Alexander Alekhin	7dceebbc4e	flann: fix out of buffer access	2017-07-30 14:14:08 +03:00
Alexander Alekhin	0312df4812	cmake: fix compiler flags	2017-07-30 14:11:10 +03:00
Alexander Alekhin	d19147bc78	Merge pull request #9218 from alalek:backport_2.4 (2.4) Backport changes from master	2017-07-24 11:40:51 +00:00
Alexander Alekhin	fc2a71dbab	build: enable __STDC_FORMAT_MACROS macro	2017-07-21 17:38:23 +03:00
kvaghel1	6bafc2c598	Fix frame timestamp in VideoCapture::get	2017-07-21 17:35:20 +03:00
Alexander Alekhin	777a0080cb	cmake: disallow in-source builds	2017-07-21 17:33:01 +03:00
Christof Kaufmann	572c86176a	cmake: Avoid adding default path as system directory for GCC 6.x This is a completion for PR #7390 and fixes #6517 and #815.	2017-07-21 17:29:50 +03:00
Alexander Alekhin	8736ece97d	Merge pull request #9116 from alalek:backport_9110_2.4 (2.4) Added detection of MSVC1911	2017-07-10 08:07:48 +00:00
Patrik Huber	ebd961585e	Added detection of MSVC1911 This is VS2017 Preview. It makes sure the version is detected properly and the INSTALL target then correctly installs to x64/vc15 (the same as MSVC1910).	2017-07-07 14:46:56 +03:00
Alexander Alekhin	2e343ef631	Merge pull request #9102 from varunagrawal:2.4-vector gpu.hpp vector scope fix	2017-07-06 16:11:07 +00:00
Varun Agrawal	af3c544483	All vector definitions have correct namespace scopes	2017-07-05 19:02:27 -04:00
Alexander Alekhin	3dedd62f54	Merge pull request #8970 from alalek:fix_libname_2.4 (2.4) cmake: fix libname for pkg-config configuration	2017-06-25 14:16:46 +03:00
Alexander Alekhin	07b7c03efc	Merge pull request #8980 from alalek:fix_typo_8979_2.4 (2.4) highgui(macos): fix video file reading via AVFoundation	2017-06-24 11:38:32 +03:00
Alexander Alekhin	aae7621243	highgui(macos): fix video file reading via AVFoundation	2017-06-24 11:01:33 +03:00
Alexander Alekhin	fa36e769cf	Merge pull request #8979 from sabzo:issue/8305_unhandled_objective_c_exception_video_avi_playback Unhandled Objective-C exception when playing video	2017-06-24 10:56:25 +03:00
Sabelo	f71bf21aaf	Unhandled Objective-C exception when playing video	2017-06-23 19:54:56 -04:00
Alexander Alekhin	70489b1e22	cmake: fix libname for pkg-config configuration	2017-06-22 19:34:50 +03:00
Alexander Alekhin	e397794ae2	Merge pull request #8959 from alalek:gitignore_cache_2.4	2017-06-22 12:29:23 +03:00
Alexander Alekhin	3d4e1bd641	.gitignore: add .cache directory (to be consistent with master branch)	2017-06-21 19:25:36 +03:00
Alexander Alekhin	3649ee3cd3	Merge pull request #8887 from krishraghuram:gpu_reduce_doc Modified doc for gpu::reduce(fixes issue 8628)	2017-06-10 22:27:17 +02:00
Raghuram Krishnaswami	d0f3a14456	Modified doc for gpu::reduce(fixes issue 8628)	2017-06-10 18:36:39 +05:30
krishraghuram	01e34b6a91	correct bug in fastmeans (ref #7899 ) (#8757 )	2017-05-23 12:40:49 +03:00
Alexander Alekhin	df5c090f2e	Merge pull request #8761 from kvaghel1:Issue-8760 Correct findChessboardCorners flags naming in calib3d doc. (#8761)	2017-05-22 16:46:59 +03:00
kvaghel1	27213a845f	Correct findChessboardCorners flags naming in calib3d doc.	2017-05-21 21:12:19 -04:00
Alexander Alekhin	91a6940930	Merge pull request #8574 from elmewo:fix-affine-constructor fix creation homogeneous affine matrix when constructing from 4x3 cv::Mat	2017-04-25 19:04:51 +03:00
Alexander Alekhin	7577f1420d	Merge pull request #8592 from tomoaki0705:fixTypoCalib3d24 calib3d: fix typo	2017-04-17 17:22:29 +03:00
Tomoaki Teshima	c72a191145	fix typo	2017-04-17 22:13:10 +09:00
André Mewes	34d7b96bfc	create homogeneous affine matrix when constructing from 4x3 cv::Mat	2017-04-13 14:39:10 +02:00
Alexander Alekhin	160f26192c	Merge pull request #8562 from alalek:fix_ffmpeg_check_2.4 (2.4) ffmpeg: add __STDC_CONSTANT_MACROS to check code	2017-04-11 16:27:25 +03:00
Alexander Alekhin	9e76ba5ccd	ffmpeg: add __STDC_CONSTANT_MACROS to check code	2017-04-11 12:45:10 +03:00
Alexander Alekhin	ec784331fb	Merge pull request #8353 from lpetre:backport_3593 backport of PR #3593	2017-03-13 10:01:07 +00:00
Adam Borowski	61936eb1a4	Get rid of sysctl includes on Linux. The 'sysctl' syscall has been strongly deprecated on Linux for ages. Currently, on old architectures it will spam syslog whenever used, and on newer ones it's missing from the headers altogether. Opencv has migrated away on Linux already, but #includes were left lingering. This commit removes them on non-__APPLE__, unbreaking x32 (and probably others).	2017-03-10 16:40:29 +00:00
Alexander Alekhin	d856604a4a	Merge pull request #8322 from StevenPuttemans:backport_8207 backport of PR #8207	2017-03-06 16:07:27 +00:00
StevenPuttemans	ab806b63a7	backport of PR #8207	2017-03-06 14:03:26 +01:00
Alexander Alekhin	0051744fa0	Merge pull request #8267 from umbraclet16:fixCalibSample Solve issue #8264	2017-02-28 11:47:37 +00:00
umbraclet16	b8d99e1ffb	Solve issue #8264 Fix bug in camera_calibration.cpp that the program tries to parse input of type VIDEO_FILE as IMAGE_LIST which causes the program to crash.	2017-02-25 16:16:23 +08:00
Alexander Alekhin	54f65a4672	Merge pull request #8002 from alalek:c_defines_2.4 (2.4) cmake: add defines to enable useful macroses	2017-02-14 19:09:17 +03:00
Alexander Alekhin	d103c116db	Merge pull request #8031 from terfendail:shortline_fix_2.4 Backport of PR #7161 fix for drawing beyond 32768 range	2017-02-14 19:08:09 +03:00
Alexander Alekhin	e304795622	cmake: add defines to enable useful macroses	2017-02-13 15:01:23 +03:00
Alexander Alekhin	ebae963884	drawing: workaround MSVC2010 32-bit compiler bug	2017-02-02 21:01:28 +03:00
Vadim Pisarevsky	19e4c7727b	Merge pull request #7546 from savuor:fix2.4/yuv_channel_order	2017-01-31 16:12:12 +00:00
Alexander Alekhin	f2a59b3d94	Merge pull request #7913 from DabeDotCom:CoreImage-pre_Xcode_7	2017-01-19 16:18:40 +00:00
Dabrien 'Dabe' Murphy	88bc0f7838	Fix 7606 "ld: framework not found CoreImage" Bug This affects OpenCV 2.4 on older Macs with Xcode versions before 7.0 (i.e., Mac OS X versions older than 10.11 El Capitan)	2017-01-19 17:07:01 +03:00
Vitaly Tuzov	2346ba7ea2	Backport of PR #7161 fix for drawing beyond 32768 range	2017-01-18 17:02:52 +03:00
parismita	f5db748312	Update linux_install.rst (#7776 ) * Update linux_install.rst whitespace between -D and \<option\> removed * Update linux_install.rst * Update linux_install.rst * Update linux_install.rst * Update linux_install.rst * Update linux_install.rst * Update linux_install.rst * Update linux_install.rst * Update linux_install.rst * Update linux_install.rst	2017-01-10 15:13:41 +03:00
Alexander Alekhin	3e66654963	Merge pull request #7973 from sturkmen72:patch-2	2017-01-06 11:07:23 +00:00
Suleyman TURKMEN	f108795e2c	Update sift.cpp	2017-01-05 19:47:34 +02:00
Alexander Alekhin	6ed571b3c6	Merge pull request #7893 from alalek:fix_ffmpeg_check_2.4	2016-12-19 14:32:42 +00:00
Alexander Alekhin	9d45f15627	cmake: fix ffmpeg check code	2016-12-19 00:22:16 +03:00
Alexander Alekhin	d7504ecaed	OpenCV version++	2016-12-16 16:19:56 +03:00
Rostislav Vasilikhin	d23190dc3e	fixed channel order from YVU to YUV	2016-11-03 17:37:22 +03:00
Rostislav Vasilikhin	e3070ed553	fixed YUV channel equivalence	2016-10-25 16:32:04 +03:00