Attachment #448054 for bug #594328

View | Details | Raw Unified | Return to bug 594328
Collapse All | Expand All




++ b/cmake/OpenCVPCHSupport.cmake

      ENDIF()
    endif()

    IF(CMAKE_COMPILER_IS_GNUCXX)

        GET_PROPERTY(_definitions DIRECTORY PROPERTY COMPILE_DEFINITIONS)
        if(_definitions)
          foreach(_def ${_definitions})
            LIST(APPEND ${_out_compile_flags} "\"-D${_def}\"")
          endforeach()
        endif()
        GET_TARGET_PROPERTY(_target_definitions ${_PCH_current_target} COMPILE_DEFINITIONS)
        if(_target_definitions)
          foreach(_def ${_target_definitions})
            LIST(APPEND ${_out_compile_flags} "\"-D${_def}\"")
          endforeach()
        endif()

    ELSE()
        ## TODO ... ? or does it work out of the box
    ENDIF()

    GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES )
    FOREACH(item ${DIRINC})
        if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")

        endif()
    ENDFOREACH(item)

    get_target_property(DIRINC ${_PCH_current_target} INCLUDE_DIRECTORIES )
    FOREACH(item ${DIRINC})
        if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")
          LIST(APPEND ${_out_compile_flags} "${_PCH_include_prefix}\"${item}\"")
        else()
          LIST(APPEND ${_out_compile_flags} "${_PCH_isystem_prefix}\"${item}\"")
        endif()
    ENDFOREACH(item)

    LIST(APPEND ${_out_compile_flags} ${CMAKE_CXX_FLAGS})

    SEPARATE_ARGUMENTS(${_out_compile_flags})

        # if you have different versions of the headers for different build types
        # you may set _pch_dowarn
        IF (_dowarn)
            SET(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -include \"${CMAKE_CURRENT_BINARY_DIR}/${_header_name}\" -Winvalid-pch " )
        ELSE (_dowarn)
            SET(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -include \"${CMAKE_CURRENT_BINARY_DIR}/${_header_name}\" " )
        ENDIF (_dowarn)

    ELSE(CMAKE_COMPILER_IS_GNUCXX)

        endif()
    endif()

    get_target_property(DIRINC ${_targetName} INCLUDE_DIRECTORIES)
    set_target_properties(${_targetName}_pch_dephelp PROPERTIES INCLUDE_DIRECTORIES "${DIRINC}")

    #MESSAGE("_compile_FLAGS: ${_compile_FLAGS}")
    #message("COMMAND ${CMAKE_CXX_COMPILER}	${_compile_FLAGS} -x c++-header -o ${_output} ${_input}")

    ADD_CUSTOM_COMMAND(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_name}"
      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_input}" "${CMAKE_CURRENT_BINARY_DIR}/${_name}" # ensure same directory! Required by gcc
      DEPENDS "${_input}"
      )






        if( norm(R1t*R1 - eye33) > 0.01 ||
            norm(R2t*R2 - eye33) > 0.01 ||
            std::abs(determinant(F)) > 0.01)
        {
            ts->printf( cvtest::TS::LOG, "The computed (by rectify) R1 and R2 are not orthogonal,"
                "or the computed (by calibrate) F is not singular, testcase %d\n", testcase);

        perspectiveTransform( _imgpt1, rectifPoints1, _H1 );
        perspectiveTransform( _imgpt2, rectifPoints2, _H2 );

        bool verticalStereo = std::abs(P2.at<double>(0,3)) < std::abs(P2.at<double>(1,3));
        double maxDiff_c = 0, maxDiff_uc = 0;
        for( int i = 0, k = 0; i < nframes; i++ )
        {


            for( int j = 0; j < npoints; j++, k++ )
            {
                double diff_c = verticalStereo ? std::abs(temp[0][j].x - temp[1][j].x) : std::abs(temp[0][j].y - temp[1][j].y);
                Point2f d = rectifPoints1.at<Point2f>(k,0) - rectifPoints2.at<Point2f>(k,0);
                double diff_uc = verticalStereo ? std::abs(d.x) : std::abs(d.y);
                maxDiff_c = max(maxDiff_c, diff_c);
                maxDiff_uc = max(maxDiff_uc, diff_uc);
                if( maxDiff_c > maxScanlineDistErr_c )

Lines 381-387 TEST_F(fisheyeTest, EtimateUncertainties) Link Here

(-)a/modules/calib3d/test/test_fisheye.cpp (-1 / +1 lines)
381	EXPECT_MAT_NEAR(errors.c, cv::Vec2d(0.890439368129246, 0.816096854937896), 1e-10);	381	EXPECT_MAT_NEAR(errors.c, cv::Vec2d(0.890439368129246, 0.816096854937896), 1e-10);
382	EXPECT_MAT_NEAR(errors.k, cv::Vec4d(0.00516248605191506, 0.0168181467500934, 0.0213118690274604, 0.00916010877545648), 1e-10);	382	EXPECT_MAT_NEAR(errors.k, cv::Vec4d(0.00516248605191506, 0.0168181467500934, 0.0213118690274604, 0.00916010877545648), 1e-10);
383	EXPECT_MAT_NEAR(err_std, cv::Vec2d(0.187475975266883, 0.185678953263995), 1e-10);	383	EXPECT_MAT_NEAR(err_std, cv::Vec2d(0.187475975266883, 0.185678953263995), 1e-10);
384	CV_Assert(abs(rms - 0.263782587133546) < 1e-10);	384	CV_Assert(std::abs(rms - 0.263782587133546) < 1e-10);
385	CV_Assert(errors.alpha == 0);	385	CV_Assert(errors.alpha == 0);
386	}	386	}
387		387




    for (int y=0;y<h;++y) {
        for (int x=0;x<w;++x) {
            // initialize
            annotate_img.at<Vec2i>(y,x)[0]=x;
            annotate_img.at<Vec2i>(y,x)[1]=y;
                annotate_img.at<Vec2i>(y,x)[1]=y;
            }

            uchar edge_val = edges_img.at<uchar>(y,x);
            if( (edge_val!=0) ) {

                dist_img.at<float>(ny,nx) = dist;
                q.push(std::make_pair(nx,ny));

                annotate_img.at<Vec2i>(ny,nx)[0]=annotate_img.at<Vec2i>(y,x)[0];
                annotate_img.at<Vec2i>(ny,nx)[1]=annotate_img.at<Vec2i>(y,x)[1];
                    annotate_img.at<Vec2i>(ny,nx)[1]=annotate_img.at<Vec2i>(y,x)[1];
                }
            }
        }
    }


    float cost = (sum_distance/truncate_)/addr.size();

    float* optr = orientation_img.ptr<float>(y)+x;
    float sum_orientation = 0;
    int cnt_orientation = 0;

    for (size_t i=0;i<addr.size();++i) {
        float* optr = orientation_img.ptr<float>(y)+x;
        float sum_orientation = 0;
        int cnt_orientation = 0;

        if(addr[i] < (orientation_img.cols*orientation_img.rows) - (offset.y*orientation_img.cols + offset.x)){
                            if (tpl->orientations[i]>=-CV_PI && (*(optr+addr[i]))>=-CV_PI) {
                sum_orientation += orientation_diff(tpl->orientations[i], (*(optr+addr[i])));
                cnt_orientation++;
                    sum_orientation += orientation_diff(tpl->orientations[i], (*(optr+addr[i])));
                    cnt_orientation++;
                }
            }
        }
    }

    if (cnt_orientation>0) {
                    cost = (float)(beta*cost+alpha*(sum_orientation/(2*CV_PI))/cnt_orientation);
        }

    }

    if(cost > 0){

Lines 913-919 -(int) updateImage { Link Here

(-)a/modules/highgui/src/cap_avfoundation.mm (-1 / +1 lines)
913	}	913	}
914		914
915		915
916	AVAssetReaderTrackOutput * output = [mMovieReader.outputs objectAtIndex:0];	916	AVAssetReaderOutput * output = [mMovieReader.outputs objectAtIndex:0];
917	CMSampleBufferRef sampleBuffer = [output copyNextSampleBuffer];	917	CMSampleBufferRef sampleBuffer = [output copyNextSampleBuffer];
918	if (!sampleBuffer) {	918	if (!sampleBuffer) {
919	[localpool drain];	919	[localpool drain];

Lines 297-303 - (IplImage*)getOutput; Link Here

(-)a/modules/highgui/src/cap_qtkit.mm (-1 / +1 lines)
297	// method exits immediately"	297	// method exits immediately"
298	// using usleep() is not a good alternative, because it may block the GUI.	298	// using usleep() is not a good alternative, because it may block the GUI.
299	// Create a dummy timer so that runUntilDate does not exit immediately:	299	// Create a dummy timer so that runUntilDate does not exit immediately:
300	[NSTimer scheduledTimerWithTimeInterval:100 target:nil selector:@selector(doFireTimer:) userInfo:nil repeats:YES];	300	[NSTimer scheduledTimerWithTimeInterval:100 target:capture selector:@selector(doFireTimer:) userInfo:nil repeats:YES];
301	while (![capture updateImage] && (total += sleepTime)<=timeOut) {	301	while (![capture updateImage] && (total += sleepTime)<=timeOut) {
302	[[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:sleepTime]];	302	[[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:sleepTime]];
303	}	303	}

Lines 247-253 if(ANDROID) Link Here

(-)a/modules/java/CMakeLists.txt (-1 / +1 lines)
247	# build the library project	247	# build the library project
248	# normally we should do this after a native part, but for a library project we can build the java part first	248	# normally we should do this after a native part, but for a library project we can build the java part first
249	add_custom_command(OUTPUT "${JAR_FILE}" "${JAR_FILE}.dephelper"	249	add_custom_command(OUTPUT "${JAR_FILE}" "${JAR_FILE}.dephelper"
250	COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug	250	COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug -Djava.target=1.6 -Djava.source=1.6
251	COMMAND ${CMAKE_COMMAND} -E touch "${JAR_FILE}.dephelper" # can not rely on classes.jar because different versions of SDK update timestamp at different times	251	COMMAND ${CMAKE_COMMAND} -E touch "${JAR_FILE}.dephelper" # can not rely on classes.jar because different versions of SDK update timestamp at different times
252	WORKING_DIRECTORY "${OpenCV_BINARY_DIR}"	252	WORKING_DIRECTORY "${OpenCV_BINARY_DIR}"
253	DEPENDS ${step3_depends}	253	DEPENDS ${step3_depends}

Lines 43-49 list(APPEND opencv_test_java_file_deps ${android_proj_target_files}) Link Here

(-)a/modules/java/android_test/CMakeLists.txt (-1 / +1 lines)
43	add_custom_command(	43	add_custom_command(
44	OUTPUT "${opencv_test_java_bin_dir}/bin/OpenCVTest-debug.apk"	44	OUTPUT "${opencv_test_java_bin_dir}/bin/OpenCVTest-debug.apk"
45	COMMAND ${CMAKE_COMMAND} -E copy "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}/libopencv_java.so" "${opencv_test_java_bin_dir}/libs/${ANDROID_NDK_ABI_NAME}/libopencv_java.so"	45	COMMAND ${CMAKE_COMMAND} -E copy "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}/libopencv_java.so" "${opencv_test_java_bin_dir}/libs/${ANDROID_NDK_ABI_NAME}/libopencv_java.so"
46	COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug	46	COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug -Djava.target=1.6 -Djava.source=1.6
47	COMMAND ${CMAKE_COMMAND} -E touch "${opencv_test_java_bin_dir}/bin/OpenCVTest-debug.apk" # needed because ant does not update the timestamp of updated apk	47	COMMAND ${CMAKE_COMMAND} -E touch "${opencv_test_java_bin_dir}/bin/OpenCVTest-debug.apk" # needed because ant does not update the timestamp of updated apk
48	WORKING_DIRECTORY "${opencv_test_java_bin_dir}"	48	WORKING_DIRECTORY "${opencv_test_java_bin_dir}"
49	MAIN_DEPENDENCY "${opencv_test_java_bin_dir}/${ANDROID_MANIFEST_FILE}"	49	MAIN_DEPENDENCY "${opencv_test_java_bin_dir}/${ANDROID_MANIFEST_FILE}"

Lines 1880-1886 bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses, Link Here

(-)a/modules/ml/src/svm.cpp (-2 / +2 lines)
1880	qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio);	1880	qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio);
1881	double old_dist = 0.0;	1881	double old_dist = 0.0;
1882	for (int k=0; k<k_fold; ++k)	1882	for (int k=0; k<k_fold; ++k)
1883	old_dist += abs(ratios[k].val-class_ratio);	1883	old_dist += std::abs(ratios[k].val-class_ratio);
1884	double new_dist = 1.0;	1884	double new_dist = 1.0;
1885	// iterate to make the folds more balanced	1885	// iterate to make the folds more balanced
1886	while (new_dist > 0.0)	1886	while (new_dist > 0.0)
Lines 1897-1903 bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses, Link Here
1897	qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio);	1897	qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio);
1898	new_dist = 0.0;	1898	new_dist = 0.0;
1899	for (int k=0; k<k_fold; ++k)	1899	for (int k=0; k<k_fold; ++k)
1900	new_dist += abs(ratios[k].val-class_ratio);	1900	new_dist += std::abs(ratios[k].val-class_ratio);
1901	if (new_dist < old_dist)	1901	if (new_dist < old_dist)
1902	{	1902	{
1903	// swapping really improves, so swap the samples	1903	// swapping really improves, so swap the samples




            minlocVal_ = src1_roi.at<float>(minLoc_);
            maxlocVal = src1_roi.at<float>(maxLoc);
            maxlocVal_ = src1_roi.at<float>(maxLoc_);
            error0 = std::abs(src1_roi.at<float>(minLoc_) - src1_roi.at<float>(minLoc));
            error1 = std::abs(src1_roi.at<float>(maxLoc_) - src1_roi.at<float>(maxLoc));
        }
        if (oneDepth == 6)
        {

            minlocVal_ = src1_roi.at<double>(minLoc_);
            maxlocVal = src1_roi.at<double>(maxLoc);
            maxlocVal_ = src1_roi.at<double>(maxLoc_);
            error0 = std::abs(src1_roi.at<double>(minLoc_) - src1_roi.at<double>(minLoc));
            error1 = std::abs(src1_roi.at<double>(maxLoc_) - src1_roi.at<double>(maxLoc));
        }

        EXPECT_DOUBLE_EQ(minVal_, minVal);

            minlocVal_ = src1_roi.at<float>(minLoc_);
            maxlocVal = src1_roi.at<float>(maxLoc);
            maxlocVal_ = src1_roi.at<float>(maxLoc_);
            error0 = std::abs(src1_roi.at<float>(minLoc_) - src1_roi.at<float>(minLoc));
            error1 = std::abs(src1_roi.at<float>(maxLoc_) - src1_roi.at<float>(maxLoc));
        }
        if (oneDepth == 6)
        {

            minlocVal_ = src1_roi.at<double>(minLoc_);
            maxlocVal = src1_roi.at<double>(maxLoc);
            maxlocVal_ = src1_roi.at<double>(maxLoc_);
            error0 = std::abs(src1_roi.at<double>(minLoc_) - src1_roi.at<double>(minLoc));
            error1 = std::abs(src1_roi.at<double>(maxLoc_) - src1_roi.at<double>(maxLoc));
        }

        EXPECT_DOUBLE_EQ(minVal_, minVal);

Lines 418-425 namespace cvtest Link Here

(-)a/modules/ts/src/gpu_test.cpp (-2 / +2 lines)
418		418
419	if (dist < maxPtDif &&	419	if (dist < maxPtDif &&
420	fabs(p1.size - p2.size) < maxSizeDif &&	420	fabs(p1.size - p2.size) < maxSizeDif &&
421	abs(p1.angle - p2.angle) < maxAngleDif &&	421	std::abs(p1.angle - p2.angle) < maxAngleDif &&
422	abs(p1.response - p2.response) < maxResponseDif &&	422	std::abs(p1.response - p2.response) < maxResponseDif &&
423	p1.octave == p2.octave &&	423	p1.octave == p2.octave &&
424	p1.class_id == p2.class_id)	424	p1.class_id == p2.class_id)
425	{	425	{






macro( ANDROID_GET_ABI_RAWNAME TOOLCHAIN_FLAG VAR )
 if( "x${TOOLCHAIN_FLAG}" STREQUAL "xARMEABI" )
  set( ${VAR} "armeabi" )
 elseif( "x${TOOLCHAIN_FLAG}" STREQUAL "xARMEABI_V7A" )
  set( ${VAR} "armeabi-v7a" )
 elseif( "x${TOOLCHAIN_FLAG}" STREQUAL "xX86" )
  set( ${VAR} "x86" )
 elseif( "x${TOOLCHAIN_FLAG}" STREQUAL "xMIPS" )
  set( ${VAR} "mips" )
 else()
  set( ${VAR} "unknown" )

                ANDROID_APP_PIE
                )
  if( DEFINED ${__var} )
   if( "${${__var}}" MATCHES " ")
    set( __toolchain_config "${__toolchain_config}set( ${__var} \"${${__var}}\" CACHE INTERNAL \"\" )\n" )
   else()
    set( __toolchain_config "${__toolchain_config}set( ${__var} ${${__var}} CACHE INTERNAL \"\" )\n" )

Lines 24-31 static void colorizeFlow(const Mat &u, const Mat &v, Mat &dst) Link Here

(-)a/samples/gpu/farneback_optical_flow.cpp (-2 / +2 lines)
24	minMaxLoc(u, &uMin, &uMax, 0, 0);	24	minMaxLoc(u, &uMin, &uMax, 0, 0);
25	double vMin, vMax;	25	double vMin, vMax;
26	minMaxLoc(v, &vMin, &vMax, 0, 0);	26	minMaxLoc(v, &vMin, &vMax, 0, 0);
27	uMin = ::abs(uMin); uMax = ::abs(uMax);	27	uMin = std::abs(uMin); uMax = std::abs(uMax);
28	vMin = ::abs(vMin); vMax = ::abs(vMax);	28	vMin = std::abs(vMin); vMax = std::abs(vMax);
29	float dMax = static_cast<float>(::max(::max(uMin, uMax), ::max(vMin, vMax)));	29	float dMax = static_cast<float>(::max(::max(uMin, uMax), ::max(vMin, vMax)));
30		30
31	dst.create(u.size(), CV_8UC3);	31	dst.create(u.size(), CV_8UC3);

Return to bug 594328

Lines 966-975 void ChamferMatcher::Matching::computeDistanceTransform(Mat& edges_img, Mat& dis Link Here

(-)a/modules/contrib/src/chamfermatching.cpp (-23 / +15 lines)
966	for (int y=0;y<h;++y) {	966	for (int y=0;y<h;++y) {
967	for (int x=0;x<w;++x) {	967	for (int x=0;x<w;++x) {
968	// initialize	968	// initialize
969	if (&annotate_img!=NULL) {	969	annotate_img.at<Vec2i>(y,x)[0]=x;
970	annotate_img.at<Vec2i>(y,x)[0]=x;	970	annotate_img.at<Vec2i>(y,x)[1]=y;
971	annotate_img.at<Vec2i>(y,x)[1]=y;
972	}
973		971
974	uchar edge_val = edges_img.at<uchar>(y,x);	972	uchar edge_val = edges_img.at<uchar>(y,x);
975	if( (edge_val!=0) ) {	973	if( (edge_val!=0) ) {
Lines 1013-1022 void ChamferMatcher::Matching::computeDistanceTransform(Mat& edges_img, Mat& dis Link Here
1013	dist_img.at<float>(ny,nx) = dist;	1011	dist_img.at<float>(ny,nx) = dist;
1014	q.push(std::make_pair(nx,ny));	1012	q.push(std::make_pair(nx,ny));
1015		1013
1016	if (&annotate_img!=NULL) {	1014	annotate_img.at<Vec2i>(ny,nx)[0]=annotate_img.at<Vec2i>(y,x)[0];
1017	annotate_img.at<Vec2i>(ny,nx)[0]=annotate_img.at<Vec2i>(y,x)[0];	1015	annotate_img.at<Vec2i>(ny,nx)[1]=annotate_img.at<Vec2i>(y,x)[1];
1018	annotate_img.at<Vec2i>(ny,nx)[1]=annotate_img.at<Vec2i>(y,x)[1];
1019	}
1020	}	1016	}
1021	}	1017	}
1022	}	1018	}
Lines 1107-1132 ChamferMatcher::Match* ChamferMatcher::Matching::localChamferDistance(Point offs Link Here
1107		1103
1108	float cost = (sum_distance/truncate_)/addr.size();	1104	float cost = (sum_distance/truncate_)/addr.size();
1109		1105
		1106	float* optr = orientation_img.ptr<float>(y)+x;
		1107	float sum_orientation = 0;
		1108	int cnt_orientation = 0;
1110		1109
1111	if (&orientation_img!=NULL) {	1110	for (size_t i=0;i<addr.size();++i) {
1112	float* optr = orientation_img.ptr<float>(y)+x;
1113	float sum_orientation = 0;
1114	int cnt_orientation = 0;
1115		1111
1116	for (size_t i=0;i<addr.size();++i) {	1112	if(addr[i] < (orientation_img.colsorientation_img.rows) - (offset.yorientation_img.cols + offset.x)){
1117		1113	if (tpl->orientations[i]>=-CV_PI && (*(optr+addr[i]))>=-CV_PI) {
1118	if(addr[i] < (orientation_img.colsorientation_img.rows) - (offset.yorientation_img.cols + offset.x)){	1114	sum_orientation += orientation_diff(tpl->orientations[i], (*(optr+addr[i])));
1119	if (tpl->orientations[i]>=-CV_PI && (*(optr+addr[i]))>=-CV_PI) {	1115	cnt_orientation++;
1120	sum_orientation += orientation_diff(tpl->orientations[i], (*(optr+addr[i])));
1121	cnt_orientation++;
1122	}
1123	}	1116	}
1124	}	1117	}
		1118	}
1125		1119
1126	if (cnt_orientation>0) {	1120	if (cnt_orientation>0) {
1127	cost = (float)(betacost+alpha(sum_orientation/(2*CV_PI))/cnt_orientation);	1121	cost = (float)(betacost+alpha(sum_orientation/(2*CV_PI))/cnt_orientation);
1128	}
1129
1130	}	1122	}
1131		1123
1132	if(cost > 0){	1124	if(cost > 0){

Lines 1613-1625 endmacro() Link Here

(-)a/platforms/android/android.toolchain.cmake (-5 / +5 lines)
1613		1613
1614		1614
1615	macro( ANDROID_GET_ABI_RAWNAME TOOLCHAIN_FLAG VAR )	1615	macro( ANDROID_GET_ABI_RAWNAME TOOLCHAIN_FLAG VAR )
1616	if( "${TOOLCHAIN_FLAG}" STREQUAL "ARMEABI" )	1616	if( "x${TOOLCHAIN_FLAG}" STREQUAL "xARMEABI" )
1617	set( ${VAR} "armeabi" )	1617	set( ${VAR} "armeabi" )
1618	elseif( "${TOOLCHAIN_FLAG}" STREQUAL "ARMEABI_V7A" )	1618	elseif( "x${TOOLCHAIN_FLAG}" STREQUAL "xARMEABI_V7A" )
1619	set( ${VAR} "armeabi-v7a" )	1619	set( ${VAR} "armeabi-v7a" )
1620	elseif( "${TOOLCHAIN_FLAG}" STREQUAL "X86" )	1620	elseif( "x${TOOLCHAIN_FLAG}" STREQUAL "xX86" )
1621	set( ${VAR} "x86" )	1621	set( ${VAR} "x86" )
1622	elseif( "${TOOLCHAIN_FLAG}" STREQUAL "MIPS" )	1622	elseif( "x${TOOLCHAIN_FLAG}" STREQUAL "xMIPS" )
1623	set( ${VAR} "mips" )	1623	set( ${VAR} "mips" )
1624	else()	1624	else()
1625	set( ${VAR} "unknown" )	1625	set( ${VAR} "unknown" )
Lines 1652-1658 if( NOT PROJECT_NAME STREQUAL "CMAKE_TRY_COMPILE" ) Link Here
1652	ANDROID_APP_PIE	1652	ANDROID_APP_PIE
1653	)	1653	)
1654	if( DEFINED ${__var} )	1654	if( DEFINED ${__var} )
1655	if( "${__var}" MATCHES " ")	1655	if( "${${__var}}" MATCHES " ")
1656	set( __toolchain_config "${__toolchain_config}set( ${__var} \"${${__var}}\" CACHE INTERNAL \"\" )\n" )	1656	set( __toolchain_config "${__toolchain_config}set( ${__var} \"${${__var}}\" CACHE INTERNAL \"\" )\n" )
1657	else()	1657	else()
1658	set( __toolchain_config "${__toolchain_config}set( ${__var} ${${__var}} CACHE INTERNAL \"\" )\n" )	1658	set( __toolchain_config "${__toolchain_config}set( ${__var} ${${__var}} CACHE INTERNAL \"\" )\n" )

Line Link Here

(-)file_not_specified_in_diff (-9 / +35 lines)
0	-- a/cmake/OpenCVPCHSupport.cmake	0	++ b/cmake/OpenCVPCHSupport.cmake
Lines 51-56 MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags) Link Here
51	ENDIF()	51	ENDIF()
52	endif()	52	endif()
53		53
		54	IF(CMAKE_COMPILER_IS_GNUCXX)
		55
		56	GET_PROPERTY(_definitions DIRECTORY PROPERTY COMPILE_DEFINITIONS)
		57	if(_definitions)
		58	foreach(_def ${_definitions})
		59	LIST(APPEND ${_out_compile_flags} "\"-D${_def}\"")
		60	endforeach()
		61	endif()
		62	GET_TARGET_PROPERTY(_target_definitions ${_PCH_current_target} COMPILE_DEFINITIONS)
		63	if(_target_definitions)
		64	foreach(_def ${_target_definitions})
		65	LIST(APPEND ${_out_compile_flags} "\"-D${_def}\"")
		66	endforeach()
		67	endif()
		68
		69	ELSE()
		70	## TODO ... ? or does it work out of the box
		71	ENDIF()
		72
54	GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES )	73	GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES )
55	FOREACH(item ${DIRINC})	74	FOREACH(item ${DIRINC})
56	if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")	75	if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")
Lines 60-70 MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags) Link Here
60	endif()	79	endif()
61	ENDFOREACH(item)	80	ENDFOREACH(item)
62		81
63	GET_DIRECTORY_PROPERTY(_directory_flags DEFINITIONS)	82	get_target_property(DIRINC ${_PCH_current_target} INCLUDE_DIRECTORIES )
64	GET_DIRECTORY_PROPERTY(_global_definitions DIRECTORY ${OpenCV_SOURCE_DIR} DEFINITIONS)	83	FOREACH(item ${DIRINC})
65	#MESSAGE("_directory_flags ${_directory_flags} ${_global_definitions}" )	84	if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")
66	LIST(APPEND ${_out_compile_flags} ${_directory_flags})	85	LIST(APPEND ${_out_compile_flags} "${_PCH_include_prefix}\"${item}\"")
67	LIST(APPEND ${_out_compile_flags} ${_global_definitions})	86	else()
		87	LIST(APPEND ${_out_compile_flags} "${_PCH_isystem_prefix}\"${item}\"")
		88	endif()
		89	ENDFOREACH(item)
		90
68	LIST(APPEND ${_out_compile_flags} ${CMAKE_CXX_FLAGS})	91	LIST(APPEND ${_out_compile_flags} ${CMAKE_CXX_FLAGS})
69		92
70	SEPARATE_ARGUMENTS(${_out_compile_flags})	93	SEPARATE_ARGUMENTS(${_out_compile_flags})
Lines 146-154 MACRO(_PCH_GET_TARGET_COMPILE_FLAGS _cflags _header_name _pch_path _dowarn ) Link Here
146	# if you have different versions of the headers for different build types	169	# if you have different versions of the headers for different build types
147	# you may set _pch_dowarn	170	# you may set _pch_dowarn
148	IF (_dowarn)	171	IF (_dowarn)
149	set(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -Winvalid-pch")	172	SET(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -include \"${CMAKE_CURRENT_BINARY_DIR}/${_header_name}\" -Winvalid-pch " )
150	ELSE (_dowarn)	173	ELSE (_dowarn)
151	set(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS}")	174	SET(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -include \"${CMAKE_CURRENT_BINARY_DIR}/${_header_name}\" " )
152	ENDIF (_dowarn)	175	ENDIF (_dowarn)
153		176
154	ELSE(CMAKE_COMPILER_IS_GNUCXX)	177	ELSE(CMAKE_COMPILER_IS_GNUCXX)
Lines 246-257 MACRO(ADD_PRECOMPILED_HEADER _targetName _input) Link Here
246	endif()	269	endif()
247	endif()	270	endif()
248		271
		272	get_target_property(DIRINC ${_targetName} INCLUDE_DIRECTORIES)
		273	set_target_properties(${_targetName}_pch_dephelp PROPERTIES INCLUDE_DIRECTORIES "${DIRINC}")
		274
249	#MESSAGE("_compile_FLAGS: ${_compile_FLAGS}")	275	#MESSAGE("_compile_FLAGS: ${_compile_FLAGS}")
250	#message("COMMAND ${CMAKE_CXX_COMPILER} ${_compile_FLAGS} -x c++-header -o ${_output} ${_input}")	276	#message("COMMAND ${CMAKE_CXX_COMPILER} ${_compile_FLAGS} -x c++-header -o ${_output} ${_input}")
251		277
252	ADD_CUSTOM_COMMAND(	278	ADD_CUSTOM_COMMAND(
253	OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_name}"	279	OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_name}"
254	COMMAND ${CMAKE_COMMAND} -E copy "${_input}" "${CMAKE_CURRENT_BINARY_DIR}/${_name}" # ensure same directory! Required by gcc	280	COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_input}" "${CMAKE_CURRENT_BINARY_DIR}/${_name}" # ensure same directory! Required by gcc
255	DEPENDS "${_input}"	281	DEPENDS "${_input}"
256	)	282	)
257		283

Lines 1480-1486 void CV_StereoCalibrationTest::run( int ) Link Here

(-)a/modules/calib3d/test/test_cameracalibration.cpp (-4 / +4 lines)
1480		1480
1481	if( norm(R1t*R1 - eye33) > 0.01 \|\|	1481	if( norm(R1t*R1 - eye33) > 0.01 \|\|
1482	norm(R2t*R2 - eye33) > 0.01 \|\|	1482	norm(R2t*R2 - eye33) > 0.01 \|\|
1483	abs(determinant(F)) > 0.01)	1483	std::abs(determinant(F)) > 0.01)
1484	{	1484	{
1485	ts->printf( cvtest::TS::LOG, "The computed (by rectify) R1 and R2 are not orthogonal,"	1485	ts->printf( cvtest::TS::LOG, "The computed (by rectify) R1 and R2 are not orthogonal,"
1486	"or the computed (by calibrate) F is not singular, testcase %d\n", testcase);	1486	"or the computed (by calibrate) F is not singular, testcase %d\n", testcase);
Lines 1617-1623 void CV_StereoCalibrationTest::run( int ) Link Here
1617	perspectiveTransform( _imgpt1, rectifPoints1, _H1 );	1617	perspectiveTransform( _imgpt1, rectifPoints1, _H1 );
1618	perspectiveTransform( _imgpt2, rectifPoints2, _H2 );	1618	perspectiveTransform( _imgpt2, rectifPoints2, _H2 );
1619		1619
1620	bool verticalStereo = abs(P2.at<double>(0,3)) < abs(P2.at<double>(1,3));	1620	bool verticalStereo = std::abs(P2.at<double>(0,3)) < std::abs(P2.at<double>(1,3));
1621	double maxDiff_c = 0, maxDiff_uc = 0;	1621	double maxDiff_c = 0, maxDiff_uc = 0;
1622	for( int i = 0, k = 0; i < nframes; i++ )	1622	for( int i = 0, k = 0; i < nframes; i++ )
1623	{	1623	{
Lines 1627-1635 void CV_StereoCalibrationTest::run( int ) Link Here
1627		1627
1628	for( int j = 0; j < npoints; j++, k++ )	1628	for( int j = 0; j < npoints; j++, k++ )
1629	{	1629	{
1630	double diff_c = verticalStereo ? abs(temp[0][j].x - temp[1][j].x) : abs(temp[0][j].y - temp[1][j].y);	1630	double diff_c = verticalStereo ? std::abs(temp[0][j].x - temp[1][j].x) : std::abs(temp[0][j].y - temp[1][j].y);
1631	Point2f d = rectifPoints1.at<Point2f>(k,0) - rectifPoints2.at<Point2f>(k,0);	1631	Point2f d = rectifPoints1.at<Point2f>(k,0) - rectifPoints2.at<Point2f>(k,0);
1632	double diff_uc = verticalStereo ? abs(d.x) : abs(d.y);	1632	double diff_uc = verticalStereo ? std::abs(d.x) : std::abs(d.y);
1633	maxDiff_c = max(maxDiff_c, diff_c);	1633	maxDiff_c = max(maxDiff_c, diff_c);
1634	maxDiff_uc = max(maxDiff_uc, diff_uc);	1634	maxDiff_uc = max(maxDiff_uc, diff_uc);
1635	if( maxDiff_c > maxScanlineDistErr_c )	1635	if( maxDiff_c > maxScanlineDistErr_c )

Lines 879-886 OCL_TEST_P(MinMaxLoc, MAT) Link Here

(-)a/modules/ocl/test/test_arithm.cpp (-8 / +8 lines)
879	minlocVal_ = src1_roi.at<float>(minLoc_);	879	minlocVal_ = src1_roi.at<float>(minLoc_);
880	maxlocVal = src1_roi.at<float>(maxLoc);	880	maxlocVal = src1_roi.at<float>(maxLoc);
881	maxlocVal_ = src1_roi.at<float>(maxLoc_);	881	maxlocVal_ = src1_roi.at<float>(maxLoc_);
882	error0 = ::abs(src1_roi.at<float>(minLoc_) - src1_roi.at<float>(minLoc));	882	error0 = std::abs(src1_roi.at<float>(minLoc_) - src1_roi.at<float>(minLoc));
883	error1 = ::abs(src1_roi.at<float>(maxLoc_) - src1_roi.at<float>(maxLoc));	883	error1 = std::abs(src1_roi.at<float>(maxLoc_) - src1_roi.at<float>(maxLoc));
884	}	884	}
885	if (oneDepth == 6)	885	if (oneDepth == 6)
886	{	886	{
Lines 888-895 OCL_TEST_P(MinMaxLoc, MAT) Link Here
888	minlocVal_ = src1_roi.at<double>(minLoc_);	888	minlocVal_ = src1_roi.at<double>(minLoc_);
889	maxlocVal = src1_roi.at<double>(maxLoc);	889	maxlocVal = src1_roi.at<double>(maxLoc);
890	maxlocVal_ = src1_roi.at<double>(maxLoc_);	890	maxlocVal_ = src1_roi.at<double>(maxLoc_);
891	error0 = ::abs(src1_roi.at<double>(minLoc_) - src1_roi.at<double>(minLoc));	891	error0 = std::abs(src1_roi.at<double>(minLoc_) - src1_roi.at<double>(minLoc));
892	error1 = ::abs(src1_roi.at<double>(maxLoc_) - src1_roi.at<double>(maxLoc));	892	error1 = std::abs(src1_roi.at<double>(maxLoc_) - src1_roi.at<double>(maxLoc));
893	}	893	}
894		894
895	EXPECT_DOUBLE_EQ(minVal_, minVal);	895	EXPECT_DOUBLE_EQ(minVal_, minVal);
Lines 993-1000 OCL_TEST_P(MinMaxLoc, MASK) Link Here
993	minlocVal_ = src1_roi.at<float>(minLoc_);	993	minlocVal_ = src1_roi.at<float>(minLoc_);
994	maxlocVal = src1_roi.at<float>(maxLoc);	994	maxlocVal = src1_roi.at<float>(maxLoc);
995	maxlocVal_ = src1_roi.at<float>(maxLoc_);	995	maxlocVal_ = src1_roi.at<float>(maxLoc_);
996	error0 = ::abs(src1_roi.at<float>(minLoc_) - src1_roi.at<float>(minLoc));	996	error0 = std::abs(src1_roi.at<float>(minLoc_) - src1_roi.at<float>(minLoc));
997	error1 = ::abs(src1_roi.at<float>(maxLoc_) - src1_roi.at<float>(maxLoc));	997	error1 = std::abs(src1_roi.at<float>(maxLoc_) - src1_roi.at<float>(maxLoc));
998	}	998	}
999	if (oneDepth == 6)	999	if (oneDepth == 6)
1000	{	1000	{
Lines 1002-1009 OCL_TEST_P(MinMaxLoc, MASK) Link Here
1002	minlocVal_ = src1_roi.at<double>(minLoc_);	1002	minlocVal_ = src1_roi.at<double>(minLoc_);
1003	maxlocVal = src1_roi.at<double>(maxLoc);	1003	maxlocVal = src1_roi.at<double>(maxLoc);
1004	maxlocVal_ = src1_roi.at<double>(maxLoc_);	1004	maxlocVal_ = src1_roi.at<double>(maxLoc_);
1005	error0 = ::abs(src1_roi.at<double>(minLoc_) - src1_roi.at<double>(minLoc));	1005	error0 = std::abs(src1_roi.at<double>(minLoc_) - src1_roi.at<double>(minLoc));
1006	error1 = ::abs(src1_roi.at<double>(maxLoc_) - src1_roi.at<double>(maxLoc));	1006	error1 = std::abs(src1_roi.at<double>(maxLoc_) - src1_roi.at<double>(maxLoc));
1007	}	1007	}
1008		1008
1009	EXPECT_DOUBLE_EQ(minVal_, minVal);	1009	EXPECT_DOUBLE_EQ(minVal_, minVal);