IplImage* prop_match(IplImage *src, IplImage *dst)
{
int *srcdata, *dstdata;
CvSize src_size = cvGetSize(src), dst_size = cvGetSize(dst);
int w1 = src_size.width - 8 + 1, h1 = src_size.height - 8 + 1;
int sz = w1*h1, plane_coeffs[] = {2, 9, 5};
int dim = plane_coeffs[0] + plane_coeffs[1] + plane_coeffs[2];
kd_tree kdt;
IplImage *matched;
coeffs(src, dim, plane_coeffs, &srcdata);
coeffs(dst, dim, plane_coeffs, &dstdata);
memset(&kdt, 0, sizeof(kdt));
kdt_new(&kdt, srcdata, sz, dim);
matched = match(&kdt, dstdata, src, dst_size);
free(srcdata);
free(dstdata);
kdt_free(&kdt);
return matched;
}
int main (int argc, char * argv[])
{
if (argc != 2) {
fprintf (stderr, "Usage: %s basename\n", argv[0]);
return -1;
}
Kdt * kdt = kdt_new ();
if (kdt_open (kdt, argv[1])) {
fprintf (stderr, "%s: could not open `%s'\n", argv[0], argv[1]);
return -1;
}
KdtRect query;
int count = 0;
// GTimer * t = g_timer_new ();
while (scanf ("%f %f %f %f",
&query[0].l, &query[1].l,
&query[0].h, &query[1].h) == 4) {
#if 1
fprintf (stderr, "%ld\n", kdt_query (kdt, query));
#else
KdtSum s;
kdt_sum_init (&s);
// g_timer_start (t);
long n = kdt_query_sum (kdt, (KdtCheck) kdt_includes, (KdtCheck) kdt_intersects,
query, query, &s);
// g_timer_stop (t);
// fprintf (stderr, "%d %g %g %g %g\n", n, s.H0, s.Hmax, s.Hmin, g_timer_elapsed (t, NULL));
printf ("%ld %g %g %g\n", n, s.H0, s.H1, s.H2);
#endif
if (count > 0 && count % 1000 == 0)
fprintf (stderr, "\r%d", count);
count++;
}
if (count >= 1000)
fputc ('\n', stderr);
kdt_destroy (kdt);
return 0;
}
int main (int argc, char * argv[])
{
int c = 0, pagesize = 4096;
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"pagesize", required_argument, NULL, 'p'},
{"verbose", no_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
{ NULL }
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "p:hv",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "p:hv"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'v': /* verbose */
verbose = 1;
break;
case 'p': /* pagesize */
pagesize = atoi (optarg);
break;
case 'h': /* help */
fprintf (stderr,
"Usage: rsurface2kdt [OPTION] BASENAME\n"
"\n"
"Converts an existing R-tree database to the KDT format.\n"
"\n"
" -p N --pagesize=N sets the pagesize in bytes (default is 4096)\n"
" -v --verbose display progress bar\n"
" -h --help display this help and exit\n"
"\n"
"Report bugs to %s\n",
"*****@*****.**");
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `rsurface2kdt -h' for more information.\n");
return 1; /* failure */
}
}
if (optind >= argc) { /* missing BASENAME */
fprintf (stderr,
"rsurface2kdt: missing BASENAME\n"
"Try `rsurface2kdt -h' for more information.\n");
return 1; /* failure */
}
RSurface * rs = r_surface_open (argv[optind], "r", 0);
if (rs == NULL) {
fprintf (stderr, "rsurface2kdt: could not open `%s'\n", argv[optind]);
return 1;
}
if (verbose)
fprintf (stderr, "rsurface2kdt: reading points...\r");
KdtHeap h;
kdt_heap_create (&h, kdt_tmpfile (), 0, -1, 1000000);
double min[2] = { -1e100, -1e100 }, max[2] = { 1e100, 1e100 };
r_surface_query_region (rs, min, max, query, &h);
kdt_heap_flush (&h);
r_surface_close (rs);
if (verbose)
fprintf (stderr, "rsurface2kdt: 0%% complete ");
struct timeval start;
gettimeofday (&start, NULL);
Kdt * kdt = kdt_new ();
kdt_create (kdt, argv[optind], pagesize, &h, verbose ? progress : NULL, &start);
kdt_destroy (kdt);
if (verbose) {
Kdt * kdt = kdt_new ();
KdtRect rect = {{-1e30,1e30},{-1e30,1e30}};
KdtSum sum;
kdt_sum_init (&sum);
assert (!kdt_open (kdt, argv[optind]));
long n = kdt_query_sum (kdt,
(KdtCheck) includes_true, (KdtCheck) includes_true, NULL,
rect, &sum);
fprintf (stderr,
"\r%ld points Height min: %g average: %g max: %g\n",
n, sum.Hmin, sum.H0/sum.w, sum.Hmax);
kdt_destroy (kdt);
}
char * name = malloc (strlen (argv[optind]) + strlen (".DataPD") + 1);
sprintf (name, "%s.DataPD", argv[optind]);
remove (name);
sprintf (name, "%s.Data", argv[optind]);
remove (name);
sprintf (name, "%s.DirPD", argv[optind]);
remove (name);
remove (argv[optind]);
free (name);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 6) print_usage(argv);
char *path = argv[1];
int start = atoi(argv[2]), end = atoi(argv[3]), i, *bkgc;
//IplImage *bkg = alignedImageFrom(mkname(path, 1), 8);
IplImage *bkg = alignedImageFrom(argv[4], 8);
int dim = plane_coeffs[0] + plane_coeffs[1] + plane_coeffs[2];
CvSize bsz = cvGetSize(bkg);
IplImage *d8 = alignedImageFrom(argv[5], 8);
//IplImage *d8 = alignedImageFrom(mkname(path, 1), 8);
int w = bsz.width - 8 + 1, h = bsz.height - 8 + 1, sz = w*h;
kd_tree kdt;
printf("cd: %s %d %d %s %s\n", path, start, end, argv[4], argv[5]);
init_g(bkg);
memset(&kdt, 0, sizeof(kd_tree));
/*
IplImage *b32 = cvCreateImage(bsz, IPL_DEPTH_32F, bkg->nChannels);
IplImage *i32 = cvCreateImage(bsz, IPL_DEPTH_32F, bkg->nChannels);
IplImage *d32 = cvCreateImage(bsz, IPL_DEPTH_32F, bkg->nChannels);
IplImage *diff= cvCreateImage(bsz, IPL_DEPTH_32F, bkg->nChannels);
cvXor(b32, b32, b32, NULL);
cvXor(d32, d32, d32, NULL);
cvConvertScale(bkg, b32, 1/255.0, 0);
for (i = 1; i < start; i++) {
IplImage *img = alignedImageFrom(mkname(path, i), 8);
cvConvertScale(img, i32, 1/256.0, 0);
cvAbsDiff(i32, b32, diff);
cvRunningAvg(diff, d32, 1.0/start, NULL);
cvRunningAvg(i32, b32, 1.0/start, NULL);
cvReleaseImage(&img);
cvShowImage("avg diff", d32);
cvWaitKey(1);
printf("i: %d\r", i);
}
cvConvertScale(b32, bkg, 255, 0);
cvReleaseImage(&b32);
cvReleaseImage(&i32);
if (argc >= 6) {
cvSaveImage(argv[4], bkg, 0);
cvConvertScale(d32, d8, 255, 0);
cvSaveImage(argv[5], d8, 0); // difference image
return 0;
}
*/
int *imgc = block_coeffs(d8, plane_coeffs);
IplImage *rev = splat(imgc, bsz, plane_coeffs);
free(imgc);
cvReleaseImage(&rev);
prop_coeffs(bkg, plane_coeffs, &bkgc);
kdt_new(&kdt, bkgc, sz, dim);
/*thread_ctx ctxs[3];
pthread_t thrs[sizeof(ctxs)/sizeof(thread_ctx)];
for (i = 0; i < (int)(sizeof(ctxs)/sizeof(thread_ctx)); i++) {
thread_ctx *ctx = &ctxs[i];
ctx->start = i+1;
ctx->end = end;
ctx->nb = sizeof(ctxs)/sizeof(thread_ctx);
ctx->path = path;
ctx->outfile = argc >= 7 ? argv[6] : NULL;
ctx->bkg = bkg;
ctx->diff = d8;
ctx->kdt = &kdt;
pthread_create(&thrs[i], NULL, run_thr, ctx);
}
for (i = 0; i < (int)(sizeof(ctxs)/sizeof(thread_ctx)); i++) {
pthread_join(thrs[i], NULL);
}
printf("all done!\n");*/
double t;
char outname[1024];
memset(outname, '\0', sizeof(outname));
for (i = start; i <= end; i++) {
IplImage *img = alignedImageFrom(mkname(path, i), 8);
double start = get_time();
if (argc >= 7) snprintf(outname, sizeof(outname), "%s/bin%06d.png", argv[6], i);
//process(&kdt, bkg, d8, img, outname);
//test(img);
cvShowImage("image", img);
t += (get_time() - start);
if ((cvWaitKey(1)&255)==27)break; // esc
cvReleaseImage(&img);
}
//free_g();
kdt_free(&kdt);
free(bkgc);
cvReleaseImage(&bkg);
cvReleaseImage(&d8);
return 0;
}
int main (int argc, char * argv[])
{
int c = 0, pagesize = 4096;
int verbose = 0;
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"pagesize", required_argument, NULL, 'p'},
{"verbose", no_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
{ NULL }
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "p:hv",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "p:hv"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'v': /* verbose */
verbose = 1;
break;
case 'p': /* pagesize */
pagesize = atoi (optarg);
break;
case 'h': /* help */
fprintf (stderr,
"Usage: kdt2kdt [OPTION] BASENAME\n"
"\n"
"Converts an existing KDT database to the most recent format.\n"
"\n"
" -p N --pagesize=N sets the pagesize in bytes (default is 4096)\n"
" -v --verbose display progress bar\n"
" -h --help display this help and exit\n"
"\n"
"Report bugs to %s\n",
"*****@*****.**");
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `kdt2kdt -h' for more information.\n");
return 1; /* failure */
}
}
if (optind >= argc) { /* missing BASENAME */
fprintf (stderr,
"kdt2kdt: missing BASENAME\n"
"Try `kdt2kdt -h' for more information.\n");
return 1; /* failure */
}
char * name = malloc (strlen (argv[optind]) + strlen (".pts") + 1);
sprintf (name, "%s.pts", argv[optind]);
FILE * fp = fopen (name, "r+w");
if (fp == NULL) {
fprintf (stderr, "kdt2kdt: could not open '%s': ", name);
perror ("");
return 1;
}
if (verbose)
fprintf (stderr, "kdt2kdt: reading points...\r");
KdtHeap h1, h;
kdt_heap_create (&h1, fp, 0, -1, 1000000);
kdt_heap_create (&h, kdt_tmpfile (), 0, -1, 1000000);
long n = 0;
KdtPoint p;
while (kdt_heap_get (&h1, &p))
if (p.z < 1e100) {
kdt_heap_put (&h, &p);
if (verbose && n % 3571 == 0)
fprintf (stderr, "kdt2kdt: reading points... %ld\r", n);
n++;
}
kdt_heap_flush (&h);
assert (unlink (name) == 0);
free (name);
kdt_heap_free (&h1);
if (verbose)
fprintf (stderr, "kdt2kdt: 0%% complete ");
struct timeval start;
gettimeofday (&start, NULL);
Kdt * kdt = kdt_new ();
kdt_create (kdt, argv[optind], pagesize, &h, verbose ? progress : NULL, &start);
kdt_destroy (kdt);
if (verbose) {
Kdt * kdt = kdt_new ();
KdtRect rect = {{-1e30,1e30},{-1e30,1e30}};
KdtSum sum;
kdt_sum_init (&sum);
assert (!kdt_open (kdt, argv[optind]));
long n = kdt_query_sum (kdt,
(KdtCheck) includes_true, (KdtCheck) includes_true, NULL,
rect, &sum);
fprintf (stderr,
"\r%ld points Height min: %g average: %g max: %g\n",
n, sum.Hmin, sum.H0/sum.w, sum.Hmax);
kdt_destroy (kdt);
}
return 0;
}
