diff --git a/modules/androidcamera/camera_wrapper/camera_wrapper.cpp b/modules/androidcamera/camera_wrapper/camera_wrapper.cpp index 66678c558f..351a6fe3d4 100644 --- a/modules/androidcamera/camera_wrapper/camera_wrapper.cpp +++ b/modules/androidcamera/camera_wrapper/camera_wrapper.cpp @@ -25,6 +25,7 @@ #elif defined(ANDROID_r4_3_0) || defined(ANDROID_r4_4_0) # include # include +# include #else # include #endif @@ -683,6 +684,7 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback, # elif defined(ANDROID_r4_4_0) void* buffer_queue_obj = operator new(sizeof(BufferQueue) + MAGIC_TAIL); handler->queue = new(buffer_queue_obj) BufferQueue(); + handler->queue->setConsumerUsageBits(GraphicBuffer::USAGE_HW_TEXTURE); void* consumer_listener_obj = operator new(sizeof(ConsumerListenerStub) + MAGIC_TAIL); handler->listener = new(consumer_listener_obj) ConsumerListenerStub(); handler->queue->consumerConnect(handler->listener, true); @@ -1087,6 +1089,7 @@ void CameraHandler::applyProperties(CameraHandler** ppcameraHandler) # elif defined(ANDROID_r4_4_0) void* buffer_queue_obj = operator new(sizeof(BufferQueue) + MAGIC_TAIL); handler->queue = new(buffer_queue_obj) BufferQueue(); + handler->queue->setConsumerUsageBits(GraphicBuffer::USAGE_HW_TEXTURE); handler->queue->consumerConnect(handler->listener, true); bufferStatus = handler->camera->setPreviewTarget(handler->queue); if (bufferStatus != 0) diff --git a/modules/calib3d/include/opencv2/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d.hpp index 65cf557b4b..66ffe2c1d3 100644 --- a/modules/calib3d/include/opencv2/calib3d.hpp +++ b/modules/calib3d/include/opencv2/calib3d.hpp @@ -166,7 +166,7 @@ pattern (every view is described by several 3D-2D point correspondences). \f[x' = (\theta_d / r) x \\ y' = (\theta_d / r) y \f] - Finally, convertion into pixel coordinates: The final pixel coordinates vector [u; v] where: + Finally, conversion into pixel coordinates: The final pixel coordinates vector [u; v] where: \f[u = f_x (x' + \alpha y') + c_x \\ v = f_y yy + c_y\f] diff --git a/modules/calib3d/src/stereobm.cpp b/modules/calib3d/src/stereobm.cpp index f093f2b2ba..78152b33d5 100644 --- a/modules/calib3d/src/stereobm.cpp +++ b/modules/calib3d/src/stereobm.cpp @@ -215,7 +215,42 @@ prefilterXSobel( const Mat& src, Mat& dst, int ftzero ) dptr0[0] = dptr0[size.width-1] = dptr1[0] = dptr1[size.width-1] = val0; x = 1; -#if CV_SSE2 +#if CV_NEON + int16x8_t ftz = vdupq_n_s16 ((short) ftzero); + uint8x8_t ftz2 = vdup_n_u8 (cv::saturate_cast(ftzero*2)); + + for(; x <=size.width-9; x += 8 ) + { + uint8x8_t c0 = vld1_u8 (srow0 + x - 1); + uint8x8_t c1 = vld1_u8 (srow1 + x - 1); + uint8x8_t d0 = vld1_u8 (srow0 + x + 1); + uint8x8_t d1 = vld1_u8 (srow1 + x + 1); + + int16x8_t t0 = vreinterpretq_s16_u16 (vsubl_u8 (d0, c0)); + int16x8_t t1 = vreinterpretq_s16_u16 (vsubl_u8 (d1, c1)); + + uint8x8_t c2 = vld1_u8 (srow2 + x - 1); + uint8x8_t c3 = vld1_u8 (srow3 + x - 1); + uint8x8_t d2 = vld1_u8 (srow2 + x + 1); + uint8x8_t d3 = vld1_u8 (srow3 + x + 1); + + int16x8_t t2 = vreinterpretq_s16_u16 (vsubl_u8 (d2, c2)); + int16x8_t t3 = vreinterpretq_s16_u16 (vsubl_u8 (d3, c3)); + + int16x8_t v0 = vaddq_s16 (vaddq_s16 (t2, t0), vaddq_s16 (t1, t1)); + int16x8_t v1 = vaddq_s16 (vaddq_s16 (t3, t1), vaddq_s16 (t2, t2)); + + + uint8x8_t v0_u8 = vqmovun_s16 (vaddq_s16 (v0, ftz)); + uint8x8_t v1_u8 = vqmovun_s16 (vaddq_s16 (v1, ftz)); + v0_u8 = vmin_u8 (v0_u8, ftz2); + v1_u8 = vmin_u8 (v1_u8, ftz2); + vqmovun_s16 (vaddq_s16 (v1, ftz)); + + vst1_u8 (dptr0 + x, v0_u8); + vst1_u8 (dptr1 + x, v1_u8); + } +#elif CV_SSE2 if( useSIMD ) { __m128i z = _mm_setzero_si128(), ftz = _mm_set1_epi16((short)ftzero), @@ -260,10 +295,19 @@ prefilterXSobel( const Mat& src, Mat& dst, int ftzero ) } } +#if CV_NEON + uint8x16_t val0_16 = vdupq_n_u8 (val0); +#endif + for( ; y < size.height; y++ ) { uchar* dptr = dst.ptr(y); - for( x = 0; x < size.width; x++ ) + x = 0; + #if CV_NEON + for(; x <= size.width-16; x+=16 ) + vst1q_u8 (dptr + x, val0_16); + #endif + for(; x < size.width; x++ ) dptr[x] = val0; } } @@ -525,6 +569,7 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right, Mat& disp, Mat& cost, const StereoBMParams& state, uchar* buf, int _dy0, int _dy1 ) { + const int ALIGN = 16; int x, y, d; int wsz = state.SADWindowSize, wsz2 = wsz/2; @@ -540,6 +585,15 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right, int uniquenessRatio = state.uniquenessRatio; short FILTERED = (short)((mindisp - 1) << DISPARITY_SHIFT); +#if CV_NEON + CV_Assert (ndisp % 8 == 0); + int32_t d0_4_temp [4]; + for (int i = 0; i < 4; i ++) + d0_4_temp[i] = i; + int32x4_t d0_4 = vld1q_s32 (d0_4_temp); + int32x4_t dd_4 = vdupq_n_s32 (4); +#endif + int *sad, *hsad0, *hsad, *hsad_sub, *htext; uchar *cbuf0, *cbuf; const uchar* lptr0 = left.ptr() + lofs; @@ -574,12 +628,29 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right, for( y = -dy0; y < height + dy1; y++, hsad += ndisp, cbuf += ndisp, lptr += sstep, rptr += sstep ) { int lval = lptr[0]; + #if CV_NEON + int16x8_t lv = vdupq_n_s16 ((int16_t)lval); + + for( d = 0; d < ndisp; d += 8 ) + { + int16x8_t rv = vreinterpretq_s16_u16 (vmovl_u8 (vld1_u8 (rptr + d))); + int32x4_t hsad_l = vld1q_s32 (hsad + d); + int32x4_t hsad_h = vld1q_s32 (hsad + d + 4); + int16x8_t diff = vabdq_s16 (lv, rv); + vst1_u8 (cbuf + d, vmovn_u16(vreinterpretq_u16_s16(diff))); + hsad_l = vaddq_s32 (hsad_l, vmovl_s16(vget_low_s16 (diff))); + hsad_h = vaddq_s32 (hsad_h, vmovl_s16(vget_high_s16 (diff))); + vst1q_s32 ((hsad + d), hsad_l); + vst1q_s32 ((hsad + d + 4), hsad_h); + } + #else for( d = 0; d < ndisp; d++ ) { int diff = std::abs(lval - rptr[d]); cbuf[d] = (uchar)diff; hsad[d] = (int)(hsad[d] + diff); } + #endif htext[y] += tab[lval]; } } @@ -609,12 +680,31 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right, hsad += ndisp, lptr += sstep, lptr_sub += sstep, rptr += sstep ) { int lval = lptr[0]; + #if CV_NEON + int16x8_t lv = vdupq_n_s16 ((int16_t)lval); + for( d = 0; d < ndisp; d += 8 ) + { + int16x8_t rv = vreinterpretq_s16_u16 (vmovl_u8 (vld1_u8 (rptr + d))); + int32x4_t hsad_l = vld1q_s32 (hsad + d); + int32x4_t hsad_h = vld1q_s32 (hsad + d + 4); + int16x8_t cbs = vreinterpretq_s16_u16 (vmovl_u8 (vld1_u8 (cbuf_sub + d))); + int16x8_t diff = vabdq_s16 (lv, rv); + int32x4_t diff_h = vsubl_s16 (vget_high_s16 (diff), vget_high_s16 (cbs)); + int32x4_t diff_l = vsubl_s16 (vget_low_s16 (diff), vget_low_s16 (cbs)); + vst1_u8 (cbuf + d, vmovn_u16(vreinterpretq_u16_s16(diff))); + hsad_h = vaddq_s32 (hsad_h, diff_h); + hsad_l = vaddq_s32 (hsad_l, diff_l); + vst1q_s32 ((hsad + d), hsad_l); + vst1q_s32 ((hsad + d + 4), hsad_h); + } + #else for( d = 0; d < ndisp; d++ ) { int diff = std::abs(lval - rptr[d]); cbuf[d] = (uchar)diff; hsad[d] = hsad[d] + diff - cbuf_sub[d]; } + #endif htext[y] += tab[lval] - tab[lptr_sub[0]]; } @@ -630,8 +720,24 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right, hsad = hsad0 + (1 - dy0)*ndisp; for( y = 1 - dy0; y < wsz2; y++, hsad += ndisp ) + { + #if CV_NEON + for( d = 0; d <= ndisp-8; d += 8 ) + { + int32x4_t s0 = vld1q_s32 (sad + d); + int32x4_t s1 = vld1q_s32 (sad + d + 4); + int32x4_t t0 = vld1q_s32 (hsad + d); + int32x4_t t1 = vld1q_s32 (hsad + d + 4); + s0 = vaddq_s32 (s0, t0); + s1 = vaddq_s32 (s1, t1); + vst1q_s32 (sad + d, s0); + vst1q_s32 (sad + d + 4, s1); + } + #else for( d = 0; d < ndisp; d++ ) sad[d] = (int)(sad[d] + hsad[d]); + #endif + } int tsum = 0; for( y = -wsz2-1; y < wsz2; y++ ) tsum += htext[y]; @@ -642,7 +748,61 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right, int minsad = INT_MAX, mind = -1; hsad = hsad0 + MIN(y + wsz2, height+dy1-1)*ndisp; hsad_sub = hsad0 + MAX(y - wsz2 - 1, -dy0)*ndisp; + #if CV_NEON + int32x4_t minsad4 = vdupq_n_s32 (INT_MAX); + int32x4_t mind4 = vdupq_n_s32(0), d4 = d0_4; + + for( d = 0; d <= ndisp-8; d += 8 ) + { + int32x4_t u0 = vld1q_s32 (hsad_sub + d); + int32x4_t u1 = vld1q_s32 (hsad + d); + + int32x4_t v0 = vld1q_s32 (hsad_sub + d + 4); + int32x4_t v1 = vld1q_s32 (hsad + d + 4); + + int32x4_t usad4 = vld1q_s32(sad + d); + int32x4_t vsad4 = vld1q_s32(sad + d + 4); + + u1 = vsubq_s32 (u1, u0); + v1 = vsubq_s32 (v1, v0); + usad4 = vaddq_s32 (usad4, u1); + vsad4 = vaddq_s32 (vsad4, v1); + + uint32x4_t mask = vcgtq_s32 (minsad4, usad4); + minsad4 = vminq_s32 (minsad4, usad4); + mind4 = vbslq_s32(mask, d4, mind4); + + vst1q_s32 (sad + d, usad4); + vst1q_s32 (sad + d + 4, vsad4); + d4 = vaddq_s32 (d4, dd_4); + + mask = vcgtq_s32 (minsad4, vsad4); + minsad4 = vminq_s32 (minsad4, vsad4); + mind4 = vbslq_s32(mask, d4, mind4); + + d4 = vaddq_s32 (d4, dd_4); + + } + int32x2_t mind4_h = vget_high_s32 (mind4); + int32x2_t mind4_l = vget_low_s32 (mind4); + int32x2_t minsad4_h = vget_high_s32 (minsad4); + int32x2_t minsad4_l = vget_low_s32 (minsad4); + + uint32x2_t mask = vorr_u32 (vclt_s32 (minsad4_h, minsad4_l), vand_u32 (vceq_s32 (minsad4_h, minsad4_l), vclt_s32 (mind4_h, mind4_l))); + mind4_h = vbsl_s32 (mask, mind4_h, mind4_l); + minsad4_h = vbsl_s32 (mask, minsad4_h, minsad4_l); + + mind4_l = vext_s32 (mind4_h,mind4_h,1); + minsad4_l = vext_s32 (minsad4_h,minsad4_h,1); + + mask = vorr_u32 (vclt_s32 (minsad4_h, minsad4_l), vand_u32 (vceq_s32 (minsad4_h, minsad4_l), vclt_s32 (mind4_h, mind4_l))); + mind4_h = vbsl_s32 (mask, mind4_h, mind4_l); + minsad4_h = vbsl_s32 (mask, minsad4_h, minsad4_l); + + mind = (int) vget_lane_s32 (mind4_h, 0); + minsad = sad[mind]; + #else for( d = 0; d < ndisp; d++ ) { int currsad = sad[d] + hsad[d] - hsad_sub[d]; @@ -653,6 +813,7 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right, mind = d; } } + #endif tsum += htext[y + wsz2] - htext[y - wsz2 - 1]; if( tsum < textureThreshold ) diff --git a/modules/core/doc/intro.markdown b/modules/core/doc/intro.markdown index ee4030d0d9..964fb06331 100644 --- a/modules/core/doc/intro.markdown +++ b/modules/core/doc/intro.markdown @@ -236,7 +236,7 @@ Multi-channel (n-channel) types can be specified using the following options: the number of channels is more than 4 or unknown at the compilation time. @note `CV_32FC1 == CV_32F, CV_32FC2 == CV_32FC(2) == CV_MAKETYPE(CV_32F, 2)`, and -`CV_MAKETYPE(depth, n) == ((x&7)<<3) + (n-1)``. This means that the constant type is formed from the +`CV_MAKETYPE(depth, n) == ((depth&7) + ((n-1)<<3)``. This means that the constant type is formed from the depth, taking the lowest 3 bits, and the number of channels minus 1, taking the next `log2(CV_CN_MAX)`` bits. diff --git a/modules/core/include/opencv2/core/matx.hpp b/modules/core/include/opencv2/core/matx.hpp index 6cc5d06251..2a17744e5e 100644 --- a/modules/core/include/opencv2/core/matx.hpp +++ b/modules/core/include/opencv2/core/matx.hpp @@ -134,7 +134,7 @@ public: //! dot product computed in double-precision arithmetics double ddot(const Matx<_Tp, m, n>& v) const; - //! convertion to another data type + //! conversion to another data type template operator Matx() const; //! change the matrix shape @@ -337,7 +337,7 @@ public: For other dimensionalities the exception is raised */ Vec cross(const Vec& v) const; - //! convertion to another data type + //! conversion to another data type template operator Vec() const; /*! element access */ diff --git a/modules/core/src/matop.cpp b/modules/core/src/matop.cpp index 243c821a59..a0ee4316d9 100644 --- a/modules/core/src/matop.cpp +++ b/modules/core/src/matop.cpp @@ -203,7 +203,11 @@ public: static void makeExpr(MatExpr& res, int method, int ndims, const int* sizes, int type, double alpha=1); }; -static MatOp_Initializer g_MatOp_Initializer; +static MatOp_Initializer* getGlobalMatOpInitializer() +{ + static MatOp_Initializer initializer; + return &initializer; +} static inline bool isIdentity(const MatExpr& e) { return e.op == &g_MatOp_Identity; } static inline bool isAddEx(const MatExpr& e) { return e.op == &g_MatOp_AddEx; } @@ -216,7 +220,7 @@ static inline bool isInv(const MatExpr& e) { return e.op == &g_MatOp_Invert; } static inline bool isSolve(const MatExpr& e) { return e.op == &g_MatOp_Solve; } static inline bool isGEMM(const MatExpr& e) { return e.op == &g_MatOp_GEMM; } static inline bool isMatProd(const MatExpr& e) { return e.op == &g_MatOp_GEMM && (!e.c.data || e.beta == 0); } -static inline bool isInitializer(const MatExpr& e) { return e.op == &g_MatOp_Initializer; } +static inline bool isInitializer(const MatExpr& e) { return e.op == getGlobalMatOpInitializer(); } ///////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1043,14 +1047,14 @@ MatExpr min(const Mat& a, const Mat& b) MatExpr min(const Mat& a, double s) { MatExpr e; - MatOp_Bin::makeExpr(e, 'm', a, s); + MatOp_Bin::makeExpr(e, 'n', a, s); return e; } MatExpr min(double s, const Mat& a) { MatExpr e; - MatOp_Bin::makeExpr(e, 'm', a, s); + MatOp_Bin::makeExpr(e, 'n', a, s); return e; } @@ -1064,14 +1068,14 @@ MatExpr max(const Mat& a, const Mat& b) MatExpr max(const Mat& a, double s) { MatExpr e; - MatOp_Bin::makeExpr(e, 'M', a, s); + MatOp_Bin::makeExpr(e, 'N', a, s); return e; } MatExpr max(double s, const Mat& a) { MatExpr e; - MatOp_Bin::makeExpr(e, 'M', a, s); + MatOp_Bin::makeExpr(e, 'N', a, s); return e; } @@ -1337,13 +1341,13 @@ void MatOp_Bin::assign(const MatExpr& e, Mat& m, int _type) const bitwise_xor(e.a, e.s, dst); else if( e.flags == '~' && !e.b.data ) bitwise_not(e.a, dst); - else if( e.flags == 'm' && e.b.data ) + else if( e.flags == 'm' ) cv::min(e.a, e.b, dst); - else if( e.flags == 'm' && !e.b.data ) + else if( e.flags == 'n' ) cv::min(e.a, e.s[0], dst); - else if( e.flags == 'M' && e.b.data ) + else if( e.flags == 'M' ) cv::max(e.a, e.b, dst); - else if( e.flags == 'M' && !e.b.data ) + else if( e.flags == 'N' ) cv::max(e.a, e.s[0], dst); else if( e.flags == 'a' && e.b.data ) cv::absdiff(e.a, e.b, dst); @@ -1580,12 +1584,12 @@ void MatOp_Initializer::multiply(const MatExpr& e, double s, MatExpr& res) const inline void MatOp_Initializer::makeExpr(MatExpr& res, int method, Size sz, int type, double alpha) { - res = MatExpr(&g_MatOp_Initializer, method, Mat(sz, type, (void*)0), Mat(), Mat(), alpha, 0); + res = MatExpr(getGlobalMatOpInitializer(), method, Mat(sz, type, (void*)0), Mat(), Mat(), alpha, 0); } inline void MatOp_Initializer::makeExpr(MatExpr& res, int method, int ndims, const int* sizes, int type, double alpha) { - res = MatExpr(&g_MatOp_Initializer, method, Mat(ndims, sizes, type, (void*)0), Mat(), Mat(), alpha, 0); + res = MatExpr(getGlobalMatOpInitializer(), method, Mat(ndims, sizes, type, (void*)0), Mat(), Mat(), alpha, 0); } /////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/modules/highgui/src/ppltasks_winrt.h b/modules/highgui/src/ppltasks_winrt.h index 1243baea97..c9867d8a56 100644 --- a/modules/highgui/src/ppltasks_winrt.h +++ b/modules/highgui/src/ppltasks_winrt.h @@ -8628,7 +8628,7 @@ auto when_all(_Iterator _Begin, _Iterator _End, Concurrency::cancellation_token #endif /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -8660,7 +8660,7 @@ task> operator&&(const task<_ReturnType> & _Lhs, const } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -8691,7 +8691,7 @@ task> operator&&(const task> & } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -8722,7 +8722,7 @@ task> operator&&(const task<_ReturnType> & _Lhs, const } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -8754,7 +8754,7 @@ task> operator&&(const task> & } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. diff --git a/modules/highgui/src/window_cocoa.mm b/modules/highgui/src/window_cocoa.mm index b9efe35bb0..56baded392 100644 --- a/modules/highgui/src/window_cocoa.mm +++ b/modules/highgui/src/window_cocoa.mm @@ -255,7 +255,7 @@ CV_IMPL void cvResizeWindow( const char* name, int width, int height) //cout << "cvResizeWindow" << endl; NSAutoreleasePool* localpool = [[NSAutoreleasePool alloc] init]; CVWindow *window = cvGetWindow(name); - if(window) { + if(window && ![window autosize]) { NSRect frame = [window frame]; frame.size.width = width; frame.size.height = height; diff --git a/modules/imgproc/include/opencv2/imgproc/types_c.h b/modules/imgproc/include/opencv2/imgproc/types_c.h index 6ec4bbb788..5ecb460782 100644 --- a/modules/imgproc/include/opencv2/imgproc/types_c.h +++ b/modules/imgproc/include/opencv2/imgproc/types_c.h @@ -462,7 +462,7 @@ enum }; /* -Internal structure that is used for sequental retrieving contours from the image. +Internal structure that is used for sequential retrieving contours from the image. It supports both hierarchical and plane variants of Suzuki algorithm. */ typedef struct _CvContourScanner* CvContourScanner; diff --git a/modules/imgproc/src/contours.cpp b/modules/imgproc/src/contours.cpp index 758ccb02bc..bb21e41067 100644 --- a/modules/imgproc/src/contours.cpp +++ b/modules/imgproc/src/contours.cpp @@ -125,7 +125,7 @@ _CvContourInfo; /* - Structure that is used for sequental retrieving contours from the image. + Structure that is used for sequential retrieving contours from the image. It supports both hierarchical and plane variants of Suzuki algorithm. */ typedef struct _CvContourScanner @@ -316,7 +316,7 @@ cvStartFindContours( void* _img, CvMemStorage* storage, tree. The retrieved contour itself is removed from the storage. Here two cases are possible: 2a. If one deals with plane variant of algorithm - (hierarchical strucutre is not reconstructed), + (hierarchical structure is not reconstructed), the contour is removed completely. 2b. In hierarchical case, the header of the contour is not removed. It's marked as "link to contour" and h_next pointer of it is set to @@ -328,8 +328,8 @@ cvStartFindContours( void* _img, CvMemStorage* storage, leaves header if hierarchical (but doesn't mark header as "link"). ------------------------------------------------------------------------ The 1st variant can be used to retrieve and store all the contours from the image - (with optional convertion from chains to contours using some approximation from - restriced set of methods). Some characteristics of contour can be computed in the + (with optional conversion from chains to contours using some approximation from + restricted set of methods). Some characteristics of contour can be computed in the same pass. The usage scheme can look like: diff --git a/modules/imgproc/src/filterengine.hpp b/modules/imgproc/src/filterengine.hpp index 0fd7931c2f..68875c078c 100644 --- a/modules/imgproc/src/filterengine.hpp +++ b/modules/imgproc/src/filterengine.hpp @@ -66,7 +66,7 @@ public: BaseRowFilter(); //! the destructor virtual ~BaseRowFilter(); - //! the filtering operator. Must be overrided in the derived classes. The horizontal border interpolation is done outside of the class. + //! the filtering operator. Must be overridden in the derived classes. The horizontal border interpolation is done outside of the class. virtual void operator()(const uchar* src, uchar* dst, int width, int cn) = 0; int ksize; @@ -94,7 +94,7 @@ public: BaseColumnFilter(); //! the destructor virtual ~BaseColumnFilter(); - //! the filtering operator. Must be overrided in the derived classes. The vertical border interpolation is done outside of the class. + //! the filtering operator. Must be overridden in the derived classes. The vertical border interpolation is done outside of the class. virtual void operator()(const uchar** src, uchar* dst, int dststep, int dstcount, int width) = 0; //! resets the internal buffers, if any virtual void reset(); diff --git a/modules/java/generator/src/java/android+JavaCameraView.java b/modules/java/generator/src/java/android+JavaCameraView.java index 09df4f85a7..fca29db6eb 100644 --- a/modules/java/generator/src/java/android+JavaCameraView.java +++ b/modules/java/generator/src/java/android+JavaCameraView.java @@ -148,7 +148,7 @@ public class JavaCameraView extends CameraBridgeViewBase implements PreviewCallb Log.d(TAG, "Set preview size to " + Integer.valueOf((int)frameSize.width) + "x" + Integer.valueOf((int)frameSize.height)); params.setPreviewSize((int)frameSize.width, (int)frameSize.height); - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH && !android.os.Build.MODEL.equals("GT-I9100")) params.setRecordingHint(true); List FocusModes = params.getSupportedFocusModes(); diff --git a/modules/photo/include/opencv2/photo.hpp b/modules/photo/include/opencv2/photo.hpp index c651b9ee33..3d969124e7 100644 --- a/modules/photo/include/opencv2/photo.hpp +++ b/modules/photo/include/opencv2/photo.hpp @@ -180,7 +180,7 @@ denoising time. Recommended value 21 pixels removes noise but also removes image details, smaller h value preserves details but also preserves some noise @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 +will be enough 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. diff --git a/modules/photo/include/opencv2/photo/cuda.hpp b/modules/photo/include/opencv2/photo/cuda.hpp index a5c83f7717..aeac1fa861 100644 --- a/modules/photo/include/opencv2/photo/cuda.hpp +++ b/modules/photo/include/opencv2/photo/cuda.hpp @@ -105,7 +105,7 @@ CV_EXPORTS void fastNlMeansDenoising(InputArray src, OutputArray dst, @param h_luminance Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise @param photo_render float 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 +enough to remove colored noise and do not distort colors @param search_window Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater search_window - greater denoising time. Recommended value 21 pixels diff --git a/modules/stitching/src/motion_estimators.cpp b/modules/stitching/src/motion_estimators.cpp index 873be6caa1..dd87725bb6 100644 --- a/modules/stitching/src/motion_estimators.cpp +++ b/modules/stitching/src/motion_estimators.cpp @@ -607,6 +607,11 @@ void waveCorrect(std::vector &rmats, WaveCorrectKind kind) #if ENABLE_LOG int64 t = getTickCount(); #endif + if (rmats.size() <= 1) + { + LOGLN("Wave correcting, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec"); + return; + } Mat moment = Mat::zeros(3, 3, CV_32F); for (size_t i = 0; i < rmats.size(); ++i) diff --git a/modules/ts/include/opencv2/ts.hpp b/modules/ts/include/opencv2/ts.hpp index 8d1c2c0fd5..4a08182c62 100644 --- a/modules/ts/include/opencv2/ts.hpp +++ b/modules/ts/include/opencv2/ts.hpp @@ -382,7 +382,7 @@ public: FAIL_HANG=-13, // unexpected response on passing bad arguments to the tested function - // (the function crashed, proceed succesfully (while it should not), or returned + // (the function crashed, proceed successfully (while it should not), or returned // error code that is different from what is expected) FAIL_BAD_ARG_CHECK=-14, @@ -392,7 +392,7 @@ public: // the test has been skipped because it is not in the selected subset of the tests to run, // because it has been run already within the same run with the same parameters, or because // of some other reason and this is not considered as an error. - // Normally TS::run() (or overrided method in the derived class) takes care of what + // Normally TS::run() (or overridden method in the derived class) takes care of what // needs to be run, so this code should not occur. SKIPPED=1 }; diff --git a/modules/videoio/src/cap_gstreamer.cpp b/modules/videoio/src/cap_gstreamer.cpp index d0854ce071..9d74df6eac 100644 --- a/modules/videoio/src/cap_gstreamer.cpp +++ b/modules/videoio/src/cap_gstreamer.cpp @@ -525,7 +525,7 @@ void CvCapture_GStreamer::newPad(GstElement * /*elem*/, * \brief CvCapture_GStreamer::open Open the given file with gstreamer * \param type CvCapture type. One of CV_CAP_GSTREAMER_* * \param filename Filename to open in case of CV_CAP_GSTREAMER_FILE - * \return boolean. Specifies if opening was succesful. + * \return boolean. Specifies if opening was successful. * * In case of CV_CAP_GSTREAMER_V4L(2), a pipelin is constructed as follows: * v4l2src ! autoconvert ! appsink diff --git a/modules/videoio/src/cap_ios_abstract_camera.mm b/modules/videoio/src/cap_ios_abstract_camera.mm index 1ded46a99f..565807cccc 100644 --- a/modules/videoio/src/cap_ios_abstract_camera.mm +++ b/modules/videoio/src/cap_ios_abstract_camera.mm @@ -193,6 +193,13 @@ // Release any retained subviews of the main view. // e.g. self.myOutlet = nil; + for (AVCaptureInput *input in self.captureSession.inputs) { + [self.captureSession removeInput:input]; + } + + for (AVCaptureOutput *output in self.captureSession.outputs) { + [self.captureSession removeOutput:output]; + } [self.captureSession stopRunning]; self.captureSession = nil; diff --git a/modules/videoio/src/cap_libv4l.cpp b/modules/videoio/src/cap_libv4l.cpp index 9eaa6374d5..daa450bfaa 100644 --- a/modules/videoio/src/cap_libv4l.cpp +++ b/modules/videoio/src/cap_libv4l.cpp @@ -102,7 +102,7 @@ I modified the following: autosetup_capture_mode_v4l2 -> autodetect capture modes for v4l2 - Modifications are according with Video4Linux old codes - Video4Linux handling is automatically if it does not recognize a Video4Linux2 device - - Tested succesful with Logitech Quickcam Express (V4L), Creative Vista (V4L) and Genius VideoCam Notebook (V4L2) + - Tested successfully with Logitech Quickcam Express (V4L), Creative Vista (V4L) and Genius VideoCam Notebook (V4L2) - Correct source lines with compiler warning messages - Information message from v4l/v4l2 detection @@ -113,7 +113,7 @@ I modified the following: - SN9C10x chip based webcams support - New methods are internal: bayer2rgb24, sonix_decompress -> decoder routines for SN9C10x decoding from Takafumi Mizuno with his pleasure :) - - Tested succesful with Genius VideoCam Notebook (V4L2) + - Tested successfully with Genius VideoCam Notebook (V4L2) Sixth Patch: Sept 10, 2005 Csaba Kertesz sign@freemail.hu For Release: OpenCV-Linux Beta5 OpenCV-0.9.7 @@ -123,7 +123,7 @@ I added the following: - Get and change V4L capture controls (hue, saturation, brightness, contrast) - New method is internal: icvSetControl -> set capture controls - - Tested succesful with Creative Vista (V4L) + - Tested successfully with Creative Vista (V4L) Seventh Patch: Sept 10, 2005 Csaba Kertesz sign@freemail.hu For Release: OpenCV-Linux Beta5 OpenCV-0.9.7 @@ -132,7 +132,7 @@ I added the following: - Detect, get and change V4L2 capture controls (hue, saturation, brightness, contrast, gain) - New methods are internal: v4l2_scan_controls_enumerate_menu, v4l2_scan_controls -> detect capture control intervals - - Tested succesful with Genius VideoCam Notebook (V4L2) + - Tested successfully with Genius VideoCam Notebook (V4L2) 8th patch: Jan 5, 2006, Olivier.Bornet@idiap.ch Add support of V4L2_PIX_FMT_YUYV and V4L2_PIX_FMT_MJPEG. diff --git a/modules/videoio/src/cap_mjpeg_encoder.cpp b/modules/videoio/src/cap_mjpeg_encoder.cpp index 2a8e0b9645..ee78809eb9 100644 --- a/modules/videoio/src/cap_mjpeg_encoder.cpp +++ b/modules/videoio/src/cap_mjpeg_encoder.cpp @@ -1237,10 +1237,10 @@ void MotionJpegWriter::writeFrameData( const uchar* data, int step, int colorspa } strm.jputShort(0*256 + 63); // start and end of spectral selection - for - // sequental DCT start is 0 and end is 63 + // sequential DCT start is 0 and end is 63 strm.putByte( 0 ); // successive approximation bit position - // high & low - (0,0) for sequental DCT + // high & low - (0,0) for sequential DCT unsigned currval = 0, code = 0, tempval = 0; int bit_idx = 32; diff --git a/modules/videoio/src/cap_v4l.cpp b/modules/videoio/src/cap_v4l.cpp index 6389d54135..791f0a2347 100644 --- a/modules/videoio/src/cap_v4l.cpp +++ b/modules/videoio/src/cap_v4l.cpp @@ -102,7 +102,7 @@ I modified the following: autosetup_capture_mode_v4l2 -> autodetect capture modes for v4l2 - Modifications are according with Video4Linux old codes - Video4Linux handling is automatically if it does not recognize a Video4Linux2 device - - Tested succesful with Logitech Quickcam Express (V4L), Creative Vista (V4L) and Genius VideoCam Notebook (V4L2) + - Tested successfully with Logitech Quickcam Express (V4L), Creative Vista (V4L) and Genius VideoCam Notebook (V4L2) - Correct source lines with compiler warning messages - Information message from v4l/v4l2 detection @@ -113,7 +113,7 @@ I modified the following: - SN9C10x chip based webcams support - New methods are internal: bayer2rgb24, sonix_decompress -> decoder routines for SN9C10x decoding from Takafumi Mizuno with his pleasure :) - - Tested succesful with Genius VideoCam Notebook (V4L2) + - Tested successfully with Genius VideoCam Notebook (V4L2) Sixth Patch: Sept 10, 2005 Csaba Kertesz sign@freemail.hu For Release: OpenCV-Linux Beta5 OpenCV-0.9.7 @@ -123,7 +123,7 @@ I added the following: - Get and change V4L capture controls (hue, saturation, brightness, contrast) - New method is internal: icvSetControl -> set capture controls - - Tested succesful with Creative Vista (V4L) + - Tested successfully with Creative Vista (V4L) Seventh Patch: Sept 10, 2005 Csaba Kertesz sign@freemail.hu For Release: OpenCV-Linux Beta5 OpenCV-0.9.7 @@ -132,7 +132,7 @@ I added the following: - Detect, get and change V4L2 capture controls (hue, saturation, brightness, contrast, gain) - New methods are internal: v4l2_scan_controls_enumerate_menu, v4l2_scan_controls -> detect capture control intervals - - Tested succesful with Genius VideoCam Notebook (V4L2) + - Tested successfully with Genius VideoCam Notebook (V4L2) 8th patch: Jan 5, 2006, Olivier.Bornet@idiap.ch Add support of V4L2_PIX_FMT_YUYV and V4L2_PIX_FMT_MJPEG. diff --git a/modules/videoio/src/ppltasks_winrt.hpp b/modules/videoio/src/ppltasks_winrt.hpp index 3eddd24ea7..8fe132a53f 100644 --- a/modules/videoio/src/ppltasks_winrt.hpp +++ b/modules/videoio/src/ppltasks_winrt.hpp @@ -8628,7 +8628,7 @@ auto when_all(_Iterator _Begin, _Iterator _End, Concurrency::cancellation_token #endif /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -8660,7 +8660,7 @@ task> operator&&(const task<_ReturnType> & _Lhs, const } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -8691,7 +8691,7 @@ task> operator&&(const task> & } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -8722,7 +8722,7 @@ task> operator&&(const task<_ReturnType> & _Lhs, const } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -8754,7 +8754,7 @@ task> operator&&(const task> & } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task.