static int SmoothLines(long n, const GpReal *px, const GpReal *py,
int closed, int smooth, int clip)
{
int value= 0;
Engine *engine;
GpReal scalx, offx, scaly, offy;
if (clip && !gpClipInit) InitializeClip();
else gpClipInit= 0;
/* Now that clip has been set up, can change coordiante transform--
output from DoSmoothing is in normalized coordinates, while input
is in world coordinates... */
SwapNormMap(&scalx, &offx, &scaly, &offy);
if (!clip || ClipBegin(px, py, n, closed)) {
DoSmoothing(&n, &px, &py, closed, smooth, scalx, offx, scaly, offy);
/* Note: if closed, n= 3*n+1, last point same as first */
for (engine=GpNextActive(0) ; engine ; engine=GpNextActive(engine))
if (!engine->inhibit)
value|= engine->DrawLines(engine, n, px, py, 0, smooth);
} else while ((n=ClipMore())) {
px= xClip;
py= yClip;
DoSmoothing(&n, &px, &py, 0, smooth, scalx, offx, scaly, offy);
for (engine=GpNextActive(0) ; engine ; engine=GpNextActive(engine))
if (!engine->inhibit)
value|= engine->DrawLines(engine, n, px, py, 0, smooth);
}
SwapMapNorm();
return value;
}
int GpLines(long n, const GpReal *px, const GpReal *py)
{
int value= 0;
Engine *engine;
int closed= gpCloseNext;
int smooth= gpSmoothNext;
int clip= gistClip && !gpClipDone;
gpCloseNext= gpSmoothNext= gpClipDone= 0;
if (smooth) return SmoothLines(n, px, py, closed, smooth, clip);
if (clip) InitializeClip();
else gpClipInit= 0;
if (!clip || ClipBegin(px, py, n, closed)) {
for (engine=GpNextActive(0) ; engine ; engine=GpNextActive(engine))
if (!engine->inhibit)
value|= engine->DrawLines(engine, n, px, py, closed, smooth);
} else while ((n=ClipMore())) {
for (engine=GpNextActive(0) ; engine ; engine=GpNextActive(engine))
if (!engine->inhibit)
value|= engine->DrawLines(engine, n, xClip, yClip, 0, smooth);
}
return value;
}
int GaFillMesh(GaQuadMesh *mesh, int region, const GpColor *colors,
long nColumns)
{
int value= 0;
long iMax= mesh->iMax;
long ijMax= iMax*mesh->jMax;
GpReal *x= mesh->x, *y= mesh->y;
int *ireg= mesh->reg;
GpReal qx[4], qy[4];
long ij, row, col;
int rgb = colors? gistA.rgb : 0;
gistA.rgb = 0;
/* Create default region array if none supplied */
if (!ireg) {
ireg= NewReg(iMax, ijMax);
if (!ireg) return 1;
mesh->reg= ireg;
}
InitializeClip();
/* The only filled area attribute set is the color. */
row= col= 0;
if (!colors) gistA.f.color = BG_COLOR;
for (ij=iMax+1 ; ij<ijMax ; ij++) {
if (EXISTS(ij)) {
qx[0]= x[ij-iMax-1]; qy[0]= y[ij-iMax-1];
qx[1]= x[ij-iMax ]; qy[1]= y[ij-iMax ];
qx[2]= x[ij ]; qy[2]= y[ij ];
qx[3]= x[ij -1]; qy[3]= y[ij -1];
if (rgb) {
gistA.f.color = P_RGB(colors[3*(row+col)],
colors[3*(row+col)+1],colors[3*(row+col)+2]);
} else if (colors) {
gistA.f.color = colors[row+col];
}
gpClipInit= 1;
value|= GpFill(4, qx, qy);
}
col++;
if (col==iMax) {
col= 0;
row+= nColumns;
}
}
if (tmpReg) FreeTmpReg();
return value;
}
int GpFill(long n, const GpReal *px, const GpReal *py)
{
int value= 0;
Engine *engine;
if (gistClip) {
InitializeClip();
n= ClipFilled(px, py, n);
px= xClip;
py= yClip;
}
gpClipInit= 0;
if (n<2) return 0;
for (engine=GpNextActive(0) ; engine ; engine=GpNextActive(engine))
if (!engine->inhibit)
value|= engine->DrawFill(engine, n, px, py);
return value;
}
int GpDisjoint(long n, const GpReal *px, const GpReal *py,
const GpReal *qx, const GpReal *qy)
{
int value= 0;
Engine *engine;
if (gistClip) {
InitializeClip();
n= ClipDisjoint(px, py, qx, qy, n);
px= xClip;
py= yClip;
qx= xClip1;
qy= yClip1;
}
gpClipInit= 0;
for (engine=GpNextActive(0) ; engine ; engine=GpNextActive(engine))
if (!engine->inhibit)
value|= engine->DrawDisjoint(engine, n, px, py, qx, qy);
return value;
}
int GpMarkers(long n, const GpReal *px, const GpReal *py)
{
int value= 0;
Engine *engine;
if (gistClip) {
InitializeClip();
n= ClipPoints(px, py, n);
px= xClip;
py= yClip;
}
gpClipInit= 0;
for (engine=GpNextActive(0) ; engine ; engine=GpNextActive(engine)) {
if (!engine->inhibit) {
if (gistA.m.type<=32) value|= engine->DrawMarkers(engine, n, px, py);
else value|= GpPseudoMark(engine, n, px, py);
}
}
return value;
}
int GaLines(long n, const GpReal *px, const GpReal *py)
/* Like GpLines, but includes GaAttributes fancy line attributes
as well as the line attributes from GpAttributes. */
{
int value= 0;
/* Redirect to polymarker if no line type */
if (gistA.l.type==L_NONE) {
/* if (!gistA.dl.marks) return 0; makes no sense */
return GpMarkers(n, px, py);
}
/* Use the (potentially faster) GpLines routine to draw
an undecorated polyline. */
if (!gistA.dl.marks && !gistA.dl.rays) {
gpCloseNext= gistA.dl.closed;
gpSmoothNext= gistA.dl.smooth;
return GpLines(n, px, py);
}
if (gistClip) InitializeClip();
gpClipInit= 0;
/* Note that a decorated line cannot be smooth... */
if (!gistClip || ClipBegin(px, py, n, gistA.dl.closed)) {
gpCloseNext= gistA.dl.closed;
gpClipDone= 1;
value= GpLines(n, px, py);
DecorateLines(n, px, py, gistA.dl.closed);
} else while ((n= ClipMore())) {
gpClipDone= 1;
value|= GpLines(n, xClip, yClip);
DecorateLines(n, xClip, yClip, 0);
}
return value;
}
int GaVectors(GaQuadMesh *mesh, int region,
const GpReal *u, const GpReal *v, GpReal scale)
{
int value= 0;
long iMax= mesh->iMax;
long ijMax= iMax*mesh->jMax;
GpReal *x= mesh->x, *y= mesh->y;
int *ireg= mesh->reg;
int hollow= gistA.vect.hollow;
GpReal aspect= gistA.vect.aspect;
int etype= gistA.e.type;
GpReal xc, yc, dx, dy, vx[3], vy[3];
long ij;
GpReal scalx, offx, scaly, offy, dxscale, dyscale;
/* Create default region array if none supplied */
if (!ireg) {
ireg= NewReg(iMax, ijMax);
if (!ireg) return 1;
mesh->reg= ireg;
}
/* Save transform map, set up for transform here */
SwapNormMap(&scalx, &offx, &scaly, &offy);
dxscale= 0.3333333333*scale*scalx;
dyscale= 0.3333333333*scale*scaly;
aspect*= 3.0;
if (!hollow) gistA.e.type= L_NONE;
InitializeClip();
for (ij=0 ; ij<ijMax ; ij++) {
if (EXISTS(ij) || EXISTS(ij+1) || EXISTS(ij+1+iMax) || EXISTS(ij+iMax)) {
xc= scalx*x[ij]+offx;
yc= scaly*y[ij]+offy;
dx= dxscale*u[ij];
dy= dyscale*v[ij];
/* Dart has centroid at (xc,yc), length 3*(dx,dy), given aspect */
vx[1]= xc + 2.0*dx;
vy[1]= yc + 2.0*dy;
vx[0]= xc - dx + aspect*dy;
vx[2]= xc - dx - aspect*dy;
vy[0]= yc - dy - aspect*dx;
vy[2]= yc - dy + aspect*dx;
if (hollow) {
gpCloseNext= gpClipInit= 1;
value|= GpLines(3, vx, vy);
} else {
gpClipInit= 1;
value|= GpFill(3, vx, vy);
}
}
}
if (!hollow) gistA.e.type= etype;
if (tmpReg) FreeTmpReg();
SwapMapNorm();
return value;
}