mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-08-06 14:36:36 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/3.4' into merge-3.4

Browse Source
This commit is contained in:
Alexander Alekhin 2021-08-28 21:30:28 +00:00
commit 4c05a697fa
10 changed files with 159 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
modules/core/src/matrix.cpp
View File

@ -809,18 +809,17 @@ Mat::Mat(const Mat& m, const Rect& roi)
data += roi.x*esz;
CV_Assert( 0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.cols &&
0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.rows );
if( u )
CV_XADD(&u->refcount, 1);
if( roi.width < m.cols || roi.height < m.rows )
flags |= SUBMATRIX_FLAG;
step[0] = m.step[0]; step[1] = esz;
updateContinuityFlag();
addref();
if( rows <= 0 || cols <= 0 )
{
release();
rows = cols = 0;
release();
}
}

26
modules/core/src/ocl.cpp
View File

@ -3453,19 +3453,33 @@ struct Kernel::Impl
void cleanupUMats()
{
bool exceptionOccurred = false;
for( int i = 0; i < MAX_ARRS; i++ )
{
if( u[i] )
{
if( CV_XADD(&u[i]->urefcount, -1) == 1 )
{
u[i]->flags |= UMatData::ASYNC_CLEANUP;
u[i]->currAllocator->deallocate(u[i]);
try
{
u[i]->currAllocator->deallocate(u[i]);
}
catch(const std::exception& exc)
{
// limited by legacy before C++11, therefore log and
// remember some exception occurred to throw below
CV_LOG_ERROR(NULL, "OCL: Unexpected C++ exception in OpenCL Kernel::Impl::cleanupUMats(): " << exc.what());
exceptionOccurred = true;
}
}
u[i] = 0;
}
}
nu = 0;
haveTempDstUMats = false;
haveTempSrcUMats = false;
CV_Assert(!exceptionOccurred);
}
void addUMat(const UMat& m, bool dst)
@ -3496,8 +3510,16 @@ struct Kernel::Impl
void finit(cl_event e)
{
CV_UNUSED(e);
cleanupUMats();
isInProgress = false;
try
{
cleanupUMats();
}
catch(...)
{
release();
throw;
}
release();
}

66
modules/core/src/umatrix.cpp
View File

@ -626,14 +626,28 @@ UMat Mat::getUMat(AccessFlag accessFlags, UMatUsageFlags usageFlags) const
CV_XADD(&(u->refcount), 1);
CV_XADD(&(u->urefcount), 1);
}
hdr.flags = flags;
hdr.usageFlags = usageFlags;
setSize(hdr, dims, size.p, step.p);
finalizeHdr(hdr);
hdr.u = new_u;
hdr.offset = 0; //data - datastart;
hdr.addref();
return hdr;
try
{
hdr.flags = flags;
hdr.usageFlags = usageFlags;
setSize(hdr, dims, size.p, step.p);
finalizeHdr(hdr);
hdr.u = new_u;
hdr.offset = 0; //data - datastart;
hdr.addref();
return hdr;
}
catch(...)
{
if (u != NULL)
{
CV_XADD(&(u->refcount), -1);
CV_XADD(&(u->urefcount), -1);
}
new_u->currAllocator->deallocate(new_u);
throw;
}
}
void UMat::create(int d, const int* _sizes, int _type, UMatUsageFlags _usageFlags)
@ -785,18 +799,17 @@ UMat::UMat(const UMat& m, const Rect& roi)
offset += roi.x*esz;
CV_Assert( 0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.cols &&
0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.rows );
if( u )
CV_XADD(&(u->urefcount), 1);
if( roi.width < m.cols || roi.height < m.rows )
flags |= SUBMATRIX_FLAG;
step[0] = m.step[0]; step[1] = esz;
updateContinuityFlag();
addref();
if( rows <= 0 || cols <= 0 )
{
release();
rows = cols = 0;
release();
}
}
@ -1062,24 +1075,29 @@ Mat UMat::getMat(AccessFlag accessFlags) const
// TODO Support ACCESS_READ (ACCESS_WRITE) without unnecessary data transfers
accessFlags |= ACCESS_RW;
UMatDataAutoLock autolock(u);
if(CV_XADD(&u->refcount, 1) == 0)
u->currAllocator->map(u, accessFlags);
if (u->data != 0)
try
{
Mat hdr(dims, size.p, type(), u->data + offset, step.p);
hdr.flags = flags;
hdr.u = u;
hdr.datastart = u->data;
hdr.data = u->data + offset;
hdr.datalimit = hdr.dataend = u->data + u->size;
return hdr;
if(CV_XADD(&u->refcount, 1) == 0)
u->currAllocator->map(u, accessFlags);
if (u->data != 0)
{
Mat hdr(dims, size.p, type(), u->data + offset, step.p);
hdr.flags = flags;
hdr.u = u;
hdr.datastart = u->data;
hdr.data = u->data + offset;
hdr.datalimit = hdr.dataend = u->data + u->size;
return hdr;
}
}
else
catch(...)
{
CV_XADD(&u->refcount, -1);
CV_Assert(u->data != 0 && "Error mapping of UMat to host memory.");
return Mat();
throw;
}
CV_XADD(&u->refcount, -1);
CV_Assert(u->data != 0 && "Error mapping of UMat to host memory.");
return Mat();
}
void* UMat::handle(AccessFlag accessFlags) const

33
modules/core/test/test_umat.cpp
View File

@ -1419,4 +1419,37 @@ TEST(UMat, resize_Mat_issue_13577)
cv::ocl::setUseOpenCL(useOCL); // restore state
}
TEST(UMat, exceptions_refcounts_issue_20594)
{
if (!cv::ocl::useOpenCL())
{
// skip test, difficult to create exception scenario without OpenCL
std::cout << "OpenCL is not enabled. Skip test" << std::endl;
return;
}
UMat umat1(10, 10, CV_8UC1);
EXPECT_EQ(0, umat1.u->refcount);
// cause exception in underlying allocator
void* const original_handle = umat1.u->handle;
umat1.u->handle = NULL;
try
{
Mat mat1 = umat1.getMat(ACCESS_RW);
}
catch (...)
{
// nothing
}
// check for correct refcount, and no change of intentional bad handle
EXPECT_EQ(0, umat1.u->refcount);
EXPECT_EQ(NULL, umat1.u->handle);
// reset UMat to good state
umat1.u->refcount = 0;
umat1.u->handle = original_handle;
}
} } // namespace opencv_test::ocl

11
modules/dnn/src/caffe/caffe_importer.cpp
View File

@ -306,16 +306,13 @@ public:
caffe::LayerParameter* binLayer = netBinary.mutable_layer(li);
const int numBlobs = binLayer->blobs_size();
std::vector<caffe::BlobProto*> blobs(numBlobs);
binLayer->mutable_blobs()->ExtractSubrange(0, numBlobs, blobs.data());
layerParams.blobs.resize(numBlobs);
for (int bi = 0; bi < numBlobs; bi++)
{
blobFromProto(binLayer->blobs(bi), layerParams.blobs[bi]);
}
binLayer->clear_blobs();
CV_Assert(numBlobs == binLayer->blobs().ClearedCount());
for (int bi = 0; bi < numBlobs; bi++)
{
delete binLayer->mutable_blobs()->ReleaseCleared();
blobFromProto(*blobs[bi], layerParams.blobs[bi]);
delete blobs[bi];
}
}

63
modules/features2d/src/kaze/KAZEFeatures.cpp
View File

@ -311,7 +311,7 @@ private:
void KAZEFeatures::Determinant_Hessian(std::vector<KeyPoint>& kpts)
{
int level = 0;
float dist = 0.0, smax = 3.0;
float smax = 3.0;
int npoints = 0, id_repeated = 0;
int left_x = 0, right_x = 0, up_y = 0, down_y = 0;
bool is_extremum = false, is_repeated = false, is_out = false;
@ -338,17 +338,24 @@ void KAZEFeatures::Determinant_Hessian(std::vector<KeyPoint>& kpts)
for (int j = 0; j < (int)kpts_par_[i].size(); j++)
{
level = i + 1;
const TEvolution& evolution_level = evolution_[level];
is_extremum = true;
is_repeated = false;
is_out = false;
// Check in case we have the same point as maxima in previous evolution levels
for (int ik = 0; ik < (int)kpts.size(); ik++) {
if (kpts[ik].class_id == level || kpts[ik].class_id == level + 1 || kpts[ik].class_id == level - 1) {
dist = pow(kpts_par_[i][j].pt.x - kpts[ik].pt.x, 2) + pow(kpts_par_[i][j].pt.y - kpts[ik].pt.y, 2);
const KeyPoint& kpts_par_ij = kpts_par_[i][j];
if (dist < evolution_[level].sigma_size*evolution_[level].sigma_size) {
if (kpts_par_[i][j].response > kpts[ik].response) {
// Check in case we have the same point as maxima in previous evolution levels
for (int ik = 0; ik < (int)kpts.size(); ik++)
{
const KeyPoint& kpts_ik = kpts[ik];
if (kpts_ik.class_id == level || kpts_ik.class_id == level + 1 || kpts_ik.class_id == level - 1) {
Point2f diff = kpts_par_ij.pt - kpts_ik.pt;
float dist = diff.dot(diff);
if (dist < evolution_level.sigma_size*evolution_level.sigma_size) {
if (kpts_par_ij.response > kpts_ik.response) {
id_repeated = ik;
is_repeated = true;
}
@ -363,23 +370,23 @@ void KAZEFeatures::Determinant_Hessian(std::vector<KeyPoint>& kpts)
if (is_extremum == true) {
// Check that the point is under the image limits for the descriptor computation
left_x = cvRound(kpts_par_[i][j].pt.x - smax*kpts_par_[i][j].size);
right_x = cvRound(kpts_par_[i][j].pt.x + smax*kpts_par_[i][j].size);
up_y = cvRound(kpts_par_[i][j].pt.y - smax*kpts_par_[i][j].size);
down_y = cvRound(kpts_par_[i][j].pt.y + smax*kpts_par_[i][j].size);
left_x = cvRound(kpts_par_ij.pt.x - smax*kpts_par_ij.size);
right_x = cvRound(kpts_par_ij.pt.x + smax*kpts_par_ij.size);
up_y = cvRound(kpts_par_ij.pt.y - smax*kpts_par_ij.size);
down_y = cvRound(kpts_par_ij.pt.y + smax*kpts_par_ij.size);
if (left_x < 0 || right_x >= evolution_[level].Ldet.cols ||
up_y < 0 || down_y >= evolution_[level].Ldet.rows) {
if (left_x < 0 || right_x >= evolution_level.Ldet.cols ||
up_y < 0 || down_y >= evolution_level.Ldet.rows) {
is_out = true;
}
if (is_out == false) {
if (is_repeated == false) {
kpts.push_back(kpts_par_[i][j]);
kpts.push_back(kpts_par_ij);
npoints++;
}
else {
kpts[id_repeated] = kpts_par_[i][j];
kpts[id_repeated] = kpts_par_ij;
}
}
}
@ -513,16 +520,16 @@ public:
if (options_.upright)
{
kpts[i].angle = 0.0;
if (options_.extended)
if (options_.extended)
Get_KAZE_Upright_Descriptor_128(kpts[i], desc.ptr<float>((int)i));
else
Get_KAZE_Upright_Descriptor_64(kpts[i], desc.ptr<float>((int)i));
}
else
{
KAZEFeatures::Compute_Main_Orientation(kpts[i], evolution, options_);
KAZEFeatures::Compute_Main_Orientation(kpts[i], evolution, options_);
if (options_.extended)
if (options_.extended)
Get_KAZE_Descriptor_128(kpts[i], desc.ptr<float>((int)i));
else
Get_KAZE_Descriptor_64(kpts[i], desc.ptr<float>((int)i));
@ -712,26 +719,26 @@ void KAZE_Descriptor_Invoker::Get_KAZE_Upright_Descriptor_64(const KeyPoint &kpt
y1 = (int)(sample_y - 0.5f);
x1 = (int)(sample_x - 0.5f);
checkDescriptorLimits(x1, y1, options_.img_width, options_.img_height);
checkDescriptorLimits(x1, y1, options_.img_width, options_.img_height);
y2 = (int)(sample_y + 0.5f);
x2 = (int)(sample_x + 0.5f);
checkDescriptorLimits(x2, y2, options_.img_width, options_.img_height);
checkDescriptorLimits(x2, y2, options_.img_width, options_.img_height);
fx = sample_x - x1;
fy = sample_y - y1;
res1 = *(evolution[level].Lx.ptr<float>(y1)+x1);
res2 = *(evolution[level].Lx.ptr<float>(y1)+x2);
res3 = *(evolution[level].Lx.ptr<float>(y2)+x1);
res4 = *(evolution[level].Lx.ptr<float>(y2)+x2);
res1 = *(evolution[level].Lx.ptr<float>(y1)+x1);
res2 = *(evolution[level].Lx.ptr<float>(y1)+x2);
res3 = *(evolution[level].Lx.ptr<float>(y2)+x1);
res4 = *(evolution[level].Lx.ptr<float>(y2)+x2);
rx = (1.0f - fx)*(1.0f - fy)*res1 + fx*(1.0f - fy)*res2 + (1.0f - fx)*fy*res3 + fx*fy*res4;
res1 = *(evolution[level].Ly.ptr<float>(y1)+x1);
res2 = *(evolution[level].Ly.ptr<float>(y1)+x2);
res3 = *(evolution[level].Ly.ptr<float>(y2)+x1);
res4 = *(evolution[level].Ly.ptr<float>(y2)+x2);
res1 = *(evolution[level].Ly.ptr<float>(y1)+x1);
res2 = *(evolution[level].Ly.ptr<float>(y1)+x2);
res3 = *(evolution[level].Ly.ptr<float>(y2)+x1);
res4 = *(evolution[level].Ly.ptr<float>(y2)+x2);
ry = (1.0f - fx)*(1.0f - fy)*res1 + fx*(1.0f - fy)*res2 + (1.0f - fx)*fy*res3 + fx*fy*res4;
rx = gauss_s1*rx;

28
modules/java/test/common_test/src/org/opencv/test/utils/ConvertersTest.java
View File

@ -28,9 +28,9 @@ public class ConvertersTest extends OpenCVTestCase {
byte value1 = 2;
byte value2 = 4;
byte value3 = 3;
truth.add(new Byte(value1));
truth.add(new Byte(value2));
truth.add(new Byte(value3));
truth.add(Byte.valueOf(value1));
truth.add(Byte.valueOf(value2));
truth.add(Byte.valueOf(value3));
assertEquals(truth, bs);
}
@ -248,9 +248,9 @@ public class ConvertersTest extends OpenCVTestCase {
byte value1 = 2;
byte value2 = 4;
byte value3 = 3;
truth.add(new Byte(value1));
truth.add(new Byte(value2));
truth.add(new Byte(value3));
truth.add(Byte.valueOf(value1));
truth.add(Byte.valueOf(value2));
truth.add(Byte.valueOf(value3));
assertEquals(truth, bs);
}
@ -276,10 +276,10 @@ public class ConvertersTest extends OpenCVTestCase {
byte value2 = 2;
byte value3 = 3;
byte value4 = 4;
bytes.add(new Byte(value1));
bytes.add(new Byte(value2));
bytes.add(new Byte(value3));
bytes.add(new Byte(value4));
bytes.add(Byte.valueOf(value1));
bytes.add(Byte.valueOf(value2));
bytes.add(Byte.valueOf(value3));
bytes.add(Byte.valueOf(value4));
dst = Converters.vector_char_to_Mat(bytes);
truth = new Mat(4, 1, CvType.CV_8SC1);
@ -499,10 +499,10 @@ public class ConvertersTest extends OpenCVTestCase {
byte value2 = 2;
byte value3 = 3;
byte value4 = 4;
bytes.add(new Byte(value1));
bytes.add(new Byte(value2));
bytes.add(new Byte(value3));
bytes.add(new Byte(value4));
bytes.add(Byte.valueOf(value1));
bytes.add(Byte.valueOf(value2));
bytes.add(Byte.valueOf(value3));
bytes.add(Byte.valueOf(value4));
dst = Converters.vector_uchar_to_Mat(bytes);
truth = new Mat(4, 1, CvType.CV_8UC1);

4
modules/photo/src/contrast_preserve.hpp
View File

@ -358,9 +358,9 @@ void Decolor::grayImContruct(vector <double> &wei, const Mat &img, Mat &Gray) co
{
for(int i = 0;i<h;i++)
for(int j=0;j<w;j++)
Gray.at<float>(i,j)=Gray.at<float>(i,j) +
Gray.at<float>(i,j)=static_cast<float>(Gray.at<float>(i,j) +
static_cast<float>(wei[kk])*pow(rgb_channel[2].at<float>(i,j),r)*pow(rgb_channel[1].at<float>(i,j),g)*
pow(rgb_channel[0].at<float>(i,j),b);
pow(rgb_channel[0].at<float>(i,j),b));
kk=kk+1;
}

3
modules/video/test/test_trackers.impl.hpp
View File

@ -46,7 +46,8 @@ float calcDistance(const Rect& a, const Rect& b)
{
Point2f p_a((float)(a.x + a.width / 2), (float)(a.y + a.height / 2));
Point2f p_b((float)(b.x + b.width / 2), (float)(b.y + b.height / 2));
return sqrt(pow(p_a.x - p_b.x, 2) + pow(p_a.y - p_b.y, 2));
Point2f diff = p_a - p_b;
return sqrt(diff.dot(diff));
}
float calcOverlap(const Rect& a, const Rect& b)

2
samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp
View File

@ -62,7 +62,7 @@ int main( int argc, char** argv )
{
float lambda_1 = myHarris_dst.at<Vec6f>(i, j)[0];
float lambda_2 = myHarris_dst.at<Vec6f>(i, j)[1];
Mc.at<float>(i, j) = lambda_1*lambda_2 - 0.04f*pow( ( lambda_1 + lambda_2 ), 2 );
Mc.at<float>(i, j) = lambda_1*lambda_2 - 0.04f*((lambda_1 + lambda_2) * (lambda_1 + lambda_2));
}
}