/* GNUPLOT - plot2d.c */

/*[

* Copyright 1986 - 1993, 1998, 2004 Thomas Williams, Colin Kelley

*

* Permission to use, copy, and distribute this software and its

* documentation for any purpose with or without fee is hereby granted,

* provided that the above copyright notice appear in all copies and

* that both that copyright notice and this permission notice appear

* in supporting documentation.

*

* Permission to modify the software is granted, but not the right to

* distribute the complete modified source code. Modifications are to

* be distributed as patches to the released version. Permission to

* distribute binaries produced by compiling modified sources is granted,

* provided you

* 1. distribute the corresponding source modifications from the

* released version in the form of a patch file along with the binaries,

* 2. add special version identification to distinguish your version

* in addition to the base release version number,

* 3. provide your name and address as the primary contact for the

* support of your modified version, and

* 4. retain our contact information in regard to use of the base

* software.

* Permission to distribute the released version of the source code along

* with corresponding source modifications in the form of a patch file is

* granted with same provisions 2 through 4 for binary distributions.

*

* This software is provided "as is" without express or implied warranty

* to the extent permitted by applicable law.

]*/

#include "gp_types.h"

#include "plot2d.h"

#include "alloc.h"

#include "axis.h"

#include "command.h"

#include "datafile.h"

#include "datablock.h"

#include "encoding.h"

#include "eval.h"

#include "filters.h"

#include "fit.h"

#include "gplocale.h"

#include "graphics.h"

#include "interpol.h"

#include "misc.h"

#include "parse.h"

#include "pm3d.h" /* for is_plot_with_palette */

#include "setshow.h"

#include "tables.h"

#include "tabulate.h"

#include "term_api.h"

#include "util.h"

#include "watch.h"

/* minimum size of points[] in curve_points */

#define MIN_CRV_POINTS 100

/* static prototypes */

static struct curve_points * cp_alloc(int num);

static int get_data(struct curve_points *);

static void store2d_point(struct curve_points *, int i, double x, double y, double xlow, double xhigh, double ylow, double yhigh, double width);

static void eval_plots(void);

static void parametric_fixup(struct curve_points * start_plot, int *plot_num);

static void box_range_fiddling(struct curve_points *plot);

static void boxplot_range_fiddling(struct curve_points *plot);

static void spiderplot_range_fiddling(struct curve_points *plot);

static void histogram_range_fiddling(struct curve_points *plot);

static void impulse_range_fiddling(struct curve_points *plot);

static void parallel_range_fiddling(struct curve_points *plot);

static int check_or_add_boxplot_factor(struct curve_points *plot, char* string, double x);

static void add_tics_boxplot_factors(struct curve_points *plot);

static void parse_kdensity_options(struct curve_points *this_plot);

static void parse_hull_options(struct curve_points *this_plot);

static int evaluate_iteration(struct curve_points *this_plot);

#ifdef USE_POLAR_GRID

static void grid_polar_data(struct curve_points *this_plot);

static double polar_dist( double t_data, double r_data, double t_grid, double r_grid );

static void store_polar_point(struct curve_points *, int i, double v[MAXDATACOLS]);

struct pgrid default_polar_grid = {

.mode = DGRID3D_QNORM,

.theta_segments = 24,

.r_segments = 10,

.norm_q = 1,

.kdensity = FALSE,

.scale = 1.0,

.rmin = 0.0,

.rmax = VERYLARGE

};

struct pgrid polar_grid;

#endif /* USE_POLAR_GRID */

/* internal and external variables */

/* the curves/surfaces of the plot */

struct curve_points *first_plot = NULL;

static double histogram_rightmost = 0.0; /* Highest x-coord of histogram so far */

static text_label histogram_title; /* Subtitle for this histogram */

static int stack_count = 0; /* counter for stackheight */

static struct coordinate *stackheight = NULL; /* Scratch space for y autoscale */

static int paxis_start, paxis_end, paxis_current; /* PARALLELPLOT bookkeeping */

/* If the user tries to plot a complex-valued function without reducing it to

* some derived value like abs(f(z)), it generates a non-obvious error message

* "all points y value undefined". Try to detect this case by counting complex

* values as they are encountered so that a better error message is possible.

*/

static int n_complex_values = 0;

/* function implementations */

/*

* cp_alloc() allocates a curve_points structure that can hold 'num'

* points. Initialize all fields to NULL.

*/

static struct curve_points *

cp_alloc(int num)

{

struct curve_points *cp;

struct lp_style_type default_lp_properties = DEFAULT_LP_STYLE_TYPE;

cp = (struct curve_points *) gp_alloc(sizeof(struct curve_points), "curve");

memset(cp, 0, sizeof(struct curve_points));

cp->p_max = (num >= 0 ? num : 0);

if (num > 0) {

cp->points = (struct coordinate *)

gp_alloc(num * sizeof(struct coordinate), "curve points");

memset(cp->points, 0, num * sizeof(struct coordinate));

}

/* Initialize various fields */

cp->lp_properties = default_lp_properties;

default_arrow_style(&(cp->arrow_properties));

cp->fill_properties = default_fillstyle;

cp->filledcurves_options = filledcurves_opts_data;

return (cp);

}

/*

* cp_extend() reallocates a curve_points structure to hold "num"

* points. This will either expand or shrink the storage.

*/

void

cp_extend(struct curve_points *cp, int num)

{

if (num == cp->p_max)

return;

if (num > 0) {

cp->points = gp_realloc(cp->points, num * sizeof(cp->points[0]),

"expanding 2D points");

if (cp->varcolor)

cp->varcolor = gp_realloc(cp->varcolor, num * sizeof(double),

"expanding curve variable colors");

cp->p_max = num;

cp->p_max -= 1; /* Set trigger point for reallocation ahead of */

/* true end in case two slots are used at once */

/* (e.g. redundant final point of closed curve) */

} else {

free(cp->points);

cp->points = NULL;

cp->p_max = 0;

free(cp->varcolor);

cp->varcolor = NULL;

if (cp->labels)

free_labels(cp->labels);

cp->labels = NULL;

}

}

/*

* cp_free() releases any memory which was previously malloc()'d to hold

* curve points (and recursively down the linked list).

*/

void

cp_free(struct curve_points *cp)

{

while (cp) {

struct curve_points *next = cp->next;

free(cp->title);

cp->title = NULL;

free(cp->title_position);

cp->title_position = NULL;

free(cp->points);

cp->points = NULL;

free(cp->varcolor);

cp->varcolor = NULL;

if (cp->labels)

free_labels(cp->labels);

cp->labels = NULL;

free_at(cp->plot_function.at);

free_watchlist(cp->watchlist);

cp->watchlist = NULL;

free(cp);

cp = next;

}

}

/*

* In the parametric case we can say plot [a= -4:4] [-2:2] [-1:1] sin(a),a**2

* while in the non-parametric case we would say only plot [b= -2:2] [-1:1]

* sin(b)

*/

void

plotrequest()

{

int dummy_token = 0;

AXIS_INDEX axis;

if (!term) /* unknown */

int_error(c_token, "use 'set term' to set terminal type first");

is_3d_plot = FALSE;

if (parametric && strcmp(set_dummy_var[0], "u") == 0)

strcpy(set_dummy_var[0], "t");

/* initialize the arrays from the 'set' scalars */

axis_init(&axis_array[FIRST_X_AXIS], FALSE);

axis_init(&axis_array[FIRST_Y_AXIS], TRUE);

axis_init(&axis_array[SECOND_X_AXIS], FALSE);

axis_init(&axis_array[SECOND_Y_AXIS], TRUE);

axis_init(&axis_array[T_AXIS], FALSE);

axis_init(&axis_array[U_AXIS], FALSE);

axis_init(&axis_array[V_AXIS], FALSE);

axis_init(&axis_array[POLAR_AXIS], TRUE);

axis_init(&axis_array[COLOR_AXIS], TRUE);

/* Always be prepared to restore the autoscaled values on "refresh"

* Dima Kogan April 2018

*/

for (axis = 0; axis < NUMBER_OF_MAIN_VISIBLE_AXES; axis++) {

AXIS *this_axis = &axis_array[axis];

if (this_axis->set_autoscale != AUTOSCALE_NONE)

this_axis->range_flags |= RANGE_WRITEBACK;

}

/* Nonlinear mapping of x or y via linkage to a hidden primary axis. */

/* The user set autoscale for the visible axis; apply it also to the hidden axis. */

for (axis = 0; axis < NUMBER_OF_MAIN_VISIBLE_AXES; axis++) {

AXIS *secondary = &axis_array[axis];

if (axis == SAMPLE_AXIS)

continue;

if (secondary->linked_to_primary

&& secondary->linked_to_primary->index == -secondary->index) {

AXIS *primary = secondary->linked_to_primary;

primary->set_autoscale = secondary->set_autoscale;

axis_init(primary, 1);

}

}

/* If we are called from a mouse zoom operation we should ignore */

/* any range limits because otherwise the zoom won't zoom. */

if (inside_zoom) {

while (equals(c_token,"["))

parse_skip_range();

}

/* Range limits for the entire plot are optional but must be given */

/* in a fixed order. The keyword 'sample' terminates range parsing. */

if (parametric || polar) {

dummy_token = parse_range(T_AXIS);

parse_range(FIRST_X_AXIS);

} else {

dummy_token = parse_range(FIRST_X_AXIS);

}

parse_range(FIRST_Y_AXIS);

parse_range(SECOND_X_AXIS);

parse_range(SECOND_Y_AXIS);

if (equals(c_token,"sample") && equals(c_token+1,"["))

c_token++;

/* Clear out any tick labels read from data files in previous plot */

for (axis=0; axis<AXIS_ARRAY_SIZE; axis++) {

struct ticdef *ticdef = &axis_array[axis].ticdef;

if (ticdef->def.user)

ticdef->def.user = prune_dataticks(ticdef->def.user);

if (!ticdef->def.user && ticdef->type == TIC_USER)

ticdef->type = TIC_COMPUTED;

}

for (axis=0; axis<num_parallel_axes; axis++) {

struct ticdef *ticdef = &parallel_axis_array[axis].ticdef;

if (ticdef->def.user)

ticdef->def.user = prune_dataticks(ticdef->def.user);

if (!ticdef->def.user && ticdef->type == TIC_USER)

ticdef->type = TIC_COMPUTED;

}

/* use the default dummy variable unless changed */

if (dummy_token > 0)

copy_str(c_dummy_var[0], dummy_token, MAX_ID_LEN);

else

strcpy(c_dummy_var[0], set_dummy_var[0]);

eval_plots();

}

/* Helper function for refresh command. Reexamine each data point and update the

* flags for INRANGE/OUTRANGE/UNDEFINED based on the current limits for that axis.

* Normally the axis limits are already known at this point. But if the user has

* forced "set autoscale" since the previous plot or refresh, we need to reset the

* axis limits and try to approximate the full auto-scaling behaviour.

*/

void

refresh_bounds(struct curve_points *first_plot, int nplots)

{

struct curve_points *this_plot = first_plot;

int iplot; /* plot index */

for (iplot = 0; iplot < nplots; iplot++, this_plot = this_plot->next) {

int i; /* point index */

struct axis *x_axis = &axis_array[this_plot->x_axis];

struct axis *y_axis = &axis_array[this_plot->y_axis];

/* IMAGE clipping is done elsewhere, so we don't need INRANGE/OUTRANGE checks */

if (this_plot->plot_style == IMAGE || this_plot->plot_style == RGBIMAGE) {

if (x_axis->set_autoscale || y_axis->set_autoscale)

process_image(this_plot, IMG_UPDATE_AXES);

continue;

}

for (i=0; i<this_plot->p_count; i++) {

struct coordinate *point = &this_plot->points[i];

if (point->type == UNDEFINED)

continue;

else

point->type = INRANGE;

/* This autoscaling logic is identical to that in

* refresh_3dbounds() in plot3d.c

*/

if (!this_plot->noautoscale) {

autoscale_one_point(x_axis, point->x);

if (this_plot->plot_style & PLOT_STYLE_HAS_VECTOR)

autoscale_one_point(x_axis, point->xhigh);

}

if (!inrange(point->x, x_axis->min, x_axis->max)) {

point->type = OUTRANGE;

continue;

}

if (!this_plot->noautoscale) {

autoscale_one_point(y_axis, point->y);

if (this_plot->plot_style == VECTOR)

autoscale_one_point(y_axis, point->yhigh);

}

if (!inrange(point->y, y_axis->min, y_axis->max)) {

point->type = OUTRANGE;

continue;

}

}

if (this_plot->plot_style == BOXES || this_plot->plot_style == IMPULSES)

impulse_range_fiddling(this_plot);

}

this_plot = first_plot;

for (iplot = 0; iplot < nplots; iplot++, this_plot = this_plot->next) {

/* handle 'reverse' ranges */

axis_check_range( this_plot->x_axis );

axis_check_range( this_plot->y_axis );

/* Make sure the bounds are reasonable, and tweak them if they aren't */

axis_checked_extend_empty_range(this_plot->x_axis, NULL);

axis_checked_extend_empty_range(this_plot->y_axis, NULL);

}

}

/* current_plot->token is after datafile spec, for error reporting

* it will later be moved past title/with/linetype/pointtype

*/

static int

get_data(struct curve_points *current_plot)

{

int i /* num. points ! */ , j;

int ngood;

int max_cols, min_cols; /* allowed range of column numbers */

struct coordinate *cp;

double v[MAXDATACOLS];

memset(v, 0, sizeof(v));

if (current_plot->varcolor == NULL) {

TBOOLEAN variable_color = FALSE;

if ((current_plot->lp_properties.pm3d_color.type == TC_RGB)

&& (current_plot->lp_properties.pm3d_color.value < 0))

variable_color = TRUE;

if (current_plot->lp_properties.pm3d_color.type == TC_Z)

variable_color = TRUE;

if (current_plot->lp_properties.pm3d_color.type == TC_COLORMAP)

variable_color = TRUE;

if (current_plot->lp_properties.l_type == LT_COLORFROMCOLUMN)

variable_color = TRUE;

if ((current_plot->plot_style == VECTOR || current_plot->plot_style == ARROWS)

&& (current_plot->arrow_properties.tag == AS_VARIABLE))

variable_color = TRUE;

if (current_plot->plot_smooth != SMOOTH_NONE) {

/* FIXME: It would be possible to support smooth cspline lc palette */

/* but it would require expanding and interpolating plot->varcolor */

/* in parallel with the y values. */

variable_color = FALSE;

}

if (variable_color) {

current_plot->varcolor = gp_alloc(current_plot->p_max * sizeof(double),

"varcolor array");

}

}

/* eval_plots has already opened file */

/* HBB 2000504: For most 2D plot styles the 'z' coordinate is unused.

* Set it to NO_AXIS to account for that. For styles that use

* the z coordinate as a real coordinate (i.e. not a width or

* 'delta' component, change the setting inside the switch: */

if ((current_plot->plot_filter == FILTER_ZSORT)

|| (current_plot->plot_style == SURFACEGRID)) {

current_plot->z_axis = FIRST_Z_AXIS;

axis_init(&axis_array[FIRST_Z_AXIS], TRUE);

} else

current_plot->z_axis = NO_AXIS;

/* HBB NEW 20060427: if there's only one, explicit using column,

* it's y data. df_axis[] has to reflect that, so df_readline()

* will expect time/date input. */

if (df_no_use_specs == 1)

df_axis[0] = df_axis[1];

switch (current_plot->plot_style) { /* set maximum columns to scan */

case XYERRORLINES:

case XYERRORBARS:

case BOXXYERROR:

min_cols = 4;

max_cols = 7;

if (df_no_use_specs >= 6) {

/* HBB 20060427: signal 3rd and 4th column are absolute x

* data --- needed so time/date parsing works */

df_axis[2] = df_axis[3] = df_axis[0];

/* and 5th and 6th are absolute y data */

df_axis[4] = df_axis[5] = df_axis[1];

}

break;

case FINANCEBARS:

/* HBB 20000504: use 'z' coordinate for y-axis quantity */

current_plot->z_axis = current_plot->y_axis;

min_cols = 5;

max_cols = 6;

/* HBB 20060427: signal 3rd and 4th column are absolute y data

* --- needed so time/date parsing works */

df_axis[2] = df_axis[3] = df_axis[4] = df_axis[1];

break;

case BOXPLOT:

min_cols = 2; /* fixed x, lots of y data points */

max_cols = 4; /* optional width, optional factor */

expect_string( 4 );

break;

case CANDLESTICKS:

current_plot->z_axis = current_plot->y_axis;

min_cols = 5;

max_cols = 7;

df_axis[2] = df_axis[3] = df_axis[4] = df_axis[1];

break;

case BOXERROR:

min_cols = 3;

max_cols = 6;

/* There are four possible cases: */

/* 3 cols --> (x,y,dy), auto dx */

/* 4 cols, boxwidth==-2 --> (x,y,ylow,yhigh), auto dx */

/* 4 cols, boxwidth!=-2 --> (x,y,dy,dx) */

/* 5 cols --> (x,y,ylow,yhigh,dx) */

/* In each case an additional column may hold variable color */

if ((df_no_use_specs == 4 && boxwidth == -2)

|| df_no_use_specs >= 5)

/* HBB 20060427: signal 3rd and 4th column are absolute y

* data --- needed so time/date parsing works */

df_axis[2] = df_axis[3] = df_axis[1];

break;

case VECTOR: /* x, y, dx, dy, variable arrow style and/or variable color */

case ARROWS: /* x, y, len, ang, variable arrow style and/or variable color */

min_cols = 4;

max_cols = 6;

break;

case XERRORLINES:

case XERRORBARS:

min_cols = 3;

max_cols = 5;

if (df_no_use_specs >= 4)

/* HBB 20060427: signal 3rd and 4th column are absolute x

* data --- needed so time/date parsing works */

df_axis[2] = df_axis[3] = df_axis[0];

break;

case YERRORLINES:

case YERRORBARS:

min_cols = 2;

max_cols = 7;

if (df_no_use_specs >= 4)

/* HBB 20060427: signal 3rd and 4th column are absolute y

* data --- needed so time/date parsing works */

df_axis[2] = df_axis[3] = df_axis[1];

break;

case HISTOGRAMS:

min_cols = 1;

max_cols = 3;

/* Stacked histogram get out of sync if "missing" values in the

* input data are silently ignored. require_value() forces a

* value of NaN to be returned in this case.

*/

if (histogram_opts.type == HT_STACKED_IN_TOWERS

|| histogram_opts.type == HT_STACKED_IN_LAYERS)

require_value(1);

break;

case BOXES:

case HSTEPS:

/* 1 column: y coordinate only */

/* 2 columns: x and y coordinates */

/* 3 columns: x and y coordinates and width */

/* extra columns allow variable colors */

min_cols = 1;

max_cols = 4;

break;

case FILLEDCURVES:

min_cols = 1;

max_cols = 3;

df_axis[2] = df_axis[1]; /* Both curves use same y axis */

break;

case IMPULSES: /* 2 + possible variable color */

case HISTEPS:

case FILLSTEPS:

case POLYGONS:

case LINES:

case DOTS:

min_cols = 1;

max_cols = 3;

break;

case LABELPOINTS:

/* 3 column data: X Y Label */

/* extra columns allow variable pointsize, pointtype, and/or rotation */

min_cols = 3;

max_cols = 6;

expect_string( 3 );

break;

case IMAGE:

min_cols = 3;

max_cols = 3;

break;

case RGBIMAGE:

min_cols = 3;

max_cols = 6;

break;

case RGBA_IMAGE:

min_cols = 3;

max_cols = 6;

break;

case CIRCLES: /* 3 + possible variable color, or 5 + possible variable color */

min_cols = 2;

max_cols = 6;

break;

case SECTORS: /* 3 + possible variable color, or 4 + possible variable color */

min_cols = 4;

max_cols = 7;

break;

case ELLIPSES:

min_cols = 2; /* x, y, major axis, minor axis */

max_cols = 6; /* + optional angle, possible variable color */

break;

case POINTSTYLE:

case LINESPOINTS:

/* 1 column: y coordinate only */

/* 2 columns x and y coordinates */

/* Allow 1 extra column because of 'pointsize variable' */

/* Allow 1 extra column because of 'pointtype variable' */

/* Allow 1 extra column because of 'lc rgb variable' */

min_cols = 1;

max_cols = 5;

break;

case PARALLELPLOT:

case SPIDERPLOT:

/* 1 column: y coordinate only */

/* extra columns for variable color, pointtype, etc */

min_cols = 1;

max_cols = 4;

break;

case TABLESTYLE:

min_cols = 1;

max_cols = MAXDATACOLS;

break;

case SURFACEGRID:

min_cols = 3;

max_cols = 3;

break;

default:

min_cols = 1;

max_cols = 2;

break;

}

/* Restictions on plots with "smooth" option */

switch (current_plot->plot_smooth) {

case SMOOTH_NONE:

break;

case SMOOTH_ACSPLINES:

max_cols++;

break;

default:

if (df_no_use_specs > 2 && current_plot->plot_style != FILLEDCURVES

&& current_plot->plot_filter != FILTER_ZSORT)

int_warn(NO_CARET, "extra columns ignored by smoothing option");

break;

}

if (current_plot->plot_smooth && current_plot->plot_style == FILLEDCURVES) {

if (current_plot->filledcurves_options.closeto == FILLEDCURVES_CLOSED) {

if (current_plot->plot_smooth == SMOOTH_CSPLINES)

current_plot->plot_smooth = SMOOTH_PATH;

if (current_plot->plot_smooth != SMOOTH_PATH) {

current_plot->plot_smooth = SMOOTH_NONE;

int_warn(NO_CARET, "only 'smooth path' or 'smooth cspline' is supported for closed curves");

}

}

}

/* May 2013 - Treating timedata columns as strings allows

* functions column(N) and column("HEADER") to work on time data.

* Sep 2014: But the column count is wrong for HISTOGRAMS

*/

if (current_plot->plot_style != HISTOGRAMS) {

if (axis_array[current_plot->x_axis].datatype == DT_TIMEDATE)

expect_string(1);

if (axis_array[current_plot->y_axis].datatype == DT_TIMEDATE)

expect_string(2);

}

if (df_no_use_specs > max_cols)

int_warn(NO_CARET, "more using specs than expected for this style");

if (df_no_use_specs > 0 && df_no_use_specs < min_cols)

int_error(NO_CARET, "Not enough columns for this style");

i = 0; ngood = 0;

/* If the user has set an explicit locale for numeric input, apply it */

/* here so that it affects data fields read from the input file. */

set_numeric_locale();

/* Initial state */

df_warn_on_missing_columnheader = TRUE;

while ((j = df_readline(v, max_cols)) != DF_EOF) {

if (i >= current_plot->p_max) {

/* overflow about to occur. Extend size of points[]

* array. Double the size, and add 1000 points, to avoid

* needlessly small steps. */

cp_extend(current_plot, i + i + 1000);

}

/* Assume range is OK; we will check later */

current_plot->points[i].type = (j == 0) ? UNDEFINED : INRANGE;

/* First handle all the special cases (j <= 0) */

switch (j) {

case 0:

df_close();

int_error(current_plot->token, "Bad data on line %d of file %s",

df_line_number, df_filename ? df_filename : "");

continue;

case DF_COMPLEX_VALUE:

n_complex_values++;

fprintf(stderr,"plot2d.c:%d caught a complex value\n",__LINE__);

/* Fall through to normal undefined case */

case DF_UNDEFINED:

/* Version 5 - We are now trying to pass back all available info even

* if one of the requested columns was missing or undefined.

*/

current_plot->points[i].type = UNDEFINED;

if (missing_val && !strcmp(missing_val, "NaN")) {

j = DF_MISSING;

/* fall through to short-circuit for missing data */

} else {

j = df_no_use_specs;

break;

/* continue with normal processing for this line */

}

case DF_MISSING:

/* Plot type specific handling of missing points goes here. */

if ((current_plot->plot_style == PARALLELPLOT)

|| (current_plot->plot_style == SPIDERPLOT)) {

current_plot->points[i].type = UNDEFINED;

j = df_no_use_specs;

break;

}

if (current_plot->plot_style == HISTOGRAMS) {

current_plot->points[i].type = UNDEFINED;

i++;

}

if (current_plot->plot_style == TABLESTYLE) {

j = df_no_use_specs;

break;

}

continue;

case DF_FIRST_BLANK:

/* The binary input routines generate DF_FIRST_BLANK at the end

* of scan lines, so that the data may be used for the isometric

* splots. Rather than turning that off inside the binary

* reading routine based upon the plot mode, DF_FIRST_BLANK is

* ignored for certain plot types requiring 3D coordinates in

* MODE_PLOT.

*/

if (current_plot->plot_style == IMAGE

|| current_plot->plot_style == RGBIMAGE

|| current_plot->plot_style == RGBA_IMAGE)

continue;

/* make type of next point undefined, but recognizable */

current_plot->points[i] = blank_data_line;

i++;

continue;

case DF_SECOND_BLANK:

/* second blank line. We dont do anything

* (we did everything when we got FIRST one)

*/

continue;

case DF_FOUND_KEY_TITLE:

df_set_key_title(current_plot);

continue;

case DF_KEY_TITLE_MISSING:

fprintf(stderr,"get_data: key title not found in requested column\n");

continue;

case DF_COLUMN_HEADERS:

continue;

default:

if (j < 0) {

df_close();

int_error(c_token,

"internal error : df_readline returned %d : datafile line %d",

j, df_line_number);

}

break; /* Not continue!! */

}

/* We now know that j > 0, i.e. there is some data on this input line */

ngood++;

/* "plot ... with table" bypasses all the column interpretation */

if (current_plot->plot_style == TABLESTYLE) {

tabulate_one_line(v, df_strings, j);

continue;

}

/* June 2010 - New mechanism for variable color */

/* If variable color is requested, take the color value from the */

/* final column of input and decrement the column count by one. */

if (current_plot->varcolor) {

static char *errmsg = "Not enough columns for variable color";

switch (current_plot->plot_style) {

case CANDLESTICKS:

case FINANCEBARS:

if (j < 6) int_error(NO_CARET,errmsg);

break;

case XYERRORLINES:

case XYERRORBARS:

case BOXXYERROR:

if (j != 7 && j != 5) int_error(NO_CARET,errmsg);

break;

case VECTOR:

case ARROWS:

if (j < 5) int_error(NO_CARET,errmsg);

/* j can be 5 if the variable styles have constant color */

if (j == 5 && current_plot->arrow_properties.tag == AS_VARIABLE)

v[j++] = 0;

break;

case LABELPOINTS:

case BOXERROR:

case XERRORLINES:

case XERRORBARS:

case YERRORLINES:

case YERRORBARS:

if (j < 4) int_error(NO_CARET,errmsg);

break;

case CIRCLES:

if (j == 5 || j < 3) int_error(NO_CARET,errmsg);

break;

case SECTORS:

if (j < 4) int_error(NO_CARET,errmsg);

break;

case ELLIPSES:

case BOXES:

case POINTSTYLE:

case LINESPOINTS:

case IMPULSES:

case LINES:

case DOTS:

if (j < 3) int_error(NO_CARET,errmsg);

break;

case PARALLELPLOT:

case SPIDERPLOT:

if (j < 1) int_error(NO_CARET,errmsg);

break;

case BOXPLOT:

/* Only the key sample uses this value */

v[j++] = current_plot->base_linetype + 1;

break;

default:

break;

}

current_plot->varcolor[i] = v[--j];

}

/* Unusual special cases */

/* In spiderplots the implicit "x coordinate" v[0] is really the axis number. */

/* Add this at the front and shift all other using specs to the right. */

if (spiderplot) {

int is;

for (is=j++; is>0; is--)

v[is] = v[is-1];

v[0] = paxis_current;

}

/* Single data value - is it y with implicit x or something else? */

if (j == 1 && !(current_plot->plot_style == HISTOGRAMS)) {

if (default_smooth_weight(current_plot->plot_smooth))

v[1] = 1.0;

else if (current_plot->plot_filter == FILTER_BINS)

v[1] = 1.0;

else {

v[1] = v[0];

v[0] = df_datum;

}

j = 2;

}

/* May 2018: The huge switch statement below is now organized by plot */

/* style. Each plot style can have its own understanding of what the */

/* value in a particular field of the "using" specifier represents. */

/* E.g. the 3rd field might be z or radius or color. */

switch (current_plot->plot_style) {

case LINES:

case DOTS:

case IMPULSES:

{ /* x y [acspline weight] */

coordval w; /* only for (current_plot->plot_smooth == SMOOTH_ACSPLINES) */

w = (j > 2) ? v[2] : 1.0;

store2d_point(current_plot, i++, v[0], v[1],

v[0], v[0], v[1], v[1], w);

break;

}

case POINTSTYLE:

case LINESPOINTS:

{ /* x y {z} {var_ps} {var_pt} {lc variable} */

/* NB: assumes CRD_PTSIZE == xlow CRD_PTTYPE == xhigh CRD_PTCHAR == ylow */

int var = 2; /* column number for next variable spec */

coordval weight = (current_plot->plot_smooth == SMOOTH_ACSPLINES) ? v[2] : 1.0;

coordval var_ps = current_plot->lp_properties.p_size;

coordval var_pt = current_plot->lp_properties.p_type;

coordval var_char = 0;

if (current_plot->plot_filter == FILTER_ZSORT)

weight = v[var++];

if (var_ps == PTSZ_VARIABLE)

var_ps = v[var++];

if (var_pt == PT_VARIABLE) {

if (isnan(v[var]) && df_tokens[var]) {

safe_strncpy( (char *)(&var_char), df_tokens[var], sizeof(coordval));

truncate_to_one_utf8_char((char *)(&var_char));

}

var_pt = v[var++];

}

if (var > j)

int_error(NO_CARET, "Not enough using specs");

if (var_pt < 0)

var_pt = 0;

store2d_point(current_plot, i++, v[0], v[1],

var_ps, var_pt, var_char, v[1], weight);

break;

}

case LABELPOINTS:

{ /* x y string {rotate variable}

* {point {pt variable} {ps variable}}

* {tc|lc variable}

*/

int var = 3; /* column number for next variable spec */

coordval var_rotation = current_plot->labels->rotate;

coordval var_ps = current_plot->labels->lp_properties.p_size;

coordval var_pt = current_plot->labels->lp_properties.p_type;

if (current_plot->labels->tag == LABEL_TAG_VARIABLE_ROTATE)

var_rotation = v[var++];

if (var_ps == PTSZ_VARIABLE)

var_ps = v[var++];

if (var_pt == PT_VARIABLE)

var_pt = v[var++] - 1;

if (var > j)

int_error(NO_CARET, "Not enough using specs");

store2d_point(current_plot, i, v[0], v[1],

var_ps, var_pt, var_rotation, v[1], 0.0);

/* Allocate and fill in a text_label structure to match it */

if (current_plot->points[i].type != UNDEFINED) {

store_label(current_plot->labels, &(current_plot->points[i]),

i, df_tokens[2],

current_plot->varcolor ? current_plot->varcolor[i] : 0.0);

}

i++;

break;

}

case STEPS:

case FSTEPS:

case FILLSTEPS:

case HISTEPS:

{ /* x y */

store2d_point(current_plot, i++, v[0], v[1],

v[0], v[0], v[1], v[1], -1.0);

break;

}

case CANDLESTICKS:

case FINANCEBARS:

{ /* x yopen ylow yhigh yclose [xhigh] */

coordval yopen = v[1];

coordval ylow = v[2];

coordval yhigh = v[3];

coordval yclose = v[4];

coordval xlow = v[0];

coordval xhigh = v[0];

/* NB: plot_c_bars will set xhigh = xlow + 2*(x-xlow) */

if (j > 5 && v[5] > 0)

xlow = v[0] - v[5]/2.;

store2d_point(current_plot, i++, v[0], yopen,

xlow, xhigh, ylow, yhigh, yclose);

break;

}

case XERRORLINES:

case XERRORBARS:

{ /* x y xdelta or x y xlow xhigh */

coordval xlow = (j > 3) ? v[2] : v[0] - v[2];

coordval xhigh = (j > 3) ? v[3] : v[0] + v[2];

store2d_point(current_plot, i++, v[0], v[1],

xlow, xhigh, v[1], v[1], 0.0);

break;

}

case YERRORLINES:

case YERRORBARS:

{ /* NB: assumes CRD_PTSIZE == xlow CRD_PTTYPE == xhigh CRD_PTCHAR == ylow

lc variable, if present, was already extracted and j reduced by 1