Img GaborImage::GaborTransform(Img Image, int Frequency, int Orientation) {
orientation = Orientation;
CalculateKernel(Orientation, Frequency);
Img retImg = (IplImage*) cvClone(Image);
Img gabor_real = (IplImage*) cvClone(Image);
Img gabor_img = (IplImage*) cvClone(Image);
cvFilter2D(Image, gabor_real, KernelRealData); //image.Convolution(this.KernelRealData);
cvFilter2D(Image, gabor_img , KernelImgData); //image.Convolution(this.KernelImgData);
cvPow(gabor_real, gabor_real, 2);
cvPow(gabor_img, gabor_img, 2);
// Img gabor = (gabor_real + gabor_img).Pow(0.5);
cvAdd(gabor_real, gabor_img, retImg);
cv::Mat in = retImg;
cv::Mat out;
cv::sqrt(in, out);
IplImage dst_img = out;
cvReleaseImage(&gabor_real);
cvReleaseImage(&gabor_img);
retImg = (IplImage*) cvClone(&dst_img);
return retImg;
}
/**
* @brief CvGabor::conv_img(IplImage *src, IplImage *dst, int Type)
* @param src
* @param dst
* @param Type
*/
void CvGabor::conv_img(IplImage *src, IplImage *dst, int Type) //函数名：conv_img
{
// printf("CvGabor::conv_img 1\n");
double ve; //, re,im;
CvMat *mat = cvCreateMat(src->width, src->height, CV_32FC1);
for (int i = 0; i < src->width; i++) {
for (int j = 0; j < src->height; j++) {
ve = CV_IMAGE_ELEM(src, uchar, j, i); //CV_IMAGE_ELEM 是取图像（j，i）位置的像素值
CV_MAT_ELEM(*mat, float, i, j) = (float)ve; //转化成float 类型
}
}
// printf("CvGabor::conv_img 2\n");
CvMat *rmat = cvCreateMat(src->width, src->height, CV_32FC1);
CvMat *imat = cvCreateMat(src->width, src->height, CV_32FC1);
switch (Type)
{
case CV_GABOR_REAL:
cvFilter2D( (CvMat*)mat, (CvMat*)mat, (CvMat*)Real, cvPoint( (Width-1)/2, (Width-1)/2));
break;
case CV_GABOR_IMAG:
cvFilter2D( (CvMat*)mat, (CvMat*)mat, (CvMat*)Imag, cvPoint( (Width-1)/2, (Width-1)/2));
break;
case CV_GABOR_MAG:
cvFilter2D( (CvMat*)mat, (CvMat*)rmat, (CvMat*)Real, cvPoint( (Width-1)/2, (Width-1)/2));
cvFilter2D( (CvMat*)mat, (CvMat*)imat, (CvMat*)Imag, cvPoint( (Width-1)/2, (Width-1)/2));
cvPow(rmat,rmat,2);
cvPow(imat,imat,2);
cvAdd(imat,rmat,mat);
cvPow(mat,mat,0.5);
break;
case CV_GABOR_PHASE:
break;
}
// printf("CvGabor::conv_img 3\n");
if (dst->depth == IPL_DEPTH_8U)
{
cvNormalize((CvMat*)mat, (CvMat*)mat, 0, 255, CV_MINMAX);
for (int i = 0; i < mat->rows; i++)
{
for (int j = 0; j < mat->cols; j++)
{
ve = CV_MAT_ELEM(*mat, float, i, j);
CV_IMAGE_ELEM(dst, uchar, j, i) = (uchar)cvRound(ve);
}
}
}
void Filters::lowPass(VRFrame* frame, int size)
{
IplImage* imgDst = 0;
IplImage* imgAux = 0;
IplImage* imgNew = 0;
VRFrame* frameAux;
Log::writeLog("%s :: param: frame[%x] size[%d]", __FUNCTION__, frame, size);
//Ajuste do tamanho da matriz.
if (size > 9)
size = 9;
int cols_i = size;
int rows_i = size;
int total_size = 0;
CvMat *filter = 0;
total_size=(int)pow((double)size,2);
// Máscara para realizar o processo de convolução.
///double convMask[total_size];
double * convMask = new double[total_size];
// Cria uma imagem com os mesmos parâmetros da original.
frameAux = new VRFrame(frame);
imgDst = VRFrame::imgAlloc(frameAux);
imgAux = VRFrame::imgAlloc(frameAux);
imgNew = VRFrame::imgAlloc(frameAux);
// Monta a máscara com o tamanho que foi passado como parâmetro.
for (int i=0; i<total_size; i++)
convMask[i] = (double)1/(double)total_size;
imgAux->imageData = frameAux->data->imageData;
imgAux->widthStep = frameAux->data->width;
imgDst->imageData = imgAux->imageData;
imgDst->widthStep = imgAux->width;
filter = cvCreateMatHeader(rows_i, cols_i, CV_64FC1);
cvSetData(filter, convMask, cols_i*8);
cvFilter2D(imgAux, imgDst, filter, cvPoint(-1,-1));
VRFrame::imgCopy(imgDst, imgNew);
frame->setImage(imgNew);
// Desaloca os temporários
VRFrame::imgDealloc(imgAux);
VRFrame::imgDealloc(imgDst);
delete[] convMask;
delete frameAux;
}
void Process(int pos)
{
//CvFileStorage *fs = cvOpenFileStorage("kernel.xml",NULL,CV_STORAGE_WRITE);
int x,y;
float kernel_val;
var = (float)pos_var;
w = (float)pos_w;
phase = (float) pos_phase*CV_PI/180;
cvZero(kernel);
for (x = -kernel_size/2+1;x<=kernel_size/2; x++) {
for (y = (-kernel_size/2+1);y<=(kernel_size/2); y++) {
kernel_val = 1/(2*CV_PI*var)*exp( -((x*x)+(y*y))/(2*var))*cos( w*x*cos(phase)+w*y*sin(phase));
cvSet2D(kernel,y+kernel_size/2-1,x+kernel_size/2-1,cvScalar(kernel_val));
}
}
//cvWrite( fs, "kernel", kernel, cvAttrList(0,0) );
//cvReleaseFileStorage(&fs);
cvFilter2D(src, dest,kernel);
cvShowImage("Process window",dest);
}
void ImgAli_common::gradient(IplImage *img,CvMat *g_x,CvMat *g_y,CvMat *margnin)
{
cvFilter2D(img,g_x,x_kernel,cvPoint(-1,-1));
cvFilter2D(img,g_y,y_kernel,cvPoint(-1,-1));
for(int i=0;i<cvGetSize(img).height;i++)
{
CV_MAT_ELEM(*g_x,double,i,0)*=2;
CV_MAT_ELEM(*g_x,double,i,cvGetSize(img).width-1)*=2;
}
for(int i=0;i<cvGetSize(img).width;i++)
{
CV_MAT_ELEM(*g_y,double,0,i)*=2;
CV_MAT_ELEM(*g_y,double,cvGetSize(img).height-1,i)*=2;
}
}
void ImgAli_common::gradient(CvMat *img,CvMat *g_x,CvMat *g_y,CvMat *margnin)
{
//for (int i=0;i<width;i++)
//{
// for (int j=0;j<height;j++)
// {
// if(i>0&&i<width-1&&j>0&&j<height-1)
// {
// cvmSet(g_x,i,j)=((double)cvGet2D(img,i,j+1)-(double)cvGet2D(img,i,j-1))/2;
// }
// }
//}
// CvMat *imgSat=cvCreateMat(width,)
cvFilter2D(img,g_x,x_kernel,cvPoint(-1,-1));
cvFilter2D(img,g_y,y_kernel,cvPoint(-1,-1));
//for (int i=0;i<width;i++)
//{
// for (int j=0;j<height;j++)
// {
// if (CV_MAT_ELEM(*margnin,double,j,i)==1)
// {
// CV_MAT_ELEM(*g_x,double,j,i)=0;
// CV_MAT_ELEM(*g_y,double,j,i)=0;
// }
// }
//}
for(int i=0;i<cvGetSize(img).height;i++)
{
CV_MAT_ELEM(*g_x,double,i,0)*=2;
CV_MAT_ELEM(*g_x,double,i,cvGetSize(img).width-1)*=2;
}
for(int i=0;i<cvGetSize(img).width;i++)
{
CV_MAT_ELEM(*g_y,double,0,i)*=2;
CV_MAT_ELEM(*g_y,double,cvGetSize(img).height-1,i)*=2;
}
}
IplImage *derivateY(const IplImage *src) {
CvMat matrix;
matrix = cvMat(5, 1, CV_32F, mat);
IplImage *dst = cvCloneImage(src);
cvFilter2D(src, dst, &matrix);
// cvReleaseImage(&img);
return dst;
}
IplImage *derivateX(const IplImage *src) {
CvMat matrix;
matrix = cvMat(1, 5, CV_32F, mat);
// IplImage *img = get_gray(src);
IplImage *dst = cvCloneImage(src);
cvFilter2D(src, dst, &matrix);
// cvReleaseImage(&img);
return dst;
}
IplImage* lowPassFilter(IplImage *image){
IplImage* filteredImage = cvCreateImage(cvSize(image->width, image->height), image->depth, image->nChannels);
double K[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
float t = 0;
for (int i = 0; i< (3 * 3); ++i)
t = t + K[i];
for (int i = 0; i< (3 * 3); ++i)
K[i] = K[i] / t;
CvMat Kernel = cvMat(3, 3, CV_64FC1, K);
cvFilter2D(image, filteredImage, &Kernel);
return filteredImage;
}
//形态学等级滤波器（二值,默认SE为矩形3*3）
void lhMorpRankFilterB(const IplImage* src, IplImage* dst, IplConvKernel* se = NULL, unsigned int rank = 0)
{
assert(src != NULL && dst != NULL && src != dst );
bool defaultse = false;
int card;
if (se == NULL)
{
card = 3*3;
assert(rank >= 0 && rank <= card);
se = cvCreateStructuringElementEx(3, 3, 1, 1, CV_SHAPE_RECT);
defaultse = true;
}
else
{
card = lhStructuringElementCard(se);
assert(rank >= 0 && rank <= card);
}
//default rank is median
if (rank == 0)
rank = card/2+1;
IplConvKernel* semap = lhStructuringElementMap(se);
CvMat *semat = cvCreateMat(semap->nRows, semap->nCols, CV_32FC1);
int i;
for (i=0; i<semap->nRows*semap->nCols; i++)
{
semat->data.fl[i] = semap->values[i];
}
cvThreshold(src, dst, 0, 1, CV_THRESH_BINARY);
IplImage *temp = cvCreateImage(cvGetSize(dst), 8, 1);
cvFilter2D(dst, temp, semat, cvPoint(semap->anchorX, semap->anchorY));
cvThreshold(temp, dst, card-rank, 255, CV_THRESH_BINARY);
cvReleaseMat(&semat);
cvReleaseStructuringElement(&semap);
if (defaultse)
cvReleaseStructuringElement(&se);
cvReleaseImage(&temp);
}
int main(int argc, char* argv[])
{
// Matrix for frames from the camera
CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY );
// Infinite loop where our scanning is down on each camera frame
while (1)
{
IplImage* frame = cvQueryFrame(capture);
if (!frame) {
fprintf(stderr, "ERROR: Frame is null\n");
getchar();
break;
}
IplImage* outputimg = cvCreateImage(cvGetSize(frame), frame->depth,1);
IplImage* test = cvCreateImage(cvGetSize(frame), frame->depth,frame->nChannels);
double a[9]={-1,20,1,-1,20,1,-1,20,1};
CvMat kernel= cvMat(3,3,CV_32FC1,a);
cvFilter2D(frame,test,&kernel,cvPoint(-1,-1));
cvCvtColor(frame, outputimg, CV_RGB2GRAY);
QR_Data data;
process_QR(outputimg, &data, frame);
cvShowImage("Camera", frame);
cvShowImage("Sharp", test);
// Delay so screen can refresh
if ((char) cvWaitKey(30) == 27) break;
}
// Release the resources
cvReleaseCapture(&capture);
cvDestroyWindow("Camera");
return 0;
}
/*
// Getting feature map for the selected subimage
//
// API
// int getFeatureMaps(const IplImage * image, const int k, featureMap **map);
// INPUT
// image - selected subimage
// k - size of cells
// OUTPUT
// map - feature map
// RESULT
// Error status
*/
int getFeatureMaps(const IplImage* image, const int k, CvLSVMFeatureMap **map)
{
int sizeX, sizeY;
int p, px, stringSize;
int height, width, numChannels;
int i, j, kk, c, ii, jj, d;
float * datadx, * datady;
int ch;
float magnitude, x, y, tx, ty;
IplImage * dx, * dy;
int *nearest;
float *w, a_x, b_x;
float kernel[3] = {-1.f, 0.f, 1.f};
CvMat kernel_dx = cvMat(1, 3, CV_32F, kernel);
CvMat kernel_dy = cvMat(3, 1, CV_32F, kernel);
float * r;
int * alfa;
float boundary_x[NUM_SECTOR + 1];
float boundary_y[NUM_SECTOR + 1];
float max, dotProd;
int maxi;
height = image->height;
width = image->width ;
numChannels = image->nChannels;
dx = cvCreateImage(cvSize(image->width, image->height),
IPL_DEPTH_32F, 3);
dy = cvCreateImage(cvSize(image->width, image->height),
IPL_DEPTH_32F, 3);
sizeX = width / k;
sizeY = height / k;
px = 3 * NUM_SECTOR;
p = px;
stringSize = sizeX * p;
allocFeatureMapObject(map, sizeX, sizeY, p);
cvFilter2D(image, dx, &kernel_dx, cvPoint(-1, 0));
cvFilter2D(image, dy, &kernel_dy, cvPoint(0, -1));
float arg_vector;
for(i = 0; i <= NUM_SECTOR; i++)
{
arg_vector = ( (float) i ) * ( (float)(PI) / (float)(NUM_SECTOR) );
boundary_x[i] = cosf(arg_vector);
boundary_y[i] = sinf(arg_vector);
}/*for(i = 0; i <= NUM_SECTOR; i++) */
r = (float *)malloc( sizeof(float) * (width * height));
alfa = (int *)malloc( sizeof(int ) * (width * height * 2));
for(j = 1; j < height - 1; j++)
{
datadx = (float*)(dx->imageData + dx->widthStep * j);
datady = (float*)(dy->imageData + dy->widthStep * j);
for(i = 1; i < width - 1; i++)
{
c = 0;
x = (datadx[i * numChannels + c]);
y = (datady[i * numChannels + c]);
r[j * width + i] =sqrtf(x * x + y * y);
for(ch = 1; ch < numChannels; ch++)
{
tx = (datadx[i * numChannels + ch]);
ty = (datady[i * numChannels + ch]);
magnitude = sqrtf(tx * tx + ty * ty);
if(magnitude > r[j * width + i])
{
r[j * width + i] = magnitude;
c = ch;
x = tx;
y = ty;
}
}/*for(ch = 1; ch < numChannels; ch++)*/
max = boundary_x[0] * x + boundary_y[0] * y;
maxi = 0;
for (kk = 0; kk < NUM_SECTOR; kk++)
{
dotProd = boundary_x[kk] * x + boundary_y[kk] * y;
if (dotProd > max)
{
max = dotProd;
maxi = kk;
}
else
{
if (-dotProd > max)
{
max = -dotProd;
maxi = kk + NUM_SECTOR;
}
}
}
alfa[j * width * 2 + i * 2 ] = maxi % NUM_SECTOR;
alfa[j * width * 2 + i * 2 + 1] = maxi;
}/*for(i = 0; i < width; i++)*/
}/*for(j = 0; j < height; j++)*/
nearest = (int *)malloc(sizeof(int ) * k);
w = (float*)malloc(sizeof(float) * (k * 2));
for(i = 0; i < k / 2; i++)
{
nearest[i] = -1;
}/*for(i = 0; i < k / 2; i++)*/
for(i = k / 2; i < k; i++)
{
nearest[i] = 1;
}/*for(i = k / 2; i < k; i++)*/
for(j = 0; j < k / 2; j++)
{
b_x = k / 2 + j + 0.5f;
a_x = k / 2 - j - 0.5f;
w[j * 2 ] = 1.0f/a_x * ((a_x * b_x) / ( a_x + b_x));
w[j * 2 + 1] = 1.0f/b_x * ((a_x * b_x) / ( a_x + b_x));
}/*for(j = 0; j < k / 2; j++)*/
for(j = k / 2; j < k; j++)
{
a_x = j - k / 2 + 0.5f;
b_x =-j + k / 2 - 0.5f + k;
w[j * 2 ] = 1.0f/a_x * ((a_x * b_x) / ( a_x + b_x));
w[j * 2 + 1] = 1.0f/b_x * ((a_x * b_x) / ( a_x + b_x));
}/*for(j = k / 2; j < k; j++)*/
for(i = 0; i < sizeY; i++)
{
for(j = 0; j < sizeX; j++)
{
for(ii = 0; ii < k; ii++)
{
for(jj = 0; jj < k; jj++)
{
if ((i * k + ii > 0) &&
(i * k + ii < height - 1) &&
(j * k + jj > 0) &&
(j * k + jj < width - 1))
{
d = (k * i + ii) * width + (j * k + jj);
(*map)->map[ i * stringSize + j * (*map)->numFeatures + alfa[d * 2 ]] +=
r[d] * w[ii * 2] * w[jj * 2];
(*map)->map[ i * stringSize + j * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] +=
r[d] * w[ii * 2] * w[jj * 2];
if ((i + nearest[ii] >= 0) &&
(i + nearest[ii] <= sizeY - 1))
{
(*map)->map[(i + nearest[ii]) * stringSize + j * (*map)->numFeatures + alfa[d * 2 ] ] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 ];
(*map)->map[(i + nearest[ii]) * stringSize + j * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 ];
}
if ((j + nearest[jj] >= 0) &&
(j + nearest[jj] <= sizeX - 1))
{
(*map)->map[i * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 ] ] +=
r[d] * w[ii * 2] * w[jj * 2 + 1];
(*map)->map[i * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] +=
r[d] * w[ii * 2] * w[jj * 2 + 1];
}
if ((i + nearest[ii] >= 0) &&
(i + nearest[ii] <= sizeY - 1) &&
(j + nearest[jj] >= 0) &&
(j + nearest[jj] <= sizeX - 1))
{
(*map)->map[(i + nearest[ii]) * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 ] ] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
(*map)->map[(i + nearest[ii]) * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
}
}
}/*for(jj = 0; jj < k; jj++)*/
}/*for(ii = 0; ii < k; ii++)*/
}/*for(j = 1; j < sizeX - 1; j++)*/
}/*for(i = 1; i < sizeY - 1; i++)*/
cvReleaseImage(&dx);
cvReleaseImage(&dy);
free(w);
free(nearest);
free(r);
free(alfa);
return LATENT_SVM_OK;
}
UINT WINAPI
//DWORD WINAPI
#elif defined(POSIX_SYS)
// using pthread
void *
#endif
ChessRecognition::HoughLineThread(
#if defined(WINDOWS_SYS)
LPVOID
#elif defined(POSIX_SYS)
void *
#endif
Param) {
// 실제로 뒤에서 동작하는 windows용 thread함수.
// 함수 인자로 클래스를 받아옴.
ChessRecognition *_TChessRecognition = (ChessRecognition *)Param;
_TChessRecognition->_HoughLineBased = new HoughLineBased();
CvSeq *_TLineX, *_TLineY;
double _TH[] = { -1, -7, -15, 0, 15, 7, 1 };
CvMat _TDoGX = cvMat(1, 7, CV_64FC1, _TH);
CvMat* _TDoGY = cvCreateMat(7, 1, CV_64FC1);
cvTranspose(&_TDoGX, _TDoGY); // transpose(&DoGx) -> DoGy
double _TMinValX, _TMaxValX, _TMinValY, _TMaxValY, _TMinValT, _TMaxValT;
int _TKernel = 1;
// Hough 사용되는 Image에 대한 Initialize.
IplImage *iplTemp = cvCreateImage(cvSize(_TChessRecognition->_Width, _TChessRecognition->_Height), IPL_DEPTH_32F, 1);
IplImage *iplDoGx = cvCreateImage(cvGetSize(iplTemp), IPL_DEPTH_32F, 1);
IplImage *iplDoGy = cvCreateImage(cvGetSize(iplTemp), IPL_DEPTH_32F, 1);
IplImage *iplDoGyClone = cvCloneImage(iplDoGy);
IplImage *iplDoGxClone = cvCloneImage(iplDoGx);
IplImage *iplEdgeX = cvCreateImage(cvGetSize(iplTemp), 8, 1);
IplImage *iplEdgeY = cvCreateImage(cvGetSize(iplTemp), 8, 1);
CvMemStorage* _TStorageX = cvCreateMemStorage(0), *_TStorageY = cvCreateMemStorage(0);
while (_TChessRecognition->_EnableThread != false) {
// 이미지를 받아옴. main루프와 동기를 맞추기 위해서 critical section 사용.
_TChessRecognition->_ChessBoardDetectionInternalImageProtectMutex.lock();
//EnterCriticalSection(&(_TChessRecognition->cs));
cvConvert(_TChessRecognition->_ChessBoardDetectionInternalImage, iplTemp);
//LeaveCriticalSection(&_TChessRecognition->cs);
_TChessRecognition->_ChessBoardDetectionInternalImageProtectMutex.unlock();
// 각 X축 Y축 라인을 검출해 내기 위해서 filter 적용.
cvFilter2D(iplTemp, iplDoGx, &_TDoGX); // 라인만 축출해내고.
cvFilter2D(iplTemp, iplDoGy, _TDoGY);
cvAbs(iplDoGx, iplDoGx);
cvAbs(iplDoGy, iplDoGy);
// 이미지 내부에서 최댓값과 최소값을 구하여 정규화.
cvMinMaxLoc(iplDoGx, &_TMinValX, &_TMaxValX);
cvMinMaxLoc(iplDoGy, &_TMinValY, &_TMaxValY);
cvMinMaxLoc(iplTemp, &_TMinValT, &_TMaxValT);
cvScale(iplDoGx, iplDoGx, 2.0 / _TMaxValX); // 정규화.
cvScale(iplDoGy, iplDoGy, 2.0 / _TMaxValY);
cvScale(iplTemp, iplTemp, 2.0 / _TMaxValT);
cvCopy(iplDoGy, iplDoGyClone);
cvCopy(iplDoGx, iplDoGxClone);
// NMS진행후 추가 작업
_TChessRecognition->_HoughLineBased->NonMaximumSuppression(iplDoGx, iplDoGyClone, _TKernel);
_TChessRecognition->_HoughLineBased->NonMaximumSuppression(iplDoGy, iplDoGxClone, _TKernel);
cvConvert(iplDoGx, iplEdgeY); // IPL_DEPTH_8U로 다시 재변환.
cvConvert(iplDoGy, iplEdgeX);
double rho = 1.0; // distance resolution in pixel-related units.
double theta = 1.0; // angle resolution measured in radians.
int threshold = 20;
if (threshold == 0)
threshold = 1;
// detecting 해낸 edge에서 hough line 검출.
_TLineX = cvHoughLines2(iplEdgeX, _TStorageX, CV_HOUGH_STANDARD, 1.0 * rho, CV_PI / 180 * theta, threshold, 0, 0);
_TLineY = cvHoughLines2(iplEdgeY, _TStorageY, CV_HOUGH_STANDARD, 1.0 * rho, CV_PI / 180 * theta, threshold, 0, 0);
// cvSeq를 vector로 바꾸기 위한 연산.
_TChessRecognition->_Vec_ProtectionMutex.lock();
_TChessRecognition->_HoughLineBased->CastSequence(_TLineX, _TLineY);
_TChessRecognition->_Vec_ProtectionMutex.unlock();
Sleep(2);
}
// mat 할당 해제.
cvReleaseMat(&_TDoGY);
// 내부 연산에 사용된 이미지 할당 해제.
cvReleaseImage(&iplTemp);
cvReleaseImage(&iplDoGx);
cvReleaseImage(&iplDoGy);
cvReleaseImage(&iplDoGyClone);
cvReleaseImage(&iplDoGxClone);
cvReleaseImage(&iplEdgeX);
cvReleaseImage(&iplEdgeY);
// houghline2에 사용된 opencv 메모리 할당 해제.
cvReleaseMemStorage(&_TStorageX);
cvReleaseMemStorage(&_TStorageY);
delete _TChessRecognition->_HoughLineBased;
#if defined(WINDOWS_SYS)
_endthread();
#elif defined(POSIX_SYS)
#endif
_TChessRecognition->_EndThread = true;
return 0;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CvMat *tgso (CvMat &tmap, int ntex, double sigma, double theta, CvMat &tsim, int useChi2) {
CvMat *roundTmap=cvCreateMat(tmap.rows,tmap.cols,CV_32FC1);
CvMat *comp=cvCreateMat(tmap.rows,tmap.cols,CV_32FC1);
for (int i=0;i<tmap.rows;i++)
for (int j=0;j<tmap.cols;j++)
cvSetReal2D(roundTmap,i,j,cvRound(cvGetReal2D(&tmap,i,j)));
cvSub(&tmap,roundTmap,comp);
if (cvCountNonZero(comp)) {
printf("texton labels not integral");
cvReleaseMat(&roundTmap);
cvReleaseMat(&comp);
exit(1);
}
double min,max;
cvMinMaxLoc(&tmap,&min,&max);
if (min<1 && max>ntex) {
char *msg=new char[50];
printf(msg,"texton labels out of range [1,%d]",ntex);
cvReleaseMat(&roundTmap);
cvReleaseMat(&comp);
exit(1);
}
cvReleaseMat(&roundTmap);
cvReleaseMat(&comp);
double wr=floor(sigma); //sigma=radius (Leo)
CvMat *x=cvCreateMat(1,wr-(-wr)+1, CV_64FC1);
CvMat *y=cvCreateMat(wr-(-wr)+1,1, CV_64FC1);
CvMat *u=cvCreateMat(wr-(-wr)+1,wr-(-wr)+1, CV_64FC1);
CvMat *v=cvCreateMat(wr-(-wr)+1,wr-(-wr)+1, CV_64FC1);
CvMat *gamma=cvCreateMat(u->rows,v->rows, CV_64FC1);
// Set x,y directions
for (int j=-wr;j<=wr;j++) {
cvSetReal2D(x,0,(j+wr),j);
cvSetReal2D(y,(j+wr),0,j);
}
// Set u,v, meshgrids
for (int i=0;i<u->rows;i++) {
cvRepeat(x,u);
cvRepeat(y,v);
}
// Compute the gamma matrix from the grid
for (int i=0;i<u->rows;i++)
for (int j=0;j<u->cols;j++)
cvSetReal2D(gamma,i,j,atan2(cvGetReal2D(v,i,j),cvGetReal2D(u,i,j)));
cvReleaseMat(&x);
cvReleaseMat(&y);
CvMat *sum=cvCreateMat(u->rows,u->cols, CV_64FC1);
cvMul(u,u,u);
cvMul(v,v,v);
cvAdd(u,v,sum);
CvMat *mask=cvCreateMat(u->rows,u->cols, CV_8UC1);
cvCmpS(sum,sigma*sigma,mask,CV_CMP_LE);
cvConvertScale(mask,mask,1.0/255);
cvSetReal2D(mask,wr,wr,0);
int count=cvCountNonZero(mask);
cvReleaseMat(&u);
cvReleaseMat(&v);
cvReleaseMat(&sum);
CvMat *sub=cvCreateMat(mask->rows,mask->cols, CV_64FC1);
CvMat *side=cvCreateMat(mask->rows,mask->cols, CV_8UC1);
cvSubS(gamma,cvScalar(theta),sub);
cvReleaseMat(&gamma);
for (int i=0;i<mask->rows;i++){
for (int j=0;j<mask->cols;j++) {
double n=cvmGet(sub,i,j);
double n_mod = n-floor(n/(2*M_PI))*2*M_PI;
cvSetReal2D(side,i,j, 1 + int(n_mod < M_PI));
}
}
cvMul(side,mask,side);
cvReleaseMat(&sub);
cvReleaseMat(&mask);
CvMat *lmask=cvCreateMat(side->rows,side->cols, CV_8UC1);
CvMat *rmask=cvCreateMat(side->rows,side->cols, CV_8UC1);
cvCmpS(side,1,lmask,CV_CMP_EQ);
cvCmpS(side,2,rmask,CV_CMP_EQ);
int count1=cvCountNonZero(lmask), count2=cvCountNonZero(rmask);
if (count1 != count2) {
printf("Bug: imbalance\n");
}
CvMat *rlmask=cvCreateMat(side->rows,side->cols, CV_32FC1);
CvMat *rrmask=cvCreateMat(side->rows,side->cols, CV_32FC1);
cvConvertScale(lmask,rlmask,1.0/(255*count)*2);
cvConvertScale(rmask,rrmask,1.0/(255*count)*2);
cvReleaseMat(&lmask);
cvReleaseMat(&rmask);
cvReleaseMat(&side);
int h=tmap.rows;
int w=tmap.cols;
CvMat *d = cvCreateMat(h*w,ntex,CV_32FC1);
CvMat *coltemp = cvCreateMat(h*w,1,CV_32FC1);
CvMat *tgL = cvCreateMat(h,w, CV_32FC1);
CvMat *tgR = cvCreateMat(h,w, CV_32FC1);
CvMat *temp = cvCreateMat(h,w,CV_8UC1);
CvMat *im = cvCreateMat(h,w, CV_32FC1);
CvMat *sub2 = cvCreateMat(h,w,CV_32FC1);
CvMat *sub2t = cvCreateMat(w,h,CV_32FC1);
CvMat *prod = cvCreateMat(h*w,ntex,CV_32FC1);
CvMat reshapehdr,*reshape;
CvMat* tgL_pad = cvCreateMat(h+rlmask->rows-1,w+rlmask->cols-1,CV_32FC1);
CvMat* tgR_pad = cvCreateMat(h+rlmask->rows-1,w+rlmask->cols-1,CV_32FC1);
CvMat* im_pad = cvCreateMat(h+rlmask->rows-1,w+rlmask->cols-1,CV_32FC1);
CvMat *tg=cvCreateMat(h,w,CV_32FC1);
cvZero(tg);
if (useChi2 == 1){
CvMat* temp_add1 = cvCreateMat(h,w,CV_32FC1);
for (int i=0;i<ntex;i++) {
cvCmpS(&tmap,i+1,temp,CV_CMP_EQ);
cvConvertScale(temp,im,1.0/255);
cvCopyMakeBorder(tgL,tgL_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvCopyMakeBorder(tgR,tgR_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvCopyMakeBorder(im,im_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvFilter2D(im_pad,tgL_pad,rlmask,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2));
cvFilter2D(im_pad,tgR_pad,rrmask,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2));
cvGetSubRect(tgL_pad,tgL,cvRect((rlmask->cols-1)/2,(rlmask->rows-1)/2,tgL->cols,tgL->rows));
cvGetSubRect(tgR_pad,tgR,cvRect((rlmask->cols-1)/2,(rlmask->rows-1)/2,tgR->cols,tgR->rows));
cvSub(tgL,tgR,sub2);
cvPow(sub2,sub2,2.0);
cvAdd(tgL,tgR,temp_add1);
cvAddS(temp_add1,cvScalar(0.0000000001),temp_add1);
cvDiv(sub2,temp_add1,sub2);
cvAdd(tg,sub2,tg);
}
cvScale(tg,tg,0.5);
cvReleaseMat(&temp_add1);
}
else{// if not chi^2
for (int i=0;i<ntex;i++) {
cvCmpS(&tmap,i+1,temp,CV_CMP_EQ);
cvConvertScale(temp,im,1.0/255);
cvCopyMakeBorder(tgL,tgL_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvCopyMakeBorder(tgR,tgR_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvCopyMakeBorder(im,im_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvFilter2D(im_pad,tgL_pad,rlmask,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2));
cvFilter2D(im_pad,tgR_pad,rrmask,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2));
cvGetSubRect(tgL_pad,tgL,cvRect((rlmask->cols-1)/2,(rlmask->rows-1)/2,tgL->cols,tgL->rows));
cvGetSubRect(tgR_pad,tgR,cvRect((rlmask->cols-1)/2,(rlmask->rows-1)/2,tgR->cols,tgR->rows));
cvSub(tgL,tgR,sub2);
cvAbs(sub2,sub2);
cvTranspose(sub2,sub2t);
reshape=cvReshape(sub2t,&reshapehdr,0,h*w);
cvGetCol(d,coltemp,i);
cvCopy(reshape,coltemp);
}
cvMatMul(d,&tsim,prod);
cvMul(prod,d,prod);
CvMat *sumcols=cvCreateMat(h*w,1,CV_32FC1);
cvSetZero(sumcols);
for (int i=0;i<prod->cols;i++) {
cvGetCol(prod,coltemp,i);
cvAdd(sumcols,coltemp,sumcols);
}
reshape=cvReshape(sumcols,&reshapehdr,0,w);
cvTranspose(reshape,tg);
cvReleaseMat(&sumcols);
}
//Smooth the gradient now!!
tg=fitparab(*tg,sigma,sigma/4,theta);
cvMaxS(tg,0,tg);
cvReleaseMat(&im_pad);
cvReleaseMat(&tgL_pad);
cvReleaseMat(&tgR_pad);
cvReleaseMat(&rlmask);
cvReleaseMat(&rrmask);
cvReleaseMat(&im);
cvReleaseMat(&tgL);
cvReleaseMat(&tgR);
cvReleaseMat(&temp);
cvReleaseMat(&coltemp);
cvReleaseMat(&sub2);
cvReleaseMat(&sub2t);
cvReleaseMat(&d);
cvReleaseMat(&prod);
return tg;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CvMat *savgolFilter(CvMat &z, double ra, double rb, double theta){
int d=2;
int k=1; // Always these, according to the matlab code (Leo)
ra = max(1.5,ra);
rb = max(1.5,rb);
double ira2 = 1.0/(ra*ra);
double irb2 = 1.0/(rb*rb);
double wr = floor(max(ra,rb));
double wd = 2*wr+1;
double sint = sin(theta);
double cost = cos(theta);
CvMat*xx= cvCreateMat(2*d+1, 1, CV_64FC1);
cvSetZero(xx);
CvMat *temp=cvCreateMat(2*d+1, 1, CV_64FC1);
for (int u=-wr;u<=wr;u++)
for (int v=-wr;v<=wr;v++) {
double ai=-u*sint+v*cost; //distance along major axis
double bi= u*cost+v*sint; //distance along minor axis
if (ai*ai*ira2+bi*bi*irb2 <= 1) {
cvSet(temp, cvScalar(ai));
cvSetReal2D(temp, 0, 0, 1.0);
double dTemp=1;
for (int i=0;i<2*d+1-1;i++) {
dTemp=dTemp*cvGetReal2D(temp,i+1,0);
cvSetReal2D(temp,i+1,0,dTemp);
}
cvAdd(xx,temp,xx);
}
}
cvReleaseMat(&temp);
CvMat *A=cvCreateMat(d+1,d+1,CV_64FC1);
for (int i=0;i<d+1;i++)
for (int j=i;j<=i+d;j++)
cvSetReal2D(A,j-i,i,cvGetReal2D(xx,j,0));
cvInvert(A,A,CV_LU);
CvMat *zz=cvCreateMat(wd,wd, CV_64FC1);
CvMat *yy=cvCreateMat(d+1,1, CV_64FC1);
CvMat *result=cvCreateMat(d+1,1, CV_64FC1);
CvMat *filt=cvCreateMat(wd,wd, CV_32FC1);
cvSetZero(filt);
for (int u=-wr;u<=wr;u++)
for (int v=-wr;v<=wr;v++) {
cvSetZero(zz);
cvSetReal2D(zz,v+wr,u+wr,1);
cvSetZero(yy);
double ai=-u*sint+v*cost; //distance along major axis
double bi= u*cost+v*sint; //distance along minor axis
if (ai*ai*ira2+bi*bi*irb2 <= 1) {
cvSet(yy, cvScalar(ai));
cvSetReal2D(yy, 0, 0, 1.0);
double dTemp=1;
for (int i=0;i<d+1-1;i++) {
dTemp=dTemp*cvGetReal2D(yy,i+1,0);
cvSetReal2D(yy,i+1,0,dTemp);
}
cvMatMul(A,yy,result);
cvSetReal2D(filt,v+wr,u+wr,cvGetReal2D(result,k-1,0));
}
}
cvReleaseMat(&zz);
cvReleaseMat(&yy);
cvReleaseMat(&xx);
cvReleaseMat(&A);
CvMat *ztemp= cvCreateMat(z.rows+filt->rows-1,z.cols+filt->cols-1,CV_32FC1);
cvCopyMakeBorder(&z,ztemp,cvPoint((filt->cols-1)/2,(filt->rows-1)/2),IPL_BORDER_CONSTANT);
CvMat *filteredtemp= cvCreateMat(ztemp->rows,ztemp->cols,CV_32FC1);
cvFilter2D(ztemp,filteredtemp,filt,cvPoint((filt->cols-1)/2,(filt->rows-1)/2));
CvMat *filtered = cvCreateMat(z.rows,z.cols,CV_32FC1);
cvGetSubRect(filteredtemp,filtered,cvRect((filt->cols-1)/2,(filt->rows-1)/2,z.cols,z.rows));
return filtered;
}
/**
* @brief CvGabor::conv_img_a(IplImage *src, IplImage *dst, int Type)
*/
void CvGabor::conv_img_a(IplImage *src, IplImage *dst, int Type) //图像做gabor卷积 函数名：conv_img_a
{
double ve, re,im;
int width = src->width;
int height = src->height;
CvMat *mat = cvCreateMat(src->width, src->height, CV_32FC1);
for (int i = 0; i < width; i++) //对整幅图像进行图像坐标转换
{
for (int j = 0; j < height; j++)
{
ve = cvGetReal2D((IplImage*)src, j, i);
cvSetReal2D( (CvMat*)mat, i, j, ve );
}
}
CvMat *rmat = cvCreateMat(width, height, CV_32FC1); //存实部
CvMat *imat = cvCreateMat(width, height, CV_32FC1); //存虚部
CvMat *kernel = cvCreateMat( Width, Width, CV_32FC1 ); //创建核函数窗口
switch (Type)
{
case CV_GABOR_REAL: //实部卷积
cvCopy( (CvMat*)Real, (CvMat*)kernel, NULL );
cvFilter2D( (CvMat*)mat, (CvMat*)mat, (CvMat*)kernel, cvPoint( (Width-1)/2, (Width-1)/2));
break;
case CV_GABOR_IMAG: //虚部卷积
cvCopy( (CvMat*)Imag, (CvMat*)kernel, NULL );
cvFilter2D( (CvMat*)mat, (CvMat*)mat, (CvMat*)kernel, cvPoint( (Width-1)/2, (Width-1)/2));
break;
case CV_GABOR_MAG: //实部与虚部卷积
/* Real Response */
cvCopy( (CvMat*)Real, (CvMat*)kernel, NULL );
cvFilter2D( (CvMat*)mat, (CvMat*)rmat, (CvMat*)kernel, cvPoint( (Width-1)/2, (Width-1)/2));
/* Imag Response */
cvCopy( (CvMat*)Imag, (CvMat*)kernel, NULL );
cvFilter2D( (CvMat*)mat, (CvMat*)imat, (CvMat*)kernel, cvPoint( (Width-1)/2, (Width-1)/2));
/* Magnitude response is the square root of the sum of the square of real response and imaginary response */
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
re = cvGetReal2D((CvMat*)rmat, i, j);
im = cvGetReal2D((CvMat*)imat, i, j);
ve = sqrt(re*re + im*im);
cvSetReal2D( (CvMat*)mat, i, j, ve );
}
}
break;
case CV_GABOR_PHASE:
break;
}
if (dst->depth == IPL_DEPTH_8U) //归一化
{
cvNormalize((CvMat*)mat, (CvMat*)mat, 0, 255, CV_MINMAX, NULL);
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
ve = cvGetReal2D((CvMat*)mat, i, j);
ve = cvRound(ve);
cvSetReal2D( (IplImage*)dst, j, i, ve );
}
}
}
if (dst->depth == IPL_DEPTH_32F)
{
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
ve = cvGetReal2D((CvMat*)mat, i, j);
cvSetReal2D( (IplImage*)dst, j, i, ve );
}
}
}
cvReleaseMat(&kernel);
cvReleaseMat(&imat);
cvReleaseMat(&rmat);
cvReleaseMat(&mat);
}
void main(){
Gabor gabor;
run_camera();
cvCvtColor( src, grayscale, CV_RGB2GRAY );
cvCopy(src,dst);
Smooth(src,smooth);
//cvShowImage( "smooth",smooth);
process_image();
//normalize(float xp,float xi, float yp,float yi, float rp,float ri ,IplImage *src)
normalize(xp, yp, rp, xi, yi,ri ,src);
cvCvtColor(normalized,greynormalized,CV_RGB2GRAY);
//cvShowImage("greynormalized",greynormalized);
cvEqualizeHist(greynormalized,eqnormalized);
//cvShowImage("eqnormalized",eqnormalized);
//1-void create_gabor_kernel_v1( float sig, float thet, float lm, float gamma , float ps , float bw)
//gabor.create_gabor_kernel_v1(0,45,8,1,0,1); //sigma = 1.6 , gamma = 1 for kernel of size 9
//2-void create_gabor_kernel_v2(int kernel_size, float sig, float thet, float lm, float gamma , float ps);
//gabor.create_gabor_kernel_v2(21,5,45,10,1,90);
//3-void create_gabor_kernel_v3(int kernel_size, float sig, float thet, float freq, float gamma , float ps)
//gabor.create_gabor_kernel_v3(9,2,0,0.2,1,0);
//4-void create_gabor_kernel_v4(int kernel_size, double sigma, double theta, double lambd, double gamma, double psi, int ktype);
//gabor.create_gabor_kernel_v4(9,2,0,35,1,0,CV_32F);
//5-void create_gabor_kernel_v5 (int kernel_size, double sigma,double theta , double freq ,double gamma)
//gabor.create_gabor_kernel_v5(9,2,0,0.25,1);
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
cvFilter2D(eqnormalized,real_gabor, kernel_real);
cvShowImage("real wavelet",real_gabor);
cvFilter2D(eqnormalized,imag_gabor, kernel_imag);
cvShowImage("imag wavelet",imag_gabor);
//cvFilter2D(eqnormalized,mag_gabor, kernel_mag);
//cvShowImage("mag wavelet",mag_gabor);
//quantize_gabor_image_real();
//quantize_gabor_image_imag();
generate_code();
//save_image_code("code_4.bmp",code); //scales code before saving
//display_image_values(0,kernel_real); // FOR DEBUGING PURPOSES
//display_image_values(code,0); // FOR DEBUGING PURPOSES
float HD =compare_code(code,"code_4.bmp");
printf("Hamming Distance = %1.2f",HD);
cvScale(code,scaled_code,255);
cvShowImage("code",scaled_code);
cvNamedWindow( "Source");
cvShowImage( "Source",dst);
//printf ( "xp:%f ,xi:%f, yp:%f, yi:%f, rp:%f, ri:%f",xp,xi,yp,yi,rp,ri);
cvWaitKey();
cvReleaseImage(&dst);
cvReleaseImage(&smooth);
cvReleaseImage(&pupil);
cvReleaseImage(&iris);
cvReleaseImage(&pedge);
cvReleaseImage(&iedge);
cvReleaseImage(&src);
cvReleaseImage(&eqnormalized);
cvReleaseImage(&greynormalized);
cvReleaseImage(&normalized);
cvReleaseImage(&real_gabor);
cvReleaseImage(&imag_gabor);
cvReleaseImage(&mag_gabor);
//cvReleaseImage(&phase_gabor);
cvReleaseImage(&quantized_real);
cvReleaseImage(&quantized_imag);
cvReleaseImage(&code);
}
IplImage*
ComputeSaliency(IplImage* image, int thresh, int scale) {
//given a one channel image
unsigned int size = floor(pow(2,scale)); //the size to do teh saliency @
IplImage* bw_im = cvCreateImage(cvSize(size,size),
IPL_DEPTH_8U,1);
cvResize(image, bw_im);
IplImage* realInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 1);
IplImage* imaginaryInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 1);
IplImage* complexInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 2);
cvScale(bw_im, realInput, 1.0/255.0);
cvZero(imaginaryInput);
cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);
CvMat* dft_A = cvCreateMat( size, size, CV_32FC2 );
// copy A to dft_A and pad dft_A with zeros
CvMat tmp;
cvGetSubRect( dft_A, &tmp, cvRect(0,0, size,size));
cvCopy( complexInput, &tmp );
// cvZero(&tmp);
cvDFT( dft_A, dft_A, CV_DXT_FORWARD, size );
cvSplit( dft_A, realInput, imaginaryInput, NULL, NULL );
// Compute the phase angle
IplImage* image_Mag = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1);
IplImage* image_Phase = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1);
//compute the phase of the spectrum
cvCartToPolar(realInput, imaginaryInput, image_Mag, image_Phase, 0);
IplImage* log_mag = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1);
cvLog(image_Mag, log_mag);
//Box filter the magnitude, then take the difference
IplImage* log_mag_Filt = cvCreateImage(cvSize(size, size),
IPL_DEPTH_32F, 1);
CvMat* filt = cvCreateMat(3,3, CV_32FC1);
cvSet(filt,cvScalarAll(1.0/9.0));
cvFilter2D(log_mag, log_mag_Filt, filt);
cvReleaseMat(&filt);
cvSub(log_mag, log_mag_Filt, log_mag);
cvExp(log_mag, image_Mag);
cvPolarToCart(image_Mag, image_Phase, realInput, imaginaryInput,0);
cvExp(log_mag, image_Mag);
cvMerge(realInput, imaginaryInput, NULL, NULL, dft_A);
cvDFT( dft_A, dft_A, CV_DXT_INV_SCALE, size);
cvAbs(dft_A, dft_A);
cvMul(dft_A,dft_A, dft_A);
cvGetSubRect( dft_A, &tmp, cvRect(0,0, size,size));
cvCopy( &tmp, complexInput);
cvSplit(complexInput, realInput, imaginaryInput, NULL,NULL);
IplImage* result_image = cvCreateImage(cvGetSize(image),IPL_DEPTH_32F, 1);
double minv, maxv;
CvPoint minl, maxl;
cvSmooth(realInput,realInput);
cvSmooth(realInput,realInput);
cvMinMaxLoc(realInput,&minv,&maxv,&minl,&maxl);
printf("Max value %lf, min %lf\n", maxv,minv);
cvScale(realInput, realInput, 1.0/(maxv-minv), 1.0*(-minv)/(maxv-minv));
cvResize(realInput, result_image);
double threshold = thresh/100.0*cvAvg(realInput).val[0];
cvThreshold(result_image, result_image, threshold, 1.0, CV_THRESH_BINARY);
IplImage* final_result = cvCreateImage(cvGetSize(image),IPL_DEPTH_8U, 1);
cvScale(result_image, final_result, 255.0, 0.0);
cvReleaseImage(&result_image);
//cvReleaseImage(&realInput);
cvReleaseImage(&imaginaryInput);
cvReleaseImage(&complexInput);
cvReleaseMat(&dft_A);
cvReleaseImage(&bw_im);
cvReleaseImage(&image_Mag);
cvReleaseImage(&image_Phase);
cvReleaseImage(&log_mag);
cvReleaseImage(&log_mag_Filt);
cvReleaseImage(&bw_im);
return final_result;
//return bw_im;
}
/*!
//void cameraCorrection(IplImage* src,IplImage* dst,int type, double A, int size)
// Corregge un singolo frame:
// @param[in] src l'immagine da correggere
// @param[out] dst dove viene memorizzato il risultato
// @param[in] type(default=MEDIAN): può assumere i seguenti valori...
// MEDIAN filtro mediano per ridurre il rumore
// SHARPENING filto di sharpening con maskera (0,-1,0;-1,5,-1;0,-1,0)
// HIGH_BOOST sharpening high boost, dipendente dal valore di A(default=1.1)
// maschera -1 -1 -1
// -1 A*9-1 -1
// -1 -1 -1
// Sono inoltre consentite le seguenti combinazioni
// (cambiando l'ordine degli addendi il risultato non cambia, le operazioni verranno applicate sempre con lo stesso ordine)
// MEDIAN+SHARPENING
// MEDIAN+SHARPENING+MEDIAN
// MEDIAN+HIGH_BOOST
// MEDIAN+HIGH_BOOST+MEDIAN
// @param[in] A (default=1.1) parametro per filtraggio con HIGH_BOOST
// @param[in] size (default=5) dimensione della maschera del filtro mediano
*/
void cameraCorrection(IplImage* src,IplImage* dst,int type, double A, int size){
double w;
CvMat* kernel = cvCreateMat( 3, 3, CV_32FC1) ;
LOG4CXX_TRACE(loggerCameraCorrection , "Camera correction started");
try{
switch(type){
case MEDIAN:
cvSmooth(src,dst,CV_MEDIAN,size,0,0,0);
LOG4CXX_DEBUG(loggerCameraCorrection,"Median filter application");
break;
case HIGH_BOOST:
w=9*A-1;
cvSet2D(kernel, 0, 0, cvRealScalar( -1) );
cvSet2D(kernel, 0, 1, cvRealScalar( -1) );
cvSet2D(kernel, 0, 2, cvRealScalar( -1) );
cvSet2D(kernel, 1, 0, cvRealScalar( -1) );
cvSet2D(kernel, 1, 1, cvRealScalar(w) );
cvSet2D(kernel, 1, 2, cvRealScalar( -1) );
cvSet2D(kernel, 2, 0, cvRealScalar( -1) );
cvSet2D(kernel, 2, 1, cvRealScalar( -1) );
cvSet2D(kernel, 2, 2, cvRealScalar( -1) );
cvFilter2D(src, dst,kernel,cvPoint(0,0));
LOG4CXX_DEBUG(loggerCameraCorrection,"High boost application");
break;
case SHARPENING:
cvSet2D(kernel, 0, 0, cvRealScalar( 0) );
cvSet2D(kernel, 0, 1, cvRealScalar( -1) );
cvSet2D(kernel, 0, 2, cvRealScalar( 0) );
cvSet2D(kernel, 1, 0, cvRealScalar( -1) );
cvSet2D(kernel, 1, 1, cvRealScalar(5) );
cvSet2D(kernel, 1, 2, cvRealScalar( -1) );
cvSet2D(kernel, 2, 0, cvRealScalar( 0) );
cvSet2D(kernel, 2, 1, cvRealScalar( -1) );
cvSet2D(kernel, 2, 2, cvRealScalar( 0) );
cvFilter2D(src, dst,kernel,cvPoint(0,0));
LOG4CXX_DEBUG(loggerCameraCorrection,"Sharpening application");
break;
case (MEDIAN+SHARPENING):
cvSet2D(kernel, 0, 0, cvRealScalar( 0) );
cvSet2D(kernel, 0, 1, cvRealScalar( -1) );
cvSet2D(kernel, 0, 2, cvRealScalar( 0) );
cvSet2D(kernel, 1, 0, cvRealScalar( -1) );
cvSet2D(kernel, 1, 1, cvRealScalar(5) );
cvSet2D(kernel, 1, 2, cvRealScalar( -1) );
cvSet2D(kernel, 2, 0, cvRealScalar( 0) );
cvSet2D(kernel, 2, 1, cvRealScalar( -1) );
cvSet2D(kernel, 2, 2, cvRealScalar( 0) );
cvSmooth(src,dst,CV_MEDIAN,size,0,0,0);
cvFilter2D(dst, dst,kernel,cvPoint(0,0));
break;
LOG4CXX_DEBUG(loggerCameraCorrection,"Median filter and Sharpening application");
case (MEDIAN+HIGH_BOOST):
w=9*A-1;
cvSet2D(kernel, 0, 0, cvRealScalar( -1) );
cvSet2D(kernel, 0, 1, cvRealScalar( -1) );
cvSet2D(kernel, 0, 2, cvRealScalar( -1) );
cvSet2D(kernel, 1, 0, cvRealScalar( -1) );
cvSet2D(kernel, 1, 1, cvRealScalar(w) );
cvSet2D(kernel, 1, 2, cvRealScalar( -1) );
cvSet2D(kernel, 2, 0, cvRealScalar( -1) );
cvSet2D(kernel, 2, 1, cvRealScalar( -1) );
cvSet2D(kernel, 2, 2, cvRealScalar( -1) );
cvSmooth(src,dst,CV_MEDIAN,size,0,0,0);
cvFilter2D(dst, dst,kernel,cvPoint(0,0));
LOG4CXX_DEBUG(loggerCameraCorrection,"Median filter and high boost application");
break;
case (MEDIAN+HIGH_BOOST+MEDIAN):
w=9*A-1;
cvSet2D(kernel, 0, 0, cvRealScalar( -1) );
cvSet2D(kernel, 0, 1, cvRealScalar( -1) );
cvSet2D(kernel, 0, 2, cvRealScalar( -1) );
cvSet2D(kernel, 1, 0, cvRealScalar( -1) );
cvSet2D(kernel, 1, 1, cvRealScalar(w) );
cvSet2D(kernel, 1, 2, cvRealScalar( -1) );
cvSet2D(kernel, 2, 0, cvRealScalar( -1) );
cvSet2D(kernel, 2, 1, cvRealScalar( -1) );
cvSet2D(kernel, 2, 2, cvRealScalar( -1) );
cvSmooth(src,dst,CV_MEDIAN,size,0,0,0);
cvFilter2D(dst, dst,kernel,cvPoint(0,0));
cvSmooth(dst,dst,CV_MEDIAN,size-2,0,0,0);
LOG4CXX_DEBUG(loggerCameraCorrection,"Median filter, high boost and median filter application again ");
break;
case(MEDIAN+SHARPENING+MEDIAN):
cvSet2D(kernel, 0, 0, cvRealScalar( 0) );
cvSet2D(kernel, 0, 1, cvRealScalar( -1) );
cvSet2D(kernel, 0, 2, cvRealScalar( 0) );
cvSet2D(kernel, 1, 0, cvRealScalar( -1) );
cvSet2D(kernel, 1, 1, cvRealScalar(5) );
cvSet2D(kernel, 1, 2, cvRealScalar( -1) );
cvSet2D(kernel, 2, 0, cvRealScalar( 0) );
cvSet2D(kernel, 2, 1, cvRealScalar( -1) );
cvSet2D(kernel, 2, 2, cvRealScalar( 0) );
cvSmooth(src,dst,CV_MEDIAN,size,0,0,0);
cvFilter2D(dst, dst,kernel,cvPoint(0,0));
cvSmooth(dst,dst,CV_MEDIAN,size-2,0,0,0);
LOG4CXX_DEBUG(loggerCameraCorrection,"Median filter, sharpening and median filter application again ");
break;
default:
throw 1;
}
}catch(int e){
LOG4CXX_ERROR(loggerCameraCorrection,"Exception: the inserted parameter 'type' in cameraCorrection() isn't allowed");
}
}
int main(int argc, char* argv[])
{
float kernel[5*5];
for (int i =0;i<25;i++) kernel[i]=1;
// получаем любую подключённую камеру
CvCapture* capture = cvCreateCameraCapture(CV_CAP_ANY); //cvCaptureFromCAM( 0 );
assert( capture );
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 640);
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 480);
// узнаем ширину и высоту кадра
double width = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH);
double height = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT);
printf("[i] %.0f x %.0f\n", width, height );
cvNamedWindow("capture", CV_WINDOW_AUTOSIZE);
printf("[i] press Enter for capture image and Esc for quit!\n\n");
int counter=0;
char filename[512];
// cvSetMouseCallback("capture", callback, NULL);
frame = cvQueryFrame( capture );
framef = cvQueryFrame( capture );
// создаём изображения
hsv = cvCreateImage( cvGetSize(frame), 8, 3 );
h_plane = cvCreateImage( cvGetSize(frame), 8, 1 );
s_plane = cvCreateImage( cvGetSize(frame), 8, 1 );
v_plane = cvCreateImage( cvGetSize(frame), 8, 1 );
bmas = cvCreateImage( cvGetSize(frame), 8, 1 );
while(true){
// получаем кадр
framef = cvQueryFrame( capture );
//cvSmooth(framef, frame, CV_GAUSSIAN,5,5);
// показываем
char c = cvWaitKey(60);
if (c == 27) { // нажата ESC
break;
}
/*for (int i = 0; i < frame->height; i++)
for (int j = 0; j < frame->width; j++)
{
if ( //beetween(PIXEL(j,i,RED), 0, 100) &&
//beetween(PIXEL(j,i,GREEN), 50, 255) &&
//beetween(PIXEL(j,i,BLUE), 0, 100)
PIXEL(j,i,GREEN)
-
(PIXEL(j,i,RED) + PIXEL(j,i,BLUE)) / 2
>
10
)
SETCOLOR(j,i,0,0,0);
}
*/
// конвертируем в HSV
cvCvtColor( frame, hsv, CV_BGR2HSV );
// разбиваем на каналы
char* ref;
for (int i = 0; i < frame->height * frame->width; i++)
{
ref = &mas[i];
if (beetween(HSVPIXEL(i,HUE), (55/2), (180/2))
&&
beetween(HSVPIXEL(i,VAL), 10, 255)
&&
beetween(HSVPIXEL(i,SAT), 50, 250)
)
*ref = (*ref + 1) % 10;
else *ref = 0;
//if (
//mas[i+1] == 0 &&
//mas[i-1] == 0 &&
//mas[i+frame->width] == 0 &&
//mas[i-frame->width] == 0 &&
//)
//*ref = 0;
if (*ref > 1)
bmas->imageData[i] = 255;
else
bmas->imageData[i] = 0;
};
CvMat kernel_matrix = cvMat(5,5,CV_32FC1,kernel);
cvFilter2D(bmas,bmas,&kernel_matrix, cvPoint(-1,-1));
//cvCvtColor( hsv, frame, CV_HSV2RGB );
cvShowImage("capture", bmas);
cvSmooth(bmas, bmas, CV_GAUSSIAN,5,5);
}
// освобождаем ресурсы
cvReleaseCapture( &capture );
cvDestroyWindow("capture");
return 0;
}
/**
Calculates the optical flow between two images.
@param[in] imgA First input image
@param[in] imgB Second input image, the flow is calculated from imgA to imgB
@param[out] imgU Horizontal flow field
@param[out] imgV Vertical flow field
@param[in] saved_data Flag indicates previous imgB is now imgA (ie subsequent frames), save some time in calculation
@return Flag to indicate succesful completion
*/
int VarFlow::CalcFlow(IplImage* imgA, IplImage* imgB, IplImage* imgU, IplImage* imgV, bool saved_data = false){
if(!initialized)
return 0;
IplImage* swap_img;
//Don't recalculate imgAfloat, just swap with imgBfloat
if(saved_data){
CV_SWAP(imgAfloat, imgBfloat, swap_img);
cvResize(imgB, imgBsmall, CV_INTER_LINEAR);
cvConvert(imgBsmall, imgBfloat); // Calculate new imgBfloat
cvSmooth(imgBfloat, imgBfloat, CV_GAUSSIAN, 0, 0, sigma, 0 );
}
//Calculate imgAfloat as well as imgBfloat
else{
cvResize(imgA, imgAsmall, CV_INTER_LINEAR);
cvResize(imgB, imgBsmall, CV_INTER_LINEAR);
cvConvert(imgAsmall, imgAfloat);
cvConvert(imgBsmall, imgBfloat);
cvSmooth(imgAfloat, imgAfloat, CV_GAUSSIAN, 0, 0, sigma, 0 );
cvSmooth(imgBfloat, imgBfloat, CV_GAUSSIAN, 0, 0, sigma, 0 );
}
cvFilter2D(imgAfloat, imgAfx, &fx_mask, cvPoint(-1,-1)); // X spacial derivative
cvFilter2D(imgAfloat, imgAfy, &fy_mask, cvPoint(-1,-1)); // Y spacial derivative
cvSub(imgBfloat, imgAfloat, imgAft, NULL); // Temporal derivative
cvMul(imgAfx,imgAfx,imgAfxfx_array[0], 1);
cvMul(imgAfx,imgAfy,imgAfxfy_array[0], 1);
cvMul(imgAfx,imgAft,imgAfxft_array[0], 1);
cvMul(imgAfy,imgAfy,imgAfyfy_array[0], 1);
cvMul(imgAfy,imgAft,imgAfyft_array[0], 1);
cvSmooth(imgAfxfx_array[0], imgAfxfx_array[0], CV_GAUSSIAN, 0, 0, rho, 0 );
cvSmooth(imgAfxfy_array[0], imgAfxfy_array[0], CV_GAUSSIAN, 0, 0, rho, 0 );
cvSmooth(imgAfxft_array[0], imgAfxft_array[0], CV_GAUSSIAN, 0, 0, rho, 0 );
cvSmooth(imgAfyfy_array[0], imgAfyfy_array[0], CV_GAUSSIAN, 0, 0, rho, 0 );
cvSmooth(imgAfyft_array[0], imgAfyft_array[0], CV_GAUSSIAN, 0, 0, rho, 0 );
int i;
//Fill all the levels of the multigrid algorithm with resized images
for(i = 1; i < (max_level - start_level + 1); i++){
cvResize(imgAfxfx_array[i-1], imgAfxfx_array[i], CV_INTER_LINEAR);
cvResize(imgAfxfy_array[i-1], imgAfxfy_array[i], CV_INTER_LINEAR);
cvResize(imgAfxft_array[i-1], imgAfxft_array[i], CV_INTER_LINEAR);
cvResize(imgAfyfy_array[i-1], imgAfyfy_array[i], CV_INTER_LINEAR);
cvResize(imgAfyft_array[i-1], imgAfyft_array[i], CV_INTER_LINEAR);
}
int k = (max_level - start_level);
while(1)
{
gauss_seidel_recursive(k, (max_level - start_level), k, pow((float)2.0,(float)(k)), imgAfxft_array, imgAfyft_array);
if(k > 0){
// Transfer velocity from coarse to fine
cvResize(imgU_array[k], imgU_array[k-1], CV_INTER_LINEAR);
cvResize(imgV_array[k], imgV_array[k-1], CV_INTER_LINEAR);
k--;
}else{
break;
}
}
// Transfer to output image, resize if necessary
cvResize(imgU_array[0], imgU, CV_INTER_LINEAR);
cvResize(imgV_array[0], imgV, CV_INTER_LINEAR);
// If started algorithm with smaller image than original, scale the flow field
if(start_level > 0){
cvScale(imgU, imgU, pow(2.0, start_level));
cvScale(imgV, imgV, pow(2.0, start_level));
}
return 1;
}
int main (int argc, const char * argv[])
{
if ( argc != 2 )
{
fprintf(stderr, "Usage: <image>\n");
exit(1);
}
IplImage* image = cvLoadImage(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
if ( image == NULL )
{
fprintf(stderr, "Couldn't load image %s\n", argv[1]);
exit(1);
}
IplImage* dst = cvCloneImage(image);
//cvSetZero(dst);
CvMat* rotation = cvCreateMat(2, 3, CV_32FC1);
#if 0
// Optimized for a finding 3 pixel wide lines.
float zeroDegreeLineData[] = {
-10, -10, -10, -10, -10,
3, 3, 3, 3, 3,
14, 14, 14, 14, 14,
3, 3, 3, 3, 3,
-10, -10, -10, -10, -10
};
#if 0
float zeroDegreeLineData[] = {
10, 10, 10, 10, 10,
-3, -3, -3, -3, -3,
-14, -14, -14, -14, -14,
-3, -3, -3, -3, -3,
10, 10, 10, 10, 10
};
#endif
CvMat zeroDegreeLine = cvMat(5, 5, CV_32FC1, zeroDegreeLineData);
PrintMat("Zero Degree Line", &zeroDegreeLine);
cv2DRotationMatrix(cvPoint2D32f(2,2), 60.0, 1.0, rotation);
CvMat* kernel = cvCreateMat(5, 5, CV_32FC1);
#else
// Optimized for finding 1 pixel wide lines. The sum of all co-efficients is 0, so this kernel has
// the tendency to send pixels towards zero
#if 0
float zeroDegreeLineData[] = {
10, 10, 10,
-20, -20, -20,
10, 10, 10
};
#elif 0
float zeroDegreeLineData[] = {
-10, -10, -10,
20, 20, 20,
-10, -10, -10
};
#else
// Line detector optimized to find a horizontal line 1 pixel wide that is darker (smaller value) than it’s surrounding pixels. This works because darker (smaller value) horizontal 1 pixel wide lines will have a smaller magnitude negative
// component, which means their convoluted value will be higher than surrounding pixels. See Convolution.numbers
// for a simple example how this works.
float zeroDegreeLineData[] = {
1, 1, 1,
-2, -2, -2,
1, 1, 1
};
#endif
CvMat zeroDegreeLine = cvMat(3, 3, CV_32FC1, zeroDegreeLineData);
PrintMat("Zero Degree Line", &zeroDegreeLine);
// Going to rotate the horizontal line detecting kernel by 60 degrees to that it will detect 60 degree lines.
cv2DRotationMatrix(cvPoint2D32f(1,1), 60.0, 1.0, rotation);
CvMat* kernel = cvCreateMat(3, 3, CV_32FC1);
#endif
PrintMat("Rotation", rotation);
cvWarpAffine(&zeroDegreeLine, kernel, rotation, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll(0));
PrintMat("Kernel", kernel);
cvFilter2D( image, dst, kernel, cvPoint(-1,-1));
cvNamedWindow("main", CV_WINDOW_NORMAL);
cvShowImage("main", image);
cvWaitKey(0);
cvShowImage("main", dst);
cvWaitKey(0);
return 0;
}
/*
// Getting feature map for the selected subimage
//
// API
// int getFeatureMaps(const IplImage * image, const int k, featureMap **map);
// INPUT
// image - selected subimage
// k - size of cells
// OUTPUT
// map - feature map
// RESULT
// Error status
*/
int getFeatureMaps_dp(const IplImage* image,const int k, CvLSVMFeatureMap **map)
{
int sizeX, sizeY;
int p, px, strsz;
int height, width, channels;
int i, j, kk, c, ii, jj, d;
float * datadx, * datady;
float tmp, x, y, tx, ty;
IplImage * dx, * dy;
int *nearest_x, *nearest_y;
float *w, a_x, b_x;
float kernel[3] = {-1.f, 0.f, 1.f};
CvMat kernel_dx = cvMat(1, 3, CV_32F, kernel);
CvMat kernel_dy = cvMat(3, 1, CV_32F, kernel);
float * r;
int * alfa;
float boundary_x[CNTPARTION+1];
float boundary_y[CNTPARTION+1];
float max, tmp_scal;
int maxi;
height = image->height;
width = image->width ;
channels = image->nChannels;
dx = cvCreateImage(cvSize(image->width , image->height) , IPL_DEPTH_32F , 3);
dy = cvCreateImage(cvSize(image->width , image->height) , IPL_DEPTH_32F , 3);
sizeX = width / k;
sizeY = height / k;
px = CNTPARTION + 2 * CNTPARTION; // контрастное и не контрастное изображение
p = px;
strsz = sizeX * p;
allocFeatureMapObject(map, sizeX, sizeY, p, px);
cvFilter2D(image, dx, &kernel_dx, cvPoint(-1, 0));
cvFilter2D(image, dy, &kernel_dy, cvPoint(0, -1));
for(i = 0; i <= CNTPARTION; i++)
{
boundary_x[i] = cosf((((float)i) * (((float)PI) / (float) (CNTPARTION))));
boundary_y[i] = sinf((((float)i) * (((float)PI) / (float) (CNTPARTION))));
}/*for(i = 0; i <= CNTPARTION; i++) */
r = (float *)malloc( sizeof(float) * (width * height));
alfa = (int *)malloc( sizeof(int ) * (width * height * 2));
for(j = 1; j < height-1; j++)
{
datadx = (float*)(dx->imageData + dx->widthStep *j);
datady = (float*)(dy->imageData + dy->widthStep *j);
for(i = 1; i < width-1; i++)
{
c = 0;
x = (datadx[i*channels+c]);
y = (datady[i*channels+c]);
r[j * width + i] =sqrtf(x*x + y*y);
for(kk = 1; kk < channels; kk++)
{
tx = (datadx[i*channels+kk]);
ty = (datady[i*channels+kk]);
tmp =sqrtf(tx*tx + ty*ty);
if(tmp > r[j * width + i])
{
r[j * width + i] = tmp;
c = kk;
x = tx;
y = ty;
}
}/*for(kk = 1; kk < channels; kk++)*/
max = boundary_x[0]*x + boundary_y[0]*y;
maxi = 0;
for (kk = 0; kk < CNTPARTION; kk++) {
tmp_scal = boundary_x[kk]*x + boundary_y[kk]*y;
if (tmp_scal> max) {
max = tmp_scal;
maxi = kk;
}else if (-tmp_scal> max) {
max = -tmp_scal;
maxi = kk + CNTPARTION;
}
}
alfa[j * width * 2 + i * 2 ] = maxi % CNTPARTION;
alfa[j * width * 2 + i * 2 + 1] = maxi;
}/*for(i = 0; i < width; i++)*/
}/*for(j = 0; j < height; j++)*/
//подсчет весов и смещений
nearest_x = (int *)malloc(sizeof(int) * k);
nearest_y = (int *)malloc(sizeof(int) * k);
w = (float*)malloc(sizeof(float) * (k * 2));
for(i = 0; i < k / 2; i++)
{
nearest_x[i] = -1;
nearest_y[i] = -1;
}/*for(i = 0; i < k / 2; i++)*/
for(i = k / 2; i < k; i++)
{
nearest_x[i] = 1;
nearest_y[i] = 1;
}/*for(i = k / 2; i < k; i++)*/
for(j = 0; j < k / 2; j++)
{
b_x = k / 2 + j + 0.5f;
a_x = k / 2 - j - 0.5f;
w[j * 2 ] = 1.0f/a_x * ((a_x * b_x) / ( a_x + b_x));
w[j * 2 + 1] = 1.0f/b_x * ((a_x * b_x) / ( a_x + b_x));
}/*for(j = 0; j < k / 2; j++)*/
for(j = k / 2; j < k; j++)
{
a_x = j - k / 2 + 0.5f;
b_x =-j + k / 2 - 0.5f + k;
w[j * 2 ] = 1.0f/a_x * ((a_x * b_x) / ( a_x + b_x));
w[j * 2 + 1] = 1.0f/b_x * ((a_x * b_x) / ( a_x + b_x));
}/*for(j = k / 2; j < k; j++)*/
//интерпол¤ци¤
for(i = 0; i < sizeY; i++)
{
for(j = 0; j < sizeX; j++)
{
for(ii = 0; ii < k; ii++)
{
for(jj = 0; jj < k; jj++)
{
if ((i * k + ii > 0) && (i * k + ii < height - 1) && (j * k + jj > 0) && (j * k + jj < width - 1))
{
d = (k*i + ii)* width + (j*k + jj);
(*map)->Map[(i ) * strsz + (j ) * (*map)->p + alfa[d * 2 ] ] +=
r[d] * w[ii * 2 ] * w[jj * 2 ];
(*map)->Map[(i ) * strsz + (j ) * (*map)->p + alfa[d * 2 + 1] + CNTPARTION] +=
r[d] * w[ii * 2 ] * w[jj * 2 ];
if ((i + nearest_y[ii] >= 0) && (i + nearest_y[ii] <= sizeY - 1))
{
(*map)->Map[(i + nearest_y[ii]) * strsz + (j ) * (*map)->p + alfa[d * 2 ] ] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 ];
(*map)->Map[(i + nearest_y[ii]) * strsz + (j ) * (*map)->p + alfa[d * 2 + 1] + CNTPARTION] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 ];
}
if ((j + nearest_x[jj] >= 0) && (j + nearest_x[jj] <= sizeX - 1))
{
(*map)->Map[(i ) * strsz + (j + nearest_x[jj]) * (*map)->p + alfa[d * 2 ] ] +=
r[d] * w[ii * 2 ] * w[jj * 2 + 1];
(*map)->Map[(i ) * strsz + (j + nearest_x[jj]) * (*map)->p + alfa[d * 2 + 1] + CNTPARTION] +=
r[d] * w[ii * 2 ] * w[jj * 2 + 1];
}
if ((i + nearest_y[ii] >= 0) && (i + nearest_y[ii] <= sizeY - 1) && (j + nearest_x[jj] >= 0) && (j + nearest_x[jj] <= sizeX - 1))
{
(*map)->Map[(i + nearest_y[ii]) * strsz + (j + nearest_x[jj]) * (*map)->p + alfa[d * 2 ] ] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
(*map)->Map[(i + nearest_y[ii]) * strsz + (j + nearest_x[jj]) * (*map)->p + alfa[d * 2 + 1] + CNTPARTION] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
}
}
}/*for(jj = 0; jj < k; jj++)*/
}/*for(ii = 0; ii < k; ii++)*/
}/*for(j = 1; j < sizeX - 1; j++)*/
}/*for(i = 1; i < sizeY - 1; i++)*/
cvReleaseImage(&dx);
cvReleaseImage(&dy);
free(w);
free(nearest_x);
free(nearest_y);
free(r);
free(alfa);
return LATENT_SVM_OK;
}
void Filters::highPass(VRFrame* frame, int typeMask)
{
IplImage* imgDst = 0;
IplImage* imgAux = 0;
IplImage* imgNew = 0;
VRFrame* frameAux = 0;
int cols = 0;
int rows = 0;
CvMat *filter = 0;
// mask type
double masks[][9] = {
// Type 1
{
-1, -1, -1,
-1, 8, -1,
-1, -1, -1,
},
// Type 2
{
0, -1, 0,
-1, 4, -1,
0, -1, 0,
},
// Type 3
{
1 , -2, 1,
-2, 4, -2,
1 , -2, 1,
},
};
// allocate memory for temporary image
imgAux = VRFrame::imgAlloc(frame);
imgDst = VRFrame::imgAlloc(frame);
imgNew = VRFrame::imgAlloc(frame);
frameAux = new VRFrame(frame);
// type 0 is the default mask. set to this type if type not found
if (typeMask > 3 || typeMask < 0)
typeMask = 0;
Log::writeLog("%s :: param: frame[%x] typeMask[%d]", __FUNCTION__, frame, typeMask);
cols = 3;
rows = 3;
imgAux->imageData = frameAux->data->imageData;
imgAux->widthStep = frameAux->data->width;
imgDst->imageData = imgAux->imageData;
imgDst->widthStep = imgAux->width;
Log::writeLog("%s :: cvCreateMatHeader: rows[%d] cols[%d] CV_64FC1", __FUNCTION__, rows, cols);
filter = cvCreateMatHeader(rows, cols, CV_64FC1);
Log::writeLog("%s :: cvSetData: filter[%x] masks[%x] cols[%d]", __FUNCTION__, filter, masks[typeMask], cols*8);
cvSetData(filter, masks[typeMask], cols*8);
Log::writeLog("%s :: cvFilter2D: imgAux[%x] imgDst[%x] filter[%x] cvPoint[%x]", __FUNCTION__, imgAux, imgDst, filter, cvPoint(-1,-1));
cvFilter2D(imgAux, imgDst, filter, cvPoint(-1,-1));
//
VRFrame::imgCopy(imgDst, imgNew);
frame->setImage(imgNew);
// release memory
VRFrame::imgDealloc(imgAux);
VRFrame::imgDealloc(imgDst);
delete frameAux;
}
/*每次从摄像头获得一张图片后调用，进行运动目标检测，并画框，
当完成一个分组后返回true, 分组没结束，则返回false,
该函数由UI来调用*/
PREPROCESS_API bool PreProcessFrame(Frame frame, Frame &lastFrame)
{
Frame tempFrame;
tempFrame = prevFrame;
currImg = frame.image;
CvSize imgSize = cvSize(currImg->width,currImg->height);
IplImage *grayImg = cvCreateImage(imgSize,IPL_DEPTH_8U,1);//当前帧的灰度图
IplImage *gxImg = cvCreateImage(imgSize,IPL_DEPTH_8U,1);//当前帧的X方向梯度图
IplImage *gyImg = cvCreateImage(imgSize,IPL_DEPTH_8U,1);//当前帧的Y方向梯度图
IplImage *diffImg = cvCreateImage(imgSize,IPL_DEPTH_8U,1);//当前帧的差分图
IplImage *diffImg_2 = cvCreateImage(imgSize,IPL_DEPTH_8U,1);//前一帧差分图
IplImage *pyr = cvCreateImage(cvSize((imgSize.width&-2)/2,(imgSize.height&-2)/2),8,1); //进行腐蚀去除噪声的中间临时图片
int height,width;//定义图像的高，宽，步长
char Kx[9] = {1,0,-1,2,0,-2,1,0,-1};//X方向掩模，用于得到X方向梯度图
char Ky[9] = {1,2,1,0,0,0,-1,-2,-1};//Y方向掩模，用于得到Y方向梯度图
CvMat KX,KY;
KX = cvMat(3,3,CV_8S,Kx);//构建掩模内核
KY = cvMat(3,3,CV_8S,Ky);//构建掩模内核
cvCvtColor(currImg,grayImg,CV_BGR2GRAY);
cvSmooth(grayImg,grayImg,CV_GAUSSIAN,7,7);//进行平滑处理
cvFilter2D(grayImg,gxImg,&KX,cvPoint(-1,-1));//得到X方向的梯度图
cvFilter2D(grayImg,gyImg,&KY,cvPoint(-1,-1));//得到Y方向的梯度图
cvAdd(gxImg,gyImg,grayImg,NULL);//得到梯度图
cvReleaseImage(&gxImg);
cvReleaseImage(&gyImg);
height = grayImg->height;
width = grayImg->width;
bool alarm = false;//警戒区域是否有运动目标
CvRect rect;//定义矩形框
if(!firstFrmRec)//如果是第一帧
{
firstFrmRec = true;
lastGrayImg = cvCreateImage(imgSize,IPL_DEPTH_8U,1);
lastDiffImg = cvCreateImage(imgSize,IPL_DEPTH_8U,1);
cvCopy(grayImg,lastGrayImg,NULL);//如果是第一帧，设置为背景
xRightAlarm = currImg->width - 100;
yBottomAlarm = currImg->height - 100;
yTopAlarm = currImg->height - 200;
}
else
{
cvAbsDiff(grayImg,lastGrayImg,diffImg);//得到当前帧的差分图
cvCopy(grayImg,lastGrayImg,NULL);//将当前帧的梯度图作为下一帧的背景
cvThreshold(diffImg,diffImg,15,255,CV_THRESH_BINARY);//二值化当前差分图
if(secondFrmRec)//如果大于等于第三帧
{
cvAnd(diffImg,lastDiffImg,diffImg_2);//进行“与”运算，得到前一帧灰度图的“准确”运动目标
cvPyrDown(diffImg_2,pyr,7);//向下采样
cvErode(pyr,pyr,0,1);//腐蚀，消除小的噪声
cvPyrUp(pyr,diffImg_2,7);
cvReleaseImage(&pyr);
if(drawAlarmArea) cvRectangle(tempFrame.image, cvPoint(xLeftAlarm, yTopAlarm), cvPoint(xRightAlarm, yBottomAlarm), CV_RGB(0, 0, 255), 3, CV_AA, 0);
alarm = AlarmArea(xLeftAlarm, yTopAlarm, xRightAlarm, yBottomAlarm, diffImg_2);
}
cvCopy(diffImg,lastDiffImg,NULL);//备份当前差分图的二值化图
cvReleaseImage(&diffImg);
minLeftX = 3000;
minLeftY = 3000;
maxRightX = 0;
maxRightY = 0;
if (alarm)//若检测出整个图片有运动目标
{
FindRectX(diffImg_2, 0, height);
FindRectY(diffImg_2, minLeftX, maxRightX);
}
if (!secondFrmRec)//设置第二帧已经收到
{
secondFrmRec = true;
}
}
if(maxRightX*maxRightY)//如果当前帧检测到运动目标，则，画框,分组
{
//防止右下角出界
maxRightX = maxRightX>1 ? maxRightX:2;
maxRightY = maxRightY>1 ? maxRightY:2;
maxRightX = maxRightX<(width+1) ? maxRightX:width;
maxRightY = maxRightY<(height+1) ? maxRightY:height;
//防止左上角出界
minLeftX = minLeftX>0 ? minLeftX:1;
minLeftY = minLeftY>0 ? minLeftY:1;
minLeftX = minLeftX<maxRightX ? minLeftX:(maxRightX-1);
minLeftY = minLeftY<maxRightY ? minLeftY:(maxRightY-1);
if (drawRect) cvRectangle(tempFrame.image, cvPoint(minLeftX, minLeftY), cvPoint(maxRightX, maxRightY), CV_RGB(255, 0, 0), 3, CV_AA, 0);
//outobj<<minLeftX<<" "<<minLeftY<<" "<<maxRightX-minLeftX<<" "<<maxRightY-minLeftY<<endl;
rect = cvRect(minLeftX, minLeftY, maxRightX-minLeftX, maxRightY-minLeftY);
tempFrame.searchRect = rect;
signelCount++;
cvReleaseImage(&grayImg);
cvReleaseImage(&diffImg_2);
prevFrame = frame;
lastFrame = tempFrame;
if(signelCount == groupCount)//如果连续检测到5个单人的情况，分组结束
{
signelCount = 0;
return true;
}
else
{
return false;
}
//if((minLeftY < 360) && ((maxRightX-minLeftX) < 420))//如果检测到框为单人大小
//{
// signelCount++;
// cvReleaseImage(&grayImg);
// cvReleaseImage(&diffImg_2);
// prevFrame = frame;
// *lastFrame = tempFrame;
// if(signelCount == groupCount)//如果连续检测到5个单人的情况，分组结束
// {
// signelCount = 0;
// return true;
// }
// else
// {
// return false;
// }
//}
//else //如果检测到多人情况，每张图片分为一组
//{
// return false;
//}
if((minLeftY < 360) && ((maxRightX-minLeftX) < 420))//如果检测到框为单人大小
{
signelCount++;
cvReleaseImage(&grayImg);
cvReleaseImage(&diffImg_2);
prevFrame = frame;
lastFrame = tempFrame;
if(signelCount == groupCount)//如果连续检测到5个单人的情况，分组结束
{
signelCount = 0;
return true;
}
else
{
return false;
}
}
else //如果检测到多人情况，每张图片分为一组
{
signelCount = 0;
cvReleaseImage(&grayImg);
cvReleaseImage(&diffImg_2);
prevFrame = frame;
lastFrame = tempFrame;
return true;
}
}
else //当前帧没检测到
{
cvReleaseImage(&grayImg);
cvReleaseImage(&diffImg_2);
prevFrame = frame;
lastFrame = tempFrame;
if (signelCount > 0)//如果前一帧为单人，当前帧没有人
{
signelCount = 0;
return true;
}
else
{
return false;
}
}
}
int main( int argc, char * argv[] )
{
const char * WINDOW_NAME = "Original Image vs. Box Filter vs. Gaussian";
const int QUIT_KEY_CODE = 113;
int box_filter_width = 3;
float sigma = 1.0;
std::string filename = "cameraman.tif";
ImageRAII original_image( filename );
CvSize image_dimensions = { original_image.image->width, original_image.image->height };
ImageRAII box_filter_image( cvCreateImage( image_dimensions, original_image.image->depth, 3 ) );
ImageRAII gaussian_image( cvCreateImage( image_dimensions, original_image.image->depth, 3 ) );
ImageRAII combined_image( cvCreateImage( cvSize( original_image.image->width * 3, original_image.image->height ), original_image.image->depth, 3 ) );
MatrixRAII box_filter = makeBoxFilter( box_filter_width );
MatrixRAII gaussian_filter_x = make1DGaussianFilter( sigma );
MatrixRAII gaussian_filter_y = cvCreateMat( sigma * 5, 1, CV_64FC1 );
cvTranspose( gaussian_filter_x.matrix, gaussian_filter_y.matrix );
std::vector<ImageRAII> original_image_channels( 3 );
std::vector<ImageRAII> box_filter_channels( 3 );
std::vector<ImageRAII> gaussian_filter_channels( 3 );
std::vector<ImageRAII> gaussian_filter_2_channels( 3 );
// initialize image channel vectors
for( int i = 0; i < original_image.image->nChannels; i++ )
{
original_image_channels[i].image = cvCreateImage( image_dimensions, original_image.image->depth, 1 );
box_filter_channels[i].image = cvCreateImage( image_dimensions, original_image.image->depth, 1 );
gaussian_filter_channels[i].image = cvCreateImage( image_dimensions, original_image.image->depth, 1 );
gaussian_filter_2_channels[i].image = cvCreateImage( image_dimensions, original_image.image->depth, 1 );
}
// split image channels
cvSplit( original_image.image, original_image_channels[0].image, original_image_channels[1].image, original_image_channels[2].image, NULL );
// apply filters
for( int i = 0; i < original_image.image->nChannels; i++ )
{
cvFilter2D( original_image_channels[i].image, box_filter_channels[i].image, box_filter.matrix );
cvFilter2D( original_image_channels[i].image, gaussian_filter_channels[i].image, gaussian_filter_x.matrix );
cvFilter2D( gaussian_filter_channels[i].image, gaussian_filter_2_channels[i].image, gaussian_filter_y.matrix );
}
// Merge channels back
cvMerge( box_filter_channels[0].image, box_filter_channels[1].image, box_filter_channels[2].image, NULL, box_filter_image.image );
cvMerge( gaussian_filter_2_channels[0].image, gaussian_filter_2_channels[1].image, gaussian_filter_2_channels[2].image, NULL, gaussian_image.image );
// Combine images side by side
int step = original_image.image->widthStep;
int step_destination = combined_image.image->widthStep;
int nChan = original_image.image->nChannels;
char *buf = combined_image.image->imageData;
char *original_buf = original_image.image->imageData;
char *box_filter_buf = box_filter_image.image->imageData;
char *gaussian_filter_buf = gaussian_image.image->imageData;
for( int row = 0; row < original_image.image->width; row++ )
{
for( int col = 0; col < original_image.image->height; col++ )
{
int width_adjust = 0;
//original image
// blue
*( buf + row * step_destination + nChan * col + width_adjust ) = *( original_buf + row * step + nChan * col );
// green
*( buf + row * step_destination + nChan * col + 1 + width_adjust ) = *( original_buf + row * step + nChan * col );
// red
*( buf + row * step_destination + nChan * col + 2 + width_adjust ) = *( original_buf + row * step + nChan * col );
// box filter
width_adjust = original_image.image->height * nChan;
*( buf + row * step_destination + nChan * col + width_adjust ) = *( box_filter_buf + row * step + nChan * col );
*( buf + row * step_destination + nChan * col + 1 + width_adjust ) = *( box_filter_buf + row * step + nChan * col );
*( buf + row * step_destination + nChan * col + 2 + width_adjust ) = *( box_filter_buf + row * step + nChan * col );
// gaussian filter
width_adjust = original_image.image->height * 2 * nChan;
*( buf + row * step_destination + nChan * col + width_adjust ) = *( gaussian_filter_buf + row * step + nChan * col );
*( buf + row * step_destination + nChan * col + 1 + width_adjust ) = *( gaussian_filter_buf + row * step + nChan * col );
*( buf + row * step_destination + nChan * col + 2 + width_adjust ) = *( gaussian_filter_buf + row * step + nChan * col );
}
}
// create windows
cvNamedWindow( WINDOW_NAME, CV_WINDOW_AUTOSIZE );
cvShowImage( WINDOW_NAME, combined_image.image );
// wait for keyboard input
int key_code = 0;
while( key_code != QUIT_KEY_CODE )
{
key_code = cvWaitKey( 0 );
}
return 0;
}
