/*
* Smithsonian Astrophysical Observatory, Cambridge, MA, USA
* This code has been modified under the terms listed below and is made
* available under the same terms.
*/
/*
* Copyright (c) 1993 George A Howlett.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <float.h>
#include <stdlib.h>
#include <string.h>
#include <cmath>
#include "tkbltGraph.h"
#include "tkbltGrElemLine.h"
#include "tkbltGrElemOption.h"
#include "tkbltGrAxis.h"
#include "tkbltGrMisc.h"
#include "tkbltGrDef.h"
#include "tkbltConfig.h"
#include "tkbltGrPSOutput.h"
#include "tkbltInt.h"
using namespace Blt;
#define SEARCH_X 0
#define SEARCH_Y 1
#define SEARCH_BOTH 2
#define SEARCH_POINTS 0 // closest data point.
#define SEARCH_TRACES 1 // closest point on trace.
#define SEARCH_AUTO 2 // traces if linewidth is > 0 and more than one
#define MIN3(a,b,c) (((a)<(b))?(((a)<(c))?(a):(c)):(((b)<(c))?(b):(c)))
#define PointInRegion(e,x,y) (((x) <= (e)->right) && ((x) >= (e)->left) && ((y) <= (e)->bottom) && ((y) >= (e)->top))
#define BROKEN_TRACE(dir,last,next) (((dir == INCREASING)&&(next < last)) || ((dir == DECREASING)&&(next > last)))
#define DRAW_SYMBOL() (symbolInterval_==0||(symbolCounter_%symbolInterval_)==0)
static const char* symbolMacros[] =
{"Li", "Sq", "Ci", "Di", "Pl", "Cr", "Sp", "Sc", "Tr", "Ar", "Bm", NULL};
// OptionSpecs
static const char* smoothObjOption[] =
{"linear", "step", "cubic", "quadratic", "catrom", NULL};
static const char* penDirObjOption[] =
{"increasing", "decreasing", "both", NULL};
static Tk_ObjCustomOption styleObjOption =
{
"styles", StyleSetProc, StyleGetProc, StyleRestoreProc, StyleFreeProc,
(ClientData)sizeof(LineStyle)
};
extern Tk_ObjCustomOption penObjOption;
extern Tk_ObjCustomOption pairsObjOption;
extern Tk_ObjCustomOption valuesObjOption;
extern Tk_ObjCustomOption xAxisObjOption;
extern Tk_ObjCustomOption yAxisObjOption;
static Tk_OptionSpec optionSpecs[] = {
{TK_OPTION_CUSTOM, "-activepen", "activePen", "ActivePen",
"active", -1, Tk_Offset(LineElementOptions, activePenPtr),
TK_OPTION_NULL_OK, &penObjOption, LAYOUT},
{TK_OPTION_BORDER, "-areabackground", "areaBackground", "AreaBackground",
NULL, -1, Tk_Offset(LineElementOptions, fillBg),
TK_OPTION_NULL_OK, NULL, LAYOUT},
{TK_OPTION_CUSTOM, "-bindtags", "bindTags", "BindTags",
"all", -1, Tk_Offset(LineElementOptions, tags),
TK_OPTION_NULL_OK, &listObjOption, 0},
{TK_OPTION_COLOR, "-color", "color", "Color",
STD_NORMAL_FOREGROUND, -1,
Tk_Offset(LineElementOptions, builtinPen.traceColor), 0, NULL, CACHE},
{TK_OPTION_CUSTOM, "-dashes", "dashes", "Dashes",
NULL, -1, Tk_Offset(LineElementOptions, builtinPen.traceDashes),
TK_OPTION_NULL_OK, &dashesObjOption, CACHE},
{TK_OPTION_CUSTOM, "-data", "data", "Data",
NULL, -1, Tk_Offset(LineElementOptions, coords),
TK_OPTION_NULL_OK, &pairsObjOption, RESET},
{TK_OPTION_COLOR, "-errorbarcolor", "errorBarColor", "ErrorBarColor",
NULL, -1, Tk_Offset(LineElementOptions, builtinPen.errorBarColor),
TK_OPTION_NULL_OK, NULL, CACHE},
{TK_OPTION_PIXELS,"-errorbarwidth", "errorBarWidth", "ErrorBarWidth",
"1", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarLineWidth),
0, NULL, CACHE},
{TK_OPTION_PIXELS, "-errorbarcap", "errorBarCap", "ErrorBarCap",
"0", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarCapWidth),
0, NULL, LAYOUT},
{TK_OPTION_COLOR, "-fill", "fill", "Fill",
NULL, -1, Tk_Offset(LineElementOptions, builtinPen.symbol.fillColor),
TK_OPTION_NULL_OK, NULL, CACHE},
{TK_OPTION_BOOLEAN, "-hide", "hide", "Hide",
"no", -1, Tk_Offset(LineElementOptions, hide), 0, NULL, LAYOUT},
{TK_OPTION_STRING, "-label", "label", "Label",
NULL, -1, Tk_Offset(LineElementOptions, label),
TK_OPTION_NULL_OK | TK_OPTION_DONT_SET_DEFAULT, NULL, LAYOUT},
{TK_OPTION_RELIEF, "-legendrelief", "legendRelief", "LegendRelief",
"flat", -1, Tk_Offset(LineElementOptions, legendRelief), 0, NULL, LAYOUT},
{TK_OPTION_PIXELS, "-linewidth", "lineWidth", "LineWidth",
"1", -1, Tk_Offset(LineElementOptions, builtinPen.traceWidth),
0, NULL, CACHE},
{TK_OPTION_CUSTOM, "-mapx", "mapX", "MapX",
"x", -1, Tk_Offset(LineElementOptions, xAxis), 0, &xAxisObjOption, RESET},
{TK_OPTION_CUSTOM, "-mapy", "mapY", "MapY",
"y", -1, Tk_Offset(LineElementOptions, yAxis), 0, &yAxisObjOption, RESET},
{TK_OPTION_INT, "-maxsymbols", "maxSymbols", "MaxSymbols",
"0", -1, Tk_Offset(LineElementOptions, reqMaxSymbols), 0, NULL, CACHE},
{TK_OPTION_COLOR, "-offdash", "offDash", "OffDash",
NULL, -1, Tk_Offset(LineElementOptions, builtinPen.traceOffColor),
TK_OPTION_NULL_OK, NULL, CACHE},
{TK_OPTION_COLOR, "-outline", "outline", "Outline",
NULL, -1, Tk_Offset(LineElementOptions, builtinPen.symbol.outlineColor),
TK_OPTION_NULL_OK, NULL, CACHE},
{TK_OPTION_PIXELS, "-outlinewidth", "outlineWidth", "OutlineWidth",
"1", -1, Tk_Offset(LineElementOptions, builtinPen.symbol.outlineWidth),
0, NULL, CACHE},
{TK_OPTION_CUSTOM, "-pen", "pen", "Pen",
NULL, -1, Tk_Offset(LineElementOptions, normalPenPtr),
TK_OPTION_NULL_OK, &penObjOption, LAYOUT},
{TK_OPTION_PIXELS, "-pixels", "pixels", "Pixels",
"0.1i", -1, Tk_Offset(LineElementOptions, builtinPen.symbol.size),
0, NULL, LAYOUT},
{TK_OPTION_DOUBLE, "-reduce", "reduce", "Reduce",
"0", -1, Tk_Offset(LineElementOptions, rTolerance), 0, NULL, RESET},
{TK_OPTION_BOOLEAN, "-scalesymbols", "scaleSymbols", "ScaleSymbols",
"yes", -1, Tk_Offset(LineElementOptions, scaleSymbols), 0, NULL, LAYOUT},
{TK_OPTION_STRING_TABLE, "-showerrorbars", "showErrorBars", "ShowErrorBars",
"both", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarShow),
0, &fillObjOption, LAYOUT},
{TK_OPTION_STRING_TABLE, "-showvalues", "showValues", "ShowValues",
"none", -1, Tk_Offset(LineElementOptions, builtinPen.valueShow),
0, &fillObjOption, CACHE},
{TK_OPTION_STRING_TABLE, "-smooth", "smooth", "Smooth",
"linear", -1, Tk_Offset(LineElementOptions, reqSmooth),
0, &smoothObjOption, LAYOUT},
{TK_OPTION_CUSTOM, "-styles", "styles", "Styles",
"", -1, Tk_Offset(LineElementOptions, stylePalette),
0, &styleObjOption, RESET},
{TK_OPTION_STRING_TABLE, "-symbol", "symbol", "Symbol",
"none", -1, Tk_Offset(LineElementOptions, builtinPen.symbol),
0, &symbolObjOption, CACHE},
{TK_OPTION_STRING_TABLE, "-trace", "trace", "Trace",
"both", -1, Tk_Offset(LineElementOptions, penDir),
0, &penDirObjOption, RESET},
{TK_OPTION_ANCHOR, "-valueanchor", "valueAnchor", "ValueAnchor",
"s", -1, Tk_Offset(LineElementOptions, builtinPen.valueStyle.anchor),
0, NULL, CACHE},
{TK_OPTION_COLOR, "-valuecolor", "valueColor", "ValueColor",
STD_NORMAL_FOREGROUND,-1,
Tk_Offset(LineElementOptions, builtinPen.valueStyle.color),
0, NULL, CACHE},
{TK_OPTION_FONT, "-valuefont", "valueFont", "ValueFont",
STD_FONT_SMALL, -1,
Tk_Offset(LineElementOptions, builtinPen.valueStyle.font),
0, NULL, CACHE},
{TK_OPTION_STRING, "-valueformat", "valueFormat", "ValueFormat",
"%g", -1, Tk_Offset(LineElementOptions, builtinPen.valueFormat),
TK_OPTION_NULL_OK, NULL, CACHE},
{TK_OPTION_DOUBLE, "-valuerotate", "valueRotate", "ValueRotate",
"0", -1, Tk_Offset(LineElementOptions, builtinPen.valueStyle.angle),
0, NULL, CACHE},
{TK_OPTION_CUSTOM, "-weights", "weights", "Weights",
NULL, -1, Tk_Offset(LineElementOptions, w),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_SYNONYM, "-x", NULL, NULL,
NULL, 0, -1, 0, (ClientData)"-xdata", 0},
{TK_OPTION_CUSTOM, "-xdata", "xData", "XData",
NULL, -1, Tk_Offset(LineElementOptions, coords.x),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_CUSTOM, "-xerror", "xError", "XError",
NULL, -1, Tk_Offset(LineElementOptions, xError),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_CUSTOM, "-xhigh", "xHigh", "XHigh",
NULL, -1, Tk_Offset(LineElementOptions, xHigh),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_CUSTOM, "-xlow", "xLow", "XLow",
NULL, -1, Tk_Offset(LineElementOptions, xLow),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_SYNONYM, "-y", NULL, NULL,
NULL, 0, -1, 0, (ClientData)"-ydata", 0},
{TK_OPTION_CUSTOM, "-ydata", "yData", "YData",
NULL, -1, Tk_Offset(LineElementOptions, coords.y),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_CUSTOM, "-yerror", "yError", "YError",
NULL, -1, Tk_Offset(LineElementOptions, yError),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_CUSTOM, "-yhigh", "yHigh", "YHigh",
NULL, -1, Tk_Offset(LineElementOptions, yHigh),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_CUSTOM, "-ylow", "yLow", "YLow",
NULL, -1, Tk_Offset(LineElementOptions, yLow),
TK_OPTION_NULL_OK, &valuesObjOption, RESET},
{TK_OPTION_END, NULL, NULL, NULL, NULL, 0, -1, 0, 0, 0}
};
LineElement::LineElement(Graph* graphPtr, const char* name, Tcl_HashEntry* hPtr)
: Element(graphPtr, name, hPtr)
{
smooth_ = LINEAR;
fillPts_ =NULL;
nFillPts_ = 0;
symbolPts_.points =NULL;
symbolPts_.length =0;
symbolPts_.map =NULL;
activePts_.points =NULL;
activePts_.length =0;
activePts_.map =NULL;
xeb_.segments =NULL;
xeb_.map =NULL;
xeb_.length =0;
yeb_.segments =NULL;
yeb_.map =NULL;
yeb_.length =0;
symbolInterval_ =0;
symbolCounter_ =0;
traces_ =NULL;
ops_ = (LineElementOptions*)calloc(1, sizeof(LineElementOptions));
LineElementOptions* ops = (LineElementOptions*)ops_;
ops->elemPtr = (Element*)this;
builtinPenPtr = new LinePen(graphPtr, "builtin", &ops->builtinPen);
ops->builtinPenPtr = builtinPenPtr;
optionTable_ = Tk_CreateOptionTable(graphPtr->interp_, optionSpecs);
ops->stylePalette = new Chain();
// this is an option and will be freed via Tk_FreeConfigOptions
// By default an element's name and label are the same
ops->label = Tcl_Alloc(strlen(name)+1);
if (name)
strcpy((char*)ops->label,(char*)name);
Tk_InitOptions(graphPtr->interp_, (char*)&(ops->builtinPen),
builtinPenPtr->optionTable(), graphPtr->tkwin_);
}
LineElement::~LineElement()
{
LineElementOptions* ops = (LineElementOptions*)ops_;
delete builtinPenPtr;
reset();
if (ops->stylePalette) {
freeStylePalette(ops->stylePalette);
delete ops->stylePalette;
}
delete [] fillPts_;
}
int LineElement::configure()
{
LineElementOptions* ops = (LineElementOptions*)ops_;
if (builtinPenPtr->configure() != TCL_OK)
return TCL_ERROR;
// Point to the static normal/active pens if no external pens have been
// selected.
ChainLink* link = Chain_FirstLink(ops->stylePalette);
if (!link) {
link = new ChainLink(sizeof(LineStyle));
ops->stylePalette->linkAfter(link, NULL);
}
LineStyle* stylePtr = (LineStyle*)Chain_GetValue(link);
stylePtr->penPtr = NORMALPEN(ops);
return TCL_OK;
}
void LineElement::map()
{
LineElementOptions* ops = (LineElementOptions*)ops_;
if (!link)
return;
reset();
if (!ops->coords.x || !ops->coords.y ||
!ops->coords.x->nValues() || !ops->coords.y->nValues())
return;
int np = NUMBEROFPOINTS(ops);
MapInfo mi;
getScreenPoints(&mi);
mapSymbols(&mi);
if (nActiveIndices_ > 0)
mapActiveSymbols();
// Map connecting line segments if they are to be displayed.
smooth_ = (Smoothing)ops->reqSmooth;
if ((np > 1) && (ops->builtinPen.traceWidth > 0)) {
// Do smoothing if necessary. This can extend the coordinate array,
// so both mi.points and mi.nPoints may change.
switch (smooth_) {
case STEP:
generateSteps(&mi);
break;
case CUBIC:
case QUADRATIC:
// Can't interpolate with less than three points
if (mi.nScreenPts < 3)
smooth_ = LINEAR;
else
generateSpline(&mi);
break;
case CATROM:
// Can't interpolate with less than three points
if (mi.nScreenPts < 3)
smooth_ = LINEAR;
else
generateParametricSpline(&mi);
break;
default:
break;
}
if (ops->rTolerance > 0.0)
reducePoints(&mi, ops->rTolerance);
if (ops->fillBg)
mapFillArea(&mi);
mapTraces(&mi);
}
delete [] mi.screenPts;
delete [] mi.map;
// Set the symbol size of all the pen styles
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle* stylePtr = (LineStyle*)Chain_GetValue(link);
LinePen* penPtr = (LinePen *)stylePtr->penPtr;
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
int size = scaleSymbol(penOps->symbol.size);
stylePtr->symbolSize = size;
stylePtr->errorBarCapWidth = penOps->errorBarCapWidth;
}
LineStyle** styleMap = (LineStyle**)StyleMap();
if (((ops->yHigh && ops->yHigh->nValues() > 0) &&
(ops->yLow && ops->yLow->nValues() > 0)) ||
((ops->xHigh && ops->xHigh->nValues() > 0) &&
(ops->xLow && ops->xLow->nValues() > 0)) ||
(ops->xError && ops->xError->nValues() > 0) ||
(ops->yError && ops->yError->nValues() > 0)) {
mapErrorBars(styleMap);
}
mergePens(styleMap);
delete [] styleMap;
}
void LineElement::extents(Region2d *extsPtr)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
extsPtr->top = extsPtr->left = DBL_MAX;
extsPtr->bottom = extsPtr->right = -DBL_MAX;
if (!ops->coords.x || !ops->coords.y ||
!ops->coords.x->nValues() || !ops->coords.y->nValues())
return;
int np = NUMBEROFPOINTS(ops);
extsPtr->right = ops->coords.x->max();
AxisOptions* axisxops = (AxisOptions*)ops->xAxis->ops();
if ((ops->coords.x->min() <= 0.0) && (axisxops->logScale))
extsPtr->left = FindElemValuesMinimum(ops->coords.x, DBL_MIN);
else
extsPtr->left = ops->coords.x->min();
extsPtr->bottom = ops->coords.y->max();
AxisOptions* axisyops = (AxisOptions*)ops->yAxis->ops();
if ((ops->coords.y->min() <= 0.0) && (axisyops->logScale))
extsPtr->top = FindElemValuesMinimum(ops->coords.y, DBL_MIN);
else
extsPtr->top = ops->coords.y->min();
// Correct the data limits for error bars
if (ops->xError && ops->xError->nValues() > 0) {
np = MIN(ops->xError->nValues(), np);
for (int ii=0; ii<np; ii++) {
double x = ops->coords.x->values_[ii] + ops->xError->values_[ii];
if (x > extsPtr->right)
extsPtr->right = x;
x = ops->coords.x->values_[ii] - ops->xError->values_[ii];
AxisOptions* axisxops = (AxisOptions*)ops->xAxis->ops();
if (axisxops->logScale) {
// Mirror negative values, instead of ignoring them
if (x < 0.0)
x = -x;
if ((x > DBL_MIN) && (x < extsPtr->left))
extsPtr->left = x;
}
else if (x < extsPtr->left)
extsPtr->left = x;
}
}
else {
if (ops->xHigh &&
(ops->xHigh->nValues() > 0) &&
(ops->xHigh->max() > extsPtr->right)) {
extsPtr->right = ops->xHigh->max();
}
if (ops->xLow && ops->xLow->nValues() > 0) {
double left;
if ((ops->xLow->min() <= 0.0) && (axisxops->logScale))
left = FindElemValuesMinimum(ops->xLow, DBL_MIN);
else
left = ops->xLow->min();
if (left < extsPtr->left)
extsPtr->left = left;
}
}
if (ops->yError && ops->yError->nValues() > 0) {
np = MIN(ops->yError->nValues(), np);
for (int ii=0; ii<np; ii++) {
double y = ops->coords.y->values_[ii] + ops->yError->values_[ii];
if (y > extsPtr->bottom)
extsPtr->bottom = y;
y = ops->coords.y->values_[ii] - ops->yError->values_[ii];
AxisOptions* axisyops = (AxisOptions*)ops->yAxis->ops();
if (axisyops->logScale) {
// Mirror negative values, instead of ignoring them
if (y < 0.0)
y = -y;
if ((y > DBL_MIN) && (y < extsPtr->left))
extsPtr->top = y;
}
else if (y < extsPtr->top)
extsPtr->top = y;
}
}
else {
if (ops->yHigh && (ops->yHigh->nValues() > 0) &&
(ops->yHigh->max() > extsPtr->bottom))
extsPtr->bottom = ops->yHigh->max();
if (ops->yLow && ops->yLow->nValues() > 0) {
double top;
if ((ops->yLow->min() <= 0.0) && (axisyops->logScale))
top = FindElemValuesMinimum(ops->yLow, DBL_MIN);
else
top = ops->yLow->min();
if (top < extsPtr->top)
extsPtr->top = top;
}
}
}
void LineElement::closest()
{
LineElementOptions* ops = (LineElementOptions*)ops_;
GraphOptions* gops = (GraphOptions*)graphPtr_->ops_;
ClosestSearch* searchPtr = &gops->search;
int mode = searchPtr->mode;
if (mode == SEARCH_AUTO) {
LinePen* penPtr = NORMALPEN(ops);
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
mode = SEARCH_POINTS;
if ((NUMBEROFPOINTS(ops) > 1) && (penOps->traceWidth > 0))
mode = SEARCH_TRACES;
}
if (mode == SEARCH_POINTS)
closestPoint(searchPtr);
else {
int found = closestTrace();
if ((!found) && (searchPtr->along != SEARCH_BOTH))
closestPoint(searchPtr);
}
}
void LineElement::draw(Drawable drawable)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
LinePen* penPtr = NORMALPEN(ops);
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
if (ops->hide)
return;
// Fill area under the curve
if (ops->fillBg && fillPts_) {
XPoint*points = new XPoint[nFillPts_];
unsigned int count =0;
for (Point2d *pp = fillPts_, *endp = pp + nFillPts_; pp < endp; pp++) {
points[count].x = (short)pp->x;
points[count].y = (short)pp->y;
count++;
}
Tk_Fill3DPolygon(graphPtr_->tkwin_, drawable, ops->fillBg, points,
nFillPts_, 0, TK_RELIEF_FLAT);
delete [] points;
}
// traces
if ((Chain_GetLength(traces_) > 0) && (penOps->traceWidth > 0))
drawTraces(drawable, penPtr);
// Symbols, error bars, values
if (ops->reqMaxSymbols > 0) {
int total = 0;
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
total += stylePtr->symbolPts.length;
}
symbolInterval_ = total / ops->reqMaxSymbols;
symbolCounter_ = 0;
}
unsigned int count =0;
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle* stylePtr = (LineStyle*)Chain_GetValue(link);
LinePen* penPtr = (LinePen *)stylePtr->penPtr;
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
if ((stylePtr->xeb.length > 0) && (penOps->errorBarShow & SHOW_X))
graphPtr_->drawSegments(drawable, penPtr->errorBarGC_,
stylePtr->xeb.segments, stylePtr->xeb.length);
if ((stylePtr->yeb.length > 0) && (penOps->errorBarShow & SHOW_Y))
graphPtr_->drawSegments(drawable, penPtr->errorBarGC_,
stylePtr->yeb.segments, stylePtr->yeb.length);
if ((stylePtr->symbolPts.length > 0) &&
(penOps->symbol.type != SYMBOL_NONE))
drawSymbols(drawable, penPtr, stylePtr->symbolSize,
stylePtr->symbolPts.length, stylePtr->symbolPts.points);
if (penOps->valueShow != SHOW_NONE)
drawValues(drawable, penPtr, stylePtr->symbolPts.length,
stylePtr->symbolPts.points, symbolPts_.map + count);
count += stylePtr->symbolPts.length;
}
symbolInterval_ = 0;
symbolCounter_ = 0;
}
void LineElement::drawActive(Drawable drawable)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
LinePen* penPtr = (LinePen*)ops->activePenPtr;
if (!penPtr)
return;
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
if (ops->hide || !active_)
return;
int symbolSize = scaleSymbol(penOps->symbol.size);
if (nActiveIndices_ > 0) {
mapActiveSymbols();
if (penOps->symbol.type != SYMBOL_NONE)
drawSymbols(drawable, penPtr, symbolSize, activePts_.length,
activePts_.points);
if (penOps->valueShow != SHOW_NONE)
drawValues(drawable, penPtr, activePts_.length, activePts_.points,
activePts_.map);
}
else if (nActiveIndices_ < 0) {
if ((Chain_GetLength(traces_) > 0) && (penOps->traceWidth > 0))
drawTraces(drawable, penPtr);
if (penOps->symbol.type != SYMBOL_NONE)
drawSymbols(drawable, penPtr, symbolSize, symbolPts_.length,
symbolPts_.points);
if (penOps->valueShow != SHOW_NONE) {
drawValues(drawable, penPtr, symbolPts_.length, symbolPts_.points,
symbolPts_.map);
}
}
}
void LineElement::drawSymbol(Drawable drawable, int x, int y, int size)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
LinePen* penPtr = NORMALPEN(ops);
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
if (penOps->traceWidth > 0) {
// Draw an extra line offset by one pixel from the previous to give a
// thicker appearance. This is only for the legend entry. This routine
// is never called for drawing the actual line segments.
XDrawLine(graphPtr_->display_, drawable, penPtr->traceGC_, x - size, y,
x + size, y);
XDrawLine(graphPtr_->display_, drawable, penPtr->traceGC_, x - size, y + 1,
x + size, y + 1);
}
if (penOps->symbol.type != SYMBOL_NONE) {
Point2d point;
point.x = x;
point.y = y;
drawSymbols(drawable, penPtr, size, 1, &point);
}
}
void LineElement::print(PSOutput* psPtr)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
LinePen* penPtr = NORMALPEN(ops);
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
if (ops->hide)
return;
psPtr->format("\n%% Element \"%s\"\n\n", name_);
// Draw fill area
if (ops->fillBg && fillPts_) {
psPtr->append("% start fill area\n");
psPtr->setBackground(ops->fillBg);
psPtr->printPolyline(fillPts_, nFillPts_);
psPtr->append("gsave fill grestore\n");
psPtr->append("% end fill area\n");
}
// traces
if ((Chain_GetLength(traces_) > 0) && (penOps->traceWidth > 0))
printTraces(psPtr, penPtr);
// Symbols, error bars, values
if (ops->reqMaxSymbols > 0) {
int total = 0;
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
total += stylePtr->symbolPts.length;
}
symbolInterval_ = total / ops->reqMaxSymbols;
symbolCounter_ = 0;
}
unsigned int count =0;
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
LinePen* penPtr = (LinePen *)stylePtr->penPtr;
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
XColor* colorPtr = penOps->errorBarColor;
if (!colorPtr)
colorPtr = penOps->traceColor;
if ((stylePtr->xeb.length > 0) && (penOps->errorBarShow & SHOW_X)) {
psPtr->setLineAttributes(colorPtr, penOps->errorBarLineWidth,
NULL, CapButt, JoinMiter);
psPtr->printSegments(stylePtr->xeb.segments, stylePtr->xeb.length);
}
if ((stylePtr->yeb.length > 0) && (penOps->errorBarShow & SHOW_Y)) {
psPtr->setLineAttributes(colorPtr, penOps->errorBarLineWidth,
NULL, CapButt, JoinMiter);
psPtr->printSegments(stylePtr->yeb.segments, stylePtr->yeb.length);
}
if ((stylePtr->symbolPts.length > 0) &&
(penOps->symbol.type != SYMBOL_NONE))
printSymbols(psPtr, penPtr, stylePtr->symbolSize,
stylePtr->symbolPts.length, stylePtr->symbolPts.points);
if (penOps->valueShow != SHOW_NONE)
printValues(psPtr, penPtr, stylePtr->symbolPts.length,
stylePtr->symbolPts.points, symbolPts_.map + count);
count += stylePtr->symbolPts.length;
}
symbolInterval_ = 0;
symbolCounter_ = 0;
}
void LineElement::printActive(PSOutput* psPtr)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
LinePen* penPtr = (LinePen *)ops->activePenPtr;
if (!penPtr)
return;
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
if (ops->hide || !active_)
return;
psPtr->format("\n%% Active Element \"%s\"\n\n", name_);
int symbolSize = scaleSymbol(penOps->symbol.size);
if (nActiveIndices_ > 0) {
mapActiveSymbols();
if (penOps->symbol.type != SYMBOL_NONE)
printSymbols(psPtr, penPtr, symbolSize, activePts_.length,
activePts_.points);
if (penOps->valueShow != SHOW_NONE)
printValues(psPtr, penPtr, activePts_.length, activePts_.points,
activePts_.map);
}
else if (nActiveIndices_ < 0) {
if ((Chain_GetLength(traces_) > 0) && (penOps->traceWidth > 0))
printTraces(psPtr, (LinePen*)penPtr);
if (penOps->symbol.type != SYMBOL_NONE)
printSymbols(psPtr, penPtr, symbolSize, symbolPts_.length,
symbolPts_.points);
if (penOps->valueShow != SHOW_NONE) {
printValues(psPtr, penPtr, symbolPts_.length, symbolPts_.points,
symbolPts_.map);
}
}
}
void LineElement::printSymbol(PSOutput* psPtr, double x, double y, int size)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
LinePen* penPtr = NORMALPEN(ops);
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
if (penOps->traceWidth > 0) {
// Draw an extra line offset by one pixel from the previous to give a
// thicker appearance. This is only for the legend entry. This routine
// is never called for drawing the actual line segments.
psPtr->setLineAttributes(penOps->traceColor, penOps->traceWidth,
&penOps->traceDashes, CapButt, JoinMiter);
psPtr->format("%g %g %d Li\n", x, y, size + size);
}
if (penOps->symbol.type != SYMBOL_NONE) {
Point2d point;
point.x = x;
point.y = y;
printSymbols(psPtr, penPtr, size, 1, &point);
}
}
// Support
double LineElement::distanceToLine(int x, int y, Point2d *p, Point2d *q,
Point2d *t)
{
double right, left, top, bottom;
*t = getProjection(x, y, p, q);
if (p->x > q->x)
right = p->x, left = q->x;
else
left = p->x, right = q->x;
if (p->y > q->y)
bottom = p->y, top = q->y;
else
top = p->y, bottom = q->y;
if (t->x > right)
t->x = right;
else if (t->x < left)
t->x = left;
if (t->y > bottom)
t->y = bottom;
else if (t->y < top)
t->y = top;
return hypot((t->x - x), (t->y - y));
}
double LineElement::distanceToX(int x, int y, Point2d *p, Point2d *q,
Point2d *t)
{
double dx, dy;
double d;
if (p->x > q->x) {
if ((x > p->x) || (x < q->x)) {
return DBL_MAX; /* X-coordinate outside line segment. */
}
} else {
if ((x > q->x) || (x < p->x)) {
return DBL_MAX; /* X-coordinate outside line segment. */
}
}
dx = p->x - q->x;
dy = p->y - q->y;
t->x = (double)x;
if (fabs(dx) < DBL_EPSILON) {
double d1, d2;
/*
* Same X-coordinate indicates a vertical line. Pick the closest end
* point.
*/
d1 = p->y - y;
d2 = q->y - y;
if (fabs(d1) < fabs(d2)) {
t->y = p->y, d = d1;
} else {
t->y = q->y, d = d2;
}
}
else if (fabs(dy) < DBL_EPSILON) {
/* Horizontal line. */
t->y = p->y, d = p->y - y;
}
else {
double m = dy / dx;
double b = p->y - (m * p->x);
t->y = (x * m) + b;
d = y - t->y;
}
return fabs(d);
}
double LineElement::distanceToY(int x, int y, Point2d *p, Point2d *q,
Point2d *t)
{
double dx, dy;
double d;
if (p->y > q->y) {
if ((y > p->y) || (y < q->y)) {
return DBL_MAX;
}
}
else {
if ((y > q->y) || (y < p->y)) {
return DBL_MAX;
}
}
dx = p->x - q->x;
dy = p->y - q->y;
t->y = y;
if (fabs(dy) < DBL_EPSILON) {
double d1, d2;
/* Save Y-coordinate indicates an horizontal line. Pick the closest end
* point. */
d1 = p->x - x;
d2 = q->x - x;
if (fabs(d1) < fabs(d2)) {
t->x = p->x, d = d1;
}
else {
t->x = q->x, d = d2;
}
}
else if (fabs(dx) < DBL_EPSILON) {
/* Vertical line. */
t->x = p->x, d = p->x - x;
}
else {
double m = dy / dx;
double b = p->y - (m * p->x);
t->x = (y - b) / m;
d = x - t->x;
}
return fabs(d);
}
int LineElement::scaleSymbol(int normalSize)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
double scale = 1.0;
if (ops->scaleSymbols) {
double xRange = (ops->xAxis->max_ - ops->xAxis->min_);
double yRange = (ops->yAxis->max_ - ops->yAxis->min_);
// Save the ranges as a baseline for future scaling
if (!xRange_ || !yRange_) {
xRange_ = xRange;
yRange_ = yRange;
}
else {
// Scale the symbol by the smallest change in the X or Y axes
double xScale = xRange_ / xRange;
double yScale = yRange_ / yRange;
scale = MIN(xScale, yScale);
}
}
int newSize = (int)(normalSize * scale);
int maxSize = MIN(graphPtr_->hRange_, graphPtr_->vRange_);
if (newSize > maxSize)
newSize = maxSize;
// Make the symbol size odd so that its center is a single pixel.
newSize |= 0x01;
return newSize;
}
void LineElement::getScreenPoints(MapInfo* mapPtr)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
GraphOptions* gops = (GraphOptions*)graphPtr_->ops_;
if (!ops->coords.x || !ops->coords.y) {
mapPtr->screenPts = NULL;
mapPtr->nScreenPts = 0;
mapPtr->map = NULL;
}
int np = NUMBEROFPOINTS(ops);
double* x = ops->coords.x->values_;
double* y = ops->coords.y->values_;
Point2d* points = new Point2d[np];
int* map = new int[np];
int count = 0;
if (gops->inverted) {
for (int ii=0; ii<np; ii++) {
if ((isfinite(x[ii])) && (isfinite(y[ii]))) {
points[count].x = ops->yAxis->hMap(y[ii]);
points[count].y = ops->xAxis->vMap(x[ii]);
map[count] = ii;
count++;
}
}
}
else {
for (int ii=0; ii< np; ii++) {
if ((isfinite(x[ii])) && (isfinite(y[ii]))) {
points[count].x = ops->xAxis->hMap(x[ii]);
points[count].y = ops->yAxis->vMap(y[ii]);
map[count] = ii;
count++;
}
}
}
mapPtr->screenPts = points;
mapPtr->nScreenPts = count;
mapPtr->map = map;
}
void LineElement::reducePoints(MapInfo *mapPtr, double tolerance)
{
int* simple = new int[mapPtr->nScreenPts];
int* map = new int[mapPtr->nScreenPts];
Point2d* screenPts = new Point2d[mapPtr->nScreenPts];
int np = simplify(mapPtr->screenPts, 0, mapPtr->nScreenPts - 1,
tolerance, simple);
for (int ii=0; ii<np; ii++) {
int kk = simple[ii];
screenPts[ii] = mapPtr->screenPts[kk];
map[ii] = mapPtr->map[kk];
}
delete [] simple;
delete [] mapPtr->screenPts;
mapPtr->screenPts = screenPts;
delete [] mapPtr->map;
mapPtr->map = map;
mapPtr->nScreenPts = np;
}
// Douglas-Peucker line simplification algorithm
int LineElement::simplify(Point2d *inputPts, int low, int high,
double tolerance, int *indices)
{
#define StackPush(a) s++, stack[s] = (a)
#define StackPop(a) (a) = stack[s], s--
#define StackEmpty() (s < 0)
#define StackTop() stack[s]
int split = -1;
double dist2, tolerance2;
int s = -1; /* Points to top stack item. */
int* stack = new int[high - low + 1];
StackPush(high);
int count = 0;
indices[count++] = 0;
tolerance2 = tolerance * tolerance;
while (!StackEmpty()) {
dist2 = findSplit(inputPts, low, StackTop(), &split);
if (dist2 > tolerance2)
StackPush(split);
else {
indices[count++] = StackTop();
StackPop(low);
}
}
delete [] stack;
return count;
}
double LineElement::findSplit(Point2d *points, int i, int j, int *split)
{
double maxDist2 = -1.0;
if ((i + 1) < j) {
double a = points[i].y - points[j].y;
double b = points[j].x - points[i].x;
double c = (points[i].x * points[j].y) - (points[i].y * points[j].x);
for (int kk = (i + 1); kk < j; kk++) {
double dist2 = (points[kk].x * a) + (points[kk].y * b) + c;
if (dist2 < 0.0)
dist2 = -dist2;
// Track the maximum.
if (dist2 > maxDist2) {
maxDist2 = dist2;
*split = kk;
}
}
// Correction for segment length---should be redone if can == 0
maxDist2 *= maxDist2 / (a * a + b * b);
}
return maxDist2;
}
void LineElement::generateSteps(MapInfo *mapPtr)
{
int newSize = ((mapPtr->nScreenPts - 1) * 2) + 1;
Point2d* screenPts = new Point2d[newSize];
int* map = new int[newSize];
screenPts[0] = mapPtr->screenPts[0];
map[0] = 0;
int count = 1;
for (int i = 1; i < mapPtr->nScreenPts; i++) {
screenPts[count + 1] = mapPtr->screenPts[i];
// Hold last y-coordinate, use new x-coordinate
screenPts[count].x = screenPts[count + 1].x;
screenPts[count].y = screenPts[count - 1].y;
// Use the same style for both the hold and the step points
map[count] = map[count + 1] = mapPtr->map[i];
count += 2;
}
delete [] mapPtr->map;
mapPtr->map = map;
delete [] mapPtr->screenPts;
mapPtr->screenPts = screenPts;
mapPtr->nScreenPts = newSize;
}
void LineElement::generateSpline(MapInfo *mapPtr)
{
int nOrigPts = mapPtr->nScreenPts;
Point2d* origPts = mapPtr->screenPts;
// check points are not monotonically increasing
for (int ii=0, jj=1; jj<nOrigPts; ii++, jj++) {
if (origPts[jj].x <= origPts[ii].x)
return;
}
if (((origPts[0].x > (double)graphPtr_->right_)) ||
((origPts[mapPtr->nScreenPts - 1].x < (double)graphPtr_->left_)))
return;
// The spline is computed in screen coordinates instead of data points so
// that we can select the abscissas of the interpolated points from each
// pixel horizontally across the plotting area.
int extra = (graphPtr_->right_ - graphPtr_->left_) + 1;
if (extra < 1)
return;
int niPts = nOrigPts + extra + 1;
Point2d* iPts = new Point2d[niPts];
int* map = new int[niPts];
// Populate the x2 array with both the original X-coordinates and extra
// X-coordinates for each horizontal pixel that the line segment contains
int count = 0;
for (int ii=0, jj=1; jj<nOrigPts; ii++, jj++) {
// Add the original x-coordinate
iPts[count].x = origPts[ii].x;
// Include the starting offset of the point in the offset array
map[count] = mapPtr->map[ii];
count++;
// Is any part of the interval (line segment) in the plotting area?
if ((origPts[jj].x >= (double)graphPtr_->left_) ||
(origPts[ii].x <= (double)graphPtr_->right_)) {
double x = origPts[ii].x + 1.0;
/*
* Since the line segment may be partially clipped on the left or
* right side, the points to interpolate are always interior to
* the plotting area.
*
* left right
* x1----|---------------------------|---x2
*
* Pick the max of the starting X-coordinate and the left edge and
* the min of the last X-coordinate and the right edge.
*/
x = MAX(x, (double)graphPtr_->left_);
double last = MIN(origPts[jj].x, (double)graphPtr_->right_);
// Add the extra x-coordinates to the interval
while (x < last) {
map[count] = mapPtr->map[ii];
iPts[count++].x = x;
x++;
}
}
}
niPts = count;
int result = 0;
if (smooth_ == CUBIC)
result = naturalSpline(origPts, nOrigPts, iPts, niPts);
else if (smooth_ == QUADRATIC)
result = quadraticSpline(origPts, nOrigPts, iPts, niPts);
// The spline interpolation failed. We will fall back to the current
// coordinates and do no smoothing (standard line segments)
if (!result) {
smooth_ = LINEAR;
delete [] iPts;
delete [] map;
}
else {
delete [] mapPtr->map;
mapPtr->map = map;
delete [] mapPtr->screenPts;
mapPtr->screenPts = iPts;
mapPtr->nScreenPts = niPts;
}
}
void LineElement::generateParametricSpline(MapInfo *mapPtr)
{
int nOrigPts = mapPtr->nScreenPts;
Point2d *origPts = mapPtr->screenPts;
Region2d exts;
graphPtr_->extents(&exts);
/*
* Populate the x2 array with both the original X-coordinates and extra
* X-coordinates for each horizontal pixel that the line segment contains.
*/
int count = 1;
for (int i = 0, j = 1; j < nOrigPts; i++, j++) {
Point2d p = origPts[i];
Point2d q = origPts[j];
count++;
if (lineRectClip(&exts, &p, &q))
count += (int)(hypot(q.x - p.x, q.y - p.y) * 0.5);
}
int niPts = count;
Point2d *iPts = new Point2d[niPts];
int* map = new int[niPts];
/*
* FIXME: This is just plain wrong. The spline should be computed
* and evaluated in separate steps. This will mean breaking
* up this routine since the catrom coefficients can be
* independently computed for original data point. This
* also handles the problem of allocating enough points
* since evaluation is independent of the number of points
* to be evalualted. The interpolated
* line segments should be clipped, not the original segments.
*/
count = 0;
int i,j;
for (i = 0, j = 1; j < nOrigPts; i++, j++) {
Point2d p = origPts[i];
Point2d q = origPts[j];
double d = hypot(q.x - p.x, q.y - p.y);
/* Add the original x-coordinate */
iPts[count].x = (double)i;
iPts[count].y = 0.0;
/* Include the starting offset of the point in the offset array */
map[count] = mapPtr->map[i];
count++;
/* Is any part of the interval (line segment) in the plotting
* area? */
if (lineRectClip(&exts, &p, &q)) {
double dp, dq;
/* Distance of original point to p. */
dp = hypot(p.x - origPts[i].x, p.y - origPts[i].y);
/* Distance of original point to q. */
dq = hypot(q.x - origPts[i].x, q.y - origPts[i].y);
dp += 2.0;
while(dp <= dq) {
/* Point is indicated by its interval and parameter t. */
iPts[count].x = (double)i;
iPts[count].y = dp / d;
map[count] = mapPtr->map[i];
count++;
dp += 2.0;
}
}
}
iPts[count].x = (double)i;
iPts[count].y = 0.0;
map[count] = mapPtr->map[i];
count++;
niPts = count;
int result = 0;
if (smooth_ == CUBIC)
result = naturalParametricSpline(origPts, nOrigPts, &exts, 0, iPts, niPts);
else if (smooth_ == CATROM)
result = catromParametricSpline(origPts, nOrigPts, iPts, niPts);
// The spline interpolation failed. We will fall back to the current
// coordinates and do no smoothing (standard line segments)
if (!result) {
smooth_ = LINEAR;
delete [] iPts;
delete [] map;
}
else {
delete [] mapPtr->map;
mapPtr->map = map;
delete [] mapPtr->screenPts;
mapPtr->screenPts = iPts;
mapPtr->nScreenPts = niPts;
}
}
void LineElement::mapSymbols(MapInfo *mapPtr)
{
Point2d* points = new Point2d[mapPtr->nScreenPts];
int *map = new int[mapPtr->nScreenPts];
Region2d exts;
graphPtr_->extents(&exts);
Point2d *pp;
int count = 0;
int i;
for (pp=mapPtr->screenPts, i=0; i<mapPtr->nScreenPts; i++, pp++) {
if (PointInRegion(&exts, pp->x, pp->y)) {
points[count].x = pp->x;
points[count].y = pp->y;
map[count] = mapPtr->map[i];
count++;
}
}
symbolPts_.points = points;
symbolPts_.length = count;
symbolPts_.map = map;
}
void LineElement::mapActiveSymbols()
{
LineElementOptions* ops = (LineElementOptions*)ops_;
delete [] activePts_.points;
activePts_.points = NULL;
delete [] activePts_.map;
activePts_.map = NULL;
Region2d exts;
graphPtr_->extents(&exts);
Point2d *points = new Point2d[nActiveIndices_];
int* map = new int[nActiveIndices_];
int np = NUMBEROFPOINTS(ops);
int count = 0;
if (ops->coords.x && ops->coords.y) {
for (int ii=0; ii<nActiveIndices_; ii++) {
int iPoint = activeIndices_[ii];
if (iPoint >= np)
continue;
double x = ops->coords.x->values_[iPoint];
double y = ops->coords.y->values_[iPoint];
points[count] = graphPtr_->map2D(x, y, ops->xAxis, ops->yAxis);
map[count] = iPoint;
if (PointInRegion(&exts, points[count].x, points[count].y)) {
count++;
}
}
}
if (count > 0) {
activePts_.points = points;
activePts_.map = map;
}
else {
delete [] points;
delete [] map;
}
activePts_.length = count;
}
void LineElement::mergePens(LineStyle **styleMap)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
if (Chain_GetLength(ops->stylePalette) < 2) {
ChainLink* link = Chain_FirstLink(ops->stylePalette);
LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
stylePtr->symbolPts.length = symbolPts_.length;
stylePtr->symbolPts.points = symbolPts_.points;
stylePtr->xeb.length = xeb_.length;
stylePtr->xeb.segments = xeb_.segments;
stylePtr->yeb.length = yeb_.length;
stylePtr->yeb.segments = yeb_.segments;
return;
}
if (symbolPts_.length > 0) {
Point2d* points = new Point2d[symbolPts_.length];
int* map = new int[symbolPts_.length];
Point2d *pp = points;
int* ip = map;
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
stylePtr->symbolPts.points = pp;
for (int ii=0; ii<symbolPts_.length; ii++) {
int iData = symbolPts_.map[ii];
if (styleMap[iData] == stylePtr) {
*pp++ = symbolPts_.points[ii];
*ip++ = iData;
}
}
stylePtr->symbolPts.length = pp - stylePtr->symbolPts.points;
}
delete [] symbolPts_.points;
symbolPts_.points = points;
delete [] symbolPts_.map;
symbolPts_.map = map;
}
if (xeb_.length > 0) {
Segment2d* segments = new Segment2d[xeb_.length];
Segment2d *sp = segments;
int* map = new int[xeb_.length];
int* ip = map;
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
stylePtr->xeb.segments = sp;
for (int ii=0; ii<xeb_.length; ii++) {
int iData = xeb_.map[ii];
if (styleMap[iData] == stylePtr) {
*sp++ = xeb_.segments[ii];
*ip++ = iData;
}
}
stylePtr->xeb.length = sp - stylePtr->xeb.segments;
}
delete [] xeb_.segments;
xeb_.segments = segments;
delete [] xeb_.map;
xeb_.map = map;
}
if (yeb_.length > 0) {
Segment2d* segments = new Segment2d[yeb_.length];
Segment2d* sp = segments;
int* map = new int [yeb_.length];
int* ip = map;
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
stylePtr->yeb.segments = sp;
for (int ii=0; ii<yeb_.length; ii++) {
int iData = yeb_.map[ii];
if (styleMap[iData] == stylePtr) {
*sp++ = yeb_.segments[ii];
*ip++ = iData;
}
}
stylePtr->yeb.length = sp - stylePtr->yeb.segments;
}
delete [] yeb_.segments;
yeb_.segments = segments;
delete [] yeb_.map;
yeb_.map = map;
}
}
#define CLIP_TOP (1<<0)
#define CLIP_BOTTOM (1<<1)
#define CLIP_RIGHT (1<<2)
#define CLIP_LEFT (1<<3)
int LineElement::outCode(Region2d *extsPtr, Point2d *p)
{
int code =0;
if (p->x > extsPtr->right)
code |= CLIP_RIGHT;
else if (p->x < extsPtr->left)
code |= CLIP_LEFT;
if (p->y > extsPtr->bottom)
code |= CLIP_BOTTOM;
else if (p->y < extsPtr->top)
code |= CLIP_TOP;
return code;
}
int LineElement::clipSegment(Region2d *extsPtr, int code1, int code2,
Point2d *p, Point2d *q)
{
int inside = ((code1 | code2) == 0);
int outside = ((code1 & code2) != 0);
/*
* In the worst case, we'll clip the line segment against each of the four
* sides of the bounding rectangle.
*/
while ((!outside) && (!inside)) {
if (code1 == 0) {
Point2d *tmp;
int code;
/* Swap pointers and out codes */
tmp = p, p = q, q = tmp;
code = code1, code1 = code2, code2 = code;
}
if (code1 & CLIP_LEFT) {
p->y += (q->y - p->y) *
(extsPtr->left - p->x) / (q->x - p->x);
p->x = extsPtr->left;
} else if (code1 & CLIP_RIGHT) {
p->y += (q->y - p->y) *
(extsPtr->right - p->x) / (q->x - p->x);
p->x = extsPtr->right;
} else if (code1 & CLIP_BOTTOM) {
p->x += (q->x - p->x) *
(extsPtr->bottom - p->y) / (q->y - p->y);
p->y = extsPtr->bottom;
} else if (code1 & CLIP_TOP) {
p->x += (q->x - p->x) *
(extsPtr->top - p->y) / (q->y - p->y);
p->y = extsPtr->top;
}
code1 = outCode(extsPtr, p);
inside = ((code1 | code2) == 0);
outside = ((code1 & code2) != 0);
}
return (!inside);
}
void LineElement::saveTrace(int start, int length, MapInfo* mapPtr)
{
bltTrace* tracePtr = new bltTrace;
Point2d* screenPts = new Point2d[length];
int* map = new int[length];
// Copy the screen coordinates of the trace into the point array
if (mapPtr->map) {
for (int ii=0, jj=start; ii<length; ii++, jj++) {
screenPts[ii].x = mapPtr->screenPts[jj].x;
screenPts[ii].y = mapPtr->screenPts[jj].y;
map[ii] = mapPtr->map[jj];
}
}
else {
for (int ii=0, jj=start; ii<length; ii++, jj++) {
screenPts[ii].x = mapPtr->screenPts[jj].x;
screenPts[ii].y = mapPtr->screenPts[jj].y;
map[ii] = jj;
}
}
tracePtr->screenPts.length = length;
tracePtr->screenPts.points = screenPts;
tracePtr->screenPts.map = map;
tracePtr->start = start;
if (traces_ == NULL)
traces_ = new Chain();
traces_->append(tracePtr);
}
void LineElement::freeTraces()
{
for (ChainLink* link = Chain_FirstLink(traces_); link;
link = Chain_NextLink(link)) {
bltTrace* tracePtr = (bltTrace*)Chain_GetValue(link);
delete [] tracePtr->screenPts.map;
delete [] tracePtr->screenPts.points;
delete tracePtr;
}
delete traces_;
traces_ = NULL;
}
void LineElement::mapTraces(MapInfo *mapPtr)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
Region2d exts;
graphPtr_->extents(&exts);
int count = 1;
int code1 = outCode(&exts, mapPtr->screenPts);
Point2d* p = mapPtr->screenPts;
Point2d* q = p + 1;
int start;
int ii;
for (ii=1; ii<mapPtr->nScreenPts; ii++, p++, q++) {
Point2d s;
s.x = 0;
s.y = 0;
int code2 = outCode(&exts, q);
// Save the coordinates of the last point, before clipping
if (code2 != 0)
s = *q;
int broken = BROKEN_TRACE(ops->penDir, p->x, q->x);
int offscreen = clipSegment(&exts, code1, code2, p, q);
if (broken || offscreen) {
// The last line segment is either totally clipped by the plotting
// area or the x-direction is wrong, breaking the trace. Either
// way, save information about the last trace (if one exists),
// discarding the current line segment
if (count > 1) {
start = ii - count;
saveTrace(start, count, mapPtr);
count = 1;
}
}
else {
// Add the point to the trace
count++;
// If the last point is clipped, this means that the trace is
// broken after this point. Restore the original coordinate
// (before clipping) after saving the trace.
if (code2 != 0) {
start = ii - (count - 1);
saveTrace(start, count, mapPtr);
mapPtr->screenPts[ii] = s;
count = 1;
}
}
code1 = code2;
}
if (count > 1) {
start = ii - count;
saveTrace(start, count, mapPtr);
}
}
void LineElement::mapFillArea(MapInfo *mapPtr)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
GraphOptions* gops = (GraphOptions*)graphPtr_->ops_;
if (fillPts_) {
delete [] fillPts_;
fillPts_ = NULL;
nFillPts_ = 0;
}
if (mapPtr->nScreenPts < 3)
return;
int np = mapPtr->nScreenPts + 3;
Region2d exts;
graphPtr_->extents(&exts);
Point2d* origPts = new Point2d[np];
if (gops->inverted) {
int i;
double minX = (double)ops->yAxis->screenMin_;
for (i = 0; i < mapPtr->nScreenPts; i++) {
origPts[i].x = mapPtr->screenPts[i].x + 1;
origPts[i].y = mapPtr->screenPts[i].y;
if (origPts[i].x < minX) {
minX = origPts[i].x;
}
}
// Add edges to make the polygon fill to the bottom of plotting window
origPts[i].x = minX;
origPts[i].y = origPts[i - 1].y;
i++;
origPts[i].x = minX;
origPts[i].y = origPts[0].y;
i++;
origPts[i] = origPts[0];
}
else {
int i;
double maxY = (double)ops->yAxis->bottom_;
for (i = 0; i < mapPtr->nScreenPts; i++) {
origPts[i].x = mapPtr->screenPts[i].x + 1;
origPts[i].y = mapPtr->screenPts[i].y;
if (origPts[i].y > maxY) {
maxY = origPts[i].y;
}
}
// Add edges to extend the fill polygon to the bottom of plotting window
origPts[i].x = origPts[i - 1].x;
origPts[i].y = maxY;
i++;
origPts[i].x = origPts[0].x;
origPts[i].y = maxY;
i++;
origPts[i] = origPts[0];
}
Point2d *clipPts = new Point2d[np * 3];
np = polyRectClip(&exts, origPts, np - 1, clipPts);
delete [] origPts;
if (np < 3)
delete [] clipPts;
else {
fillPts_ = clipPts;
nFillPts_ = np;
}
}
void LineElement::reset()
{
LineElementOptions* ops = (LineElementOptions*)ops_;
freeTraces();
for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
link = Chain_NextLink(link)) {
LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
stylePtr->symbolPts.length = 0;
stylePtr->xeb.length = 0;
stylePtr->yeb.length = 0;
}
delete [] symbolPts_.points;
symbolPts_.points = NULL;
delete [] symbolPts_.map;
symbolPts_.map = NULL;
symbolPts_.length = 0;
delete [] activePts_.points;
activePts_.points = NULL;
activePts_.length = 0;
delete [] activePts_.map;
activePts_.map = NULL;
delete [] xeb_.segments;
xeb_.segments = NULL;
delete [] xeb_.map;
xeb_.map = NULL;
xeb_.length = 0;
delete [] yeb_.segments;
yeb_.segments = NULL;
delete [] yeb_.map;
yeb_.map = NULL;
yeb_.length = 0;
}
void LineElement::mapErrorBars(LineStyle **styleMap)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
Region2d exts;
graphPtr_->extents(&exts);
int nn =0;
int np = NUMBEROFPOINTS(ops);
if (ops->coords.x && ops->coords.y) {
if (ops->xError && (ops->xError->nValues() > 0))
nn = MIN(ops->xError->nValues(), np);
else
if (ops->xHigh && ops->xLow)
nn = MIN3(ops->xHigh->nValues(), ops->xLow->nValues(), np);
}
if (nn) {
Segment2d* errorBars = new Segment2d[nn * 3];
Segment2d* segPtr = errorBars;
int* errorToData = new int[nn * 3];
int* indexPtr = errorToData;
for (int ii=0; ii<nn; ii++) {
double x = ops->coords.x->values_[ii];
double y = ops->coords.y->values_[ii];
LineStyle* stylePtr = styleMap[ii];
if ((isfinite(x)) && (isfinite(y))) {
double high;
double low;
if (ops->xError->nValues() > 0) {
high = x + ops->xError->values_[ii];
low = x - ops->xError->values_[ii];
}
else {
high = ops->xHigh ? ops->xHigh->values_[ii] : 0;
low = ops->xLow ? ops->xLow->values_[ii] : 0;
}
if ((isfinite(high)) && (isfinite(low))) {
Point2d p = graphPtr_->map2D(high, y, ops->xAxis, ops->yAxis);
Point2d q = graphPtr_->map2D(low, y, ops->xAxis, ops->yAxis);
segPtr->p = p;
segPtr->q = q;
if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
segPtr++;
*indexPtr++ = ii;
}
// Left cap
segPtr->p.x = p.x;
segPtr->q.x = p.x;
segPtr->p.y = p.y - stylePtr->errorBarCapWidth;
segPtr->q.y = p.y + stylePtr->errorBarCapWidth;
if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
segPtr++;
*indexPtr++ = ii;
}
// Right cap
segPtr->p.x = q.x;
segPtr->q.x = q.x;
segPtr->p.y = q.y - stylePtr->errorBarCapWidth;
segPtr->q.y = q.y + stylePtr->errorBarCapWidth;
if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
segPtr++;
*indexPtr++ = ii;
}
}
}
}
xeb_.segments = errorBars;
xeb_.length = segPtr - errorBars;
xeb_.map = errorToData;
}
nn =0;
if (ops->coords.x && ops->coords.y) {
if (ops->yError && (ops->yError->nValues() > 0))
nn = MIN(ops->yError->nValues(), np);
else
if (ops->yHigh && ops->yLow)
nn = MIN3(ops->yHigh->nValues(), ops->yLow->nValues(), np);
}
if (nn) {
Segment2d* errorBars = new Segment2d[nn * 3];
Segment2d* segPtr = errorBars;
int* errorToData = new int[nn * 3];
int* indexPtr = errorToData;
for (int ii=0; ii<nn; ii++) {
double x = ops->coords.x->values_[ii];
double y = ops->coords.y->values_[ii];
LineStyle* stylePtr = styleMap[ii];
if ((isfinite(x)) && (isfinite(y))) {
double high;
double low;
if (ops->yError->nValues() > 0) {
high = y + ops->yError->values_[ii];
low = y - ops->yError->values_[ii];
}
else {
high = ops->yHigh->values_[ii];
low = ops->yLow->values_[ii];
}
if ((isfinite(high)) && (isfinite(low))) {
Point2d p = graphPtr_->map2D(x, high, ops->xAxis, ops->yAxis);
Point2d q = graphPtr_->map2D(x, low, ops->xAxis, ops->yAxis);
segPtr->p = p;
segPtr->q = q;
if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
segPtr++;
*indexPtr++ = ii;
}
// Top cap
segPtr->p.y = p.y;
segPtr->q.y = p.y;
segPtr->p.x = p.x - stylePtr->errorBarCapWidth;
segPtr->q.x = p.x + stylePtr->errorBarCapWidth;
if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
segPtr++;
*indexPtr++ = ii;
}
// Bottom cap
segPtr->p.y = q.y;
segPtr->q.y = q.y;
segPtr->p.x = q.x - stylePtr->errorBarCapWidth;
segPtr->q.x = q.x + stylePtr->errorBarCapWidth;
if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
segPtr++;
*indexPtr++ = ii;
}
}
}
}
yeb_.segments = errorBars;
yeb_.length = segPtr - errorBars;
yeb_.map = errorToData;
}
}
int LineElement::closestTrace()
{
LineElementOptions* ops = (LineElementOptions*)ops_;
GraphOptions* gops = (GraphOptions*)graphPtr_->ops_;
ClosestSearch* searchPtr = &gops->search;
Point2d closest;
int iClose = -1;
double dMin = searchPtr->dist;
closest.x = closest.y = 0;
for (ChainLink *link=Chain_FirstLink(traces_); link;
link = Chain_NextLink(link)) {
bltTrace *tracePtr = (bltTrace*)Chain_GetValue(link);
for (Point2d *p=tracePtr->screenPts.points,
*pend=p + (tracePtr->screenPts.length - 1); p<pend; p++) {
Point2d b;
double d;
if (searchPtr->along == SEARCH_X)
d = distanceToX(searchPtr->x, searchPtr->y, p, p + 1, &b);
else if (searchPtr->along == SEARCH_Y)
d = distanceToY(searchPtr->x, searchPtr->y, p, p + 1, &b);
else
d = distanceToLine(searchPtr->x, searchPtr->y, p, p + 1, &b);
if (d < dMin) {
closest = b;
iClose = tracePtr->screenPts.map[p-tracePtr->screenPts.points];
dMin = d;
}
}
}
if (dMin < searchPtr->dist) {
searchPtr->dist = dMin;
searchPtr->elemPtr = (Element*)this;
searchPtr->index = iClose;
searchPtr->point = graphPtr_->invMap2D(closest.x, closest.y,
ops->xAxis, ops->yAxis);
return 1;
}
return 0;
}
void LineElement::closestPoint(ClosestSearch *searchPtr)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
double dMin = searchPtr->dist;
int iClose = 0;
// Instead of testing each data point in graph coordinates, look at the
// array of mapped screen coordinates. The advantages are
// 1) only examine points that are visible (unclipped), and
// 2) the computed distance is already in screen coordinates.
int count =0;
for (Point2d *pp = symbolPts_.points; count < symbolPts_.length;
count++, pp++) {
double dx = (double)(searchPtr->x - pp->x);
double dy = (double)(searchPtr->y - pp->y);
double d;
if (searchPtr->along == SEARCH_BOTH)
d = hypot(dx, dy);
else if (searchPtr->along == SEARCH_X)
d = dx;
else if (searchPtr->along == SEARCH_Y)
d = dy;
else
continue;
if (d < dMin) {
iClose = symbolPts_.map[count];
dMin = d;
}
}
if (dMin < searchPtr->dist) {
searchPtr->elemPtr = (Element*)this;
searchPtr->dist = dMin;
searchPtr->index = iClose;
searchPtr->point.x = ops->coords.x->values_[iClose];
searchPtr->point.y = ops->coords.y->values_[iClose];
}
}
void LineElement::drawCircle(Display *display, Drawable drawable,
LinePen* penPtr,
int nSymbolPts, Point2d *symbolPts, int radius)
{
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
int count = 0;
int s = radius + radius;
XArc* arcs = new XArc[nSymbolPts];
XArc *ap = arcs;
for (Point2d *pp=symbolPts, *pend=pp+nSymbolPts; pp<pend; pp++) {
if (DRAW_SYMBOL()) {
ap->x = (short)(pp->x - radius);
ap->y = (short)(pp->y - radius);
ap->width = (short)s;
ap->height = (short)s;
ap->angle1 = 0;
ap->angle2 = 23040;
ap++;
count++;
}
symbolCounter_++;
}
for (XArc *ap=arcs, *aend=ap+count; ap<aend; ap++) {
if (penOps->symbol.fillGC)
XFillArc(display, drawable, penOps->symbol.fillGC,
ap->x, ap->y, ap->width, ap->height, ap->angle1, ap->angle2);
if (penOps->symbol.outlineWidth > 0)
XDrawArc(display, drawable, penOps->symbol.outlineGC,
ap->x, ap->y, ap->width, ap->height, ap->angle1, ap->angle2);
}
delete [] arcs;
}
void LineElement::drawSquare(Display *display, Drawable drawable,
LinePen* penPtr,
int nSymbolPts, Point2d *symbolPts, int r)
{
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
int s = r + r;
int count =0;
Rectangle* rectangles = new Rectangle[nSymbolPts];
Rectangle* rp=rectangles;
for (Point2d *pp=symbolPts, *pend=pp+nSymbolPts; pp<pend; pp++) {
if (DRAW_SYMBOL()) {
rp->x = (int)pp->x - r;
rp->y = (int)pp->y - r;
rp->width = s;
rp->height = s;
rp++;
count++;
}
symbolCounter_++;
}
for (Rectangle *rp=rectangles, *rend=rp+count; rp<rend; rp ++) {
if (penOps->symbol.fillGC)
XFillRectangle(display, drawable, penOps->symbol.fillGC,
rp->x, rp->y, rp->width, rp->height);
if (penOps->symbol.outlineWidth > 0)
XDrawRectangle(display, drawable, penOps->symbol.outlineGC,
rp->x, rp->y, rp->width, rp->height);
}
delete [] rectangles;
}
void LineElement::drawSCross(Display* display, Drawable drawable,
LinePen* penPtr,
int nSymbolPts, Point2d* symbolPts, int r2)
{
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
Point pattern[4];
if (penOps->symbol.type == SYMBOL_SCROSS) {
r2 = (int)(r2 * M_SQRT1_2);
pattern[3].y = pattern[2].x = pattern[0].x = pattern[0].y = -r2;
pattern[3].x = pattern[2].y = pattern[1].y = pattern[1].x = r2;
}
else {
pattern[0].y = pattern[1].y = pattern[2].x = pattern[3].x = 0;
pattern[0].x = pattern[2].y = -r2;
pattern[1].x = pattern[3].y = r2;
}
for (Point2d *pp=symbolPts, *endp=pp+nSymbolPts; pp<endp; pp++) {
if (DRAW_SYMBOL()) {
int rndx = (int)pp->x;
int rndy = (int)pp->y;
XDrawLine(graphPtr_->display_, drawable, penOps->symbol.outlineGC,
pattern[0].x + rndx, pattern[0].y + rndy,
pattern[1].x + rndx, pattern[1].y + rndy);
XDrawLine(graphPtr_->display_, drawable, penOps->symbol.outlineGC,
pattern[2].x + rndx, pattern[2].y + rndy,
pattern[3].x + rndx, pattern[3].y + rndy);
}
}
}
void LineElement::drawCross(Display *display, Drawable drawable,
LinePen* penPtr,
int nSymbolPts, Point2d *symbolPts, int r2)
{
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
/*
* 2 3 The plus/cross symbol is a closed polygon
* of 12 points. The diagram to the left
* 0,12 1 4 5 represents the positions of the points
* x,y which are computed below. The extra
* 11 10 7 6 (thirteenth) point connects the first and
* last points.
* 9 8
*/
int d = (r2 / 3);
Point pattern[13];
pattern[0].x = pattern[11].x = pattern[12].x = -r2;
pattern[2].x = pattern[1].x = pattern[10].x = pattern[9].x = -d;
pattern[3].x = pattern[4].x = pattern[7].x = pattern[8].x = d;
pattern[5].x = pattern[6].x = r2;
pattern[2].y = pattern[3].y = -r2;
pattern[0].y = pattern[1].y = pattern[4].y = pattern[5].y =
pattern[12].y = -d;
pattern[11].y = pattern[10].y = pattern[7].y = pattern[6].y = d;
pattern[9].y = pattern[8].y = r2;
if (penOps->symbol.type == SYMBOL_CROSS) {
// For the cross symbol, rotate the points by 45 degrees
for (int ii=0; ii<12; ii++) {
double dx = (double)pattern[ii].x * M_SQRT1_2;
double dy = (double)pattern[ii].y * M_SQRT1_2;
pattern[ii].x = (int)(dx - dy);
pattern[ii].y = (int)(dx + dy);
}
pattern[12] = pattern[0];
}
int count = 0;
XPoint* polygon = new XPoint[nSymbolPts*13];
XPoint* xpp = polygon;
for (Point2d *pp = symbolPts, *endp = pp + nSymbolPts; pp < endp; pp++) {
if (DRAW_SYMBOL()) {
int rndx = (int)pp->x;
int rndy = (int)pp->y;
for (int ii=0; ii<13; ii++) {
xpp->x = (short)(pattern[ii].x + rndx);
xpp->y = (short)(pattern[ii].y + rndy);
xpp++;
}
count++;
}
symbolCounter_++;
}
if (penOps->symbol.fillGC) {
XPoint* xpp = polygon;
for (int ii=0; ii<count; ii++, xpp += 13)
XFillPolygon(graphPtr_->display_, drawable,
penOps->symbol.fillGC, xpp, 13, Complex,
CoordModeOrigin);
}
if (penOps->symbol.outlineWidth > 0) {
XPoint*xpp = polygon;
for (int ii=0; ii<count; ii++, xpp += 13)
XDrawLines(graphPtr_->display_, drawable,
penOps->symbol.outlineGC, xpp, 13, CoordModeOrigin);
}
delete [] polygon;
}
void LineElement::drawDiamond(Display *display, Drawable drawable,
LinePen* penPtr,
int nSymbolPts, Point2d *symbolPts, int r1)
{
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
/*
* The plus symbol is a closed polygon
* 1 of 4 points. The diagram to the left
* represents the positions of the points
* 0,4 x,y 2 which are computed below. The extra
* (fifth) point connects the first and
* 3 last points.
*/
Point pattern[5];
pattern[1].y = pattern[0].x = -r1;
pattern[2].y = pattern[3].x = pattern[0].y = pattern[1].x = 0;
pattern[3].y = pattern[2].x = r1;
pattern[4] = pattern[0];
int count = 0;
XPoint* polygon = new XPoint[nSymbolPts*5];
XPoint* xpp = polygon;
for (Point2d *pp = symbolPts, *endp = pp + nSymbolPts; pp < endp; pp++) {
if (DRAW_SYMBOL()) {
int rndx = (int)pp->x;
int rndy = (int)pp->y;
for (int ii=0; ii<5; ii++) {
xpp->x = (short)(pattern[ii].x + rndx);
xpp->y = (short)(pattern[ii].y + rndy);
xpp++;
}
count++;
}
symbolCounter_++;
}
if (penOps->symbol.fillGC) {
XPoint* xpp = polygon;
for (int ii=0; ii<count; ii++, xpp += 5)
XFillPolygon(graphPtr_->display_, drawable,
penOps->symbol.fillGC, xpp, 5, Convex, CoordModeOrigin);
}
if (penOps->symbol.outlineWidth > 0) {
XPoint* xpp = polygon;
for (int ii=0; ii<count; ii++, xpp += 5)
XDrawLines(graphPtr_->display_, drawable,
penOps->symbol.outlineGC, xpp, 5, CoordModeOrigin);
}
delete [] polygon;
}
#define B_RATIO 1.3467736870885982
#define TAN30 0.57735026918962573
#define COS30 0.86602540378443871
void LineElement::drawArrow(Display *display, Drawable drawable,
LinePen* penPtr,
int nSymbolPts, Point2d *symbolPts, int size)
{
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
double b = size * B_RATIO * 0.7 * 0.5;
short b2 = (short)b;
short h2 = (short)(TAN30 * b);
short h1 = (short)(b / COS30);
/*
* The triangle symbol is a closed polygon
* 0,3 of 3 points. The diagram to the left
* represents the positions of the points
* x,y which are computed below. The extra
* (fourth) point connects the first and
* 2 1 last points.
*/
Point pattern[4];
if (penOps->symbol.type == SYMBOL_ARROW) {
pattern[3].x = pattern[0].x = 0;
pattern[3].y = pattern[0].y = h1;
pattern[1].x = b2;
pattern[2].y = pattern[1].y = -h2;
pattern[2].x = -b2;
} else {
pattern[3].x = pattern[0].x = 0;
pattern[3].y = pattern[0].y = -h1;
pattern[1].x = b2;
pattern[2].y = pattern[1].y = h2;
pattern[2].x = -b2;
}
int count = 0;
XPoint* polygon = new XPoint[nSymbolPts*4];
XPoint* xpp = polygon;
for (Point2d *pp = symbolPts, *endp = pp + nSymbolPts; pp < endp; pp++) {
if (DRAW_SYMBOL()) {
int rndx = (int)pp->x;
int rndy = (int)pp->y;
for (int ii=0; ii<4; ii++) {
xpp->x = (short)(pattern[ii].x + rndx);
xpp->y = (short)(pattern[ii].y + rndy);
xpp++;
}
count++;
}
symbolCounter_++;
}
if (penOps->symbol.fillGC) {
XPoint* xpp = polygon;
for (int ii=0; ii<count; ii++, xpp += 4)
XFillPolygon(graphPtr_->display_, drawable,
penOps->symbol.fillGC, xpp, 4, Convex, CoordModeOrigin);
}
if (penOps->symbol.outlineWidth > 0) {
XPoint* xpp = polygon;
for (int ii=0; ii<count; ii++, xpp += 4)
XDrawLines(graphPtr_->display_, drawable,
penOps->symbol.outlineGC, xpp, 4, CoordModeOrigin);
}
delete [] polygon;
}
#define S_RATIO 0.886226925452758
void LineElement::drawSymbols(Drawable drawable, LinePen* penPtr, int size,
int nSymbolPts, Point2d* symbolPts)
{
LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
if (size < 3) {
if (penOps->symbol.fillGC) {
for (Point2d *pp = symbolPts, *endp = pp + nSymbolPts; pp < endp; pp++)
XDrawLine(graphPtr_->display_, drawable, penOps->symbol.fillGC,
(int)pp->x, (int)pp->y, (int)pp->x+1, (int)pp->y+1);
}
return;
}
int r1 = (int)ceil(size * 0.5);
int r2 = (int)ceil(size * S_RATIO * 0.5);
switch (penOps->symbol.type) {
case SYMBOL_NONE:
break;
case SYMBOL_SQUARE:
drawSquare(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r2);
break;
case SYMBOL_CIRCLE:
drawCircle(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r1);
break;
case SYMBOL_SPLUS:
case SYMBOL_SCROSS:
drawSCross(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r2);
break;
case SYMBOL_PLUS:
case SYMBOL_CROSS:
drawCross(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r2);
break;
case SYMBOL_DIAMOND:
drawDiamond(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r1);
break;
case SYMBOL_TRIANGLE:
case SYMBOL_ARROW:
drawArrow(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,size);
break;
}
}
void LineElement::drawTraces(Drawable drawable, LinePen* penPtr)
{
for (ChainLink* link = Chain_FirstLink(traces_); link;
link = Chain_NextLink(link)) {
bltTrace* tracePtr = (bltTrace*)Chain_GetValue(link);
int count = tracePtr->screenPts.length;
XPoint* points = new XPoint[count];
XPoint*xpp = points;
for (int ii=0; ii<count; ii++, xpp++) {
xpp->x = (short)tracePtr->screenPts.points[ii].x;
xpp->y = (short)tracePtr->screenPts.points[ii].y;
}
XDrawLines(graphPtr_->display_, drawable, penPtr->traceGC_, points,
count, CoordModeOrigin);
delete [] points;
}
}
void LineElement::drawValues(Drawable drawable, LinePen* penPtr,
int length, Point2d *points, int *map)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
LinePenOptions* pops = (LinePenOptions*)penPtr->ops();
char string[TCL_DOUBLE_SPACE * 2 + 2];
const char* fmt = pops->valueFormat;
if (fmt == NULL)
fmt = "%g";
TextStyle ts(graphPtr_, &pops->valueStyle);
double* xval = ops->coords.x->values_;
double* yval = ops->coords.y->values_;
int count = 0;
for (Point2d *pp = points, *endp = points + length; pp < endp; pp++) {
double x = xval[map[count]];
double y = yval[map[count]];
count++;
if (pops->valueShow == SHOW_X)
snprintf(string, TCL_DOUBLE_SPACE, fmt, x);
else if (pops->valueShow == SHOW_Y)
snprintf(string, TCL_DOUBLE_SPACE, fmt, y);
else if (pops->valueShow == SHOW_BOTH) {
snprintf(string, TCL_DOUBLE_SPACE, fmt, x);
strcat(string, ",");
snprintf(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
}
ts.drawText(drawable, string, pp->x, pp->y);
}
}
void LineElement::printSymbols(PSOutput* psPtr, LinePen* penPtr, int size,
int nSymbolPts, Point2d *symbolPts)
{
LinePenOptions* pops = (LinePenOptions*)penPtr->ops();
double symbolSize;
// Set line and foreground attributes
XColor* fillColor = pops->symbol.fillColor;
if (!fillColor)
fillColor = pops->traceColor;
XColor* outlineColor = pops->symbol.outlineColor;
if (!outlineColor)
outlineColor = pops->traceColor;
if (pops->symbol.type == SYMBOL_NONE)
psPtr->setLineAttributes(pops->traceColor, pops->traceWidth + 2,
&pops->traceDashes, CapButt, JoinMiter);
else {
psPtr->setLineWidth(pops->symbol.outlineWidth);
psPtr->setDashes(NULL);
}
// build DrawSymbolProc
psPtr->append("\n/DrawSymbolProc {\n");
switch (pops->symbol.type) {
case SYMBOL_NONE:
break;
default:
psPtr->append(" ");
psPtr->setBackground(fillColor);
psPtr->append(" gsave fill grestore\n");
if (pops->symbol.outlineWidth > 0) {
psPtr->append(" ");
psPtr->setForeground(outlineColor);
psPtr->append(" stroke\n");
}
break;
}
psPtr->append("} def\n\n");
// set size
symbolSize = (double)size;
switch (pops->symbol.type) {
case SYMBOL_SQUARE:
case SYMBOL_CROSS:
case SYMBOL_PLUS:
case SYMBOL_SCROSS:
case SYMBOL_SPLUS:
symbolSize = (double)size * S_RATIO;
break;
case SYMBOL_TRIANGLE:
case SYMBOL_ARROW:
symbolSize = (double)size * 0.7;
break;
case SYMBOL_DIAMOND:
symbolSize = (double)size * M_SQRT1_2;
break;
default:
break;
}
int count =0;
for (Point2d *pp=symbolPts, *endp=symbolPts + nSymbolPts; pp < endp; pp++) {
if (DRAW_SYMBOL()) {
psPtr->format("%g %g %g %s\n", pp->x, pp->y, symbolSize,
symbolMacros[pops->symbol.type]);
count++;
}
symbolCounter_++;
}
}
void LineElement::setLineAttributes(PSOutput* psPtr, LinePen* penPtr)
{
LinePenOptions* pops = (LinePenOptions*)penPtr->ops();
psPtr->setLineAttributes(pops->traceColor, pops->traceWidth,
&pops->traceDashes, CapButt, JoinMiter);
if ((LineIsDashed(pops->traceDashes)) &&
(pops->traceOffColor)) {
psPtr->append("/DashesProc {\n gsave\n ");
psPtr->setBackground(pops->traceOffColor);
psPtr->append(" ");
psPtr->setDashes(NULL);
psPtr->append("stroke\n grestore\n} def\n");
} else {
psPtr->append("/DashesProc {} def\n");
}
}
void LineElement::printTraces(PSOutput* psPtr, LinePen* penPtr)
{
setLineAttributes(psPtr, penPtr);
for (ChainLink* link = Chain_FirstLink(traces_); link;
link = Chain_NextLink(link)) {
bltTrace *tracePtr = (bltTrace*)Chain_GetValue(link);
if (tracePtr->screenPts.length > 0) {
psPtr->append("% start trace\n");
psPtr->printMaxPolyline(tracePtr->screenPts.points,
tracePtr->screenPts.length);
psPtr->append("% end trace\n");
}
}
}
void LineElement::printValues(PSOutput* psPtr, LinePen* penPtr,
int nSymbolPts, Point2d *symbolPts,
int *pointToData)
{
LineElementOptions* ops = (LineElementOptions*)ops_;
LinePenOptions* pops = (LinePenOptions*)penPtr->ops();
const char* fmt = pops->valueFormat;
if (fmt == NULL)
fmt = "%g";
TextStyle ts(graphPtr_, &pops->valueStyle);
int count = 0;
for (Point2d *pp=symbolPts, *endp=symbolPts + nSymbolPts; pp < endp; pp++) {
double x = ops->coords.x->values_[pointToData[count]];
double y = ops->coords.y->values_[pointToData[count]];
count++;
char string[TCL_DOUBLE_SPACE * 2 + 2];
if (pops->valueShow == SHOW_X)
snprintf(string, TCL_DOUBLE_SPACE, fmt, x);
else if (pops->valueShow == SHOW_Y)
snprintf(string, TCL_DOUBLE_SPACE, fmt, y);
else if (pops->valueShow == SHOW_BOTH) {
snprintf(string, TCL_DOUBLE_SPACE, fmt, x);
strcat(string, ",");
snprintf(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
}
ts.printText(psPtr, string, pp->x, pp->y);
}
}