int main(int args,char *argv[]){
IplImage *inputImage;
IplImage *outputImage;
cvNamedWindow("inputImage",CV_WINDOW_AUTOSIZE);
cvMoveWindow("inputImage",100,100);
cvNamedWindow("outputImage",CV_WINDOW_AUTOSIZE);
cvMoveWindow("outputImage",200,200);
//
printf("%s",argv[1]);
assert(argv[1]);
// 只有灰度图才可以canny
inputImage = cvLoadImage(argv[1],CV_LOAD_IMAGE_GRAYSCALE);
cvShowImage("inputImage",inputImage);
// float lowThresh 内部轮廓。数字越大越模糊
// float highThresh //外部轮廓。数字越大越模糊
// float aperture
outputImage = canny(inputImage,100,100,3);
cvShowImage("outputImage",outputImage);
cvWaitKey(0);
//
cvDestroyWindow("outputImage");
cvDestroyWindow("inputImage");
cvReleaseImage(&outputImage);
cvReleaseImage(&inputImage);
return 0;
}
Rhythm::Rhythm(float inputSampleRate)
: Plugin(inputSampleRate) {
m_sampleRate = inputSampleRate;
numBands = 7;
bandHighFreq = NULL;
calculateBandFreqs();
// calculate and save half-hanny window
halfHannLength = 12;
halfHannWindow = new float[halfHannLength];
for (int i = 0; i < halfHannLength; i++)
halfHannWindow[i] = halfHanning((float) i);
// calculate and save canny window
cannyLength = 12;
cannyShape = 4.f;
cannyWindow = new float[cannyLength * 2 + 1];
for (int i = cannyLength * -1; i < cannyLength + 1; i++)
cannyWindow[i + cannyLength] = canny((float) i);
// set up parameters
threshold = 1;
average_window = 200;
peak_window = 6;
max_bpm = 300;
min_bpm = 12;
}
int main(int argc, char** argv)
{
int arg;
IplImage* img = cvLoadImage(argv[1], CV_LOAD_IMAGE_UNCHANGED);
IplImage* out = 0;
printf("Chose an operation:-\n0 - Blur\n1 - Pyre\n2 - Canny\n3 - Grey");
scanf("%d",&arg);
printf("%d\n",arg);
if(arg == 0)
out = blur(img);
else if(arg == 1)
out = pyre(img, 2,2);
else if(arg == 2)
out = canny(img, 10,100,3);
else
out = gray(img);
cvNamedWindow("Example7-In",CV_WINDOW_AUTOSIZE);
cvNamedWindow("Example7-Out",CV_WINDOW_AUTOSIZE);
cvShowImage("Example7-In", img);
cvShowImage("Example7-Out", out);
cvWaitKey(0);
cvReleaseImage(&img);
cvReleaseImage(&out);
cvDestroyWindow("Example7-In");
cvDestroyWindow("Example7-Out");
return(0);
}
int main()
{
int width = 2048;
int height = 2048;
float * input = new float[width*height];
float * output = new float[width*height];
for( int i = 0 ; i < height ; i++)
for( int j = 0 ; j < width ; j++ ){
input[i*width+j] = (rand()%256)/ 5.0;
}
milliseconds time(0);
bool useDevMem = false;
if (const char *var = getenv("FORMA_USE_DEVICE_MEMORY")) {
useDevMem = (atoi(var) != 0);
}
float* inputPtr = input;
if (useDevMem) {
cudaMalloc(&inputPtr, sizeof(float)*width*height);
cudaMemcpy(inputPtr, input, sizeof(float)*width*height, cudaMemcpyHostToDevice);
}
canny(inputPtr,height,width,output);
if (check_error(input,height,width,output) < 0)
return -1;
for( int i = 0 ; i < _NTRIALS_ ; i++ ){
auto start = HighResolutionClock::now();
canny(inputPtr,height,width,output);
auto stop = HighResolutionClock::now();
time += std::chrono::duration_cast<milliseconds>(stop-start);
}
printf("[FORMA] Total Time(ms) : %lf\n",(double)time.count()/_NTRIALS_);
if (useDevMem)
cudaFree(inputPtr);
delete[] input;
delete[] output;
return 0;
}
void EdgeHistogram::InitializeImage(const vigra::FVector3Image& image) {
// Consider grayscale image
vigra::FImage image_gray(image.width(), image.height());
vigra::transformImage(srcImageRange(image), destImage(image_gray),
VectorMeanTransformAccessor<vigra::FVector3Image::Accessor>());
// 1. Compute canny edge image
vigra::BImage canny(image_gray.width(), image_gray.height());
canny = 0;
vigra::cannyEdgeImage(srcImageRange(image_gray), destImage(canny),
1, 15, 255); // scale, threshold, edgevalue
//vigra::exportImage(srcImageRange(canny), "canny.png");
// 2. Get gradient magnitude and orientation of original image
vigra::FVector2Image gradient(canny.width(), canny.height());
vigra::gradientBasedTransform(srcImageRange(image_gray),
destImage(gradient),
MagnitudeOrientationGradientFunctor<float>(undirected_edges));
// 3. Produce matrices: histogram bin and gradient magnitude for each pixel
bin_image.resize(gradient.height(), gradient.width());
gmm::fill(bin_image, 0);
bin_value.resize(gradient.height(), gradient.width());
gmm::fill(bin_value, 0);
for (int y = 0; y < gradient.height(); ++y) {
for (int x = 0; x < gradient.width(); ++x) {
// No edge -> skip
if (canny(x, y) == 0)
continue;
// Edge: calculate bin index and gradient magnitude
double magnitude = gradient(x, y)[0];
double orientation = gradient(x, y)[1]; // range 0 to 1.
assert(orientation >= 0.0 && orientation <= 1.0);
if (orientation >= 1.0)
orientation = 0.0;
orientation *= static_cast<double>(bin_count);
int orientation_index = static_cast<int>(orientation) % bin_count;
// Bin value of zero denotes no edge.
bin_image(y, x) = orientation_index + 1;
bin_value(y, x) = magnitude;
}
}
}
void MainWindow::cannySlot()
{
int high = QInputDialog::getInt(this,"High Threshold value","High Threshold value");
int low = QInputDialog::getInt(this,"Low Threshold value","Low Threshold value");
image = canny(image,low,high);
setImages();
}
//! Connect Image Processing Actions to Slots Methods
//!
void ImageView::connectActionToSlots()
{
connect(ui->actionMid_Filter_2, SIGNAL(triggered()), this, SLOT(median_smoooth()));
connect(ui->actionGaussian, SIGNAL(triggered()), this, SLOT(gaussian_smooth()));
connect(ui->actionBilateral_Smooth,SIGNAL(triggered()), this, SLOT(bilateral_smooth()));
connect(ui->actionGLCM, SIGNAL(triggered()), this, SLOT(gLCM()));
connect(ui->actionCanny, SIGNAL(triggered()), this, SLOT(canny()));
connect(ui->actionLecel_Set, SIGNAL(triggered()), this, SLOT(levelSetSegmentation()));
connect(ui->actionVideo_Camera_Track, SIGNAL(triggered()), this, SLOT(videoCameraTrack()));
}
int main( int argc, char * argv[] )
{
typedef mist::rgb< unsigned char > pixel_type;
typedef mist::array2< pixel_type > color_image_type;
typedef mist::array2< unsigned char > gray_image_type;
typedef mist::vector2< double > vector_type;
if( argc < 2 )
{
std::cerr << "This program requires a path to an input image." << std::endl;
return( 1 );
}
color_image_type orginal_img;
color_image_type canny_img;
if( !read_image( orginal_img, argv[ 1 ] ) )
{
std::cerr << "Could not open the image [" << argv[ 1 ] << "]." << std::endl;
return( 1 );
}
// エッジを検出する
canny( orginal_img, canny_img, 100, 200 );
// Hough変換により直線のパラメータを求める
std::vector< std::complex< double > > lines;
mist::line::hough_transform( canny_img, lines, 100, 1, 3.1415926535897932384626433832795 / 360.0, 200 );
// 直線を描画する
double scale = orginal_img.width( ) > orginal_img.height( ) ? orginal_img.width( ) : orginal_img.height( );
for( size_t i = 0 ; i < lines.size( ) ; i++ )
{
double rho = lines[ i ].real( );
double theta = lines[ i ].imag( );
vector_type p1( std::cos( theta ) * rho, std::sin( theta ) * rho );
vector_type p2( p1.x - rho * std::sin( theta ), p1.y + rho * std::cos( theta ) );
vector_type d = ( p2 - p1 ).unit( );
p1 -= d * scale;
p2 += d * scale;
int x1 = static_cast< int >( p1.x + 0.5 );
int y1 = static_cast< int >( p1.y + 0.5 );
int x2 = static_cast< int >( p2.x + 0.5 );
int y2 = static_cast< int >( p2.y + 0.5 );
mist::draw_line( orginal_img, x1, y1, x2, y2, mist::colors< pixel_type >::red( ) );
}
write_image( orginal_img, "output.png" );
return( 0 );
}
JNIEXPORT void JNICALL Java_com_jiminger_image_canny_EdgeDetectorOpImage_canny
(JNIEnv * env, jobject /*this*/, jint destwidth, jint destheight,
jbyteArray dest, jint /*destOffset*/, jint /*destPixelStride*/, jint /*destScanlineStride*/,
jbyteArray src, jint /*srcOffset*/, jint /*srcPixelStride*/, jint /*srcScanLineStride*/,
jfloat lowThreshold, jfloat highThreshold, jfloat sigma, jbyte noedgeval,
jbyte edgeval, jbyte possibleEdge,
jbyteArray gradDirImData
// jfloatArray gradDirImData
)
{
// printf(" destwidth = %ld\n", destwidth);
// printf(" destheight = %ld\n", destheight);
// printf(" destOffset = %ld\n",destOffset);
// printf(" destPixelStride = %ld\n", destPixelStride);
// printf(" destScanlineStride = %ld\n", destScanlineStride);
// printf(" srcOffset = %ld\n",srcOffset);
// printf(" srcPixelStride = %ld\n", srcPixelStride);
// printf(" srcScanLineStride = %ld\n", srcScanLineStride);
jboolean isCopy;
jbyte* srcData =
(jbyte*)(env->GetPrimitiveArrayCritical(src, &isCopy));
jbyte* destData =
(jbyte*)(env->GetPrimitiveArrayCritical(dest, &isCopy));
jbyte* gradDirIm =
(gradDirImData != NULL) ?
(jbyte*)(env->GetPrimitiveArrayCritical(gradDirImData, &isCopy)) :
NULL;
// jfloat* gradDirIm =
// (gradDirImData != NULL) ?
// (jfloat*)(env->GetPrimitiveArrayCritical(gradDirImData, &isCopy)) :
// NULL;
NOEDGE = (unsigned char)noedgeval;
EDGE = (unsigned char)edgeval;
POSSIBLE_EDGE = (unsigned char)possibleEdge;
canny((unsigned char*)srcData, destheight, destwidth, (float)sigma,
(float)lowThreshold, (float)highThreshold,
(unsigned char*)destData, (unsigned char*)gradDirIm);
if (gradDirIm != NULL)
env->ReleasePrimitiveArrayCritical(gradDirImData,gradDirIm,0);
env->ReleasePrimitiveArrayCritical(dest,destData,0);
env->ReleasePrimitiveArrayCritical(src,srcData,0);
}
/*
* mexFunction: Matlab entry function into this C++ code
* Inputs:
* int nlhs: Number of left hand arguments (output)
* mxArray *plhs[]: The left hand arguments (output)
* int nrhs: Number of right hand arguments (inputs)
* const mxArray *prhs[]: The right hand arguments (inputs)
*
* Notes:
* (Left) goes_out = foo(goes_in); (Right)
*/
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
{
image8 im_in, im_out;
float sigma = 2.0; /* Standard deviation of the gaussian kernel. */
float tlow = 0.3; /* Fraction of the high threshold in hysteresis. */
float thigh = 0.7; /* High hysteresis threshold control. The actual
threshold is the (100 * thigh) percentage point
in the histogram of the magnitude of the
gradient image that passes non-maximal suppression. */
int inputProc = 0;
char *cmd, dbg[128];
if (nrhs == 0) {
help();
return;
}
for (inputProc = 0; inputProc < nrhs; ) {
getStr( &prhs[inputProc++], &cmd );
//mexPrintf("Cmd = %s\n",cmd);
if (strcmp(cmd,"image")==0) {
getData( &prhs[inputProc++], &im_in );
} else if(strcmp(cmd,"sigma")==0) {
sigma = (float) getDblRetDbl( &prhs[inputProc++] );
} else if(strcmp(cmd,"tlow")==0) {
tlow = (float) getDblRetDbl( &prhs[inputProc++] );
} else if(strcmp(cmd,"thigh")==0) {
thigh = (float) getDblRetDbl( &prhs[inputProc++] );
}else if(strcmp(cmd,"help")==0 || strcmp(cmd,"HELP")==0){
help();
return;
} else {
sprintf(dbg,"%s is not a valid command...\n",cmd);
mexErrMsgTxt( dbg );
}
mxFree( cmd );
}
canny(im_in.im, im_in.dims[1], im_in.dims[0], sigma, tlow, thigh, &(im_out.im));
im_out.dims[0] = im_in.dims[0];
im_out.dims[1] = im_in.dims[1];
//Send the edged image back to Matlab.
sendData( &plhs[0], &im_out);
free( im_in.im );
free( im_out.im );
}
int main(int argc, char** argv){
FILE* inputImage=fopen(argv[1],"rb");
FILE* outputMagnitudes=fopen(argv[2],"wb");
FILE* outputPeaks=fopen(argv[3],"wb");
FILE* outputFinal=fopen(argv[4],"wb");
double sigma = atof(argv[5]);
Record record;
fread(&record, sizeof(record), 1, inputImage);
fwrite(&record, sizeof(record), 1, outputMagnitudes);
fwrite(&record, sizeof(record), 1, outputPeaks);
fwrite(&record, sizeof(record), 1, outputFinal);
canny(inputImage, outputMagnitudes, outputPeaks, outputFinal, sigma);
}
QVector<int> hysteresis(int width, int height,
const QVector<int> &image)
{
QVector<int> canny(image);
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++)
trace(width, height, canny, x, y);
// Remaining gray pixels becomes black.
for (int i = 0; i < canny.size(); i++)
if (canny[i] == 127)
canny[i] = 0;
return canny;
}
static void do_canny(lti::gaussianPyramid<lti::image> &imgPyramid,
std::vector<lti::channel8*> &edges,
double minSharpness) {
uint64_t start_time_in_ms;
uint64_t end_time_in_ms;
struct timeval tv;
gettimeofday(&tv, NULL);
start_time_in_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
// params
lti::cannyEdges::parameters cannyParam;
if (minSharpness == 0) {
cannyParam.thresholdMax = 0.04;
} else {
cannyParam.thresholdMax = 0.10 + 0.90 * ((minSharpness - 1) / 4.0);
}
cannyParam.thresholdMin = 0.04;
cannyParam.kernelSize = 7;
// run
lti::cannyEdges canny(cannyParam);
g_assert(edges.size() == 0);
for (int i = 0; i < imgPyramid.size(); i++) {
fprintf(stderr, "canny[%d]: %dx%d\n", i, imgPyramid[i].columns(),
imgPyramid[i].rows());
lti::channel8 *c8 = new lti::channel8;
canny.apply(imgPyramid[i], *c8);
edges.push_back(c8);
}
gettimeofday(&tv, NULL);
end_time_in_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
fprintf(stderr, "canny done in %ju ms\n", end_time_in_ms - start_time_in_ms);
}
int main(int argc, char* argv[]){
// Load input video
cv::VideoCapture input_cap(argv[1]);
if (!input_cap.isOpened()){
std::cout << "!!! Input video could not be opened" << std::endl;
return -1;
}
// Setup output video
cv::VideoWriter output_cap;
output_cap.open("output.avi",
(int)CV_FOURCC('X','V','I','D'),
input_cap.get(CV_CAP_PROP_FPS),
cv::Size(input_cap.get(CV_CAP_PROP_FRAME_WIDTH), input_cap.get(CV_CAP_PROP_FRAME_HEIGHT)),false); //true for color image
// false for gray image
if (!output_cap.isOpened()){
std::cout << "!!! Output video could not be opened" << std::endl;
return -1;
}
// Loop to read frames from the input capture and write it to the output capture
cv::Mat frame;
cv::Mat can;
while (true){
if (!input_cap.read(frame))
break;
canny(frame,can);
output_cap.write(frame);
output_cap.write(frame);
}
input_cap.release();
output_cap.release();
return 0;
}
int main( int argc, char * argv[] )
{
const char * WINDOW_NAME = "Original Image";
// x is low
// y is high
std::pair< int, int > thresh = std::make_pair( THRESH_MIN, THRESH_MAX);
if( argc < 2 )
{
std::cerr << "Not enough parameters.\n";
exit( -1 );
}
ImageRAII image( argv[1] );
cvNamedWindow( WINDOW_NAME );
cvShowImage( WINDOW_NAME, image.image );
cvMoveWindow( WINDOW_NAME, 0, 0 );
ImageRAII edge_detection_image = canny( image.image, thresh, SIGMA );
cvWaitKey( 0 );
return 0;
}
main(int argc, char *argv[])
{
char *infilename = NULL; /* Name of the input image */
char *dirfilename = NULL; /* Name of the output gradient direction image */
char outfilename[128]; /* Name of the output "edge" image */
char composedfname[128]; /* Name of the output "direction" image */
unsigned char *image; /* The input image */
unsigned char *edge; /* The output edge image */
int rows, cols; /* The dimensions of the image. */
float sigma, /* Standard deviation of the gaussian kernel. */
tlow, /* Fraction of the high threshold in hysteresis. */
thigh; /* High hysteresis threshold control. The actual
threshold is the (100 * thigh) percentage point
in the histogram of the magnitude of the
gradient image that passes non-maximal
suppression. */
/****************************************************************************
* Get the command line arguments.
****************************************************************************/
if(argc < 5){
fprintf(stderr,"\n<USAGE> %s image sigma tlow thigh [writedirim]\n",argv[0]);
fprintf(stderr,"\n image: An image to process. Must be in ");
fprintf(stderr,"PGM format.\n");
fprintf(stderr," sigma: Standard deviation of the gaussian");
fprintf(stderr," blur kernel.\n");
fprintf(stderr," tlow: Fraction (0.0-1.0) of the high ");
fprintf(stderr,"edge strength threshold.\n");
fprintf(stderr," thigh: Fraction (0.0-1.0) of the distribution");
fprintf(stderr," of non-zero edge\n strengths for ");
fprintf(stderr,"hysteresis. The fraction is used to compute\n");
fprintf(stderr," the high edge strength threshold.\n");
fprintf(stderr," writedirim: Optional argument to output ");
fprintf(stderr,"a floating point");
fprintf(stderr," direction image.\n\n");
exit(1);
}
infilename = argv[1];
sigma = atof(argv[2]);
tlow = atof(argv[3]);
thigh = atof(argv[4]);
if(argc == 6) dirfilename = infilename;
else dirfilename = NULL;
/****************************************************************************
* Read in the image. This read function allocates memory for the image.
****************************************************************************/
if(VERBOSE) printf("Reading the image %s.\n", infilename);
if(read_pgm_image(infilename, &image, &rows, &cols) == 0){
fprintf(stderr, "Error reading the input image, %s.\n", infilename);
exit(1);
}
/****************************************************************************
* Perform the edge detection. All of the work takes place here.
****************************************************************************/
if(VERBOSE) printf("Starting Canny edge detection.\n");
if(dirfilename != NULL){
sprintf(composedfname, "%s_s_%3.2f_l_%3.2f_h_%3.2f.fim", infilename,
sigma, tlow, thigh);
dirfilename = composedfname;
}
canny(image, rows, cols, sigma, tlow, thigh, &edge, dirfilename);
/****************************************************************************
* Write out the edge image to a file.
****************************************************************************/
sprintf(outfilename, "%s_s_%3.2f_l_%3.2f_h_%3.2f.pgm", infilename,
sigma, tlow, thigh);
if(VERBOSE) printf("Writing the edge iname in the file %s.\n", outfilename);
if(write_pgm_image(outfilename, edge, rows, cols, "", 255) == 0){
fprintf(stderr, "Error writing the edge image, %s.\n", outfilename);
exit(1);
}
}
int main(int argc, char *argv[])
{
char *infilename = NULL; /* Name of the input image */
char *dirfilename = NULL; /* Name of the output gradient direction image */
char outfilename[128]; /* Name of the output "edge" image */
char composedfname[128]; /* Name of the output "direction" image */
unsigned char *image; /* The input image */
unsigned char *edge; /* The output edge image */
int rows, cols; /* The dimensions of the image. */
float sigma=2.5, /* Standard deviation of the gaussian kernel. */
tlow=0.5, /* Fraction of the high threshold in hysteresis. */
thigh=0.5; /* High hysteresis threshold control. The actual
threshold is the (100 * thigh) percentage point
in the histogram of the magnitude of the
gradient image that passes non-maximal
suppression. */
/****************************************************************************
* Get the command line arguments.
****************************************************************************/
if(argc < 2)
{
fprintf(stderr,"\n<USAGE> %s image sigma tlow thigh [writedirim]\n",argv[0]);
fprintf(stderr,"\n image: An image to process. Must be in ");
fprintf(stderr,"PGM format.\n");
exit(1);
}
infilename = argv[1];
Timer totalTime;
initTimer(&totalTime, "Total Time");
/****************************************************************************
* Read in the image. This read function allocates memory for the image.
****************************************************************************/
if(VERBOSE) printf("Reading the image %s.\n", infilename);
if(read_pgm_image(infilename, &image, &rows, &cols) == 0)
{
fprintf(stderr, "Error reading the input image, %s.\n", infilename);
exit(1);
}
/****************************************************************************
* Perform the edge detection. All of the work takes place here.
****************************************************************************/
if(VERBOSE) printf("Starting Canny edge detection.\n");
if(dirfilename != NULL)
{
sprintf(composedfname, "%s_s_%3.2f_l_%3.2f_h_%3.2f.fim", infilename,
sigma, tlow, thigh);
dirfilename = composedfname;
}
// MCPROF_START();
canny(image, rows, cols, sigma, tlow, thigh, &edge, dirfilename);
// MCPROF_STOP();
/****************************************************************************
* Write out the edge image to a file.
****************************************************************************/
sprintf(outfilename, "%s_s_%3.2f_l_%3.2f_h_%3.2f.pgm", infilename,
sigma, tlow, thigh);
if(VERBOSE) printf("Writing the edge iname in the file %s.\n", outfilename);
if(write_pgm_image(outfilename, edge, rows, cols, "", 255) == 0)
{
fprintf(stderr, "Error writing the edge image, %s.\n", outfilename);
exit(1);
}
free(image);
free(edge);
return 0;
}
int edgedetect(int j,unsigned int* total)
{
int i = 0;
int k = 0;
int averow = 0;
int avecol = 0;
int diffrow = 0;
int diffcol = 0;
int confirmed = 0;
int confirmed2 = 0;
int position = 0;
unsigned char rows[100];
unsigned char cols[100];
unsigned char rows2[100];
unsigned char cols2[100];
unsigned char numberofhits[1] = {0};
//savegreyscale(j);
canny(j);
for(i=0;i<59;i++)
{
for(k=0;k<33;k++)
{
if(numberofhits[0]==100)
{
return 1;
}
cornerdetect(img.pixel_data,i,k,numberofhits,rows,cols);
}
}
if(numberofhits[0]>0)
{
for(i=0;i<numberofhits[0];i++)
{
averow = averow + rows[i];
avecol = avecol + cols[i];
}
averow = averow/numberofhits[0];
avecol = avecol/numberofhits[0];
for(i=0;i<numberofhits[0];i++)
{
diffrow = abs(averow-rows[i]);
diffcol = abs(avecol-cols[i]);
if(diffcol < 6 && diffrow < 6)
{
rows2[position] = rows[i];
cols2[position] = cols[i];
confirmed2 = confirmed2 + 1;
position = position + 1;
}
}
numberofhits[0] = confirmed2;
}
averow = 0;
avecol = 0;
if(numberofhits[0]>0)
{
for(i=0;i<numberofhits[0];i++)
{
averow = averow + rows2[i];
avecol = avecol + cols2[i];
printf(" %d %d ",rows2[i],cols2[i]);
}
averow = averow/numberofhits[0];
avecol = avecol/numberofhits[0];
for(i=0;i<numberofhits[0];i++)
{
diffrow = abs(averow-rows2[i]);
diffcol = abs(avecol-cols2[i]);
if(diffcol < 4 && diffrow < 4)
{
confirmed = confirmed + 1;
total[0] = total[0] + 1;
}
}
numberofhits[0] = confirmed;
}
printf("\nResults\n\nHits: %d \nConfirmed: %d \n\n",numberofhits[0],confirmed);
return 0;
}
int Masek::findline(Masek::IMAGE *image, double **lines)
{
filter *I2, *orND, *I3, *I4, *edgeimage;
double theta[180];
double *R, *xp;
double maxval;
int size, linecount;
double cx, cy;
int i, j, index, x, y;
double r, t;
int tmpcount;
FILE *fid;
fid = fopen("image.txt", "w");
for (i = 0; i<image->hsize[0]; i++)
{
for (j = 0; j<image->hsize[1]; j++)
fprintf(fid, "%d %d %d\n", i+1, j+1, image->data[i*image->hsize[1]+j]);
}
fclose(fid);
I2 = (filter*)malloc(sizeof(filter));
orND = (filter*)malloc(sizeof(filter));
image = canny(image, 2, 1, 0.00, 1.00, I2, orND);
//imwrite("C:\\testImage090716.bmp", image);
/*fid = fopen("I2.txt", "w");
for (i = 0; i<I2->hsize[0]; i++)
{
for (j = 0; j<I2->hsize[1]; j++)
fprintf(fid, "%d %d %f\n", i+1, j+1, I2->data[i*I2->hsize[1]+j]);
}
fclose(fid);
fid = fopen("or.txt", "w");
for (i = 0; i<or->hsize[0]; i++)
{
for (j = 0; j<or->hsize[1]; j++)
fprintf(fid, "%d %d %f\n", i+1, j+1, or->data[i*or->hsize[1]+j]);
}
fclose(fid);*/
I3 = adjgamma(I2, 1.9);
/*fid = fopen("I3.txt", "w");
for (i = 0; i<I3->hsize[0]; i++)
{
for (j = 0; j<I3->hsize[1]; j++)
fprintf(fid, "%d %d %f\n", i+1, j+1, I3->data[i*I3->hsize[1]+j]);
}
fclose(fid);*/
I4 = nonmaxsup(I3, orND, 1.5);
/*fid = fopen("I4.txt", "w");
for (i = 0; i<I4->hsize[0]; i++)
{
for (j = 0; j<I4->hsize[1]; j++)
fprintf(fid, "%d %d %f\n", i+1, j+1, I4->data[i*I4->hsize[1]+j]);
}
fclose(fid);*/
edgeimage = hysthresh(I4, 0.20, 0.15);
//edgeimage = hysthresh(I4, 0.25, 0.10);//LEE:
for (i = 0; i<180; i++)
theta[i] = i;
/*fid = fopen("edge.txt", "w");
for (i = 0; i<edgeimage->hsize[0]; i++)
{
for (j = 0; j<edgeimage->hsize[1]; j++)
fprintf(fid, "%d %d %f\n", i+1, j+1, edgeimage->data[i*edgeimage->hsize[1]+j]);
}
fclose(fid);*/
size = radonc(edgeimage->data, theta, edgeimage->hsize[0], edgeimage->hsize[1], 180, &R, &xp);
/*fid = fopen("r.txt", "w");
for (i = 0; i<size; i++)
{
for (j = 0; j<180; j++)
fprintf(fid, "%d %d %f\n", i+1, j+1, R[i*180+j]);
}
fclose(fid);
fid = fopen("xp.txt", "w");
for (i = 0; i<size; i++)
{
fprintf(fid, "%f\n", xp[i]);
}
fclose(fid);
*/
maxval = -1;
index = -1;
linecount=0;
for (i = 0; i<size*180; i++)
{
if (R[i]>maxval)
{
maxval = R[i];
index = i;
linecount=1;
}
else if (R[i]==maxval)
{
linecount++;
}
}
if (maxval<=25)
return 0;
*lines = (double*) malloc(sizeof(double)*linecount*3);
cx = image->hsize[1]/2.0-1;
cy = image->hsize[0]/2.0-1;
tmpcount=0;
for (i = index; i<size*180; i++)
{
if (R[i]==maxval)
{
y = i/180;
x = i%180;
t = -theta[x]*PI/180;
r = xp[y];
(*lines)[tmpcount*3] = cos(t);
(*lines)[tmpcount*3+1] = sin(t);
(*lines)[tmpcount*3+2] = -r;
(*lines)[tmpcount*3+2] = (*lines)[tmpcount*3+2] - (*lines)[tmpcount*3]*cx - (*lines)[tmpcount*3+1]*cy;
tmpcount++;
}
}
free(R);
free(xp);
free(I2->data);
free(I2);
free(orND->data);
free(orND);
return linecount;
}
