#ifndef lint

static char *RCSid() { return RCSid("$Id: plot2d.c,v 1.263 2012/04/18 00:13:46 sfeam Exp $"); }

#endif

/* 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 "binary.h"

#include "command.h"

#include "datafile.h"

#include "eval.h"

#include "fit.h"

#include "graphics.h"

#include "interpol.h"

#include "misc.h"

#include "parse.h"

#include "setshow.h"

#include "tables.h"

#include "tabulate.h"

#include "term_api.h"

#include "util.h"

#include "variable.h" /* For locale handling */

#ifndef _Windows

# include "help.h"

#endif

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

#define MIN_CRV_POINTS 100

/* static prototypes */

static struct curve_points * cp_alloc __PROTO((int num));

static int get_data __PROTO((struct curve_points *));

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

static void eval_plots __PROTO((void));

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

static void box_range_fiddling __PROTO((struct curve_points *plot));

static void boxplot_range_fiddling __PROTO((struct curve_points *plot));

static void histogram_range_fiddling __PROTO((struct curve_points *plot));

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

static void add_tics_boxplot_factors __PROTO((struct curve_points *plot));

static void sort_boxplot_factors __PROTO((struct curve_points *plot));

static int compare_boxplot_factors __PROTO((SORTFUNC_ARGS arg1, SORTFUNC_ARGS arg2));

/* internal and external variables */

/* the curves/surfaces of the plot */

struct curve_points *first_plot = NULL;

static struct udft_entry plot_func;

/* box width (automatic) */

double boxwidth = -1.0;

/* whether box width is absolute (default) or relative */

TBOOLEAN boxwidth_is_absolute = TRUE;

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

static char *histogram_title = NULL; /* Subtitle for this histogram */

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

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

/* function implementations */

/* HBB 20000508: moved cp_alloc() &friends to the main module using them, and

* made cp_alloc 'static'.

*/

/*

* 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 GPHUGE *)

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

/* Initialize various fields */

cp->lp_properties = default_lp_properties;

default_arrow_style(&(cp->arrow_properties));

cp->fill_properties = default_fillstyle;

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) {

if (cp->points == NULL) {

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

"curve points");

} else {

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

"expanding curve points");

if (cp->varcolor)

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

"expanding curve variable colors");

}

cp->p_max = num;

} else {

free(cp->points);

cp->points = NULL;

cp->p_max = 0;

free(cp->varcolor);

cp->varcolor = NULL;

}

}

/*

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

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

*/

/* HBB 20000506: instead of risking stack havoc by recursion, operate

* iteratively */

void

cp_free(struct curve_points *cp)

{

while (cp) {

struct curve_points *next = cp->next;

free(cp->title);

cp->title = NULL;

free(cp->points);

cp->points = NULL;

free(cp->varcolor);

cp->varcolor = NULL;

if (cp->labels)

free_labels(cp->labels);

cp->labels = NULL;

free(cp->boxplot_factor_order);

cp->boxplot_factor_order = 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 = -1;

int t_axis;

if (!term) /* unknown */

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

is_3d_plot = FALSE;

/* Deactivate if 'set view map' is still running after the previous 'splot': */

/* EAM Jan 2012 - this should no longer be necessary, but it doesn't hurt. */

splot_map_deactivate();

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

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

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

AXIS_INIT2D(FIRST_X_AXIS, 0);

AXIS_INIT2D(FIRST_Y_AXIS, 1);

AXIS_INIT2D(SECOND_X_AXIS, 0);

AXIS_INIT2D(SECOND_Y_AXIS, 1);

AXIS_INIT2D(T_AXIS, 0);

AXIS_INIT2D(POLAR_AXIS, 1);

AXIS_INIT2D(COLOR_AXIS, 1);

t_axis = (parametric || polar) ? T_AXIS : FIRST_X_AXIS;

dummy_token = parse_named_range(t_axis, dummy_token);

if (parametric || polar) /* set optional x ranges */

parse_range(FIRST_X_AXIS);

parse_range(FIRST_Y_AXIS);

parse_range(SECOND_X_AXIS);

parse_range(SECOND_Y_AXIS);

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

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

struct ticdef *ticdef = &axis_array[t_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

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

eval_plots();

}

#ifdef VOLATILE_REFRESH

/* 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)

plot_image_or_update_axes(this_plot,TRUE);

continue;

}

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

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

if (point->type == UNDEFINED)

continue;

else

point->type = INRANGE;

/* If the state has been set to autoscale since the last plot,

* mark everything INRANGE and re-evaluate the axis limits now.

* Otherwise test INRANGE/OUTRANGE against previous axis limits.

*/

if (!this_plot->noautoscale

&& (x_axis->set_autoscale & (AUTOSCALE_MIN|AUTOSCALE_MAX))) {

if (point->x > x_axis->max) x_axis->max = point->x;

if (point->x < x_axis->min) x_axis->min = point->x;

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

point->type = OUTRANGE;

continue;

}

if (!this_plot->noautoscale

&& (y_axis->set_autoscale & (AUTOSCALE_MIN|AUTOSCALE_MAX))) {

if (point->y > y_axis->max) y_axis->max = point->y;

if (point->y < y_axis->min) y_axis->min = point->y;

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

point->type = OUTRANGE;

continue;

}

}

}

}

#endif

/* A quick note about boxes style. For boxwidth auto, we cannot

* calculate widths yet, since it may be sorted, etc. But if

* width is set, we must do it now, before logs of xmin/xmax

* are taken.

* We store -1 in point->z as a marker to mean width needs to be

* calculated, or 0 to mean that xmin/xmax are set correctly

*/

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

* it will later be moved passed 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 */

double v[MAXDATACOLS];

int storetoken = current_plot->token;

struct coordinate GPHUGE *cp;

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.l_type == LT_COLORFROMCOLUMN)

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: */

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 color or arrow style */

min_cols = 4;

max_cols = 5;

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 = 3;

max_cols = 5;

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;

break;

case BOXES:

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 LINES:

case DOTS:

min_cols = 1;

max_cols = 3;

break;

case LABELPOINTS:

/* 3 column data: X Y Label */

/* 4th column allows rgb variable or pointsize variable */

min_cols = 3;

max_cols = 4;

expect_string( 3 );

break;

case IMAGE:

min_cols = 3;

max_cols = 3;

break;

case RGBIMAGE:

min_cols = 5;

max_cols = 6;

break;

case RGBA_IMAGE:

min_cols = 6;

max_cols = 6;

break;

#ifdef EAM_OBJECTS

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

min_cols = 2;

max_cols = 6;

break;

case ELLIPSES:

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

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

break;

#endif

case POINTSTYLE:

case LINESPOINTS:

/* Allow 3rd column because of 'pointsize variable' */

/* Allow 4th column because of 'lc rgb variable' */

min_cols = 1;

max_cols = 4;

break;

default:

min_cols = 1;

max_cols = 2;

break;

}

if (current_plot->plot_smooth == SMOOTH_ACSPLINES) {

max_cols = 3;

current_plot->z_axis = FIRST_Z_AXIS;

df_axis[2] = FIRST_Z_AXIS;

}

if (df_no_use_specs > max_cols)

int_error(NO_CARET, "Too many using specs 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();

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

/* j <= max_cols */

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);

}

if (j > 0) {

ngood++;

/* 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:

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

break;

case LABELPOINTS:

case BOXERROR:

case XERRORLINES:

case XERRORBARS:

case YERRORLINES:

case YERRORBARS:

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

break;

#ifdef EAM_OBJECTS

case CIRCLES:

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

break;

case ELLIPSES:

#endif

case BOXES:

case POINTSTYLE:

case LINESPOINTS:

case IMPULSES:

case LINES:

case DOTS:

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

break;

default:

break;

}

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

}

}

switch (j) {

default:

{

df_close();

int_error(c_token, "internal error : df_readline returned %d : datafile line %d", j, df_line_number);

}

case DF_MISSING:

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

if (current_plot->plot_style == HISTOGRAMS) {

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

i++;

continue;

}

/* Jun 2006 - Return to behavior of 3.7 and current docs:

* do not interrupt plotted line because of missing data

*/

FPRINTF((stderr,"Missing datum %d\n", i));

continue;

case DF_UNDEFINED:

/* NaN or bad result from extended using expression */

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

i++;

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;

/* break in data, make next point undefined */

/* FIXME: We really should distinguish between a blank */

/* line and an undefined value on a non-blank line. */

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

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;

case 0: /* not blank line, but df_readline couldn't parse it */

{

df_close();

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

df_line_number, df_filename ? df_filename : "");

}

case 1:

{ /* only one number */

/* x is index, assign number to y */

v[1] = v[0];

v[0] = df_datum;

/* nobreak */

}

case 2:

H_ERR_BARS:

if (current_plot->plot_style == HISTOGRAMS) {

if (histogram_opts.type == HT_ERRORBARS) {

/* The code is a tangle, but we can get here with j = 1, 2, or 3 */

if (j == 1)

int_error(c_token, "Not enough columns in using specification");

else if (j == 2) {

v[3] = v[0] + v[1];

v[2] = v[0] - v[1];

} else {

v[3] = v[2];

v[2] = v[1];

}

v[1] = v[0];

v[0] = df_datum;

} else if (j >= 2)

int_error(c_token, "Too many columns in using specification");

else

v[2] = v[3] = v[1];

if (histogram_opts.type == HT_STACKED_IN_TOWERS) {

histogram_rightmost = current_plot->histogram_sequence

+ current_plot->histogram->start;

current_plot->histogram->end = histogram_rightmost;

} else if (v[0] + current_plot->histogram->start > histogram_rightmost) {

histogram_rightmost = v[0] + current_plot->histogram->start;

current_plot->histogram->end = histogram_rightmost;

}

/* Histogram boxwidths are always absolute */

if (boxwidth > 0)

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

v[0] - boxwidth / 2, v[0] + boxwidth / 2,

v[2], v[3], 0.0);

else

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

v[0] - 0.5, v[0] + 0.5,

v[2], v[3], 0.0);

/* x, y */

/* ylow and yhigh are same as y */

} else if ( (current_plot->plot_style == BOXES)

&& boxwidth > 0 && boxwidth_is_absolute) {

/* calculate width now */

if (axis_array[current_plot->x_axis].log) {

double base = axis_array[current_plot->x_axis].base;

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

v[0] * pow(base, -boxwidth/2.), v[0] * pow(base, boxwidth/2.),

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

} else

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

v[0] - boxwidth / 2, v[0] + boxwidth / 2,

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

#ifdef EAM_OBJECTS

} else if (current_plot->plot_style == CIRCLES) {

/* x, y, default radius, full circle */

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

0., 360., DEFAULT_RADIUS);

} else if (current_plot->plot_style == ELLIPSES) {

/* x, y, major axis = minor axis = default, default orientation */

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

0.0, 0.0, DEFAULT_ELLIPSE);

#endif

} else {

if (current_plot->plot_style == CANDLESTICKS

|| current_plot->plot_style == FINANCEBARS) {

int_warn(storetoken, "This plot style does not work with 1 or 2 cols. Setting to points");

current_plot->plot_style = POINTSTYLE;

}

/* xlow and xhigh are same as x */

/* auto width if boxes, else ignored */

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

v[1], -1.0);

}

break;

case 3:

/* x, y, ydelta OR x, y, xdelta OR x, y, width */

if (current_plot->plot_smooth == SMOOTH_ACSPLINES)

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

v[1], v[2]);

else

switch (current_plot->plot_style) {

case HISTOGRAMS:

if (histogram_opts.type == HT_ERRORBARS)

goto H_ERR_BARS;

else

/* fall through */

default:

int_warn(storetoken, "This plot style does not work with 3 cols. Setting to yerrorbars");

current_plot->plot_style = YERRORBARS;

/* fall through */

case FILLEDCURVES:

current_plot->filledcurves_options.closeto = FILLEDCURVES_BETWEEN;

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

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

break;

case YERRORLINES:

case YERRORBARS:

case BOXERROR: /* x, y, dy */

/* auto width if boxes, else ignored */

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

v[1] - v[2], v[1] + v[2], -1.0);

break;

case XERRORLINES:

case XERRORBARS:

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

v[0] + v[2], v[1], v[1], 0.0);

break;

case BOXES:

/* calculate xmin and xmax here, so that logs are taken if if necessary */

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

v[0] - v[2] / 2, v[0] + v[2] / 2,

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

break;

case LABELPOINTS:

/* Load the coords just as we would have for a point plot */

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

v[1], -1.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 IMAGE: /* x_center y_center color_value */

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

v[1], v[2]);

cp = &(current_plot->points[i]);

COLOR_STORE_WITH_LOG_AND_UPDATE_RANGE(cp->CRD_COLOR, v[2], cp->type,

COLOR_AXIS, current_plot->noautoscale, NOOP, cp->CRD_COLOR=v[2]);

i++;

break;

case POINTSTYLE: /* x, y, variable point size */

case LINESPOINTS:

case IMPULSES:

case LINES:

case DOTS:

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

v[1], v[1], v[2]);

break;

case BOXPLOT: /* x, y, width */

store2d_point(current_plot, i++, v[0], v[1], v[0]-v[2]/2., v[0]+v[2]/2.,

v[1], v[1], v[2]);

break;

#ifdef EAM_OBJECTS

case CIRCLES: /* x, y, radius */

/* by default a full circle is drawn */

/* negative radius means default radius -> set flag in width */

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

0.0, 360.0, (v[2] >= 0) ? 0.0 : DEFAULT_RADIUS);

break;

case ELLIPSES: /* x, y, major axis = minor axis, 0 as orientation */

store2d_point(current_plot, i++, v[0], v[1], fabs(v[2]), fabs(v[2]),

0.0, v[2], (v[2] >= 0) ? 0.0 : DEFAULT_RADIUS);

break;

#endif

} /*inner switch */

break;

case 4:

/* x, y, ylow, yhigh OR

* x, y, xlow, xhigh OR

* x, y, xdelta, ydelta OR

* x, y, ydelta, width

*/

switch (current_plot->plot_style) {

default:

int_warn(storetoken, "This plot style does not work with 4 cols. Setting to yerrorbars");

current_plot->plot_style = YERRORBARS;

/* fall through */

case YERRORLINES:

case YERRORBARS:

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

v[3], -1.0);

break;

case BOXXYERROR: /* x, y, dx, dy */

case XYERRORLINES:

case XYERRORBARS:

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

v[0] - v[2], v[0] + v[2],

v[1] - v[3], v[1] + v[3], 0.0);

break;

case BOXES:

/* x, y, xmin, xmax */

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

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

break;

case XERRORLINES:

case XERRORBARS:

/* x, y, xmin, xmax */

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

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

break;

case BOXERROR:

if (boxwidth == -2)

/* x,y, ylow, yhigh --- width automatic */

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

v[2], v[3], -1.0);

else

/* x, y, dy, width */

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

v[0] - v[3] / 2, v[0] + v[3] / 2,

v[1] - v[2], v[1] + v[2], 0.0);

break;

case BOXPLOT: /* x, y, width, factor */

/* Load the coords just as we would have for 3-argument boxplot,

* index of factor in ylow , yhigh is the same as y */

store2d_point(current_plot, i++, v[0], v[1], v[0]-v[2]/2., v[0]+v[2]/2.,

check_or_add_boxplot_factor(current_plot, df_tokens[3], v[0]),

v[1], v[2]);

break;

case VECTOR:

/* x,y,dx,dy */

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

v[1], v[1] + v[3], 0.);

break;

case LABELPOINTS:

/* Load the coords just as we would have for a point plot */

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

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

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

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

struct text_label *tl;

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

i, df_tokens[2],

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

tl->lp_properties.p_size = v[3];

}

i++;

break;

case POINTSTYLE:

case LINESPOINTS:

/* These are here only to catch the case where no using spec */

/* is given and there are more than 3 columns in the data file */

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

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

break;

#ifdef EAM_OBJECTS

case ELLIPSES: /* x, y, major axis, minor axis, 0 as orientation */

store2d_point(current_plot, i++, v[0], v[1], fabs(v[2]), fabs(v[3]),

0.0, v[2], ((v[2] >= 0) && (v[3] >= 0)) ? 0.0 : DEFAULT_RADIUS);

break;

#endif

} /*inner switch */

break;

case 5:

{ /* x, y, ylow, yhigh, width or x open low high close */

switch (current_plot->plot_style) {

default:

int_warn(storetoken, "Unrecognized 5 column plot style; resetting to boxerrorbars");

current_plot->plot_style = BOXERROR;

/*fall through */

case BOXERROR: /* x, y, ylow, yhigh, width */

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

v[0] - v[4] / 2, v[0] + v[4] / 2,

v[2], v[3], 0.0);

break;

case FINANCEBARS: /* x yopen ylow yhigh yclose */

case CANDLESTICKS:

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

v[2], v[3], v[4]);

break;

case VECTOR:

/* x,y,dx,dy, variable arrowstyle */

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

v[1], v[1] + v[3], v[4]);

break;

#ifdef EAM_OBJECTS

case CIRCLES: /* x, y, radius, arc begin, arc end */

/* negative radius means default radius -> set flag in width */

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

v[3], v[4], (v[2] >= 0) ? 0.0 : DEFAULT_RADIUS);

break;

case ELLIPSES: /* x, y, major axis, minor axis, orientation */

store2d_point(current_plot, i++, v[0], v[1], fabs(v[2]), fabs(v[3]),

v[4], v[2], ((v[2] >= 0) && (v[3] >= 0)) ? 0.0 : DEFAULT_RADIUS);

break;

#endif

case RGBIMAGE: /* x_center y_center r_value g_value b_value (rgb) */