__PORT void templateMatch(ushort areaSizeX, ushort areaSizeY, ushort areaNum,

ushort subPixelRatio, float* areaOriginArrayX, float* areaOriginArrayY, float*

resultX, float* resultY, float* resultScore)
{
// Start measurement templateMatch
CountTime* countTime_templateMatch = new CountTime();
countTime_templateMatch->setStartCount();

cudaMemcpyToSymbol(c_areaSizeX, &areaSizeX, sizeof(ushort));

cudaMemcpyToSymbol(c_areaSizeY, &areaSizeY, sizeof(ushort));
cudaMemcpyToSymbol(c_subPixelRatio, &subPixelRatio, sizeof(ushort));

if(oldMode == 1)
{
cudaMemcpyToSymbol(c_areaOriginX, areaOriginArrayX,
areaNum*sizeof(float));
cudaMemcpyToSymbol(c_areaOriginY, areaOriginArrayY,
areaNum*sizeof(float));
}
else
{
//�cc��Y��a��3��3���ʂ�I��a��?��A��I�GG��?�AA��I��E�uu��d�vv�ZZ
float* areaOriginArrayXInverseTrans = (float*)malloc(sizeof(float) *
areaNum);
float* areaOriginArrayYInverseTrans = (float*)malloc(sizeof(float) *
areaNum);

// Start measurement Distortion Correction of Marker Coordinate

Processing (inverseTranslatePoint()).
CountTime* countTimeInverseTrans_ = new CountTime();
countTimeInverseTrans_->setStartCount();

for(int i=0; i<areaNum; i++)

{
double input[2] = {areaOriginArrayX[i], areaOriginArrayY[i]};
double output[2] = {0, 0};
inverseTranslatePoint(input, output, h_drNumX, h_drNumY,
distortionParam);
areaOriginArrayXInverseTrans[i] = round(output[0]);
areaOriginArrayYInverseTrans[i] = round(output[1]);
/*
double inputTest[2] = {areaOriginArrayXInverseTrans[i],
areaOriginArrayYInverseTrans[i]};
double test[2] = {0, 0};
translatePoint(inputTest, test, h_drNumX, h_drNumY,
distortionParam);
printf("inverse translation i %d x %f y %f x' %f y' %f x->x'-
>x %f y->y'->y %f\n", i, input[0], input[1], areaOriginArrayXInverseTrans[i],
areaOriginArrayYInverseTrans[i], test[0], test[1]);
*/
}

// End measurement and output log for Distortion Correction of Marker

Coordinate Processing (inverseTranslatePoint()).
countTimeInverseTrans_->setEndCount();
countTimeInverseTrans_->makeLog("Distortion Correction of Marker
Coordinate Process_inverseTranslatePoint()");
delete countTimeInverseTrans_;
 cudaMemcpyToSymbol(c_areaOriginX, areaOriginArrayXInverseTrans,
areaNum*sizeof(float));
cudaMemcpyToSymbol(c_areaOriginY, areaOriginArrayYInverseTrans,
areaNum*sizeof(float));
}

//�TT�[[�``�GG��?�AA��I��?��A�ee��?�vv��?�[[�gg��I���L�__��a��R��-
��I��I��I�AA areaSize - tempNum
int moveAreaX = areaSizeX - h_tempNumX;
int moveAreaY = areaSizeY - h_tempNumY;

int outputSize = 4 * moveAreaX * moveAreaY * areaNum * sizeof(float);

float* output, * d_output;

cudaMalloc((void**) &d_output, outputSize);
output=(float*)malloc(outputSize);

//�vv�ZZ
int blockSizeX = 2;
dim3 blockSize(blockSizeX, blockSizeX);
dim3 gridSize( (uint)(moveAreaX/ blockSize.x), (uint)(moveAreaY*areaNum/
blockSize.y));
if(oldMode == 1)
{
d_calcCorrelationLattice<<<gridSize, blockSize>>>(d_output, d_template,
d_drImage, moveAreaX, moveAreaY);
}
else
{
d_calcCorrelationLattice<<<gridSize, blockSize>>>(d_output, d_template,
d_drImageOriginal, moveAreaX, moveAreaY);
}

//��?��E��d�zz�XX�gg��E�RR�ss�[[
cudaMemcpy(output, d_output, outputSize, cudaMemcpyDeviceToHost);

// printf("areaNUm=%d moveAreaX=%d moveAreaY=%d gridSizeX=%d gridSizeY=%d

blockSizeX=%d blockSizeY=%d\n", areaNum, moveAreaX, moveAreaY, gridSize.x,
gridSize.y, blockSize.x, blockSize.y);

/*
printf("\n frame ID :%d \n", frameID);
frameID++;
if((frameID % 2) ==0 ){
printf("\n frame index:%d \n", frameID/2);
printf("\n");
for(int j=0; j<moveAreaY; j++){
for(int i=0; i<moveAreaX; i++){
double d = output[(i + j*moveAreaX)*4+3];
if(d<0)d=0;
printf("%d ", (int)(d*d*100));
// printf("%3.2f ", d);
}
printf("\n");
}
}
fprintf(stderr, "There is score.\n");
*/
/*
{
printf("print search area value\n");
int numX = h_tempNumX;
int numY = h_tempNumY;
// int numX = 768;
// int numY = 768;

ushort* d_testResult;
int testSize = sizeof(ushort)*numX*numY;
cudaMalloc((void**) &d_testResult, testSize);

int blockSizeXTest = 1;
dim3 blockSizeTest(blockSizeX, blockSizeX);
dim3 gridSizeTest((uint)(1), (uint)(1));
d_test<<<gridSizeTest, blockSizeTest>>>(d_testResult, d_template,
d_drImage, numX, numY);

ushort* testResult = (ushort*)malloc(testSize);

cudaMemcpy(testResult, d_testResult, testSize, cudaMemcpyDeviceToHost);

printf("GPU origin triming image \n");

for(int j=0; j<numX; j++){
for(int i=0; i<numY; i++){
printf("%d ", testResult[i + j*h_tempNumX]);
}
printf("\n");
}
printf("\n");

FILE *fp = fopen("c:\\data\\temp\\templateResult.dat", "wb");

fwrite(testResult, sizeof(ushort), numX*numY, fp);
}
*/

//��?��E��d��u��e��e�zz��n��d��?��u����
for(int i=0; i<areaNum; i++)
{
resultX[i] = -1;
resultY[i] = -1;
resultScore[i] = -1;
}
CountTime* ct = new CountTime();
for(int i=0; i<moveAreaX*moveAreaY*areaNum; i++)
{
int area = (int)output[i*4];
float x = output[i*4 +1];
float y = output[i*4 +2];
float correlation = output[i*4 +3];

float score = 0;
printf("\nTemplateMatch correlation:%d\n", correlation);
if(correlation > 0){
score = (100 * correlation * correlation);
printf("\nTemplateMatch i:%d, score:%d\n", i, score);
ct->makeLog1("TemplateMatch ",score,correlation);
}

if(score > resultScore[area])

 {
resultX[area] = x;
resultY[area] = y;
resultScore[area] = score;
}
}
delete ct;
free(output);
output = 0;
cudaFree(d_output);
d_output= 0;

//��E��o�AA�TT�uu�ss�NN�ZZ��?�vv�ZZ
cudaMemcpyToSymbol(c_areaOriginSubX, resultX, areaNum*sizeof(float));
cudaMemcpyToSymbol(c_areaOriginSubY, resultY, areaNum*sizeof(float));

int calcSize = subPixelRatio*2-1;

int outputSizeSub = 4*calcSize*calcSize*areaNum* sizeof(float);

float* outputSub, *d_outputSub;

cudaMalloc((void**) &d_outputSub, outputSizeSub);
outputSub = (float*)malloc(outputSizeSub);

int blockSizeXSub = 8;
dim3 blockSizeSub(blockSizeXSub, blockSizeXSub);
dim3 gridSizeSub((uint)(calcSize/ blockSizeSub.x+1), (uint)
(calcSize*areaNum/blockSizeSub.y+1));//��O��I��A��?��A�����e��E�����BB
if(oldMode == 1)
{
d_calcCorrelationSub<<<gridSizeSub, blockSizeSub>>>(d_outputSub,
d_template, d_drImage);
}
else
{
d_calcCorrelationSub<<<gridSizeSub, blockSizeSub>>>(d_outputSub,
d_template, d_drImageOriginal);
}

//��?��E��d�zz�XX�gg��E�RR�ss�[[
cudaMemcpy(outputSub, d_outputSub, outputSizeSub, cudaMemcpyDeviceToHost);

for(int i=0; i<areaNum;i++)

{
resultX[i] = -1;
resultY[i] = -1;
resultScore[i] = -1;
}

for(int i=0; i<calcSize*calcSize*areaNum; i++)

{
int area = (int)outputSub[i*4];
float x = outputSub[i*4 +1];
float y = outputSub[i*4 +2];
float correlation = outputSub[i*4 +3];

float score = 0;
if(correlation > 0){
score = (100 * correlation * correlation);
}
 if(score > resultScore[area])
{
resultX[area] = x;
resultY[area] = y;
resultScore[area] = score;
}
}

if(oldMode == 1)
{
for(int i=0; i<areaNum;i++)
{
resultScore[i] = (int)resultScore[i];
}
}
else
{
// Start measurement Distortion Correction of Marker Coordinate
Processing (translatePoint()).
CountTime* countTimeTrans_ = new CountTime();
countTimeTrans_->setStartCount();

for(int i=0; i<areaNum;i++)

{
double input[2] = {resultX[i] , resultY[i] };
double output[2] = {0, 0};
translatePoint(input, output, h_drNumX, h_drNumY,
distortionParam);
double transX = output[0];
double transY = output[1];
/*
frameID++;
if(frameID%2 == 0){
printf("%d matching result x %f y %f transX %f transY %f
\n", frameID/2, resultX[i], resultY[i], transX, transY);
}
*/
resultX[i] = transX + 0.5;//�cc��Y��a��3��d��A�{���ʂ�?
�GG��I0.5�ss�NN�ZZ��?�����a��E���C��e��A������e��?��E��I��?
resultY[i] = transY + 0.5;//�cc��Y��a��3��d��A�{���ʂ�?
�GG��I0.5�ss�NN�ZZ��?�����a��E���C��e��A������e��?��E��I��?
resultScore[i] = (int)resultScore[i];
}

// End measurement and output log for Distortion Correction of Marker

Coordinate Processing (translatePoint()).
countTimeTrans_->setEndCount();
countTimeTrans_->makeLog("Distortion Correction of Marker Coordinate
Process_translatePoint()");
delete countTimeTrans_;
}

free(outputSub);
cudaFree(d_outputSub);
outputSub = 0;
d_outputSub = 0;

// End measurement templateMatch

 countTime_templateMatch->setEndCount();
countTime_templateMatch->makeLog("Processing calculations 2D of
template_Match()");
delete countTime_templateMatch;
}