/* A version of nnbathy that interpolates output points serially. Can save a * bit of memory for large output grids. */ int main(int argc, char* argv[]) { specs* s = specs_create(); int nin = 0; point* pin = NULL; minell* me = NULL; point* pout = NULL; double k = NaN; preader* pr = NULL; delaunay* d = NULL; void* interpolator = NULL; int ndone = 0; parse_commandline(argc, argv, s); if (s->fin == NULL) quit("no input data\n"); if (!s->generate_points && s->fout == NULL && !s->nointerp) quit("no output grid specified\n"); points_read(s->fin, 3, &nin, &pin); if (nin < 3) return 0; if (s->thin == 1) points_thingrid(&nin, &pin, s->nxd, s->nyd); else if (s->thin == 2) points_thinlin(&nin, &pin, s->rmax); if (s->nointerp) { points_write(nin, pin); specs_destroy(s); free(pin); return 0; } if (s->generate_points) { points_getrange(nin, pin, s->zoom, &s->xmin, &s->xmax, &s->ymin, &s->ymax); pr = preader_create1(s->xmin, s->xmax, s->ymin, s->ymax, s->nx, s->ny); } else pr = preader_create2(s->fout); if (s->invariant) { me = minell_build(nin, pin); minell_scalepoints(me, nin, pin); } else if (s->square) k = points_scaletosquare(nin, pin); d = delaunay_build(nin, pin, 0, NULL, 0, NULL); if (s->linear) interpolator = lpi_build(d); else { interpolator = nnpi_create(d); nnpi_setwmin(interpolator, s->wmin); } while ((pout = preader_getpoint(pr)) != NULL) { if (s->invariant) minell_scalepoints(me, 1, pout); else if (s->square) points_scale(1, pout, k); if (s->linear) lpi_interpolate_point(interpolator, pout); else nnpi_interpolate_point(interpolator, pout); if (s->invariant) minell_rescalepoints(me, 1, pout); else if (s->square) points_scale(1, pout, 1.0 / k); points_write(1, pout); ndone++; if (s->npoints > 0) fprintf(stderr, " %5.2f%% done\r", 100.0 * ndone / s->npoints); } if (s->npoints > 0) fprintf(stderr, " \r"); if (me != NULL) minell_destroy(me); if (s->linear) lpi_destroy(interpolator); else nnpi_destroy(interpolator); delaunay_destroy(d); preader_destroy(pr); specs_destroy(s); free(pin); return 0; }
int main(int argc, char* argv[]) { char* fname = NULL; int npoints = 0; point* points = NULL; minell* me = NULL; struct timeval tv0, tv1; struct timezone tz; parse_commandline(argc, argv, &fname); if (fname == NULL) { fprintf(stderr, "error: minimal ellipse: no input data\n"); usage(); } points_read(fname, 2, &npoints, &points); gettimeofday(&tv0, &tz); if (userandomseed) me_seed = tv0.tv_usec % INT_MAX; if (!test) { me = minell_build(npoints, points); gettimeofday(&tv1, &tz); minell_info(me, stdout); if (me_verbose) { long dt = 1000000 * (tv1.tv_sec - tv0.tv_sec) + tv1.tv_usec - tv0.tv_usec; minell_stats(me, stdout); fprintf(stdout, "minimal ellipse: elapsed time = %ld us\n", dt); } minell_destroy(me); } else { int minell_calc_count = 0; int minell_calc3_count = 0; int minell_calc4_count = 0; int minell_calc5_count = 0; int minell_eval3_count = 0; int minell_eval4_count = 0; int minell_eval5_count = 0; long dt; int i; for (i = 0; i < NTEST; ++i, ++me_seed) { me = minell_build(npoints, points); minell_calc_count += me->minell_calc_count; minell_calc3_count += me->minell_calc3_count; minell_calc4_count += me->minell_calc4_count; minell_calc5_count += me->minell_calc5_count; minell_eval3_count += me->minell_eval3_count; minell_eval4_count += me->minell_eval4_count; minell_eval5_count += me->minell_eval5_count; minell_destroy(me); } gettimeofday(&tv1, &tz); dt = 1000000 * (tv1.tv_sec - tv0.tv_sec) + tv1.tv_usec - tv0.tv_usec; fprintf(stdout, "minimal ellipse:\n"); fprintf(stdout, " average build time = %ld us\n", dt / NTEST); fprintf(stdout, " average number of calls to Welzl's procedure = %d\n", minell_calc_count / NTEST); fprintf(stdout, " average number of ellipses built by 3 support points = %d\n", minell_calc3_count / NTEST); fprintf(stdout, " average number of ellipses built by 4 support points = %d\n", minell_calc4_count / NTEST); fprintf(stdout, " average number of in-ellipse test by 3 support points = %d\n", minell_eval3_count / NTEST); fprintf(stdout, " average number of in-ellipse test by 4 support points = %d\n", minell_eval4_count / NTEST); fprintf(stdout, " average number of in-ellipse test by 5 support points = %d\n", minell_eval5_count / NTEST); } if (points != NULL) free(points); return 0; }
/* A simpler version of nnbathy that allocates the whole output grid in memory */ int main(int argc, char* argv[]) { specs* s = specs_create(); int nin = 0; point* pin = NULL; minell* me = NULL; int nout = 0; point* pout = NULL; double k = NaN; parse_commandline(argc, argv, s); if (s->fin == NULL) quit("no input data\n"); if (!s->generate_points && s->fout == NULL && !s->nointerp) quit("no output grid specified\n"); points_read(s->fin, 3, &nin, &pin); if (nin < 3) return 0; if (s->thin == 1) points_thingrid(&nin, &pin, s->nxd, s->nyd); else if (s->thin == 2) points_thinlin(&nin, &pin, s->rmax); if (s->nointerp) { points_write(nin, pin); specs_destroy(s); free(pin); return 0; } if (s->generate_points) { /* * points_getrange() only writes the proper values to those arguments * which do not point to NaNs */ points_getrange(nin, pin, s->zoom, &s->xmin, &s->xmax, &s->ymin, &s->ymax); points_generate(s->xmin, s->xmax, s->ymin, s->ymax, s->nx, s->ny, &nout, &pout); } else points_read(s->fout, 2, &nout, &pout); if (s->invariant) { me = minell_build(nin, pin); minell_scalepoints(me, nin, pin); minell_scalepoints(me, nout, pout); } else if (s->square) { k = points_scaletosquare(nin, pin); points_scale(nout, pout, k); } if (s->linear) lpi_interpolate_points(nin, pin, nout, pout); else nnpi_interpolate_points(nin, pin, s->wmin, nout, pout); if (s->invariant) minell_rescalepoints(me, nout, pout); else if (s->square) points_scale(nout, pout, 1.0 / k); points_write(nout, pout); if (me != NULL) minell_destroy(me); specs_destroy(s); free(pin); free(pout); return 0; }
int main(int argc, char* argv[]) { char* bathyfname = NULL; int nbathy = -1; point* pbathy = NULL; char* gridfname = NULL; NODETYPE nt = NT_DD; gridnodes* gn = NULL; gridmap* gm = NULL; char* maskfname = NULL; int** mask = NULL; int ppe = PPE_DEF; double zmin = ZMIN_DEF; double zmax = ZMAX_DEF; delaunay* d = NULL; void (*interpolate_point) (void*, point *) = NULL; void* interpolator = NULL; int i = -1, j = -1; parse_commandline(argc, argv, &bathyfname, &gridfname, &maskfname, &nt, &ppe, &zmin, &zmax, &i, &j); /* * sanity check */ if (bathyfname == NULL) quit("no input bathymetry data specified"); if (gridfname == NULL) quit("no input grid data specified"); if (ppe <= 0 || ppe > PPE_MAX) quit("number of points per edge specified = %d greater than %d", ppe, PPE_MAX); if (zmin >= zmax) quit("min depth = %.3g > max depth = %.3g", zmin, zmax); if (nt != NT_DD && nt != NT_COR) quit("unsupported node type"); /* * read bathymetry */ points_read(bathyfname, 3, &nbathy, &pbathy); if (gu_verbose) fprintf(stderr, "## %d input bathymetry values", nbathy); if (nbathy < 3) quit("less than 3 input bathymetry values"); /* * read and validate grid */ gn = gridnodes_read(gridfname, nt); gridnodes_validate(gn); /* * read mask */ if (maskfname != NULL) { int nx = gridnodes_getnce1(gn); int ny = gridnodes_getnce2(gn); mask = gu_readmask(maskfname, nx, ny); } /* * transform grid nodes to corner type */ if (nt != NT_COR) { gridnodes* newgn = gridnodes_transform(gn, NT_COR); gridnodes_destroy(gn); gn = newgn; } /* * build the grid map for physical <-> index space conversions */ gm = gridmap_build(gridnodes_getnce1(gn), gridnodes_getnce2(gn), gridnodes_getx(gn), gridnodes_gety(gn)); /* * convert bathymetry to index space if necessary */ if (indexspace) { point* newpbathy = malloc(nbathy * sizeof(point)); int newnbathy = 0; int ii; for (ii = 0; ii < nbathy; ++ii) { point* p = &pbathy[ii]; point* newp = &newpbathy[newnbathy]; double ic, jc; if (gridmap_xy2fij(gm, p->x, p->y, &ic, &jc)) { newp->x = ic; newp->y = jc; newp->z = p->z; newnbathy++; } } free(pbathy); pbathy = newpbathy; nbathy = newnbathy; } /* * create interpolator */ if (rule == CSA) { /* using libcsa */ interpolator = csa_create(); csa_addpoints(interpolator, nbathy, pbathy); csa_calculatespline(interpolator); interpolate_point = (void (*)(void*, point *)) csa_approximatepoint; } else if (rule == AVERAGE) { interpolator = ga_create(gm); ga_addpoints(interpolator, nbathy, pbathy); interpolate_point = (void (*)(void*, point *)) ga_getvalue; ppe = 1; } else { /* using libnn */ /* * triangulate */ if (gu_verbose) { fprintf(stderr, "## triangulating..."); fflush(stdout); } d = delaunay_build(nbathy, pbathy, 0, NULL, 0, NULL); if (gu_verbose) { fprintf(stderr, "done\n"); fflush(stderr); } if (rule == NN_SIBSON || rule == NN_NONSIBSONIAN) { interpolator = nnpi_create(d); if (rule == NN_SIBSON) nn_rule = SIBSON; else nn_rule = NON_SIBSONIAN; interpolate_point = (void (*)(void*, point *)) nnpi_interpolate_point; } else if (rule == LINEAR) { interpolator = lpi_build(d); interpolate_point = (void (*)(void*, point *)) lpi_interpolate_point; } } /* * main cycle -- over grid cells */ { double** gx = gridnodes_getx(gn); int jmin, jmax, imin, imax; if (i < 0) { imin = 0; imax = gridnodes_getnce1(gn) - 1; jmin = 0; jmax = gridnodes_getnce2(gn) - 1; } else { if (gu_verbose) fprintf(stderr, "## calculating depth for cell (%d,%d)\n", i, j); imin = i; imax = i; jmin = j; jmax = j; } for (j = jmin; j <= jmax; ++j) { for (i = imin; i <= imax; ++i) { double sum = 0.0; int count = 0; int ii, jj; if ((mask != NULL && mask[j][i] == 0) || isnan(gx[j][i]) || isnan(gx[j + 1][i + 1]) || isnan(gx[j][i + 1]) || isnan(gx[j + 1][i])) { printf("NaN\n"); continue; } for (ii = 0; ii < ppe; ++ii) { for (jj = 0; jj < ppe; ++jj) { double fi = (double) i + 0.5 / (double) ppe * (1.0 + 2.0 * (double) ii); double fj = (double) j + 0.5 / (double) ppe * (1.0 + 2.0 * (double) jj); point p; if (!indexspace) gridmap_fij2xy(gm, fi, fj, &p.x, &p.y); else { p.x = fi; p.y = fj; } interpolate_point(interpolator, &p); if (isnan(p.z)) continue; else if (p.z < zmin) p.z = zmin; else if (p.z > zmax) p.z = zmax; sum += p.z; count++; } } if (count == 0) printf("NaN\n"); else printf("%.2f\n", sum / (double) count); fflush(stdout); } } } /* * clean up, just because */ if (rule == CSA) csa_destroy(interpolator); else if (rule == AVERAGE) ga_destroy(interpolator); else { if (rule == NN_SIBSON || rule == NN_NONSIBSONIAN) nnpi_destroy(interpolator); else if (rule == LINEAR) lpi_destroy(interpolator); delaunay_destroy(d); } if (mask != NULL) gu_free2d(mask); gridmap_destroy(gm); gridnodes_destroy(gn); free(pbathy); return 0; }