SDDSlib
Loading...
Searching...
No Matches
Classes | Macros | Enumerations | Functions | Variables
sdds2dinterpolate.c File Reference

Interpolates scalar 2D data at specified points using Natural Neighbours or Cubic Spline Approximation. More...

#include "SDDS.h"
#include "mdb.h"
#include "scan.h"
#include "nn_2d_interpolate.h"
#include "csa.h"

Go to the source code of this file.

Classes

struct  OUT_POINT
 

Macros

#define ALGORITHMS   2
 
#define LINEAR_NN   0x0001UL
 
#define SIBSON_NN   0x0002UL
 
#define NONSIBSON_NN   0x0004UL
 
#define SCALE_OPTIONS   2
 

Enumerations

enum  option_type {
  CLO_PIPE , CLO_INDEPENDENT_COLUMN , CLO_DEPENDENT_COLUMN , CLO_SCALE ,
  CLO_OUT_DIMENSION , CLO_RANGE , CLO_ZOOM , CLO_DIMENSION_THIN ,
  CLO_CLUSTER_THIN , CLO_PREPROCESS , CLO_ALGORITHM , CLO_WEIGHT ,
  CLO_VERTEX , CLO_NPOINTS , CLO_VERBOSE , CLO_MERGE ,
  CLO_FILE , CLO_MAJOR_ORDER , N_OPTIONS
}
 

Functions

void ReadInputFile (char *inputFile, char *xCol, char *yCol, char **zColMatch, long zColMatches, char ***zCol, int32_t *zCols, char *stdCol, long *pages, long **rows, double ***x, double ***y, double ****z, double ***std, SDDS_DATASET *SDDS_in)
 
void SetupOutputFile (SDDS_DATASET *SDDS_out, SDDS_DATASET *SDDS_in, char *outputFile, char *xCol, char *yCol, char *xName, char *yName, char **zCol, long zCols, short columnMajorOrder)
 
void WriteOutputPage (SDDS_DATASET *SDDS_out, char *xCol, char *yCol, char *zCol, specs *spec, int nout, point *pout, long writepage)
 
void ReadPointFile (char *pointsFile, char *xCol, char *yCol, long *point_pages, OUT_POINT **out_point)
 
int interpolate_output_points (int nin, point **pin, double *std, char *xCol, char *yCol, char *xName, char *yName, char **zCol, long zCols, specs *spec, long pages, OUT_POINT *out_point, SDDS_DATASET *SDDS_out)
 
int main (int argc, char *argv[])
 

Variables

char * option [N_OPTIONS]
 
static const char * USAGE
 
char * algorithm_option [ALGORITHMS] = {"nn", "csa"}
 
char * scale_option [SCALE_OPTIONS] = {"circle", "square"}
 
static char * INFINITY_OPTION [1] = {"infinity"}
 

Detailed Description

Interpolates scalar 2D data at specified points using Natural Neighbours or Cubic Spline Approximation.

This program reads 2D scalar data from an SDDS file, performs interpolation at specified output points, and writes the interpolated data to an output SDDS file. Various options are available to control the interpolation process, scaling, output grid, and other parameters.

Usage

sdds2dinterpolate <input> <output> [options]

Options

-pipe=[input][,output] -independentColumn=xcolumn=<string>,ycolumn=<string>[,errorColumn=<string>] -dependentColumn=

scale=circle|square -outDimension=xdimension=<nx>,ydimension=<ny> -range=xminimum=

,xmaximum=

,yminimum=

,ymaximum=

-zoom=

-dimensionThin=xdimension=<nx>,ydimension=<ny> -clusterThin=

-preprocess -algorithm=<string>,linear|sibson|nonsibson[,average=

][,sensitivity=

] -weight=

-vertex=<id> -npoints=<integer> -verbose -merge -file=<output points file>[,<xName>,<yName>] -majorOrder=row|column

Note
Converted from nnbathy.c by Hairong Shang (April 2007) for interpolating scalar 2D data in specified points using Natural Neighbours interpolation. The interpolated values are written to an SDDS file.
Copyright
  • (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
  • (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.
License
This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.
Author
H. Shang, R. Soliday, L. Emery, M. Borland

Definition in file sdds2dinterpolate.c.

Macro Definition Documentation

◆ ALGORITHMS

#define ALGORITHMS   2

Definition at line 134 of file sdds2dinterpolate.c.

◆ LINEAR_NN

#define LINEAR_NN   0x0001UL

Definition at line 135 of file sdds2dinterpolate.c.

◆ NONSIBSON_NN

#define NONSIBSON_NN   0x0004UL

Definition at line 137 of file sdds2dinterpolate.c.

◆ SCALE_OPTIONS

#define SCALE_OPTIONS   2

Definition at line 141 of file sdds2dinterpolate.c.

◆ SIBSON_NN

#define SIBSON_NN   0x0002UL

Definition at line 136 of file sdds2dinterpolate.c.

Enumeration Type Documentation

◆ option_type

enum option_type

Definition at line 56 of file sdds2dinterpolate.c.

56 {
57 CLO_PIPE,
58 CLO_INDEPENDENT_COLUMN,
59 CLO_DEPENDENT_COLUMN,
60 CLO_SCALE,
61 CLO_OUT_DIMENSION,
62 CLO_RANGE,
63 CLO_ZOOM,
64 CLO_DIMENSION_THIN,
65 CLO_CLUSTER_THIN,
66 CLO_PREPROCESS,
67 CLO_ALGORITHM,
68 CLO_WEIGHT,
69 CLO_VERTEX,
70 CLO_NPOINTS,
71 CLO_VERBOSE,
72 CLO_MERGE,
73 CLO_FILE,
74 CLO_MAJOR_ORDER,
75 N_OPTIONS
76};

Function Documentation

◆ interpolate_output_points()

int interpolate_output_points ( int nin,
point ** pin,
double * std,
char * xCol,
char * yCol,
char * xName,
char * yName,
char ** zCol,
long zCols,
specs * spec,
long pages,
OUT_POINT * out_point,
SDDS_DATASET * SDDS_out )

Definition at line 860 of file sdds2dinterpolate.c.

861 {
862 int nout, page, k, writepage = 0, i;
863 point *pout = NULL;
864
865 for (page = 0; page < pages; page++) {
866 nout = out_point[page].nout;
867 pout = out_point[page].pout;
868 spec->nx = out_point[page].nx;
869 spec->ny = out_point[page].ny;
870 spec->xmin = out_point[page].xmin;
871 spec->xmax = out_point[page].xmax;
872 spec->dx = out_point[page].dx;
873 spec->ymin = out_point[page].ymin;
874 spec->ymax = out_point[page].ymax;
875 spec->dy = out_point[page].dy;
876 for (k = 0; k < zCols; k++) {
877 if (spec->method == NN) {
878 do_nn_2d_interpolate(spec, &nin, &pin[k], &nout, &pout);
879 } else {
880 do_csa_2d_interpolate(spec, nin, pin[k], &nout, &pout, std);
881 }
882 if (!spec->nointerp) {
883 if (!writepage) {
884 WriteOutputPage(SDDS_out, xName ? xName : xCol, yName ? yName : yCol, zCol[k], spec, nout, pout, 0);
885 writepage = 1;
886 } else {
887 for (i = 0; i < nout; i++) {
888 if (!SDDS_SetRowValues(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, i,
889 zCol[k], pout[i].z, NULL))
890 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
891 }
892 }
893 }
894 }
895 }
896 if (writepage && !SDDS_WritePage(SDDS_out))
897 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
898 return 1;
899}
SDDS_SetRowValues
int32_t SDDS_SetRowValues(SDDS_DATASET *SDDS_dataset, int32_t mode, int64_t row,...)
Definition SDDS_dataprep.c:988
SDDS_WritePage
int32_t SDDS_WritePage(SDDS_DATASET *SDDS_dataset)
Writes the current data table to the output file.
Definition SDDS_output.c:1222
SDDS_PrintErrors
void SDDS_PrintErrors(FILE *fp, int32_t mode)
Prints recorded error messages to a specified file stream.
Definition SDDS_utils.c:432

◆ main()

int main ( int argc,
char * argv[] )

Definition at line 156 of file sdds2dinterpolate.c.

156 {
157 SDDS_DATASET SDDS_out, SDDS_in;
158 char *inputFile, *outputFile, *xCol = "x", *yCol = "y", **zCol = NULL, *stdCol = "StdError", *pointsFile = NULL, **zColMatch = NULL;
159 char *pointsFileXName = NULL, *pointsFileYName = NULL;
160 long i, j, i_arg, k, scale, *rows, pages, merge = 0, point_pages = 0, writepage = 0, zColMatches = 0;
161 int32_t zCols = 1;
162 unsigned long dummyFlags = 0, pipeFlags = 0, majorOrderFlag;
163 SCANNED_ARG *s_arg;
164 double **x = NULL, **y = NULL, ***z = NULL, xmin = 0, xmax = 0, ymin = 0, ymax = 0, **std = NULL, *std_all = NULL;
165 specs *spec = specs_create();
166 int nin = 0;
167 point **pin = NULL;
168 int nout = 0;
169 point *pout = NULL;
170 OUT_POINT *out_point = NULL;
171 short columnMajorOrder = -1;
172
173 /* Turn off the extrapolation by default */
174 spec->wmin = 0;
175 inputFile = outputFile = NULL;
176 SDDS_RegisterProgramName(argv[0]);
177 argc = scanargs(&s_arg, argc, argv);
178 if (argc < 2) {
179 fprintf(stderr, "%s", USAGE);
180 return EXIT_FAILURE;
181 }
182
183 for (i_arg = 1; i_arg < argc; i_arg++) {
184 if (s_arg[i_arg].arg_type == OPTION) {
185 delete_chars(s_arg[i_arg].list[0], "_");
186 switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
187 case CLO_MAJOR_ORDER:
188 majorOrderFlag = 0;
189 s_arg[i_arg].n_items -= 1;
190 if (s_arg[i_arg].n_items > 0 &&
191 (!scanItemList(&majorOrderFlag, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
192 "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER,
193 "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) {
194 SDDS_Bomb("Invalid -majorOrder syntax/values");
195 }
196 if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
197 columnMajorOrder = 1;
198 else if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
199 columnMajorOrder = 0;
200 break;
201 case CLO_FILE:
202 if (s_arg[i_arg].n_items != 2 && s_arg[i_arg].n_items != 4)
203 SDDS_Bomb("Invalid -file syntax.");
204 pointsFile = s_arg[i_arg].list[1];
205 if (s_arg[i_arg].n_items == 4) {
206 pointsFileXName = s_arg[i_arg].list[2];
207 pointsFileYName = s_arg[i_arg].list[3];
208 }
209 break;
210 case CLO_PIPE:
211 if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipeFlags))
212 SDDS_Bomb("Invalid -pipe syntax");
213 break;
214 case CLO_INDEPENDENT_COLUMN:
215 if (s_arg[i_arg].n_items < 3)
216 SDDS_Bomb("Invalid -independentColumn syntax.");
217 s_arg[i_arg].n_items--;
218 if (!scanItemList(&dummyFlags, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
219 "xcolumn", SDDS_STRING, &xCol, 1, 0,
220 "ycolumn", SDDS_STRING, &yCol, 1, 0,
221 "errorcolumn", SDDS_STRING, &stdCol, 1, 0, NULL))
222 SDDS_Bomb("Invalid -independentColumn syntax");
223 s_arg[i_arg].n_items++;
224 break;
225 case CLO_DEPENDENT_COLUMN:
226 if (s_arg[i_arg].n_items < 2)
227 SDDS_Bomb("Invalid -dependentColumn syntax.");
228 zColMatches = s_arg[i_arg].n_items - 1;
229 zColMatch = tmalloc(sizeof(*zColMatch) * zColMatches);
230 for (i = 0; i < zColMatches; i++)
231 zColMatch[i] = s_arg[i_arg].list[i + 1];
232 break;
233 case CLO_SCALE:
234 if (s_arg[i_arg].n_items != 2)
235 SDDS_Bomb("Invalid -scale syntax.");
236 if ((scale = match_string(s_arg[i_arg].list[1], scale_option, SCALE_OPTIONS, 0)) == -1) {
237 fprintf(stderr, "Invalid scale option - %s provided.\n", s_arg[i_arg].list[1]);
238 exit(EXIT_FAILURE);
239 }
240 spec->square = !scale;
241 spec->invariant = scale;
242 break;
243 case CLO_OUT_DIMENSION:
244 if (s_arg[i_arg].n_items != 3)
245 SDDS_Bomb("Invalid -outDimension syntax.");
246 s_arg[i_arg].n_items--;
247 if (!scanItemList(&dummyFlags, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
248 "xdimension", SDDS_LONG, &spec->nx, 1, 0,
249 "ydimension", SDDS_LONG, &spec->ny, 1, 0, NULL))
250 SDDS_Bomb("Invalid -outDimension syntax");
251 s_arg[i_arg].n_items++;
252 if (spec->nx <= 0 || spec->nx > NMAX || spec->ny <= 0 || spec->ny > NMAX)
253 SDDS_Bomb("Invalid size for output grid.");
254 spec->generate_points = 1;
255 break;
256 case CLO_RANGE:
257 if (s_arg[i_arg].n_items < 2)
258 SDDS_Bomb("Invalid -range syntax.");
259 s_arg[i_arg].n_items--;
260 if (!scanItemList(&dummyFlags, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
261 "xminimum", SDDS_DOUBLE, &spec->xmin, 1, 0,
262 "xmaximum", SDDS_DOUBLE, &spec->xmax, 1, 0,
263 "yminimum", SDDS_DOUBLE, &spec->ymin, 1, 0,
264 "ymaximum", SDDS_DOUBLE, &spec->ymax, 1, 0, NULL))
265 SDDS_Bomb("Invalid -range syntax");
266 s_arg[i_arg].n_items++;
267 if (spec->xmin > spec->xmax || spec->ymin > spec->ymax ||
268 isnan(spec->xmin) || isnan(spec->xmax) || isnan(spec->ymin) || isnan(spec->ymax))
269 SDDS_Bomb("Invalid -range provided.");
270 spec->range = 1;
271 break;
272 case CLO_ZOOM:
273 if (s_arg[i_arg].n_items != 2)
274 SDDS_Bomb("Invalid -zoom syntax.");
275 if (!get_double(&spec->zoom, s_arg[i_arg].list[1]))
276 SDDS_Bomb("Invalid -zoom value provided.");
277 break;
278 case CLO_DIMENSION_THIN:
279 if (s_arg[i_arg].n_items != 3)
280 SDDS_Bomb("Invalid -dimensionThin syntax.");
281 s_arg[i_arg].n_items--;
282 if (!scanItemList(&dummyFlags, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
283 "xdimension", SDDS_LONG, &spec->nxd, 1, 0,
284 "ydimension", SDDS_LONG, &spec->nyd, 1, 0, NULL))
285 SDDS_Bomb("Invalid -dimensionThin syntax");
286 s_arg[i_arg].n_items++;
287 spec->thin = 1;
288 break;
289 case CLO_CLUSTER_THIN:
290 if (s_arg[i_arg].n_items != 2)
291 SDDS_Bomb("Invalid -clusterThin syntax.");
292 if (!get_double(&spec->rmax, s_arg[i_arg].list[1]))
293 SDDS_Bomb("Invalid -clusterThin value provided.");
294 spec->thin = 2;
295 break;
296 case CLO_PREPROCESS:
297 spec->nointerp = 1;
298 break;
299 case CLO_ALGORITHM:
300 if (s_arg[i_arg].n_items < 2)
301 SDDS_Bomb("Invalid -algorithm syntax!");
302 if ((spec->method = match_string(s_arg[i_arg].list[1], algorithm_option, ALGORITHMS, 0)) == -1) {
303 fprintf(stderr, "Invalid algorithm - %s provided, has to be nn or csa.\n", s_arg[i_arg].list[1]);
304 exit(EXIT_FAILURE);
305 }
306 dummyFlags = 0;
307 s_arg[i_arg].n_items -= 2;
308 if (!scanItemList(&dummyFlags, s_arg[i_arg].list + 2, &s_arg[i_arg].n_items, 0,
309 "linear", -1, NULL, 0, LINEAR_NN,
310 "sibson", -1, NULL, 0, SIBSON_NN,
311 "nonSibson", -1, NULL, 0, NONSIBSON_NN,
312 "average", SDDS_LONG, &spec->nppc, 1, 0,
313 "sensitivity", SDDS_DOUBLE, &spec->k, 1, 0, NULL))
314 SDDS_Bomb("Invalid -algorithm syntax!");
315 spec->linear = 0;
316 if (!dummyFlags || dummyFlags & LINEAR_NN) {
317 spec->linear = 1;
318 } else if (dummyFlags & SIBSON_NN) {
319 nn_rule = SIBSON;
320 } else if (dummyFlags & NONSIBSON_NN) {
321 nn_rule = NON_SIBSONIAN;
322 }
323 s_arg[i_arg].n_items += 2;
324 break;
325 case CLO_WEIGHT:
326 if (s_arg[i_arg].n_items != 2)
327 SDDS_Bomb("Invalid -weight syntax.");
328 if (match_string(s_arg[i_arg].list[1], INFINITY_OPTION, 1, 0) == 0)
329 spec->wmin = -DBL_MAX;
330 else {
331 if (!get_double(&spec->wmin, s_arg[i_arg].list[1]))
332 SDDS_Bomb("Invalid weight value provided.");
333 }
334 break;
335 case CLO_VERTEX:
336 if (s_arg[i_arg].n_items != 2)
337 SDDS_Bomb("Invalid -vertex syntax.");
338 if (!get_int(&nn_test_vertice, s_arg[i_arg].list[1]))
339 SDDS_Bomb("Invalid vertex value provided.");
340 nn_verbose = 1;
341 break;
342 case CLO_NPOINTS:
343 if (s_arg[i_arg].n_items != 2)
344 SDDS_Bomb("Invalid -npoints syntax.");
345 if (!get_int(&spec->npoints, s_arg[i_arg].list[1]))
346 SDDS_Bomb("Invalid npoints value provided.");
347 break;
348 case CLO_VERBOSE:
349 nn_verbose = 2;
350 break;
351 case CLO_MERGE:
352 merge = 1;
353 break;
354 default:
355 fprintf(stderr, "Unknown option - %s provided.\n", s_arg[i_arg].list[0]);
356 exit(EXIT_FAILURE);
357 break;
358 }
359 } else {
360 if (!inputFile)
361 inputFile = s_arg[i_arg].list[0];
362 else if (!outputFile)
363 outputFile = s_arg[i_arg].list[0];
364 else
365 SDDS_Bomb("Too many files given!");
366 }
367 }
368
369 processFilenames("sdds2dinterpolate", &inputFile, &outputFile, pipeFlags, 0, NULL);
370 if (!spec->generate_points && !spec->nointerp && !pointsFile) {
371 fprintf(stderr, "No output grid specified.\n");
372 exit(EXIT_FAILURE);
373 }
374 if (spec->thin) {
375 if (spec->nxd == -1)
376 spec->nxd = spec->nx;
377 if (spec->nyd == -1)
378 spec->nyd = spec->ny;
379 if (spec->nxd <= 0 || spec->nyd <= 0) {
380 fprintf(stderr, "Invalid grid size for thinning.\n");
381 exit(EXIT_FAILURE);
382 }
383 }
384 if (spec->npoints == 1) {
385 if (spec->nx <= 0)
386 spec->npoints = 0;
387 else
388 spec->npoints = spec->nx * spec->ny;
389 }
390 ReadInputFile(inputFile, xCol, yCol, zColMatch, zColMatches, &zCol, &zCols, stdCol, &pages, &rows, &x, &y, &z, &std, &SDDS_in);
391 if (!spec->nointerp)
392 SetupOutputFile(&SDDS_out, &SDDS_in, outputFile, xCol, yCol, pointsFileXName, pointsFileYName,
393 zCol, zCols, columnMajorOrder);
394 if (!SDDS_Terminate(&SDDS_in))
395 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
396 if (pointsFile)
397 ReadPointFile(pointsFile, pointsFileXName ? pointsFileXName : xCol, pointsFileYName ? pointsFileYName : yCol,
398 &point_pages, &out_point);
399 pin = tmalloc(sizeof(*pin) * zCols);
400 if (merge) {
401 for (i = 0; i < pages; i++) {
402 if (!i) {
403 xmin = xmax = x[0][0];
404 ymin = ymax = y[0][0];
405 }
406 for (k = 0; k < zCols; k++)
407 pin[k] = SDDS_Realloc(pin[k], sizeof(**pin) * (nin + rows[i]));
408 if (std)
409 std_all = SDDS_Realloc(std_all, sizeof(*std_all) * (nin + rows[i]));
410 for (j = 0; j < rows[i]; j++) {
411 if (x[i][j] < xmin)
412 xmin = x[i][j];
413 else if (x[i][j] > xmax)
414 xmax = x[i][j];
415 if (y[i][j] < ymin)
416 ymin = y[i][j];
417 else if (y[i][j] > ymax)
418 ymax = y[i][j];
419 for (k = 0; k < zCols; k++) {
420 pin[k][nin + j].x = x[i][j];
421 pin[k][nin + j].y = y[i][j];
422 pin[k][nin + j].z = z[k][i][j];
423 }
424 if (std)
425 std_all[nin + j] = std[i][j];
426 }
427 nin += rows[i];
428 free(x[i]);
429 free(y[i]);
430 for (k = 0; k < zCols; k++) {
431 free(z[k][i]);
432 z[k][i] = NULL;
433 }
434 if (std && std[i]) {
435 free(std[i]);
436 std[i] = NULL;
437 }
438 x[i] = y[i] = NULL;
439 }
440 free(x);
441 free(y);
442 x = y = NULL;
443 for (k = 0; k < zCols; k++) {
444 free(z[k]);
445 z[k] = NULL;
446 }
447 free(z);
448 z = NULL;
449 if (std)
450 free(std);
451 std = NULL;
452 if (!spec->range) {
453 spec->xmin = xmin;
454 spec->ymin = ymin;
455 spec->xmax = xmax;
456 spec->ymax = ymax;
457 }
458 if (pointsFile) {
459 if (!interpolate_output_points(nin, pin, std_all, xCol, yCol, pointsFileXName, pointsFileYName,
460 zCol, zCols, spec, pages, out_point, &SDDS_out))
461 exit(EXIT_FAILURE);
462 writepage = 1;
463 } else {
464 for (k = 0; k < zCols; k++) {
465 if (spec->method == NN) {
466 do_nn_2d_interpolate(spec, &nin, &pin[k], &nout, &pout);
467 } else if (spec->method == CSA) {
468 do_csa_2d_interpolate(spec, nin, pin[k], &nout, &pout, std_all);
469 }
470 if (!spec->nointerp) {
471 if (!writepage) {
472 WriteOutputPage(&SDDS_out, pointsFileXName ? pointsFileXName : xCol,
473 pointsFileYName ? pointsFileYName : yCol,
474 zCol[k], spec, nout, pout, 0);
475 writepage = 1;
476 } else {
477 for (i = 0; i < nout; i++) {
478 if (!SDDS_SetRowValues(&SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, i,
479 zCol[k], pout[i].z, NULL))
480 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
481 }
482 }
483 }
484 }
485 if (writepage && !SDDS_WritePage(&SDDS_out))
486 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
487 }
488 } else {
489 for (i = 0; i < pages; i++) {
490 xmin = xmax = x[i][0];
491 ymin = ymax = y[i][0];
492 nin = rows[i];
493 for (j = 0; j < nin; j++) {
494 if (x[i][j] < xmin)
495 xmin = x[i][j];
496 else if (x[i][j] > xmax)
497 xmax = x[i][j];
498 if (y[i][j] < ymin)
499 ymin = y[i][j];
500 else if (y[i][j] > ymax)
501 ymax = y[i][j];
502 }
503 if (!spec->range) {
504 spec->xmin = xmin;
505 spec->ymin = ymin;
506 spec->xmax = xmax;
507 spec->ymax = ymax;
508 }
509 for (k = 0; k < zCols; k++) {
510 pin[k] = malloc(sizeof(**pin) * nin);
511 for (j = 0; j < rows[i]; j++) {
512 pin[k][j].x = x[i][j];
513 pin[k][j].y = y[i][j];
514 pin[k][j].z = z[k][i][j];
515 }
516 free(z[k][i]);
517 }
518 free(x[i]);
519 free(y[i]);
520 x[i] = y[i] = NULL;
521 if (std && std[i])
522 std_all = std[i];
523 else
524 std_all = NULL;
525 if (pointsFile) {
526 if (!interpolate_output_points(nin, pin, std_all, xCol, yCol, pointsFileXName, pointsFileYName,
527 zCol, zCols, spec, point_pages, out_point, &SDDS_out))
528 exit(EXIT_FAILURE);
529 writepage = 1;
530 } else {
531 for (k = 0; k < zCols; k++) {
532 if (spec->method == NN) {
533 do_nn_2d_interpolate(spec, &nin, &pin[k], &nout, &pout);
534 } else if (spec->method == CSA) {
535 do_csa_2d_interpolate(spec, nin, pin[k], &nout, &pout, std_all);
536 }
537 if (!spec->nointerp) {
538 if (!writepage) {
539 WriteOutputPage(&SDDS_out, pointsFileXName ? pointsFileXName : xCol,
540 pointsFileYName ? pointsFileYName : yCol,
541 zCol[k], spec, nout, pout, 0);
542 writepage = 1;
543 } else {
544 for (j = 0; j < nout; j++) {
545 if (!SDDS_SetRowValues(&SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, j,
546 zCol[k], pout[j].z, NULL))
547 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
548 }
549 }
550 }
551 }
552 if (std && std[i]) {
553 free(std[i]);
554 std[i] = NULL;
555 }
556 if (writepage && !SDDS_WritePage(&SDDS_out))
557 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
558 }
559 }
560 free(x);
561 free(y);
562 for (k = 0; k < zCols; k++)
563 free(z[k]);
564 free(z);
565 x = y = NULL;
566 }
567 if (std)
568 free(std);
569 for (k = 0; k < zCols; k++)
570 free(pin[k]);
571 free(pin);
572 if (writepage && !SDDS_Terminate(&SDDS_out))
573 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
574 if (point_pages && out_point) {
575 for (i = 0; i < point_pages; i++) {
576 free(out_point[i].pout);
577 }
578 free(out_point);
579 }
580 if (pout)
581 free(pout);
582 free(spec);
583 free(rows);
584 for (i = 0; i < zCols; i++)
585 free(zCol[i]);
586 free(zCol);
587 free_scanargs(&s_arg, argc);
588 return EXIT_SUCCESS;
589}
SDDS_Terminate
int32_t SDDS_Terminate(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1448
SDDS_RegisterProgramName
void SDDS_RegisterProgramName(const char *name)
Registers the executable program name for use in error messages.
Definition SDDS_utils.c:288
SDDS_Bomb
void SDDS_Bomb(char *message)
Terminates the program after printing an error message and recorded errors.
Definition SDDS_utils.c:342
SDDS_Realloc
void * SDDS_Realloc(void *old_ptr, size_t new_size)
Reallocates memory to a new size.
Definition SDDS_utils.c:677
SDDS_STRING
#define SDDS_STRING
Identifier for the string data type.
Definition SDDStypes.h:85
SDDS_LONG
#define SDDS_LONG
Identifier for the signed 32-bit integer data type.
Definition SDDStypes.h:61
SDDS_DOUBLE
#define SDDS_DOUBLE
Identifier for the double data type.
Definition SDDStypes.h:37
tmalloc
void * tmalloc(uint64_t size_of_block)
Allocates a memory block of the specified size with zero initialization.
Definition array.c:59
get_double
int get_double(double *dptr, char *s)
Parses a double value from the given string.
Definition data_scan.c:40
get_int
int get_int(int *iptr, char *s)
Parses an integer value from the given string.
Definition data_scan.c:380
delete_chars
char * delete_chars(char *s, char *t)
Removes all occurrences of characters found in string t from string s.
Definition delete_chars.c:28
match_string
long match_string(char *string, char **option, long n_options, long mode)
Matches a given string against an array of option strings based on specified modes.
Definition match_string.c:34
scanargs
int scanargs(SCANNED_ARG **scanned, int argc, char **argv)
Definition scanargs.c:36
processPipeOption
long processPipeOption(char **item, long items, unsigned long *flags)
Definition scanargs.c:356
processFilenames
void processFilenames(char *programName, char **input, char **output, unsigned long pipeFlags, long noWarnings, long *tmpOutputUsed)
Definition scanargs.c:390
free_scanargs
void free_scanargs(SCANNED_ARG **scanned, int argc)
Definition scanargs.c:584
scanItemList
long scanItemList(unsigned long *flags, char **item, long *items, unsigned long mode,...)
Scans a list of items and assigns values based on provided keywords and types.
Definition scanitemlist.c:41
OUT_POINT
Definition sdds2dinterpolate.c:128
SDDS_DATASET
Definition SDDS.h:303

◆ ReadInputFile()

void ReadInputFile ( char * inputFile,
char * xCol,
char * yCol,
char ** zColMatch,
long zColMatches,
char *** zCol,
int32_t * zCols,
char * stdCol,
long * pages,
long ** rows,
double *** x,
double *** y,
double **** z,
double *** std,
SDDS_DATASET * SDDS_in )

Definition at line 591 of file sdds2dinterpolate.c.

592 {
593 int64_t rows1 = 0;
594 long i, pages0 = 0, std_exist = 0;
595
596 if (!SDDS_InitializeInput(SDDS_in, inputFile))
597 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
598 if (!zColMatches) {
599 *zCol = tmalloc(sizeof(**zCol));
600 SDDS_CopyString(zCol[0], "z");
601 *zCols = 1;
602 } else {
603 *zCol = getMatchingSDDSNames(SDDS_in, zColMatch, zColMatches, zCols, SDDS_MATCH_COLUMN);
604 free(zColMatch);
605 if (!(*zCols)) {
606 fprintf(stderr, "No dependent columns found in input file.\n");
607 exit(EXIT_FAILURE);
608 }
609 }
610 *z = tmalloc(sizeof(**z) * (*zCols));
611 *rows = NULL;
612 if (SDDS_CheckColumn(SDDS_in, xCol, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) {
613 fprintf(stderr, "X column - %s does not exist!\n", xCol);
614 exit(EXIT_FAILURE);
615 }
616 if (SDDS_CheckColumn(SDDS_in, yCol, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) {
617 fprintf(stderr, "Y column - %s does not exist!\n", yCol);
618 exit(EXIT_FAILURE);
619 }
620 for (i = 0; i < *zCols; i++) {
621 if (SDDS_CheckColumn(SDDS_in, (*zCol)[i], NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) {
622 fprintf(stderr, "Z column - %s does not exist!\n", (*zCol)[i]);
623 exit(EXIT_FAILURE);
624 }
625 }
626 if (SDDS_CheckColumn(SDDS_in, stdCol, NULL, SDDS_ANY_NUMERIC_TYPE, NULL) == SDDS_CHECK_OK)
627 std_exist = 1;
628
629 while (SDDS_ReadPage(SDDS_in) > 0) {
630 rows1 = SDDS_CountRowsOfInterest(SDDS_in);
631 if (!rows1)
632 continue;
633 if (rows1 > INT32_MAX) {
634 fprintf(stderr, "Too many input rows for 2D interpolate library routines.\n");
635 exit(EXIT_FAILURE);
636 }
637 *rows = SDDS_Realloc(*rows, sizeof(**rows) * (pages0 + 1));
638 (*rows)[pages0] = rows1;
639 if (!(*x = SDDS_Realloc(*x, sizeof(**x) * (pages0 + 1))) ||
640 !(*y = SDDS_Realloc(*y, sizeof(**y) * (pages0 + 1)))) {
641 fprintf(stderr, "Memory allocation error for X and Y data.\n");
642 exit(EXIT_FAILURE);
643 }
644 for (i = 0; i < *zCols; i++) {
645 if (!((*z)[i] = SDDS_Realloc((*z)[i], sizeof(***z) * (pages0 + 1)))) {
646 fprintf(stderr, "Memory allocation error for Z data.\n");
647 exit(EXIT_FAILURE);
648 }
649 }
650 if (std_exist) {
651 if (!(*std = SDDS_Realloc(*std, sizeof(**std) * (pages0 + 1)))) {
652 fprintf(stderr, "Memory allocation error for standard error.\n");
653 exit(EXIT_FAILURE);
654 }
655 (*std)[pages0] = NULL;
656 }
657
658 (*x)[pages0] = (*y)[pages0] = NULL;
659 if (!((*x)[pages0] = (double *)SDDS_GetColumnInDoubles(SDDS_in, xCol)) ||
660 !((*y)[pages0] = (double *)SDDS_GetColumnInDoubles(SDDS_in, yCol)))
661 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
662 for (i = 0; i < *zCols; i++) {
663 (*z)[i][pages0] = NULL;
664 if (!((*z)[i][pages0] = (double *)SDDS_GetColumnInDoubles(SDDS_in, (*zCol)[i])))
665 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
666 }
667 if (std_exist && !((*std)[pages0] = (double *)SDDS_GetColumnInDoubles(SDDS_in, stdCol)))
668 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
669 pages0++;
670 }
671
672 if (!pages0) {
673 fprintf(stderr, "No data found in the input file.\n");
674 exit(EXIT_FAILURE);
675 }
676 *pages = pages0;
677 return;
678}
SDDS_CountRowsOfInterest
int64_t SDDS_CountRowsOfInterest(SDDS_DATASET *SDDS_dataset)
Counts the number of rows marked as "of interest" in the current data table.
Definition SDDS_extract.c:364
SDDS_GetColumnInDoubles
double * SDDS_GetColumnInDoubles(SDDS_DATASET *SDDS_dataset, char *column_name)
Retrieves the data of a specified numerical column as an array of doubles, considering only rows mark...
Definition SDDS_extract.c:872
SDDS_InitializeInput
int32_t SDDS_InitializeInput(SDDS_DATASET *SDDS_dataset, char *filename)
Definition SDDS_input.c:49
SDDS_ReadPage
int32_t SDDS_ReadPage(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1006
getMatchingSDDSNames
char ** getMatchingSDDSNames(SDDS_DATASET *dataset, char **matchName, int32_t matches, int32_t *names, short type)
Retrieves an array of matching SDDS entity names based on specified criteria.
Definition SDDS_utils.c:5556
SDDS_CheckColumn
int32_t SDDS_CheckColumn(SDDS_DATASET *SDDS_dataset, char *name, char *units, int32_t type, FILE *fp_message)
Checks if a column exists in the SDDS dataset with the specified name, units, and type.
Definition SDDS_utils.c:4562
SDDS_CopyString
int32_t SDDS_CopyString(char **target, const char *source)
Copies a source string to a target string with memory allocation.
Definition SDDS_utils.c:856
SDDS_ANY_NUMERIC_TYPE
#define SDDS_ANY_NUMERIC_TYPE
Special identifier used by SDDS_Check*() routines to accept any numeric type.
Definition SDDStypes.h:157

◆ ReadPointFile()

void ReadPointFile ( char * pointsFile,
char * xCol,
char * yCol,
long * point_pages,
OUT_POINT ** out_point )

Definition at line 780 of file sdds2dinterpolate.c.

780 {
781 SDDS_DATASET SDDS_in;
782 int64_t rows1 = 0;
783 long pages0 = 0;
784 double *x, *y, xmin, xmax, firstx, firsty, ymin, ymax;
785 int nx, ny, i;
786
787 if (!SDDS_InitializeInput(&SDDS_in, inputFile))
788 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
789 if (SDDS_CheckColumn(&SDDS_in, xCol, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) {
790 fprintf(stderr, "X column - %s does not exist!\n", xCol);
791 exit(EXIT_FAILURE);
792 }
793 if (SDDS_CheckColumn(&SDDS_in, yCol, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) {
794 fprintf(stderr, "Y column - %s does not exist!\n", yCol);
795 exit(EXIT_FAILURE);
796 }
797 while (SDDS_ReadPage(&SDDS_in) > 0) {
798 rows1 = SDDS_CountRowsOfInterest(&SDDS_in);
799 if (!rows1)
800 continue;
801 if (rows1 > INT32_MAX) {
802 fprintf(stderr, "Too many input rows for 2D interpolate library routines.\n");
803 exit(EXIT_FAILURE);
804 }
805 *out_point = SDDS_Realloc(*out_point, sizeof(**out_point) * (pages0 + 1));
806 x = y = NULL;
807 (*out_point)[pages0].pout = malloc(sizeof(point) * rows1);
808 (*out_point)[pages0].nout = rows1;
809 if (!(x = (double *)SDDS_GetColumnInDoubles(&SDDS_in, xCol)) ||
810 !(y = (double *)SDDS_GetColumnInDoubles(&SDDS_in, yCol)))
811 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
812 xmin = xmax = firstx = x[0];
813 ymin = ymax = firsty = y[0];
814 nx = ny = 0;
815
816 for (i = 0; i < rows1; i++) {
817 (*out_point)[pages0].pout[i].x = x[i];
818 (*out_point)[pages0].pout[i].y = y[i];
819 if (x[i] < xmin)
820 xmin = x[i];
821 else if (x[i] > xmax)
822 xmax = x[i];
823 if (x[i] == firstx)
824 ny++;
825 if (y[i] < ymin)
826 ymin = y[i];
827 else if (y[i] > ymax)
828 ymax = y[i];
829 if (y[i] == firsty)
830 nx++;
831 }
832 free(x);
833 free(y);
834 (*out_point)[pages0].xmin = xmin;
835 (*out_point)[pages0].xmax = xmax;
836 (*out_point)[pages0].ymin = ymin;
837 (*out_point)[pages0].ymax = ymax;
838 (*out_point)[pages0].nx = nx;
839 (*out_point)[pages0].ny = ny;
840 if (nx > 1)
841 (*out_point)[pages0].dx = (xmax - xmin) / (nx - 1);
842 else
843 (*out_point)[pages0].dx = 0;
844 if (ny > 1)
845 (*out_point)[pages0].dy = (ymax - ymin) / (ny - 1);
846 else
847 (*out_point)[pages0].dy = 0;
848 pages0++;
849 }
850 if (!SDDS_Terminate(&SDDS_in))
851 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
852 if (!pages0) {
853 fprintf(stderr, "No data found in the points file.\n");
854 exit(EXIT_FAILURE);
855 }
856 *pages = pages0;
857 return;
858}

◆ SetupOutputFile()

void SetupOutputFile ( SDDS_DATASET * SDDS_out,
SDDS_DATASET * SDDS_in,
char * outputFile,
char * xCol,
char * yCol,
char * xName,
char * yName,
char ** zCol,
long zCols,
short columnMajorOrder )

Definition at line 680 of file sdds2dinterpolate.c.

681 {
682 char tmpstr[256], *xUnits = NULL, *yUnits = NULL;
683 long i;
684
685 if (!SDDS_InitializeOutput(SDDS_out, SDDS_BINARY, 1, NULL, NULL, outputFile))
686 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
687 if (!SDDS_DefineSimpleParameter(SDDS_out, "Variable1Name", NULL, SDDS_STRING) ||
688 !SDDS_DefineSimpleParameter(SDDS_out, "Variable2Name", NULL, SDDS_STRING) ||
689 !SDDS_TransferColumnDefinition(SDDS_out, SDDS_in, xCol, xName) ||
690 !SDDS_TransferColumnDefinition(SDDS_out, SDDS_in, yCol, yName))
691 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
692 if (columnMajorOrder != -1)
693 SDDS_out->layout.data_mode.column_major = columnMajorOrder;
694 else
695 SDDS_out->layout.data_mode.column_major = SDDS_in->layout.data_mode.column_major;
696 for (i = 0; i < zCols; i++) {
697 if (!SDDS_TransferColumnDefinition(SDDS_out, SDDS_in, zCol[i], NULL))
698 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
699 }
700 if (SDDS_GetColumnInformation(SDDS_in, "units", &xUnits, SDDS_GET_BY_NAME, xCol) != SDDS_STRING ||
701 SDDS_GetColumnInformation(SDDS_in, "units", &yUnits, SDDS_GET_BY_NAME, yCol) != SDDS_STRING)
702 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
703 sprintf(tmpstr, "%sDimension", xName ? xName : xCol);
704 if (!SDDS_DefineSimpleParameter(SDDS_out, tmpstr, NULL, SDDS_LONG))
705 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
706 sprintf(tmpstr, "%sDimension", yName ? yName : yCol);
707 if (!SDDS_DefineSimpleParameter(SDDS_out, tmpstr, NULL, SDDS_LONG))
708 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
709 sprintf(tmpstr, "%sInterval", xName ? xName : xCol);
710 if (!SDDS_DefineSimpleParameter(SDDS_out, tmpstr, xUnits, SDDS_DOUBLE))
711 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
712 sprintf(tmpstr, "%sInterval", yName ? yName : yCol);
713 if (!SDDS_DefineSimpleParameter(SDDS_out, tmpstr, yUnits, SDDS_DOUBLE))
714 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
715 sprintf(tmpstr, "%sMinimum", xName ? xName : xCol);
716 if (!SDDS_DefineSimpleParameter(SDDS_out, tmpstr, xUnits, SDDS_DOUBLE))
717 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
718 sprintf(tmpstr, "%sMinimum", yName ? yName : yCol);
719 if (!SDDS_DefineSimpleParameter(SDDS_out, tmpstr, yUnits, SDDS_DOUBLE))
720 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
721 sprintf(tmpstr, "%sMaximum", xName ? xName : xCol);
722 if (!SDDS_DefineSimpleParameter(SDDS_out, tmpstr, xUnits, SDDS_DOUBLE))
723 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
724 sprintf(tmpstr, "%sMaximum", yName ? yName : yCol);
725 if (!SDDS_DefineSimpleParameter(SDDS_out, tmpstr, yUnits, SDDS_DOUBLE))
726 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
727 if (!SDDS_WriteLayout(SDDS_out))
728 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
729 if (xUnits)
730 free(xUnits);
731 if (yUnits)
732 free(yUnits);
733}
SDDS_GetColumnInformation
int32_t SDDS_GetColumnInformation(SDDS_DATASET *SDDS_dataset, char *field_name, void *memory, int32_t mode,...)
Retrieves information about a specified column in the SDDS dataset.
Definition SDDS_info.c:41
SDDS_InitializeOutput
int32_t SDDS_InitializeOutput(SDDS_DATASET *SDDS_dataset, int32_t data_mode, int32_t lines_per_row, const char *description, const char *contents, const char *filename)
Initializes the SDDS output dataset.
Definition SDDS_output.c:595
SDDS_DefineSimpleParameter
int32_t SDDS_DefineSimpleParameter(SDDS_DATASET *SDDS_dataset, const char *name, const char *unit, int32_t type)
Defines a simple data parameter within the SDDS dataset.
Definition SDDS_output.c:1894
SDDS_WriteLayout
int32_t SDDS_WriteLayout(SDDS_DATASET *SDDS_dataset)
Writes the SDDS layout header to the output file.
Definition SDDS_output.c:893
SDDS_TransferColumnDefinition
int32_t SDDS_TransferColumnDefinition(SDDS_DATASET *target, SDDS_DATASET *source, char *name, char *newName)
Transfers a column definition from a source dataset to a target dataset.
Definition SDDS_transfer.c:35

◆ WriteOutputPage()

void WriteOutputPage ( SDDS_DATASET * SDDS_out,
char * xCol,
char * yCol,
char * zCol,
specs * spec,
int nout,
point * pout,
long writepage )

Definition at line 735 of file sdds2dinterpolate.c.

735 {
736 char tmpstr[256];
737 int i;
738
739 if (!SDDS_StartPage(SDDS_out, nout))
740 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
741 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE,
742 "Variable1Name", xCol,
743 "Variable2Name", yCol, NULL))
744 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
745 sprintf(tmpstr, "%sDimension", xCol);
746 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, tmpstr, spec->nx, NULL))
747 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
748 sprintf(tmpstr, "%sDimension", yCol);
749 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, tmpstr, spec->ny, NULL))
750 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
751 sprintf(tmpstr, "%sInterval", xCol);
752 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, tmpstr, spec->dx, NULL))
753 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
754 sprintf(tmpstr, "%sInterval", yCol);
755 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, tmpstr, spec->dy, NULL))
756 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
757 sprintf(tmpstr, "%sMinimum", xCol);
758 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, tmpstr, spec->xmin, NULL))
759 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
760 sprintf(tmpstr, "%sMinimum", yCol);
761 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, tmpstr, spec->ymin, NULL))
762 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
763 sprintf(tmpstr, "%sMaximum", xCol);
764 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, tmpstr, spec->xmax, NULL))
765 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
766 sprintf(tmpstr, "%sMaximum", yCol);
767 if (!SDDS_SetParameters(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, tmpstr, spec->ymax, NULL))
768 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
769 for (i = 0; i < nout; i++) {
770 if (!SDDS_SetRowValues(SDDS_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, i,
771 xCol, pout[i].x,
772 yCol, pout[i].y,
773 zCol, pout[i].z, NULL))
774 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
775 }
776 if (writepage && !SDDS_WritePage(SDDS_out))
777 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
778}
SDDS_StartPage
int32_t SDDS_StartPage(SDDS_DATASET *SDDS_dataset, int64_t expected_n_rows)
Definition SDDS_dataprep.c:64
SDDS_SetParameters
int32_t SDDS_SetParameters(SDDS_DATASET *SDDS_dataset, int32_t mode,...)
Definition SDDS_dataprep.c:369

Variable Documentation

◆ algorithm_option

char* algorithm_option[ALGORITHMS] = {"nn", "csa"}

Definition at line 139 of file sdds2dinterpolate.c.

139{"nn", "csa"};

◆ INFINITY_OPTION

char* INFINITY_OPTION[1] = {"infinity"}
static

Definition at line 154 of file sdds2dinterpolate.c.

154{"infinity"};

◆ option

char* option[N_OPTIONS]
Initial value:
= {
"pipe", "independentColumn", "dependentColumn", "scale",
"outDimension", "range", "zoom", "dimensionThin", "clusterThin",
"preprocess", "algorithm", "weight", "vertex", "npoints", "verbose", "merge", "file", "majorOrder"}

Definition at line 78 of file sdds2dinterpolate.c.

78 {
79 "pipe", "independentColumn", "dependentColumn", "scale",
80 "outDimension", "range", "zoom", "dimensionThin", "clusterThin",
81 "preprocess", "algorithm", "weight", "vertex", "npoints", "verbose", "merge", "file", "majorOrder"};

◆ scale_option

char* scale_option[SCALE_OPTIONS] = {"circle", "square"}

Definition at line 142 of file sdds2dinterpolate.c.

142{"circle", "square"};

◆ USAGE

const char* USAGE
static

Definition at line 83 of file sdds2dinterpolate.c.

Generated by doxygen 1.12.0