mirror of
https://github.com/opencv/opencv.git
synced 2025-06-07 09:25:45 +08:00
Use BufferArea in more places
This commit is contained in:
Maksim Shabunin
parent
f9bd025722
commit
bf96d8239d
@ -55,7 +55,7 @@
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
#include "rho.h"
|
||||
|
||||
#include "opencv2/core/utils/buffer_area.private.hpp"
|
||||
|
||||
|
||||
|
||||
@ -65,7 +65,6 @@ namespace cv{/* For C support, replace with extern "C" { */
|
||||
|
||||
|
||||
/* Constants */
|
||||
const int MEM_ALIGN = 32;
|
||||
const size_t HSIZE = (3*3*sizeof(float));
|
||||
const double MIN_DELTA_CHNG = 0.1;
|
||||
// const double CHI_STAT = 2.706;
|
||||
@ -312,16 +311,14 @@ struct RHO_HEST_REFC : RHO_HEST{
|
||||
|
||||
/* Levenberg-Marquardt Refinement */
|
||||
struct{
|
||||
float (* JtJ)[8]; /* JtJ matrix */
|
||||
float (* tmp1)[8]; /* Temporary 1 */
|
||||
float* JtJ; /* JtJ matrix */
|
||||
float* tmp1; /* Temporary 1 */
|
||||
float* Jte; /* Jte vector */
|
||||
} lm;
|
||||
|
||||
/* Memory Management */
|
||||
struct{
|
||||
cv::Mat perObj;
|
||||
cv::Mat perRun;
|
||||
} mem;
|
||||
utils::BufferArea runArea;
|
||||
utils::BufferArea objArea;
|
||||
|
||||
/* Initialized? */
|
||||
int initialized;
|
||||
@ -659,16 +656,9 @@ inline int RHO_HEST_REFC::initialize(void){
|
||||
|
||||
fastSeed((uint64_t)~0);
|
||||
|
||||
initialized = 1;
|
||||
|
||||
int areAllAllocsSuccessful = !mem.perObj.empty();
|
||||
|
||||
if(!areAllAllocsSuccessful){
|
||||
finalize();
|
||||
}else{
|
||||
initialized = 1;
|
||||
}
|
||||
|
||||
return areAllAllocsSuccessful;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -835,45 +825,14 @@ unsigned RHO_HEST_REFC::rhoHest(const float* src, /* Source points */
|
||||
*/
|
||||
|
||||
inline void RHO_HEST_REFC::allocatePerObj(void){
|
||||
/* We have known sizes */
|
||||
size_t ctrl_smpl_sz = SMPL_SIZE*sizeof(*ctrl.smpl);
|
||||
size_t curr_pkdPts_sz = SMPL_SIZE*2*2*sizeof(*curr.pkdPts);
|
||||
size_t curr_H_sz = HSIZE;
|
||||
size_t best_H_sz = HSIZE;
|
||||
size_t lm_JtJ_sz = 8*8*sizeof(float);
|
||||
size_t lm_tmp1_sz = 8*8*sizeof(float);
|
||||
size_t lm_Jte_sz = 1*8*sizeof(float);
|
||||
|
||||
/* We compute offsets */
|
||||
size_t total = 0;
|
||||
#define MK_OFFSET(v) \
|
||||
size_t v ## _of = total; \
|
||||
total = alignSize(v ## _of + v ## _sz, MEM_ALIGN)
|
||||
|
||||
MK_OFFSET(ctrl_smpl);
|
||||
MK_OFFSET(curr_pkdPts);
|
||||
MK_OFFSET(curr_H);
|
||||
MK_OFFSET(best_H);
|
||||
MK_OFFSET(lm_JtJ);
|
||||
MK_OFFSET(lm_tmp1);
|
||||
MK_OFFSET(lm_Jte);
|
||||
|
||||
#undef MK_OFFSET
|
||||
|
||||
/* Allocate dynamic memory managed by cv::Mat */
|
||||
mem.perObj.create(1, (int)(total + MEM_ALIGN), CV_8UC1);
|
||||
|
||||
/* Extract aligned pointer */
|
||||
unsigned char* ptr = alignPtr(mem.perObj.data, MEM_ALIGN);
|
||||
|
||||
/* Assign pointers */
|
||||
ctrl.smpl = (unsigned*) (ptr + ctrl_smpl_of);
|
||||
curr.pkdPts = (float*) (ptr + curr_pkdPts_of);
|
||||
curr.H = (float*) (ptr + curr_H_of);
|
||||
best.H = (float*) (ptr + best_H_of);
|
||||
lm.JtJ = (float(*)[8])(ptr + lm_JtJ_of);
|
||||
lm.tmp1 = (float(*)[8])(ptr + lm_tmp1_of);
|
||||
lm.Jte = (float*) (ptr + lm_Jte_of);
|
||||
objArea.allocate(ctrl.smpl, SMPL_SIZE);
|
||||
objArea.allocate(curr.pkdPts, SMPL_SIZE*2*2);
|
||||
objArea.allocate(curr.H, HSIZE);
|
||||
objArea.allocate(best.H, HSIZE);
|
||||
objArea.allocate(lm.JtJ, 8*8);
|
||||
objArea.allocate(lm.tmp1, 8*8);
|
||||
objArea.allocate(lm.Jte, 1*8);
|
||||
objArea.commit();
|
||||
}
|
||||
|
||||
|
||||
@ -885,30 +844,9 @@ inline void RHO_HEST_REFC::allocatePerObj(void){
|
||||
*/
|
||||
|
||||
inline void RHO_HEST_REFC::allocatePerRun(void){
|
||||
/* We have known sizes */
|
||||
size_t best_inl_sz = arg.N;
|
||||
size_t curr_inl_sz = arg.N;
|
||||
|
||||
/* We compute offsets */
|
||||
size_t total = 0;
|
||||
#define MK_OFFSET(v) \
|
||||
size_t v ## _of = total; \
|
||||
total = alignSize(v ## _of + v ## _sz, MEM_ALIGN)
|
||||
|
||||
MK_OFFSET(best_inl);
|
||||
MK_OFFSET(curr_inl);
|
||||
|
||||
#undef MK_OFFSET
|
||||
|
||||
/* Allocate dynamic memory managed by cv::Mat */
|
||||
mem.perRun.create(1, (int)(total + MEM_ALIGN), CV_8UC1);
|
||||
|
||||
/* Extract aligned pointer */
|
||||
unsigned char* ptr = alignPtr(mem.perRun.data, MEM_ALIGN);
|
||||
|
||||
/* Assign pointers */
|
||||
best.inl = (char*)(ptr + best_inl_of);
|
||||
curr.inl = (char*)(ptr + curr_inl_of);
|
||||
runArea.allocate(best.inl, arg.N);
|
||||
runArea.allocate(curr.inl, arg.N);
|
||||
runArea.commit();
|
||||
}
|
||||
|
||||
|
||||
@ -919,10 +857,7 @@ inline void RHO_HEST_REFC::allocatePerRun(void){
|
||||
*/
|
||||
|
||||
inline void RHO_HEST_REFC::deallocatePerRun(void){
|
||||
best.inl = NULL;
|
||||
curr.inl = NULL;
|
||||
|
||||
mem.perRun.release();
|
||||
runArea.release();
|
||||
}
|
||||
|
||||
|
||||
@ -933,15 +868,7 @@ inline void RHO_HEST_REFC::deallocatePerRun(void){
|
||||
*/
|
||||
|
||||
inline void RHO_HEST_REFC::deallocatePerObj(void){
|
||||
ctrl.smpl = NULL;
|
||||
curr.pkdPts = NULL;
|
||||
curr.H = NULL;
|
||||
best.H = NULL;
|
||||
lm.JtJ = NULL;
|
||||
lm.tmp1 = NULL;
|
||||
lm.Jte = NULL;
|
||||
|
||||
mem.perObj.release();
|
||||
objArea.release();
|
||||
}
|
||||
|
||||
|
||||
@ -2144,7 +2071,7 @@ inline void RHO_HEST_REFC::refine(void){
|
||||
*/
|
||||
/* Find initial conditions */
|
||||
sacCalcJacobianErrors(best.H, arg.src, arg.dst, best.inl, arg.N,
|
||||
lm.JtJ, lm.Jte, &S);
|
||||
(float(*)[8])lm.JtJ, lm.Jte, &S);
|
||||
|
||||
/*Levenberg-Marquardt Loop.*/
|
||||
for(i=0;i<MAXLEVMARQITERS;i++){
|
||||
@ -2169,11 +2096,11 @@ inline void RHO_HEST_REFC::refine(void){
|
||||
* transpose) then multiply Jte in order to find dH.
|
||||
*/
|
||||
|
||||
while(!sacChol8x8Damped(lm.JtJ, L, lm.tmp1)){
|
||||
while(!sacChol8x8Damped((float(*)[8])lm.JtJ, L, (float(*)[8])lm.tmp1)){
|
||||
L *= 2.0f;
|
||||
}
|
||||
sacTRInv8x8 (lm.tmp1, lm.tmp1);
|
||||
sacTRISolve8x8(lm.tmp1, lm.Jte, dH);
|
||||
sacTRInv8x8 ((float(*)[8])lm.tmp1, (float(*)[8])lm.tmp1);
|
||||
sacTRISolve8x8((float(*)[8])lm.tmp1, lm.Jte, dH);
|
||||
sacSub8x1 (newH, best.H, dH);
|
||||
sacCalcJacobianErrors(newH, arg.src, arg.dst, best.inl, arg.N,
|
||||
NULL, NULL, &newS);
|
||||
@ -2204,7 +2131,7 @@ inline void RHO_HEST_REFC::refine(void){
|
||||
S = newS;
|
||||
memcpy(best.H, newH, sizeof(newH));
|
||||
sacCalcJacobianErrors(best.H, arg.src, arg.dst, best.inl, arg.N,
|
||||
lm.JtJ, lm.Jte, &S);
|
||||
(float(*)[8])lm.JtJ, lm.Jte, &S);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -74,6 +74,25 @@ public:
|
||||
allocate_((void**)(&ptr), static_cast<ushort>(sizeof(T)), count, alignment);
|
||||
}
|
||||
|
||||
/** @brief Fill one of buffers with zeroes
|
||||
|
||||
@param ptr pointer to memory block previously added using BufferArea::allocate
|
||||
|
||||
BufferArea::commit must be called before using this method
|
||||
*/
|
||||
template <typename T>
|
||||
void zeroFill(T*&ptr)
|
||||
{
|
||||
CV_Assert(ptr);
|
||||
zeroFill_((void**)&ptr);
|
||||
}
|
||||
|
||||
/** @brief Fill all buffers with zeroes
|
||||
|
||||
BufferArea::commit must be called before using this method
|
||||
*/
|
||||
void zeroFill();
|
||||
|
||||
/** @brief Allocate memory and initialize all bound pointers
|
||||
|
||||
Each pointer bound to the area with the BufferArea::allocate will be initialized and will be set
|
||||
@ -83,10 +102,18 @@ public:
|
||||
*/
|
||||
void commit();
|
||||
|
||||
/** @brief Release all memory and unbind all pointers
|
||||
|
||||
All memory will be freed and all pointers will be reset to NULL and untied from the area allowing
|
||||
to call `allocate` and `commit` again.
|
||||
*/
|
||||
void release();
|
||||
|
||||
private:
|
||||
BufferArea(const BufferArea &); // = delete
|
||||
BufferArea &operator=(const BufferArea &); // = delete
|
||||
void allocate_(void **ptr, ushort type_size, size_t count, ushort alignment);
|
||||
void zeroFill_(void **ptr);
|
||||
|
||||
private:
|
||||
class Block;
|
||||
|
||||
@ -66,6 +66,16 @@ public:
|
||||
*ptr = buf;
|
||||
return static_cast<void*>(static_cast<uchar*>(*ptr) + type_size * count);
|
||||
}
|
||||
bool operator==(void **other) const
|
||||
{
|
||||
CV_Assert(ptr && other);
|
||||
return *ptr == *other;
|
||||
}
|
||||
void zeroFill() const
|
||||
{
|
||||
CV_Assert(ptr && *ptr);
|
||||
memset(static_cast<uchar*>(*ptr), 0, count * type_size);
|
||||
}
|
||||
private:
|
||||
void **ptr;
|
||||
void * raw_mem;
|
||||
@ -85,10 +95,7 @@ BufferArea::BufferArea(bool safe_) :
|
||||
|
||||
BufferArea::~BufferArea()
|
||||
{
|
||||
for(std::vector<Block>::const_iterator i = blocks.begin(); i != blocks.end(); ++i)
|
||||
i->cleanup();
|
||||
if (oneBuf)
|
||||
fastFree(oneBuf);
|
||||
release();
|
||||
}
|
||||
|
||||
void BufferArea::allocate_(void **ptr, ushort type_size, size_t count, ushort alignment)
|
||||
@ -100,6 +107,26 @@ void BufferArea::allocate_(void **ptr, ushort type_size, size_t count, ushort al
|
||||
totalSize += blocks.back().getByteCount();
|
||||
}
|
||||
|
||||
void BufferArea::zeroFill_(void **ptr)
|
||||
{
|
||||
for(std::vector<Block>::const_iterator i = blocks.begin(); i != blocks.end(); ++i)
|
||||
{
|
||||
if (*i == ptr)
|
||||
{
|
||||
i->zeroFill();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void BufferArea::zeroFill()
|
||||
{
|
||||
for(std::vector<Block>::const_iterator i = blocks.begin(); i != blocks.end(); ++i)
|
||||
{
|
||||
i->zeroFill();
|
||||
}
|
||||
}
|
||||
|
||||
void BufferArea::commit()
|
||||
{
|
||||
if (!safe)
|
||||
@ -116,6 +143,20 @@ void BufferArea::commit()
|
||||
}
|
||||
}
|
||||
|
||||
void BufferArea::release()
|
||||
{
|
||||
for(std::vector<Block>::const_iterator i = blocks.begin(); i != blocks.end(); ++i)
|
||||
{
|
||||
i->cleanup();
|
||||
}
|
||||
blocks.clear();
|
||||
if (oneBuf)
|
||||
{
|
||||
fastFree(oneBuf);
|
||||
oneBuf = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//==================================================================================================
|
||||
|
||||
}} // cv::utils::
|
||||
|
||||
@ -337,6 +337,21 @@ TEST_P(BufferArea, basic)
|
||||
ASSERT_TRUE(dbl_ptr != NULL);
|
||||
EXPECT_EQ((size_t)0, (size_t)int_ptr % sizeof(int));
|
||||
EXPECT_EQ((size_t)0, (size_t)dbl_ptr % sizeof(double));
|
||||
for (size_t i = 0; i < SZ; ++i)
|
||||
{
|
||||
int_ptr[i] = (int)i + 1;
|
||||
uchar_ptr[i] = (uchar)i + 1;
|
||||
dbl_ptr[i] = (double)i + 1;
|
||||
}
|
||||
area.zeroFill(int_ptr);
|
||||
area.zeroFill(uchar_ptr);
|
||||
area.zeroFill(dbl_ptr);
|
||||
for (size_t i = 0; i < SZ; ++i)
|
||||
{
|
||||
EXPECT_EQ((int)0, int_ptr[i]);
|
||||
EXPECT_EQ((uchar)0, uchar_ptr[i]);
|
||||
EXPECT_EQ((double)0, dbl_ptr[i]);
|
||||
}
|
||||
}
|
||||
EXPECT_TRUE(int_ptr == NULL);
|
||||
EXPECT_TRUE(uchar_ptr == NULL);
|
||||
|
||||
@ -47,6 +47,7 @@ The references are:
|
||||
#include "opencl_kernels_features2d.hpp"
|
||||
#include "hal_replacement.hpp"
|
||||
#include "opencv2/core/hal/intrin.hpp"
|
||||
#include "opencv2/core/utils/buffer_area.private.hpp"
|
||||
|
||||
#include "opencv2/core/openvx/ovx_defs.hpp"
|
||||
|
||||
@ -80,20 +81,26 @@ void FAST_t(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bo
|
||||
for( i = -255; i <= 255; i++ )
|
||||
threshold_tab[i+255] = (uchar)(i < -threshold ? 1 : i > threshold ? 2 : 0);
|
||||
|
||||
AutoBuffer<uchar> _buf((img.cols+16)*3*(sizeof(int) + sizeof(uchar)) + 128);
|
||||
uchar* buf[3];
|
||||
buf[0] = _buf.data(); buf[1] = buf[0] + img.cols; buf[2] = buf[1] + img.cols;
|
||||
int* cpbuf[3];
|
||||
cpbuf[0] = (int*)alignPtr(buf[2] + img.cols, sizeof(int)) + 1;
|
||||
cpbuf[1] = cpbuf[0] + img.cols + 1;
|
||||
cpbuf[2] = cpbuf[1] + img.cols + 1;
|
||||
memset(buf[0], 0, img.cols*3);
|
||||
uchar* buf[3] = { 0 };
|
||||
int* cpbuf[3] = { 0 };
|
||||
utils::BufferArea area;
|
||||
for (unsigned idx = 0; idx < 3; ++idx)
|
||||
{
|
||||
area.allocate(buf[idx], img.cols);
|
||||
area.allocate(cpbuf[idx], img.cols + 1);
|
||||
}
|
||||
area.commit();
|
||||
|
||||
for (unsigned idx = 0; idx < 3; ++idx)
|
||||
{
|
||||
memset(buf[idx], 0, img.cols);
|
||||
}
|
||||
|
||||
for(i = 3; i < img.rows-2; i++)
|
||||
{
|
||||
const uchar* ptr = img.ptr<uchar>(i) + 3;
|
||||
uchar* curr = buf[(i - 3)%3];
|
||||
int* cornerpos = cpbuf[(i - 3)%3];
|
||||
int* cornerpos = cpbuf[(i - 3)%3] + 1; // cornerpos[-1] is used to store a value
|
||||
memset(curr, 0, img.cols);
|
||||
int ncorners = 0;
|
||||
|
||||
@ -266,7 +273,7 @@ void FAST_t(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bo
|
||||
|
||||
const uchar* prev = buf[(i - 4 + 3)%3];
|
||||
const uchar* pprev = buf[(i - 5 + 3)%3];
|
||||
cornerpos = cpbuf[(i - 4 + 3)%3];
|
||||
cornerpos = cpbuf[(i - 4 + 3)%3] + 1; // cornerpos[-1] is used to store a value
|
||||
ncorners = cornerpos[-1];
|
||||
|
||||
for( k = 0; k < ncorners; k++ )
|
||||
|
||||
Loading…
Reference in New Issue
Block a user