/* Performs Natural Neighbours interpolation for an array of points.
*
* @param nin Number of input points
* @param pin Array of input points [pin]
* @param wmin Minimal allowed weight
* @param nout Number of output points
* @param pout Array of output points [nout]
*/
void nnpi_interpolate_points(int nin, point pin[], double wmin, int nout, point pout[])
{
delaunay* d = delaunay_build(nin, pin, 0, NULL, 0, NULL);
nnpi* nn = nnpi_create(d);
int seed = 0;
int i;
nnpi_setwmin(nn, wmin);
if (nn_verbose) {
fprintf(stderr, "xytoi:\n");
for (i = 0; i < nout; ++i) {
point* p = &pout[i];
fprintf(stderr, "(%.7g,%.7g) -> %d\n", p->x, p->y, delaunay_xytoi(d, p, seed));
}
}
for (i = 0; i < nout; ++i)
nnpi_interpolate_point(nn, &pout[i]);
if (nn_verbose) {
fprintf(stderr, "output:\n");
for (i = 0; i < nout; ++i) {
point* p = &pout[i];
fprintf(stderr, " %d:%15.7g %15.7g %15.7g\n", i, p->x, p->y, p->z);
}
}
nnpi_destroy(nn);
delaunay_destroy(d);
}
NaturalNeigbourInterpolation::NaturalNeigbourInterpolation(
QVector<QVector3D> &values) :
Interpolation(values),
delaunay_(NULL),
interpolator_(NULL)
{
points_.clear();
for (int i = 0; i < values_.size(); ++i)
{
point a;
a.x = values_[i].x();
a.y = values_[i].y();
a.z = values_[i].z();
points_.append(a);
}
delaunay_ = delaunay_build(points_.size(), points_.data(), 0, NULL, 0, NULL);
interpolator_ = nnpi_create(delaunay_);
nnpi_setwmin(interpolator_, -DBL_MAX);
}
/* 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;
}
