generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' into gpu-cuda-rename

Browse Source 
Conflicts:
	modules/core/include/opencv2/core/cuda.hpp
	modules/cudacodec/src/thread.cpp
	modules/cudacodec/src/thread.hpp
	modules/superres/perf/perf_superres.cpp
	modules/superres/src/btv_l1_cuda.cpp
	modules/superres/src/optical_flow.cpp
	modules/videostab/src/global_motion.cpp
	modules/videostab/src/inpainting.cpp
	samples/cpp/stitching_detailed.cpp
	samples/cpp/videostab.cpp
	samples/gpu/stereo_multi.cpp
This commit is contained in:
Vladislav Vinogradov
2013-09-06 15:44:44 +04:00
parent f46b7fcf86
commit 0c7663eb3b
184 changed files with 2414 additions and 1467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
modules/core/test/test_ds.cpp
View File

@@ -358,8 +358,6 @@ Core_DynStructBaseTest::Core_DynStructBaseTest()
iterations = max_struct_size*2;
gen = struct_idx = iter = -1;
test_progress = -1;
storage = 0;
}
@@ -999,7 +997,7 @@ void Core_SeqBaseTest::run( int )
{
t = cvtest::randReal(rng)*(max_log_storage_block_size - min_log_storage_block_size)
+ min_log_storage_block_size;
storage = cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) );
storage.reset(cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) ));
}
iter = struct_idx = -1;
@@ -1083,11 +1081,11 @@ void Core_SeqSortInvTest::run( int )
{
struct_idx = iter = -1;
if( storage.empty() )
if( !storage )
{
t = cvtest::randReal(rng)*(max_log_storage_block_size - min_log_storage_block_size)
+ min_log_storage_block_size;
storage = cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) );
storage.reset(cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) ));
}
for( iter = 0; iter < iterations/10; iter++ )
@@ -1384,7 +1382,7 @@ void Core_SetTest::run( int )
{
struct_idx = iter = -1;
t = cvtest::randReal(rng)*(max_log_storage_block_size - min_log_storage_block_size) + min_log_storage_block_size;
storage = cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) );
storage.reset(cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) ));
for( int i = 0; i < struct_count; i++ )
{
@@ -1398,7 +1396,7 @@ void Core_SetTest::run( int )
cvTsReleaseSimpleSet( (CvTsSimpleSet**)&simple_struct[i] );
simple_struct[i] = cvTsCreateSimpleSet( max_struct_size, pure_elem_size );
cxcore_struct[i] = cvCreateSet( 0, sizeof(CvSet), elem_size, storage );
cxcore_struct[i] = cvCreateSet( 0, sizeof(CvSet), elem_size, storage );
}
if( test_set_ops( iterations*100 ) < 0 )
@@ -1811,7 +1809,7 @@ void Core_GraphTest::run( int )
int block_size = cvRound( exp(t * CV_LOG2) );
block_size = MAX(block_size, (int)(sizeof(CvGraph) + sizeof(CvMemBlock) + sizeof(CvSeqBlock)));
storage = cvCreateMemStorage(block_size);
storage.reset(cvCreateMemStorage(block_size));
for( i = 0; i < struct_count; i++ )
{
@@ -1929,7 +1927,7 @@ void Core_GraphScanTest::run( int )
storage_blocksize = MAX(storage_blocksize, (int)(sizeof(CvGraph) + sizeof(CvMemBlock) + sizeof(CvSeqBlock)));
storage_blocksize = MAX(storage_blocksize, (int)(sizeof(CvGraphEdge) + sizeof(CvMemBlock) + sizeof(CvSeqBlock)));
storage_blocksize = MAX(storage_blocksize, (int)(sizeof(CvGraphVtx) + sizeof(CvMemBlock) + sizeof(CvSeqBlock)));
storage = cvCreateMemStorage(storage_blocksize);
storage.reset(cvCreateMemStorage(storage_blocksize));
if( gen == 0 )
{

12
modules/core/test/test_io.cpp
View File

@@ -270,16 +270,16 @@ protected:
cvRelease((void**)&m_nd);
Ptr<CvSparseMat> m_s = (CvSparseMat*)fs["test_sparse_mat"].readObj();
Ptr<CvSparseMat> _test_sparse_ = cvCreateSparseMat(test_sparse_mat);
Ptr<CvSparseMat> _test_sparse = (CvSparseMat*)cvClone(_test_sparse_);
Ptr<CvSparseMat> m_s((CvSparseMat*)fs["test_sparse_mat"].readObj());
Ptr<CvSparseMat> _test_sparse_(cvCreateSparseMat(test_sparse_mat));
Ptr<CvSparseMat> _test_sparse((CvSparseMat*)cvClone(_test_sparse_));
SparseMat m_s2;
fs["test_sparse_mat"] >> m_s2;
Ptr<CvSparseMat> _m_s2 = cvCreateSparseMat(m_s2);
Ptr<CvSparseMat> _m_s2(cvCreateSparseMat(m_s2));
if( !m_s || !CV_IS_SPARSE_MAT(m_s) ||
!cvTsCheckSparse(m_s, _test_sparse,0) ||
!cvTsCheckSparse(_m_s2, _test_sparse,0))
!cvTsCheckSparse(m_s, _test_sparse, 0) ||
!cvTsCheckSparse(_m_s2, _test_sparse, 0))
{
ts->printf( cvtest::TS::LOG, "the read sparse matrix is not correct\n" );
ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );

4
modules/core/test/test_mat.cpp
View File

@@ -669,7 +669,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
cvSetReal3D(&matA, idx1[0], idx1[1], idx1[2], -val0);
cvSetND(&matB, idx0, val1);
cvSet3D(&matB, idx1[0], idx1[1], idx1[2], -val1);
Ptr<CvMatND> matC = cvCloneMatND(&matB);
Ptr<CvMatND> matC(cvCloneMatND(&matB));
if( A.at<float>(idx0[0], idx0[1], idx0[2]) != val0 ||
A.at<float>(idx1[0], idx1[1], idx1[2]) != -val0 ||
@@ -762,7 +762,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
}
}
Ptr<CvSparseMat> M2 = cvCreateSparseMat(M);
Ptr<CvSparseMat> M2(cvCreateSparseMat(M));
MatND Md;
M.copyTo(Md);
SparseMat M3; SparseMat(Md).convertTo(M3, Md.type(), 2);

389
modules/core/test/test_ptr.cpp Normal file
View File

@@ -0,0 +1,389 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, NVIDIA Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the copyright holders or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "test_precomp.hpp"
using namespace cv;
namespace {
struct Reporter {
Reporter(bool* deleted) : deleted_(deleted)
{ *deleted_ = false; }
// the destructor is virtual, so that we can test dynamic_cast later
virtual ~Reporter()
{ *deleted_ = true; }
private:
bool* deleted_;
Reporter(const Reporter&);
Reporter& operator = (const Reporter&);
};
struct ReportingDeleter {
ReportingDeleter(bool* deleted) : deleted_(deleted)
{ *deleted_ = false; }
void operator()(void*)
{ *deleted_ = true; }
private:
bool* deleted_;
};
int dummyObject;
}
TEST(Core_Ptr, default_ctor)
{
Ptr<int> p;
EXPECT_EQ(NULL, p.get());
}
TEST(Core_Ptr, owning_ctor)
{
bool deleted = false;
{
Reporter* r = new Reporter(&deleted);
Ptr<void> p(r);
EXPECT_EQ(r, p.get());
}
EXPECT_TRUE(deleted);
{
Ptr<int> p(&dummyObject, ReportingDeleter(&deleted));
EXPECT_EQ(&dummyObject, p.get());
}
EXPECT_TRUE(deleted);
{
Ptr<void> p((void*)0, ReportingDeleter(&deleted));
EXPECT_EQ(NULL, p.get());
}
EXPECT_FALSE(deleted);
}
TEST(Core_Ptr, sharing_ctor)
{
bool deleted = false;
{
Ptr<Reporter> p1(new Reporter(&deleted));
Ptr<Reporter> p2(p1);
EXPECT_EQ(p1.get(), p2.get());
p1.release();
EXPECT_FALSE(deleted);
}
EXPECT_TRUE(deleted);
{
Ptr<Reporter> p1(new Reporter(&deleted));
Ptr<void> p2(p1);
EXPECT_EQ(p1.get(), p2.get());
p1.release();
EXPECT_FALSE(deleted);
}
EXPECT_TRUE(deleted);
{
Ptr<Reporter> p1(new Reporter(&deleted));
Ptr<int> p2(p1, &dummyObject);
EXPECT_EQ(&dummyObject, p2.get());
p1.release();
EXPECT_FALSE(deleted);
}
EXPECT_TRUE(deleted);
}
TEST(Core_Ptr, assignment)
{
bool deleted1 = false, deleted2 = false;
{
Ptr<Reporter> p1(new Reporter(&deleted1));
p1 = p1;
EXPECT_FALSE(deleted1);
}
EXPECT_TRUE(deleted1);
{
Ptr<Reporter> p1(new Reporter(&deleted1));
Ptr<Reporter> p2(new Reporter(&deleted2));
p2 = p1;
EXPECT_TRUE(deleted2);
EXPECT_EQ(p1.get(), p2.get());
p1.release();
EXPECT_FALSE(deleted1);
}
EXPECT_TRUE(deleted1);
{
Ptr<Reporter> p1(new Reporter(&deleted1));
Ptr<void> p2(new Reporter(&deleted2));
p2 = p1;
EXPECT_TRUE(deleted2);
EXPECT_EQ(p1.get(), p2.get());
p1.release();
EXPECT_FALSE(deleted1);
}
EXPECT_TRUE(deleted1);
}
TEST(Core_Ptr, release)
{
bool deleted = false;
Ptr<Reporter> p1(new Reporter(&deleted));
p1.release();
EXPECT_TRUE(deleted);
EXPECT_EQ(NULL, p1.get());
}
TEST(Core_Ptr, reset)
{
bool deleted_old = false, deleted_new = false;
{
Ptr<void> p(new Reporter(&deleted_old));
Reporter* r = new Reporter(&deleted_new);
p.reset(r);
EXPECT_TRUE(deleted_old);
EXPECT_EQ(r, p.get());
}
EXPECT_TRUE(deleted_new);
{
Ptr<void> p(new Reporter(&deleted_old));
p.reset(&dummyObject, ReportingDeleter(&deleted_new));
EXPECT_TRUE(deleted_old);
EXPECT_EQ(&dummyObject, p.get());
}
EXPECT_TRUE(deleted_new);
}
TEST(Core_Ptr, swap)
{
bool deleted1 = false, deleted2 = false;
{
Reporter* r1 = new Reporter(&deleted1);
Reporter* r2 = new Reporter(&deleted2);
Ptr<Reporter> p1(r1), p2(r2);
p1.swap(p2);
EXPECT_EQ(r1, p2.get());
EXPECT_EQ(r2, p1.get());
EXPECT_FALSE(deleted1);
EXPECT_FALSE(deleted2);
p1.release();
EXPECT_TRUE(deleted2);
}
EXPECT_TRUE(deleted1);
{
Reporter* r1 = new Reporter(&deleted1);
Reporter* r2 = new Reporter(&deleted2);
Ptr<Reporter> p1(r1), p2(r2);
swap(p1, p2);
EXPECT_EQ(r1, p2.get());
EXPECT_EQ(r2, p1.get());
EXPECT_FALSE(deleted1);
EXPECT_FALSE(deleted2);
p1.release();
EXPECT_TRUE(deleted2);
}
EXPECT_TRUE(deleted1);
}
TEST(Core_Ptr, accessors)
{
{
Ptr<int> p;
EXPECT_EQ(NULL, static_cast<int*>(p));
EXPECT_TRUE(p.empty());
}
{
Size* s = new Size();
Ptr<Size> p(s);
EXPECT_EQ(s, static_cast<Size*>(p));
EXPECT_EQ(s, &*p);
EXPECT_EQ(&s->width, &p->width);
EXPECT_FALSE(p.empty());
}
}
namespace {
struct SubReporterBase {
virtual ~SubReporterBase() {}
int padding;
};
/* multiple inheritance, so that casts do something interesting */
struct SubReporter : SubReporterBase, Reporter
{
SubReporter(bool* deleted) : Reporter(deleted)
{}
};
}
TEST(Core_Ptr, casts)
{
bool deleted = false;
{
Ptr<const Reporter> p1(new Reporter(&deleted));
Ptr<Reporter> p2 = p1.constCast<Reporter>();
EXPECT_EQ(p1.get(), p2.get());
p1.release();
EXPECT_FALSE(deleted);
}
EXPECT_TRUE(deleted);
{
SubReporter* sr = new SubReporter(&deleted);
Ptr<Reporter> p1(sr);
// This next check isn't really for Ptr itself; it checks that Reporter
// is at a non-zero offset within SubReporter, so that the next
// check will give us more confidence that the cast actually did something.
EXPECT_NE(static_cast<void*>(sr), static_cast<void*>(p1.get()));
Ptr<SubReporter> p2 = p1.staticCast<SubReporter>();
EXPECT_EQ(sr, p2.get());
p1.release();
EXPECT_FALSE(deleted);
}
EXPECT_TRUE(deleted);
{
SubReporter* sr = new SubReporter(&deleted);
Ptr<Reporter> p1(sr);
EXPECT_NE(static_cast<void*>(sr), static_cast<void*>(p1.get()));
Ptr<void> p2 = p1.dynamicCast<void>();
EXPECT_EQ(sr, p2.get());
p1.release();
EXPECT_FALSE(deleted);
}
EXPECT_TRUE(deleted);
{
Ptr<Reporter> p1(new Reporter(&deleted));
Ptr<SubReporter> p2 = p1.dynamicCast<SubReporter>();
EXPECT_EQ(NULL, p2.get());
p1.release();
EXPECT_FALSE(deleted);
}
EXPECT_TRUE(deleted);
}
TEST(Core_Ptr, comparisons)
{
Ptr<int> p1, p2(new int), p3(new int);
Ptr<int> p4(p2, p3.get());
// Not using EXPECT_EQ here, since none of them are really "expected" or "actual".
EXPECT_TRUE(p1 == p1);
EXPECT_TRUE(p2 == p2);
EXPECT_TRUE(p2 != p3);
EXPECT_TRUE(p2 != p4);
EXPECT_TRUE(p3 == p4);
}
TEST(Core_Ptr, make)
{
bool deleted = true;
{
Ptr<void> p = makePtr<Reporter>(&deleted);
EXPECT_FALSE(deleted);
}
EXPECT_TRUE(deleted);
}
namespace {
struct SpeciallyDeletable
{
SpeciallyDeletable() : deleted(false)
{}
bool deleted;
};
}
namespace cv {
template<>
void DefaultDeleter<SpeciallyDeletable>::operator()(SpeciallyDeletable * obj) const
{ obj->deleted = true; }
}
TEST(Core_Ptr, specialized_deleter)
{
SpeciallyDeletable sd;
{ Ptr<void> p(&sd); }
ASSERT_TRUE(sd.deleted);
}