static void
plot1( void )
{
PLFLT shade_min, shade_max, sh_color;
PLINT sh_cmap = 0, sh_width;
PLINT min_color = 0, min_width = 0, max_color = 0, max_width = 0;
pladv( 0 );
plvpor( 0.1, 0.9, 0.1, 0.9 );
plwind( -1.0, 1.0, -1.0, 1.0 );
/* Plot using identity transform */
shade_min = zmin + ( zmax - zmin ) * 0.4;
shade_max = zmin + ( zmax - zmin ) * 0.6;
sh_color = 7;
sh_width = 2;
min_color = 9;
max_color = 2;
min_width = 2;
max_width = 2;
plpsty( 8 );
plshade1( &z[0][0], XPTS, YPTS, NULL, -1., 1., -1., 1.,
shade_min, shade_max,
sh_cmap, sh_color, sh_width,
min_color, min_width, max_color, max_width,
plfill, 1, NULL, NULL );
plcol0( 1 );
plbox( "bcnst", 0.0, 0, "bcnstv", 0.0, 0 );
plcol0( 2 );
pllab( "distance", "altitude", "Bogon flux" );
}
static void plplot_set_axis(plot_driver_type * driver , const plot_range_type * range , const char * timefmt , plot_color_type box_color , double tick_font_size) {
plplot_state_type * state = driver->state;
{
double xmin , xmax , ymin , ymax;
plot_range_get_limits( range , &xmin , &xmax , &ymin , &ymax);
if (state->logx) {
xmin = log( xmin );
xmax = log( xmax );
}
if (state->logy) {
ymin = log( ymin );
ymax = log( ymax );
}
plwind( xmin , xmax , ymin , ymax );
}
plcol0(box_color);
plschr(0, tick_font_size * PLOT_DEFAULT_LABEL_FONTSIZE);
if (timefmt != NULL) {
pltimefmt(timefmt);
state->plbox_xopt = util_realloc_sprintf( state->plbox_xopt , "%s%c" , state->plbox_xopt , 'd');
}
plbox(state->plbox_xopt, 0.0, 0, state->plbox_yopt , 0.0, 0);
}
static void plstrip_gen( PLStrip *strip )
{
int i;
PLFLT x[]={0.,1.,1.,0.}, y[]={0.,0.,1.,1.};
/* Set up window */
plvpor(0,1,0,1);
plwind(0,1,0,1);
plcol(0);plpsty(0);
plfill(4, &x[0], &y[0]);
plvsta();
/* Draw box and same window dimensions */
strip->wxmin=strip->xmin; strip->wxmax=strip->xmax;
strip->wymin=strip->ymin; strip->wymax=strip->ymax; /* FIXME - can exist some redundancy here */
plwind(strip->xmin, strip->xmax, strip->ymin, strip->ymax);
pllsty(1);
plcol(strip->colbox);
plbox(strip->xspec, 0.0, 0, strip->yspec, 0.0, 0);
plcol(strip->collab);
pllab(strip->labx, strip->laby, strip->labtop);
for (i=0; i<PEN; i++) {
if (strip->npts[i] > 0) {
plcol(strip->colline[i]);pllsty(strip->styline[i]);
plline(strip->npts[i], strip->x[i], strip->y[i]);
}
}
plstrip_legend(strip,0);
}
int
main(int argc, char *argv[])
{
char text[10];
int i, j, k;
PLFLT x, y;
/* Parse and process command line arguments */
(void) plparseopts(&argc, argv, PL_PARSE_FULL);
/* Initialize plplot */
plinit();
pladv(0);
/* Set up viewport and window */
plcol0(2);
plvpor(0.1, 1.0, 0.1, 0.9);
plwind(0.0, 1.0, 0.0, 1.3);
/* Draw the grid using plbox */
plbox("bcg", 0.1, 0, "bcg", 0.1, 0);
/* Write the digits below the frame */
plcol0(15);
for (i = 0; i <= 9; i++) {
sprintf(text, "%d", i);
plmtex("b", 1.5, (0.1 * i + 0.05), 0.5, text);
}
k = 0;
for (i = 0; i <= 12; i++) {
/* Write the digits to the left of the frame */
sprintf(text, "%d", 10 * i);
plmtex("lv", 1.0, (1.0 - (2 * i + 1) / 26.0), 1.0, text);
for (j = 0; j <= 9; j++) {
x = 0.1 * j + 0.05;
y = 1.25 - 0.1 * i;
/* Display the symbols (plpoin expects that x and y are arrays so */
/* pass pointers) */
if (k < 128)
plpoin(1, &x, &y, k);
k = k + 1;
}
}
plmtex("t", 1.5, 0.5, 0.5, "PLplot Example 6 - plpoin symbols");
plend();
exit(0);
}
void
plot3( void )
{
PLINT space0 = 0, mark0 = 0, space1 = 1500, mark1 = 1500;
int i;
// For the final graph we wish to override the default tick intervals, and
// so do not use plenv().
//
pladv( 0 );
// Use standard viewport, and define X range from 0 to 360 degrees, Y range
// from -1.2 to 1.2.
//
plvsta();
plwind( 0.0, 360.0, -1.2, 1.2 );
// Draw a box with ticks spaced 60 degrees apart in X, and 0.2 in Y.
plcol0( 1 );
plbox( "bcnst", 60.0, 2, "bcnstv", 0.2, 2 );
// Superimpose a dashed line grid, with 1.5 mm marks and spaces.
// plstyl expects a pointer!
//
plstyl( 1, &mark1, &space1 );
plcol0( 2 );
plbox( "g", 30.0, 0, "g", 0.2, 0 );
plstyl( 0, &mark0, &space0 );
plcol0( 3 );
pllab( "Angle (degrees)", "sine", "#frPLplot Example 1 - Sine function" );
for ( i = 0; i < 101; i++ )
{
x[i] = 3.6 * i;
y[i] = sin( x[i] * M_PI / 180.0 );
}
plcol0( 4 );
plline( 101, x, y );
}
void
plot3( void )
{
int i;
// For the final graph we wish to override the default tick intervals, and
// so do not use PLENV
pladv( 0 );
// Use standard viewport, and define X range from 0 to 360 degrees, Y range
// from -1.2 to 1.2.
plvsta();
plwind( (PLFLT) 0.0, (PLFLT) 360.0, (PLFLT) -1.2, (PLFLT) 1.2 );
// Draw a box with ticks spaced 60 degrees apart in X, and 0.2 in Y.
plcol0( 1 );
plbox( "bcnst", (PLFLT) 60.0, 2, "bcnstv", (PLFLT) 0.2, 2 );
// Superimpose a dashed line grid, with 1.5 mm marks and spaces. plstyl
// expects a pointer!!
plstyl( 1, &mark1, &space1 );
plcol0( 2 );
plbox( "g", (PLFLT) 30.0, 0, "g", (PLFLT) 0.2, 0 );
plstyl( 0, &mark0, &space0 );
plcol0( 3 );
pllab( "Angle (degrees)", "sine", "#frPLplot Example 1 - Sine function" );
for ( i = 0; i < 101; i++ )
{
x[i] = 3.6 * i;
y[i] = sin( x[i] * 3.141592654 / 180.0 );
}
plcol0( 4 );
plline( 101, x, y );
}
int
main( int argc, const char *argv[] )
{
/* Parse and process command line arguments */
(void) plparseopts( &argc, argv, PL_PARSE_FULL );
/* Initialize plplot */
plinit();
pladv( 0 );
plvpor( 0.0, 1.0, 0.0, 1.0 );
plwind( 0.0, 1.0, 0.0, 1.0 );
plbox( "bc", 0.0, 0, "bc", 0.0, 0 );
plsvpa( 50.0, 150.0, 50.0, 100.0 );
plwind( 0.0, 1.0, 0.0, 1.0 );
plbox( "bc", 0.0, 0, "bc", 0.0, 0 );
plptex( 0.5, 0.5, 1.0, 0.0, 0.5, "BOX at (50,150,50,100)" );
plend();
exit( 0 );
}
static void
plot2( void )
{
PLFLT shade_min, shade_max, sh_color;
PLINT sh_cmap = 0, sh_width;
PLINT min_color = 0, min_width = 0, max_color = 0, max_width = 0;
int i;
static PLINT nlin[10] = { 1, 1, 1, 1, 1, 2, 2, 2, 2, 2 };
static PLINT inc[10][2] = { { 450, 0 }, { -450, 0 }, { 0, 0 }, { 900, 0 },
{ 300, 0 }, { 450, -450 }, { 0, 900 }, { 0, 450 },
{ 450, -450 }, { 0, 900 } };
static PLINT del[10][2] = { { 2000, 2000 }, { 2000, 2000 }, { 2000, 2000 },
{ 2000, 2000 }, { 2000, 2000 }, { 2000, 2000 },
{ 2000, 2000 }, { 2000, 2000 }, { 4000, 4000 },
{ 4000, 2000 } };
sh_width = 2;
pladv( 0 );
plvpor( 0.1, 0.9, 0.1, 0.9 );
plwind( -1.0, 1.0, -1.0, 1.0 );
/* Plot using identity transform */
for ( i = 0; i < 10; i++ )
{
shade_min = zmin + ( zmax - zmin ) * i / 10.0;
shade_max = zmin + ( zmax - zmin ) * ( i + 1 ) / 10.0;
sh_color = i + 6;
plpat( nlin[i], inc[i], del[i] );
plshade1( &z[0][0], XPTS, YPTS, NULL, -1., 1., -1., 1.,
shade_min, shade_max,
sh_cmap, sh_color, sh_width,
min_color, min_width, max_color, max_width,
plfill, 1, NULL, NULL );
}
plcol0( 1 );
plbox( "bcnst", 0.0, 0, "bcnstv", 0.0, 0 );
plcol0( 2 );
pllab( "distance", "altitude", "Bogon flux" );
}
int
main( int argc, char *argv[] )
{
int i, j;
plparseopts( &argc, argv, PL_PARSE_FULL );
plinit();
pladv( 0 );
plvpor( 0.0, 1.0, 0.0, 1.0 );
plwind( 0.0, 1.0, 0.0, 1.0 );
plcol0( 0 );
plbox( "", 1.0, 0, "", 1.0, 0 );
plscmap0n( 7 );
plscmap0( red, green, blue, 7 );
plschr( 0, 4.0 );
plfont( 1 );
for ( i = 0; i < 4; i++ )
{
plcol0( i + 1 );
plfill( 4, px, py );
for ( j = 0; j < 4; j++ )
py [j] += 1.0 / 4.0;
}
plcol0( 0 );
for ( i = 0; i < 12; i++ )
plptex( sx [i], sy [i], 1.0, 0.0, 0.5, peace [i] );
plend();
exit( 0 );
}
int
main( int argc, const char *argv[] )
{
char text[10];
int i, j, k, l;
PLFLT x, y;
// Parse and process command line arguments
(void) plparseopts( &argc, argv, PL_PARSE_FULL );
// Initialize plplot
plinit();
plfontld( 0 );
for ( l = 0; l < 20; l++ )
{
if ( l == 2 )
plfontld( 1 );
pladv( 0 );
// Set up viewport and window
plcol0( 2 );
plvpor( 0.15, 0.95, 0.1, 0.9 );
plwind( 0.0, 1.0, 0.0, 1.0 );
// Draw the grid using plbox
plbox( "bcg", 0.1, 0, "bcg", 0.1, 0 );
// Write the digits below the frame
plcol0( 15 );
for ( i = 0; i <= 9; i++ )
{
sprintf( text, "%d", i );
plmtex( "b", 1.5, ( 0.1 * i + 0.05 ), 0.5, text );
}
k = 0;
for ( i = 0; i <= 9; i++ )
{
// Write the digits to the left of the frame
sprintf( text, "%d", base[l] + 10 * i );
plmtex( "lv", 1.0, ( 0.95 - 0.1 * i ), 1.0, text );
for ( j = 0; j <= 9; j++ )
{
x = 0.1 * j + 0.05;
y = 0.95 - 0.1 * i;
// Display the symbols
plsym( 1, &x, &y, base[l] + k );
k = k + 1;
}
}
if ( l < 2 )
plmtex( "t", 1.5, 0.5, 0.5, "PLplot Example 7 - PLSYM symbols (compact)" );
else
plmtex( "t", 1.5, 0.5, 0.5, "PLplot Example 7 - PLSYM symbols (extended)" );
}
plend();
exit( 0 );
}
static void potential( void )
//shielded potential contour plot example.
{
int i, j;
PLcGrid2 cgrid2;
PLFLT rmax, xmin, xmax, x0, ymin, ymax, y0, zmin, zmax;
PLFLT peps, xpmin, xpmax, ypmin, ypmax;
PLFLT eps, q1, d1, q1i, d1i, q2, d2, q2i, d2i;
PLFLT div1, div1i, div2, div2i;
PLFLT **z;
PLINT nlevelneg, nlevelpos;
PLFLT dz, clevel2, clevelneg[PNLEVEL], clevelpos[PNLEVEL];
PLINT ncollin, ncolbox, ncollab;
PLFLT px[PPERIMETERPTS], py[PPERIMETERPTS];
PLFLT t, r, theta;
//create data to be contoured.
plAlloc2dGrid( &cgrid2.xg, PRPTS, PTHETAPTS );
plAlloc2dGrid( &cgrid2.yg, PRPTS, PTHETAPTS );
plAlloc2dGrid( &z, PRPTS, PTHETAPTS );
cgrid2.nx = PRPTS;
cgrid2.ny = PTHETAPTS;
for ( i = 0; i < PRPTS; i++ )
{
r = 0.5 + (double) i;
for ( j = 0; j < PTHETAPTS; j++ )
{
theta = ( 2. * M_PI / (double) ( PTHETAPTS - 1 ) ) * ( 0.5 + (double) j );
cgrid2.xg[i][j] = r * cos( theta );
cgrid2.yg[i][j] = r * sin( theta );
}
}
rmax = r;
f2mnmx( cgrid2.xg, PRPTS, PTHETAPTS, &xmin, &xmax );
f2mnmx( cgrid2.yg, PRPTS, PTHETAPTS, &ymin, &ymax );
x0 = ( xmin + xmax ) / 2.;
y0 = ( ymin + ymax ) / 2.;
// Expanded limits
peps = 0.05;
xpmin = xmin - fabs( xmin ) * peps;
xpmax = xmax + fabs( xmax ) * peps;
ypmin = ymin - fabs( ymin ) * peps;
ypmax = ymax + fabs( ymax ) * peps;
// Potential inside a conducting cylinder (or sphere) by method of images.
// Charge 1 is placed at (d1, d1), with image charge at (d2, d2).
// Charge 2 is placed at (d1, -d1), with image charge at (d2, -d2).
// Also put in smoothing term at small distances.
//
eps = 2.;
q1 = 1.;
d1 = rmax / 4.;
q1i = -q1 * rmax / d1;
d1i = pow( rmax, 2. ) / d1;
q2 = -1.;
d2 = rmax / 4.;
q2i = -q2 * rmax / d2;
d2i = pow( rmax, 2. ) / d2;
for ( i = 0; i < PRPTS; i++ )
{
for ( j = 0; j < PTHETAPTS; j++ )
{
div1 = sqrt( pow( cgrid2.xg[i][j] - d1, 2. ) + pow( cgrid2.yg[i][j] - d1, 2. ) + pow( eps, 2. ) );
div1i = sqrt( pow( cgrid2.xg[i][j] - d1i, 2. ) + pow( cgrid2.yg[i][j] - d1i, 2. ) + pow( eps, 2. ) );
div2 = sqrt( pow( cgrid2.xg[i][j] - d2, 2. ) + pow( cgrid2.yg[i][j] + d2, 2. ) + pow( eps, 2. ) );
div2i = sqrt( pow( cgrid2.xg[i][j] - d2i, 2. ) + pow( cgrid2.yg[i][j] + d2i, 2. ) + pow( eps, 2. ) );
z[i][j] = q1 / div1 + q1i / div1i + q2 / div2 + q2i / div2i;
}
}
f2mnmx( z, PRPTS, PTHETAPTS, &zmin, &zmax );
// printf("%.15g %.15g %.15g %.15g %.15g %.15g %.15g %.15g \n",
// q1, d1, q1i, d1i, q2, d2, q2i, d2i);
// printf("%.15g %.15g %.15g %.15g %.15g %.15g \n",
// xmin, xmax, ymin, ymax, zmin, zmax);
// Positive and negative contour levels.
dz = ( zmax - zmin ) / (double) PNLEVEL;
nlevelneg = 0;
nlevelpos = 0;
for ( i = 0; i < PNLEVEL; i++ )
{
clevel2 = zmin + ( (double) i + 0.5 ) * dz;
if ( clevel2 <= 0. )
clevelneg[nlevelneg++] = clevel2;
else
clevelpos[nlevelpos++] = clevel2;
}
// Colours!
ncollin = 11;
ncolbox = 1;
ncollab = 2;
// Finally start plotting this page!
pladv( 0 );
plcol0( ncolbox );
plvpas( 0.1, 0.9, 0.1, 0.9, 1.0 );
plwind( xpmin, xpmax, ypmin, ypmax );
plbox( "", 0., 0, "", 0., 0 );
plcol0( ncollin );
if ( nlevelneg > 0 )
{
// Negative contours
pllsty( 2 );
plcont( (const PLFLT * const *) z, PRPTS, PTHETAPTS, 1, PRPTS, 1, PTHETAPTS,
clevelneg, nlevelneg, pltr2, (void *) &cgrid2 );
}
if ( nlevelpos > 0 )
{
// Positive contours
pllsty( 1 );
plcont( (const PLFLT * const *) z, PRPTS, PTHETAPTS, 1, PRPTS, 1, PTHETAPTS,
clevelpos, nlevelpos, pltr2, (void *) &cgrid2 );
}
// Draw outer boundary
for ( i = 0; i < PPERIMETERPTS; i++ )
{
t = ( 2. * M_PI / ( PPERIMETERPTS - 1 ) ) * (double) i;
px[i] = x0 + rmax * cos( t );
py[i] = y0 + rmax * sin( t );
}
plcol0( ncolbox );
plline( PPERIMETERPTS, px, py );
plcol0( ncollab );
pllab( "", "", "Shielded potential of charges in a conducting sphere" );
plFree2dGrid( z, PRPTS, PTHETAPTS );
plFree2dGrid( cgrid2.xg, PRPTS, PTHETAPTS );
plFree2dGrid( cgrid2.yg, PRPTS, PTHETAPTS );
}
int
main(int argc, char *argv[])
{
/* ============== Begin variable definition section. ============= */
/*
* i, j, and k are counting variables used in loops and such. M is the
* number of lines to be plotted and N is the number of sample points
* for each line.
*/
int i, j, k, M, N, leglen;
/*
* x is a pointer to an array containing the N x-coordinate values. y
* points to an array of M pointers each of which points to an array
* containing the N y-coordinate values for that line.
*/
PLFLT *x, **y;
/* Define storage for the min and max values of the data. */
PLFLT xmin, xmax, ymin, ymax, xdiff, ydiff;
/* Define storage for the filename and define the input file pointer. */
char filename[80], string[80], tmpstr[80];
FILE *datafile;
/* Here are the character strings that appear in the plot legend. */
static char *legend[] =
{
"Aardvarks",
"Gnus",
"Llamas",
NULL}; /* Make sure last element is NULL */
/* ============== Read in data from input file. ============= */
/* Parse and process command line arguments */
(void) plparseopts(&argc, argv, PL_PARSE_FULL);
/* First prompt the user for the input data file name */
printf("Enter input data file name. ");
scanf("%s", filename);
/* and open the file. */
datafile = fopen(filename, "r");
if (datafile == NULL) /* error opening input file */
error("Error opening input file.");
/* Read in values of M and N */
k = fscanf(datafile, "%d %d", &M, &N);
if (k != 2) /* something's wrong */
error("Error while reading data file.");
/* Allocate memory for all the arrays. */
x = (PLFLT *) malloc(N * sizeof(PLFLT));
if (x == NULL)
error("Out of memory!");
y = (PLFLT **) malloc(M * sizeof(PLFLT *));
if (y == NULL)
error("Out of memory!");
for (i = 0; i < M; i++) {
y[i] = (PLFLT *) malloc(N * sizeof(PLFLT));
if (y[i] == NULL)
error("Out of memory!");
}
/* Now read in all the data. */
for (i = 0; i < N; i++) { /* N points */
k = fscanf(datafile, "%f", &x[i]);
if (k != 1)
error("Error while reading data file.");
for (j = 0; j < M; j++) { /* M lines */
k = fscanf(datafile, "%f", &y[j][i]);
if (k != 1)
error("Error while reading data file.");
}
}
/* ============== Graph the data. ============= */
/* Set graph to portrait orientation. (Default is landscape.) */
/* (Portrait is usually desired for inclusion in TeX documents.) */
plsori(1);
/* Initialize plplot */
plinit();
/*
* We must call pladv() to advance to the first (and only) subpage.
* You might want to use plenv() instead of the pladv(), plvpor(),
* plwind() sequence.
*/
pladv(0);
/*
* Set up the viewport. This is the window into which the data is
* plotted. The size of the window can be set with a call to
* plvpor(), which sets the size in terms of normalized subpage
* coordinates. I want to plot the lines on the upper half of the
* page and I want to leave room to the right of the figure for
* labelling the lines. We must also leave room for the title and
* labels with plvpor(). Normally a call to plvsta() can be used
* instead.
*/
plvpor(0.15, 0.70, 0.5, 0.9);
/*
* We now need to define the size of the window in user coordinates.
* To do this, we first need to determine the range of the data
* values.
*/
xmin = xmax = x[0];
ymin = ymax = y[0][0];
for (i = 0; i < N; i++) {
if (x[i] < xmin)
xmin = x[i];
if (x[i] > xmax)
xmax = x[i];
for (j = 0; j < M; j++) {
if (y[j][i] < ymin)
ymin = y[j][i];
if (y[j][i] > ymax)
ymax = y[j][i];
}
}
/*
* Now set the size of the window. Leave a small border around the
* data.
*/
xdiff = (xmax - xmin) / 20.;
ydiff = (ymax - ymin) / 20.;
plwind(xmin - xdiff, xmax + xdiff, ymin - ydiff, ymax + ydiff);
/*
* Call plbox() to draw the axes (see the PLPLOT manual for
* information about the option strings.)
*/
plbox("bcnst", 0.0, 0, "bcnstv", 0.0, 0);
/*
* Label the axes and title the graph. The string "#gm" plots the
* Greek letter mu, all the Greek letters are available, see the
* PLplot manual.
*/
pllab("Time (weeks)", "Height (#gmparsecs)", "Specimen Growth Rate");
/*
* Plot the data. plpoin() draws a symbol at each point. plline()
* connects all the points.
*/
for (i = 0; i < M; i++) {
plpoin(N, x, y[i], i + OFFSET);
plline(N, x, y[i]);
}
/*
* Draw legend to the right of the chart. Things get a little messy
* here. You may want to remove this section if you don't want a
* legend drawn. First find length of longest string.
*/
leglen = 0;
for (i = 0; i < M; i++) {
if (legend[i] == NULL)
break;
j = strlen(legend[i]);
if (j > leglen)
leglen = j;
}
/*
* Now build the string. The string consists of an element from the
* legend string array, padded with spaces, followed by one of the
* symbols used in plpoin above.
*/
for (i = 0; i < M; i++) {
if (legend[i] == NULL)
break;
strcpy(string, legend[i]);
j = strlen(string);
if (j < leglen) { /* pad string with spaces */
for (k = j; k < leglen; k++)
string[k] = ' ';
string[k] = '\0';
}
/* pad an extra space */
strcat(string, " ");
j = strlen(string);
/* insert the ASCII value of the symbol plotted with plpoin() */
string[j] = i + OFFSET;
string[j + 1] = '\0';
/* plot the string */
plmtex("rv", 1., 1. - (double) (i + 1) / (M + 1), 0., string);
}
/* Tell plplot we are done with this page. */
pladv(0); /* advance page */
/* Don't forget to call plend() to finish off! */
plend();
exit(0);
}
bool plotNoiseStandardDeviation(const hoNDArray< std::complex<T> >& m, const std::vector<std::string>& coilStrings,
const std::string& xlabel, const std::string& ylabel, const std::string& title,
size_t xsize, size_t ysize, bool trueColor,
hoNDArray<float>& plotIm)
{
try
{
size_t CHA = m.get_size(0);
GADGET_CHECK_RETURN_FALSE(coilStrings.size() == CHA);
hoNDArray<double> xd, yd, yd2;
xd.create(CHA);
yd.create(CHA);
size_t c;
for (c = 0; c < CHA; c++)
{
xd(c) = c+1;
yd(c) = std::sqrt( std::abs(m(c, c)) );
}
double maxY = Gadgetron::max(&yd);
yd2 = yd;
std::sort(yd2.begin(), yd2.end());
double medY = yd2(CHA / 2);
// increase dot line to be 1 sigma ~= 33%
double medRange = 0.33;
if (maxY < medY*(1 + medRange))
{
maxY = medY*(1 + medRange);
}
hoNDArray<unsigned char> im;
im.create(3, xsize, ysize);
Gadgetron::clear(im);
plsdev("mem");
plsmem(im.get_size(1), im.get_size(2), im.begin());
plinit();
plfont(2);
pladv(0);
plvpor(0.15, 0.75, 0.1, 0.8);
plwind(0, CHA+1, 0, maxY*1.05);
plcol0(15);
plbox("bcnst", 0.0, 0, "bcnstv", 0.0, 0);
std::string gly;
getPlotGlyph(0, gly); // circle
plstring(CHA, xd.begin(), yd.begin(), gly.c_str());
// draw the median line
pllsty(1);
double px[2], py[2];
px[0] = 0;
px[1] = CHA+1;
py[0] = medY;
py[1] = medY;
plline(2, px, py);
pllsty(2);
py[0] = medY*(1 - medRange);
py[1] = medY*(1 - medRange);
plline(2, px, py);
py[0] = medY*(1 + medRange);
py[1] = medY*(1 + medRange);
plline(2, px, py);
plmtex("b", 3.2, 0.5, 0.5, xlabel.c_str());
plmtex("t", 2.0, 0.5, 0.5, title.c_str());
plmtex("l", 5.0, 0.5, 0.5, ylabel.c_str());
// draw the legend
std::vector<PLINT> opt_array(CHA), text_colors(CHA), line_colors(CHA), line_styles(CHA), symbol_numbers(CHA), symbol_colors(CHA);
std::vector<PLFLT> symbol_scales(CHA), line_widths(CHA), box_scales(CHA, 1);
std::vector<const char*> symbols(CHA);
PLFLT legend_width, legend_height;
std::vector<const char*> legend_text(CHA);
std::vector<std::string> legends(CHA);
size_t n;
for (n = 0; n < CHA; n++)
{
opt_array[n] = PL_LEGEND_SYMBOL;
text_colors[n] = 15;
line_colors[n] = 15;
line_styles[n] = (n % 8 + 1);
line_widths[n] = 0.2;
symbol_colors[n] = 15;
symbol_scales[n] = 0.75;
symbol_numbers[n] = 1;
symbols[n] = gly.c_str();
std::ostringstream ostr;
ostr << n+1 << ":" << coilStrings[n];
legends[n] = ostr.str();
legend_text[n] = legends[n].c_str();
}
pllegend(&legend_width,
&legend_height,
PL_LEGEND_BACKGROUND,
PL_POSITION_OUTSIDE | PL_POSITION_RIGHT,
0.02, // x
0.0, // y
0.05, // plot_width
0, // bg_color
15, // bb_color
1, // bb_style
0, // nrow
0, // ncolumn
CHA, // nlegend
&opt_array[0],
0.05, // text_offset
0.5, // text_scale
1.0, // text_spacing
0.5, // text_justification
&text_colors[0],
(const char **)(&legend_text[0]),
NULL, // box_colors
NULL, // box_patterns
&box_scales[0], // box_scales
NULL, // box_line_widths
&line_colors[0],
&line_styles[0],
&line_widths[0],
&symbol_colors[0],
&symbol_scales[0],
&symbol_numbers[0],
(const char **)(&symbols[0])
);
plend();
outputPlotIm(im, trueColor, plotIm);
}
catch (...)
{
GERROR_STREAM("Errors happened in plotNoiseStandardDeviation(...) ... ");
return false;
}
return true;
}
static void
c_plenvi(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
PLINT just, PLINT axis, PLINT old)
{
PLFLT lb, rb, tb, bb, dx, dy;
PLFLT xsize, ysize, size, xscale, yscale, scale;
PLFLT spxmin, spxmax, spymin, spymax;
PLFLT vpxmin, vpxmax, vpymin, vpymax;
if (plsc->level < 1) {
plabort("plenv: Please call plinit first");
return;
}
if (xmin == xmax) {
plabort("plenv: Invalid xmin and xmax arguments");
return;
}
if (ymin == ymax) {
plabort("plenv: Invalid ymin and ymax arguments");
return;
}
if (just < -1 || just > 2) {
plabort("plenv: Invalid just option");
return;
}
if (plsc->nsubx * plsc->nsuby == 1) /* not multiplot mode */
old = 1;
if (old == 1)
pladv(0);
else
plclear();
if (just == 0)
plvsta();
else if (just == 1){
lb = 8.0 * plsc->chrht;
rb = 5.0 * plsc->chrht;
tb = 5.0 * plsc->chrht;
bb = 5.0 * plsc->chrht;
dx = ABS(xmax - xmin);
dy = ABS(ymax - ymin);
plgspa(&spxmin, &spxmax, &spymin, &spymax);
xsize = spxmax - spxmin;
ysize = spymax - spymin;
xscale = dx / (xsize - lb - rb);
yscale = dy / (ysize - tb - bb);
scale = MAX(xscale, yscale);
vpxmin = MAX(lb, 0.5 * (xsize - dx / scale));
vpxmax = vpxmin + (dx / scale);
vpymin = MAX(bb, 0.5 * (ysize - dy / scale));
vpymax = vpymin + (dy / scale);
plsvpa(vpxmin, vpxmax, vpymin, vpymax);
} else if(just == 2) {
lb = 8.0 * plsc->chrht;
rb = 5.0 * plsc->chrht;
tb = 5.0 * plsc->chrht;
bb = 5.0 * plsc->chrht;
plgspa(&spxmin, &spxmax, &spymin, &spymax);
xsize = spxmax - spxmin;
ysize = spymax - spymin;
size = MIN(xsize-lb-rb, ysize-tb-bb);
dx = (xsize-size-lb-rb)/2;
vpxmin = lb + dx;
vpxmax = vpxmin + size;
dy = (ysize-size-bb-tb)/2;
vpymin = bb + dy;
vpymax = vpymin + size;
plsvpa(vpxmin, vpxmax, vpymin, vpymax);
}
plwind(xmin, xmax, ymin, ymax);
switch (axis) {
case -2:
break;
case -1:
plbox("bc", (PLFLT) 0.0, 0, "bc", (PLFLT) 0.0, 0);
break;
case 0:
plbox("bcnst", (PLFLT) 0.0, 0, "bcnstv", (PLFLT) 0.0, 0);
break;
case 1:
plbox("abcnst", (PLFLT) 0.0, 0, "abcnstv", (PLFLT) 0.0, 0);
break;
case 2:
plbox("abcgnst", (PLFLT) 0.0, 0, "abcgnstv", (PLFLT) 0.0, 0);
break;
case 3:
plbox("abcgnsth", (PLFLT) 0.0, 0, "abcgnstvh", (PLFLT) 0.0, 0);
break;
case 10:
plbox("bclnst", (PLFLT) 0.0, 0, "bcnstv", (PLFLT) 0.0, 0);
break;
case 11:
plbox("abclnst", (PLFLT) 0.0, 0, "abcnstv", (PLFLT) 0.0, 0);
break;
case 12:
plbox("abcglnst", (PLFLT) 0.0, 0, "abcgnstv", (PLFLT) 0.0, 0);
break;
case 13:
plbox("abcglnsth", (PLFLT) 0.0, 0, "abcgnstvh", (PLFLT) 0.0, 0);
break;
case 20:
plbox("bcnst", (PLFLT) 0.0, 0, "bclnstv", (PLFLT) 0.0, 0);
break;
case 21:
plbox("abcnst", (PLFLT) 0.0, 0, "abclnstv", (PLFLT) 0.0, 0);
break;
case 22:
plbox("abcgnst", (PLFLT) 0.0, 0, "abcglnstv", (PLFLT) 0.0, 0);
break;
case 23:
plbox("abcgnsth", (PLFLT) 0.0, 0, "abcglnstvh", (PLFLT) 0.0, 0);
break;
case 30:
plbox("bclnst", (PLFLT) 0.0, 0, "bclnstv", (PLFLT) 0.0, 0);
break;
case 31:
plbox("abclnst", (PLFLT) 0.0, 0, "abclnstv", (PLFLT) 0.0, 0);
break;
case 32:
plbox("abcglnst", (PLFLT) 0.0, 0, "abcglnstv", (PLFLT) 0.0, 0);
break;
case 33:
plbox("abcglnsth", (PLFLT) 0.0, 0, "abcglnstvh", (PLFLT) 0.0, 0);
break;
default:
plwarn("plenv: Invalid axis argument");
}
}
void nemo_main()
{
int i, dir, nrad, npots=0, ltype, ndim = NDIM, nx, ny, ns, ndat, nret;
int cols[4], n, idx, idx_max;
real pmax, symsize, rr, omk_max = 0.0, omk_rmax;
real rad[MAXPT], *vel, *vel1, *vel2, *vel3, *vel4, *curve;
real *ome, *kap, *opk, *omk, r0l[MAXPT+2], omega, *f;
real inrad[MAXPT], invel[MAXPT], inrade[MAXPT], invele[MAXPT];
double pos[3], acc[3], pot, time = 0.0;
/* char *fmt, s[20], pfmt[256]; */
char headline[256], fmt1[80];
string axis, mode, infile, plotlabel;
stream instr;
bool Qtab, Qplot, Qome, Qvel, Qlv, Qin, QoILR;
mode = getparam("mode");
n = getiparam("n");
plotlabel = getparam("headline");
sprintf(fmt1,"%s ",getparam("format"));
Qome = (*mode == 'o'); /* options are: velocity|omega|lv */
Qlv = (*mode == 'l');
Qvel = (*mode == 'v');
Qtab = getbparam("tab");
Qplot = getbparam("plot");
infile = getparam("in");
Qin = (*infile != 0);
if (Qin) {
nret = nemoinpi(getparam("cols"),cols,4);
if (nret<0 || nret > 4) error("cols= requires 4 numbers");
for (i=nret; i<4; i++)
cols[i] = 0;
instr = stropen(infile,"r");
ndat = read_table(instr,MAXPT,inrad,invel,inrade,invele,cols);
strclose(instr);
}
mypot1 = get_potential(getparam("name1"),getparam("pars1"),getparam("file1"));
omega = get_pattern();
dprintf(0,"Pattern speed: %f\n",omega);
mypot2 = get_potential(getparam("name2"),getparam("pars2"),getparam("file2"));
mypot3 = get_potential(getparam("name3"),getparam("pars3"),getparam("file3"));
mypot4 = get_potential(getparam("name4"),getparam("pars4"),getparam("file4"));
headline[0] = '\0'; /* accumulate headline */
if (mypot1) {
strcat(headline,getparam("name1"));
strcat(headline,"(");
strcat(headline,getparam("pars1"));
strcat(headline,")");
npots++;
}
if (mypot2) {
strcat(headline,getparam("name2"));
strcat(headline,"(");
strcat(headline,getparam("pars2"));
strcat(headline,") ");
npots++;
}
if (mypot3) {
strcat(headline,getparam("name3"));
strcat(headline,"(");
strcat(headline,getparam("pars3"));
strcat(headline,") ");
npots++;
}
if (mypot4) {
strcat(headline,getparam("name4"));
strcat(headline,"(");
strcat(headline,getparam("pars4"));
strcat(headline,")");
npots++;
}
nrad = nemoinpr(getparam("radii"),rad,MAXPT); /* get radii */
if (nrad <= 0)
warning("Using %d radii is not very productive",nrad);
vel = (real *) allocate(sizeof(real) * nrad); /* allocate stuff */
vel1 = (real *) allocate(sizeof(real) * nrad);
vel2 = (real *) allocate(sizeof(real) * nrad);
vel3 = (real *) allocate(sizeof(real) * nrad);
vel4 = (real *) allocate(sizeof(real) * nrad);
if (Qome) {
ome = (real *) allocate(4 * sizeof(real) * nrad); /* plus spline */
kap = (real *) allocate(sizeof(real) * nrad);
opk = (real *) allocate(sizeof(real) * nrad);
omk = (real *) allocate(sizeof(real) * nrad);
}
axis = getparam("axis");
dir = 0;
if (*axis == 'x') dir=0;
if (*axis == 'y') dir=1;
if (*axis == 'z') dir=2;
if (dir>NDIM) error("Axis %s not supported in NDIM=%d",axis,NDIM);
pmax = 0.0;
for (i=0; i<nrad; i++) { /* loop to compute */
CLRV(pos); /* clear positions */
pos[dir] = rad[i]; /* set the right axis */
vel[i] = 0.0;
if (mypot1) {
CLRV(acc);
(*mypot1) (&ndim,pos,acc,&pot,&time);
vel1[i] = -rad[i] * acc[dir];
vel[i] += vel1[i];
vel1[i] = sqrt(vel1[i]);
}
if (mypot2) {
CLRV(acc);
(*mypot2) (&ndim,pos,acc,&pot,&time);
vel2[i] = -rad[i] * acc[dir];
vel[i] += vel2[i];
vel2[i] = sqrt(vel2[i]);
}
if (mypot3) {
CLRV(acc);
(*mypot3) (&ndim,pos,acc,&pot,&time);
vel3[i] = -rad[i] * acc[dir];
vel[i] += vel3[i];
vel3[i] = sqrt(vel3[i]);
}
if (mypot4) {
CLRV(acc);
(*mypot4) (&ndim,pos,acc,&pot,&time);
vel4[i] = -rad[i] * acc[dir];
vel[i] += vel4[i];
vel4[i] = sqrt(vel4[i]);
}
vel[i] = sqrt(vel[i]);
}
if (Qome) {
lindblad(nrad,rad,vel,ome,kap,opk,omk,n);
if (omega> 0.0) { /* compute resonances */
f = opk;
idx = nrad-1;
if (omega < f[idx]) {
warning("Radii not far enough out for OLR: %g",f[idx]);
f = ome;
if (omega < f[idx]) {
warning("Radii not far enough out for CR: %g",f[idx]);
f = omk;
}
}
QoILR = FALSE;
for(; idx>0; idx--) {
if (omk[idx] > omk_max) {
idx_max = idx;
omk_max = omk[idx];
}
if (f==omk) {
if (QoILR) {
if (omega < f[idx]) continue;
} else {
if (omega > f[idx]) continue;
}
} else {
if (omega > f[idx]) continue;
}
/* found a resonance: */
rr = rad[idx] + (rad[idx+1]-rad[idx])*
(omega-f[idx])/(f[idx+1]-f[idx]);
if (f == omk) {
#if 0
if (QoILR) {
dprintf(0,"iILR: %g\n",rr);
break;
} else {
dprintf(0,"oILR: %g\n",rr);
QoILR = TRUE;
}
#endif
} else if (f == ome) {
dprintf(0,"CR: %g\n",rr);
f = omk;
} else if (f == opk) {
dprintf(0,"OLR: %g\n",rr);
f = ome;
} else
error("impossble resonance");
}
peak(nrad,rad,omk,idx_max,1, &omk_rmax, &omk_max);
dprintf(0,"OMK_max: %g\n",omk_max);
dprintf(0,"OMK_rmax: %g\n",omk_rmax);
if (omega < omk_max) { /* search for ILR */
for (idx=idx_max; idx<nrad; idx++) {
if (omega > omk[idx]) {
rr = rad[idx-1] + (rad[idx]-rad[idx-1])*
(omega-f[idx-1])/(f[idx]-f[idx-1]);
dprintf(0,"oILR: %g\n",rr);
break;
}
}
for (idx=idx_max; idx>0; idx--) {
if (omega > omk[idx]) {
rr = rad[idx] + (rad[idx+1]-rad[idx])*
(omega-f[idx])/(f[idx+1]-f[idx]);
dprintf(0,"iILR: %g\n",rr);
break;
}
}
}
}
}
for (i=0; i<nrad; i++) { /* loop to print */
if (Qtab) {
printf(fmt1,rad[i]);
printf(fmt1,vel[i]);
}
if (Qtab && npots>1 && !Qome) {
if (mypot1) printf(fmt1,vel1[i]);
if (mypot2) printf(fmt1,vel2[i]);
if (mypot3) printf(fmt1,vel3[i]);
if (mypot4) printf(fmt1,vel4[i]);
}
if (Qtab && Qome) {
printf(fmt1,ome[i]);
printf(fmt1,kap[i]);
printf(fmt1,opk[i]);
printf(fmt1,omk[i]);
}
if (Qtab) printf("\n");
if (Qome)
pmax = MAX(pmax,opk[i]);
else
pmax = MAX(pmax,vel[i]);
}
if (Qin && Qvel)
goodness(nrad,rad,vel,ndat,inrad,invel,(cols[3]>0?invele:NULL));
if (Qplot) {
plinit("***",0.0,20.0,0.0,20.0); /* open device */
nx = nemoinpr(getparam("xrange"),xplot,2); /* get xrange in plot */
switch(nx) {
case 0:
xplot[0] = rad[0];
case 1:
xplot[1] = rad[nrad-1];
break;
case 2:
break;
default:
warning("xrange= only accepts two values");
break;
}
ny = nemoinpr(getparam("yrange"),yplot,2); /* get yrange in plot */
switch(ny) {
case 0:
yplot[0] = 0.0;
yplot[1] = 1.1 * pmax; /* extra 10% for egde */
break;
case 1:
yplot[1] = 1.1 * pmax; /* extra 10% for egde */
break;
case 2:
break;
default:
warning("yrange= only accepts two values");
break;
}
xaxis ( 2.0, 2.0, 16.0, xplot, -7, xtrans, "R"); /* plot axes */
xaxis ( 2.0,18.0, 16.0, xplot, -7, xtrans, NULL);
if (Qome)
yaxis ( 2.0, 2.0, 16.0, yplot, -7, ytrans, "[V/R]");
else
yaxis ( 2.0, 2.0, 16.0, yplot, -7, ytrans, "V");
yaxis (18.0, 2.0, 16.0, yplot, -7, ytrans, NULL);
if (*plotlabel)
pltext(plotlabel,2.0,18.5,0.5,0.0);
else
pltext(headline,2.0,18.5,0.35,0.0);
if (*plotmsg)
pltext(plotmsg,8.0,2.5,0.25,0.0);
curve = (Qome ? ome : vel); /* assign first curve */
plltype(3,1); /* thick solid line */
plmove(xtrans(rad[0]),ytrans(curve[0]));
for (i=1; i<nrad; i++)
plline(xtrans(rad[i]),ytrans(curve[i]));
if (Qome) { /* if Lindblad - plot omk, opk */
plltype(1,1); /* all regular solid lines */
plmove(xtrans(rad[0]), ytrans(omk[0]));
for (i=1; i<nrad; i++)
plline(xtrans(rad[i]),ytrans(omk[i]));
plmove(xtrans(rad[0]), ytrans(opk[0]));
for (i=1; i<nrad; i++)
plline(xtrans(rad[i]),ytrans(opk[i]));
} else if (npots>1) { /* if velocity and > 1 component */
ltype = 1;
if (mypot1) {
plltype(1,++ltype);
plmove(xtrans(rad[0]),ytrans(vel1[0]));
for (i=1; i<nrad; i++)
plline(xtrans(rad[i]),ytrans(vel1[i]));
}
if (mypot2) {
plltype(1,++ltype);
plmove(xtrans(rad[0]),ytrans(vel2[0]));
for (i=1; i<nrad; i++)
plline(xtrans(rad[i]),ytrans(vel2[i]));
}
if (mypot3) {
plltype(1,++ltype);
plmove(xtrans(rad[0]),ytrans(vel2[0]));
for (i=1; i<nrad; i++)
plline(xtrans(rad[i]),ytrans(vel3[i]));
}
if (mypot4) {
plltype(1,++ltype);
plmove(xtrans(rad[0]),ytrans(vel2[0]));
for (i=1; i<nrad; i++)
plline(xtrans(rad[i]),ytrans(vel4[i]));
}
}
plltype(1,1);
symsize = 0.1;
if (Qin && Qvel) { /* if input file with velocities */
for (i=0; i<ndat; i++)
plbox(xtrans(inrad[i]),ytrans(invel[i]),symsize);
if (cols[3]>0) { /* if error bars in radius */
for (i=0; i<ndat; i++) {
plmove(xtrans(inrad[i]-inrade[i]),ytrans(invel[i]));
plline(xtrans(inrad[i]+inrade[i]),ytrans(invel[i]));
}
}
if (cols[4]>0) { /* if error bars in velocity */
for (i=0; i<ndat; i++) {
plmove(xtrans(inrad[i]),ytrans(invel[i]-invele[i]));
plline(xtrans(inrad[i]),ytrans(invel[i]+invele[i]));
}
}
} else if (Qin && Qome) { /* if input file with omega */
for (i=0; i<ndat; i++)
plbox(xtrans(inrad[i]),ytrans(invel[i]/inrad[i]),symsize);
}
plstop();
} /* if plot vel/ome */
if (Qlv) {
ns = nemoinpr(getparam("r0l"),r0l,MAXPT+2) - 2;
if (ns < 0)
error("r0l= needs at least two values: r0 and l");
else if (ns==0)
warning("r0l= no lv-radii array supplied");
lv(nrad,rad,vel,r0l[0],r0l[1],ns,&r0l[2]);
}
}
template <typename T> EXPORTGTPLPLOT
bool plotCurves(const std::vector<hoNDArray<T> >& x, const std::vector<hoNDArray<T> >& y,
const std::string& xlabel, const std::string& ylabel,
const std::string& title, const std::vector<std::string>& legend,
const std::vector<std::string>& symbols,
size_t xsize, size_t ysize,
T xlim[2], T ylim[2],
bool trueColor, bool drawLine,
hoNDArray<float>& plotIm)
{
try
{
GADGET_CHECK_RETURN_FALSE(x.size()>0);
GADGET_CHECK_RETURN_FALSE(y.size()>0);
GADGET_CHECK_RETURN_FALSE(x.size() == y.size());
T minX = xlim[0];
T maxX = xlim[1];
T minY = ylim[0];
T maxY = ylim[1];
plsdev("mem");
hoNDArray<unsigned char> im;
im.create(3, xsize, ysize);
Gadgetron::clear(im);
plsmem(im.get_size(1), im.get_size(2), im.begin());
plinit();
plfont(2);
pladv(0);
if (legend.size() == x.size())
{
plvpor(0.11, 0.75, 0.1, 0.9);
}
else
{
plvpor(0.15, 0.85, 0.1, 0.9);
}
T spaceX = 0.01*(maxX - minX);
T spaceY = 0.05*(maxY - minY);
plwind(minX - spaceX, maxX + spaceX, minY - spaceY, maxY + spaceY);
plcol0(15);
plbox("bgcnst", 0.0, 0, "bgcnstv", 0.0, 0);
// int mark[2], space[2];
//mark[0] = 4000;
//space[0] = 2500;
//plstyl(1, mark, space);
size_t num = x.size();
size_t n;
hoNDArray<double> xd, yd;
// draw lines
for (n = 0; n < num; n++)
{
size_t N = y[n].get_size(0);
xd.copyFrom(x[n]);
yd.copyFrom(y[n]);
if (drawLine)
{
int c;
getPlotColor(n, c);
plcol0(c);
pllsty(n % 8 + 1);
plline(N, xd.begin(), yd.begin());
}
std::string gly;
if(symbols.size()>n)
{
gly = symbols[n];
}
else
getPlotGlyph(n, gly);
plstring(N, xd.begin(), yd.begin(), gly.c_str());
}
plcol0(15);
plmtex("b", 3.2, 0.5, 0.5, xlabel.c_str());
plmtex("t", 2.0, 0.5, 0.5, title.c_str());
plmtex("l", 5.0, 0.5, 0.5, ylabel.c_str());
// draw the legend
if (legend.size() == x.size())
{
std::vector<PLINT> opt_array(num), text_colors(num), line_colors(num), line_styles(num), symbol_numbers(num), symbol_colors(num);
std::vector<PLFLT> symbol_scales(num), line_widths(num), box_scales(num, 1);
std::vector<std::string> glyphs(num);
std::vector<const char*> symbols(num);
PLFLT legend_width, legend_height;
std::vector<const char*> legend_text(num);
for (n = 0; n < num; n++)
{
int c;
getPlotColor(n, c);
getPlotGlyph(n, glyphs[n]);
opt_array[n] = PL_LEGEND_SYMBOL | PL_LEGEND_LINE;
text_colors[n] = 15;
line_colors[n] = c;
line_styles[n] = (n%8+1);
line_widths[n] = 0.2;
symbol_colors[n] = c;
symbol_scales[n] = 0.75;
symbol_numbers[n] = 1;
symbols[n] = glyphs[n].c_str();
legend_text[n] = legend[n].c_str();
}
pllegend(&legend_width,
&legend_height,
PL_LEGEND_BACKGROUND,
PL_POSITION_OUTSIDE | PL_POSITION_RIGHT | PL_POSITION_TOP,
0.02, // x
0.0, // y
0.05, // plot_width
0, // bg_color
15, // bb_color
1, // bb_style
0, // nrow
0, // ncolumn
num, // nlegend
&opt_array[0],
0.05, // text_offset
0.35, // text_scale
1.0, // text_spacing
0.5, // text_justification
&text_colors[0],
(const char **)(&legend_text[0]),
NULL, // box_colors
NULL, // box_patterns
&box_scales[0], // box_scales
NULL, // box_line_widths
&line_colors[0],
&line_styles[0],
&line_widths[0],
&symbol_colors[0],
&symbol_scales[0],
&symbol_numbers[0],
(const char **)(&symbols[0])
);
}
plend();
outputPlotIm(im, trueColor, plotIm);
}
catch (...)
{
GERROR_STREAM("Errors happened in plotCurves(xlim, ylim) ... ");
return false;
}
return true;
}
out_slit()
{
real xsky, ysky, vrad, inv_surden, sigma, mass;
real xslit, yslit, xplt, yplt, sinpa, cospa;
real m_max, v_min, v_max, s_max; /* local min/max */
int i, islit;
Body *bp;
for (islit=0; islit<nslit; islit++) /* reset local variables */
v0star[islit] = v1star[islit] = v2star[islit] = 0.0;
m_max = v_min = v_max = s_max = 0.0;
inv_surden = 1.0 / (slit_width*slit_cell);
sinpa = sin(pa); cospa = cos(pa);
for(bp=btab, i=0; i<nobj; bp++, i++) { /* loop over all particles */
xsky = xvar(bp,tsnap,i);
ysky = yvar(bp,tsnap,i);
vrad = zvar(bp,tsnap,i);
mass = evar(bp,tsnap,i) * inv_surden;
xsky -= origin[0]; /* translate to slit origin */
ysky -= origin[1];
xslit = -cospa*ysky + sinpa*xsky; /* and rotate to slit frame */
yslit = sinpa*ysky + cospa*xsky; /* !!! check signs !!! */
if (fabs(yslit) > 0.5*slit_width)
continue; /* not in slit */
islit = (xslit+0.5*slit_length)/slit_cell;
if (islit<0 || islit>=nslit)
continue; /* not in slit */
v0star[islit] += mass;
v1star[islit] += vrad * mass;
v2star[islit] += sqr(vrad) * mass;
} /*-- end particles loop --*/
while (nsmooth-- > 0) { /* convolution */
dprintf (0,"Convolving with %d-length beam: ",lsmooth);
for (i=0; i<lsmooth; i++)
dprintf (0,"%f ",smooth[i]);
convolve (v0star, nslit, smooth, lsmooth);
convolve (v1star, nslit, smooth, lsmooth);
convolve (v2star, nslit, smooth, lsmooth);
dprintf (0,"\n");
}
for (islit=0; islit<nslit; islit++) { /* moment analysis: M, MV and MV^2 */
if (v0star[islit]==0.0)
continue; /* no data - skip to next pixel */
v1star[islit] /= v0star[islit];
sigma = v2star[islit]/v0star[islit] - sqr(v1star[islit]);
if (sigma<0.0) { /* should never happen */
warning("islit=%d sigma^2=%e < 0 !!!\n",islit,sigma);
v2star[islit] = 0.0;
continue; /* something really wrong */
}
v2star[islit] = sqrt(sigma);
if (v0star[islit] > m_max) m_max = v0star[islit];
if (v1star[islit] < v_min) v_min = v1star[islit];
if (v1star[islit] > v_max) v_max = v1star[islit];
if (v2star[islit] > s_max) s_max = v2star[islit];
if (Qtab) {
xslit = islit*slit_cell;
printf ("%g %g %g %g\n",
xslit,v0star[islit], v1star[islit], v2star[islit]);
}
} /* for(islit) */
if (Qtab)
return(0);
plinit ("***", 0.0, 20.0, 0.0, 20.0);
/* reset default autoscales to user supplied if necessary */
if (mmax==0.0) mmax=m_max;
if (vmin==0.0) vmin=v_min;
if (vmax==0.0) vmax=v_max;
if (smax==0.0) smax=s_max;
dprintf (0,"mmax=%f vmin=%f vmax=%f smax=%f reset to:\n",m_max,v_min,v_max,s_max);
if (mmax==0) mmax=1;
if (vmin==0 && vmax==0) vmax=1;
if (smax==0) smax=1;
dprintf (0,"mmax=%f vmin=%f vmax=%f smax=%f \n",mmax, vmin, vmax, smax);
/* general plot header */
sprintf (plabel,"File: %s; var{%s,%s,%s,%s} slit{%s %s %s %s}",
infile,getparam("xvar"),getparam("yvar"),
getparam("zvar"),getparam("evar"),
getparam("origin"),getparam("pa"),getparam("width"),
getparam("length"),getparam("cell"));
pltext (plabel,2.0,18.4, 0.32, 0.0);
#if 0
if (*headline!=NULL) /* identification */
pltext (headline,2.0,19.0,0.25,0.0);
#endif
xplot[0] = -0.5*slit_length; /* PLOT1: upper panel */
xplot[1] = 0.5*slit_length;
sprintf(xlabel,"slit: {x=%s,y=%s}",getparam("xvar"),getparam("yvar"));
yplot[0]=0.0;
yplot[1]=mmax;
strcpy (ylabel,"mass surface density");
xaxis ( 2.0,12.0, 16.0, xplot, -7, xtrans, NULL);
xaxis ( 2.0,17.0, 16.0, xplot, -7, xtrans, NULL);
yaxis ( 2.0,12.0, 5.0, yplot, -3, ytransm, ylabel);
yaxis (18.0,12.0, 5.0, yplot, -3, ytransm, NULL);
for (islit=0; islit<nslit; islit++) {
xplt = xtrans (-0.5*slit_length + (islit+0.5)*slit_cell);
yplt = ytransm (v0star[islit]);
plbox (xplt, yplt, SYMBOLSIZE);
}
yplot[0]=vmin; /* PLOT2: middle panel */
yplot[1]=vmax;
strcpy (ylabel,"velocity");
xaxis (2.0, 7.0, 16.0, xplot, -7, xtrans, NULL); /* line ?? */
yaxis (2.0, 7.0, 5.0, yplot, -3, ytransv1, ylabel);
yaxis (18.0,7.0, 5.0, yplot, -3, ytransv1, NULL);
for (islit=0; islit<nslit; islit++) {
xplt = xtrans (-0.5*slit_length + (islit+0.5)*slit_cell);
yplt = ytransv1 (v1star[islit]);
plcross (xplt, yplt, SYMBOLSIZE);
}
if (vmin<0.0 || vmax>0.0) {
plltype (1,2); /* dashed line at v=0 */
plmove (xtrans(xplot[0]), ytransv1(0.0));
plline (xtrans(xplot[1]), ytransv1(0.0));
plltype (1,1);
}
yplot[0]=0.0; /* PLOT3: bottom panel */
yplot[1]=smax;
strcpy (ylabel,"velocity dispersion");
xaxis (2.0, 2.0, 16.0, xplot, -7, xtrans, xlabel);
yaxis (2.0, 2.0, 5.0, yplot, -3, ytransv2, ylabel);
yaxis (18.0,2.0, 5.0, yplot, -3, ytransv2, NULL);
for (islit=0; islit<nslit; islit++) {
xplt = xtrans (-0.5*slit_length + (islit+0.5)*slit_cell);
yplt = ytransv2 (v2star[islit]);
plcross (xplt, yplt, -SYMBOLSIZE);
}
plstop();
}
int
main( int argc, const char *argv[] )
{
int i, j, k;
int npts = 0;
PLFLT xextreme[10][2];
PLFLT yextreme[10][2];
PLFLT x0[10];
PLFLT y0[10];
// Parse and process command line arguments
(void) plparseopts( &argc, argv, PL_PARSE_FULL );
// Initialize plplot
plssub( 3, 3 );
plinit();
xextreme[0][0] = -120.0; xextreme[0][1] = 120.0; yextreme[0][0] = -120.0; yextreme[0][1] = 120.0;
xextreme[1][0] = -120.0; xextreme[1][1] = 120.0; yextreme[1][0] = 20.0; yextreme[1][1] = 120.0;
xextreme[2][0] = -120.0; xextreme[2][1] = 120.0; yextreme[2][0] = -20.0; yextreme[2][1] = 120.0;
xextreme[3][0] = -80.0; xextreme[3][1] = 80.0; yextreme[3][0] = -20.0; yextreme[3][1] = 120.0;
xextreme[4][0] = -220.0; xextreme[4][1] = -120.0; yextreme[4][0] = -120.0; yextreme[4][1] = 120.0;
xextreme[5][0] = -20.0; xextreme[5][1] = 20.0; yextreme[5][0] = -120.0; yextreme[5][1] = 120.0;
xextreme[6][0] = -20.0; xextreme[6][1] = 20.0; yextreme[6][0] = -20.0; yextreme[6][1] = 20.0;
xextreme[7][0] = -80.0; xextreme[7][1] = 80.0; yextreme[7][0] = -80.0; yextreme[7][1] = 80.0;
xextreme[8][0] = 20.0; xextreme[8][1] = 120.0; yextreme[8][0] = -120.0; yextreme[8][1] = 120.0;
for ( k = 0; k < 2; k++ )
{
for ( j = 0; j < 4; j++ )
{
if ( j == 0 )
{
// Polygon 1: a diamond
x0[0] = 0; y0[0] = -100;
x0[1] = -100; y0[1] = 0;
x0[2] = 0; y0[2] = 100;
x0[3] = 100; y0[3] = 0;
npts = 4;
}
if ( j == 1 )
{
// Polygon 1: a diamond - reverse direction
x0[3] = 0; y0[3] = -100;
x0[2] = -100; y0[2] = 0;
x0[1] = 0; y0[1] = 100;
x0[0] = 100; y0[0] = 0;
npts = 4;
}
if ( j == 2 )
{
// Polygon 2: a square with punctures
x0[0] = -100; y0[0] = -100;
x0[1] = -100; y0[1] = -80;
x0[2] = 80; y0[2] = 0;
x0[3] = -100; y0[3] = 80;
x0[4] = -100; y0[4] = 100;
x0[5] = -80; y0[5] = 100;
x0[6] = 0; y0[6] = 80;
x0[7] = 80; y0[7] = 100;
x0[8] = 100; y0[8] = 100;
x0[9] = 100; y0[9] = -100;
npts = 10;
}
if ( j == 3 )
{
// Polygon 2: a square with punctures - reversed direction
x0[9] = -100; y0[9] = -100;
x0[8] = -100; y0[8] = -80;
x0[7] = 80; y0[7] = 0;
x0[6] = -100; y0[6] = 80;
x0[5] = -100; y0[5] = 100;
x0[4] = -80; y0[4] = 100;
x0[3] = 0; y0[3] = 80;
x0[2] = 80; y0[2] = 100;
x0[1] = 100; y0[1] = 100;
x0[0] = 100; y0[0] = -100;
npts = 10;
}
for ( i = 0; i < 9; i++ )
{
pladv( 0 );
plvsta();
plwind( xextreme[i][0], xextreme[i][1], yextreme[i][0], yextreme[i][1] );
plcol0( 2 );
plbox( "bc", 1.0, 0, "bcnv", 10.0, 0 );
plcol0( 1 );
plpsty( 0 );
if ( k == 0 )
plfill( npts, x0, y0 );
else
plgradient( npts, x0, y0, 45. );
plcol0( 2 );
pllsty( 1 );
plline( npts, x0, y0 );
}
}
}
// Don't forget to call plend() to finish off!
plend();
exit( 0 );
}
nemo_main()
{
int i, j, np;
string name, dumpfile;
name = getparam("name");
dumpfile = getparam("screendump");
np = getiparam("pages");
printf("Testing wth pages=%d\n",np);
plinit(name, 0.0, 20.0, 0.0, 20.0); /* open device */
x_init_plobj();
plmove(0.0, 0.0);
plcolor(0);
plline(20.0, 0.0);
plcolor(1);
plline(20.0, 20.0);
plcolor(2);
plline(0.0, 20.0);
plcolor(3);
plline(0.0, 0.0);
plcolor(4);
plline(20.0, 20.0);
plmove(20.0, 0.0);
plcolor(5);
plline(0.0, 20.0);
plltype(12, 0);
plmove(4.0, 18.0);
plcolor(6);
plline(16.0, 18.0);
plltype(-6, 0);
plmove(6.0, 18.0);
plcolor(7);
plline(14.0, 18.0);
for (i = 1; i <= 4; i++) {
plcolor(8+i);
plltype(i, 1);
plmove(1.0, 13.0 - i);
plline(3.0, 13.0 - i);
plpoint(3.5, 13.0 - i);
plltype(1, i);
for (j = 1; j <= 4; j++) {
plmove(1.5, 13.0 - i - 0.2*j);
plline(1.5 + j, 13.0 - i - 0.2*j);
}
}
plcolor(12);
plltype(1, 1);
plcircle(15.0, 9.0, -0.5);
plcolor(13);
plcircle(16.0, 9.0, 0.25);
plcolor(14);
plcircle(17.0, 9.0, 0.125);
plcolor(15);
plcircle(18.0, 9.0, 0.0625);
plbox(16.0, 8.0, 0.4);
plbox(17.0, 8.0, 0.2);
plbox(18.0, 8.0, -0.2);
plcross(16.0, 7.0, 0.4);
plcross(17.0, 7.0, 0.2);
plcross(18.0, 7.0, -0.2);
plcolor(4);
pltext("Foo Bar!", 8.0, 5.0, 0.5, 0.0);
plcolor(5);
pltext("Fum Bar!", 8.0, 3.0, 0.25, 0.0);
plcolor(6);
for (i = 0; i <= 4; i++)
pltext(" testing angles", 16.0, 10.0, 0.2, 45.0*i);
plmove(10.0, 8.5);
plline(10.0, 11.5);
pljust(-1);
plcolor(3);
pltext("left justified", 10.0, 9.0, 0.25, 0.0);
plcolor(2);
pljust(0);
pltext("centered", 10.0, 10.0, 0.25, 0.0);
plcolor(1);
pljust(1);
pltext("right justified", 10.0, 11.0, 0.25, 0.0);
pljust(0);
plcolor(7);
pltext(getparam("headline"),10.0, 19.0, 0.5, 0.0);
plcolor(1);
plflush();
if (*dumpfile)
pl_screendump(dumpfile);
if (np>1) {
plflush();
plframe();
plmove(0.0, 0.0);
plline(20.0, 0.0);
plline(20.0, 20.0);
plline(0.0, 20.0);
plline(0.0, 0.0);
pljust(0);
pltext("This is page 2", 10.0,10.0,0.25,0.0);
#define IMAX 100
#define ISTEP 20.0/IMAX
plmove (0.0,0.0);
for (i=0; i<IMAX; i++)
plline(i*ISTEP, i*ISTEP);
}
plstop();
}
void
shade(void)
{
int i, j;
PLFLT x, y, argx, argy, distort;
PLFLT **z, **w, zmin, zmax;
PLFLT xg1[XPTS], yg1[YPTS];
PLcGrid cgrid1;
PLcGrid2 cgrid2;
PLFLT shade_min, shade_max, sh_color;
PLINT sh_cmap = 1, sh_width;
PLINT min_color = 1, min_width = 0, max_color = 0, max_width = 0;
/* Set up function arrays */
plAlloc2dGrid(&z, XPTS, YPTS);
plAlloc2dGrid(&w, XPTS, YPTS);
/* Set up data array */
for (i = 0; i < XPTS; i++) {
x = (double) (i - (XPTS / 2)) / (double) (XPTS / 2);
for (j = 0; j < YPTS; j++) {
y = (double) (j - (YPTS / 2)) / (double) (YPTS / 2) - 1.0;
z[i][j] = - sin(7.*x) * cos(7.*y) + x*x - y*y;
w[i][j] = - cos(7.*x) * sin(7.*y) + 2 * x * y;
}
}
f2mnmx(z, XPTS, YPTS, &zmin, &zmax);
for (i = 0; i < NCONTR; i++)
clevel[i] = zmin + (zmax - zmin) * (i + 0.5) / (PLFLT) NCONTR;
/* Set up coordinate grids */
cgrid1.xg = xg1;
cgrid1.yg = yg1;
cgrid1.nx = XPTS;
cgrid1.ny = YPTS;
plAlloc2dGrid(&cgrid2.xg, XPTS, YPTS);
plAlloc2dGrid(&cgrid2.yg, XPTS, YPTS);
cgrid2.nx = XPTS;
cgrid2.ny = YPTS;
for (i = 0; i < XPTS; i++) {
for (j = 0; j < YPTS; j++) {
mypltr((PLFLT) i, (PLFLT) j, &x, &y, NULL);
argx = x * PI/2;
argy = y * PI/2;
distort = 0.4;
cgrid1.xg[i] = x + distort * cos(argx);
cgrid1.yg[j] = y - distort * cos(argy);
cgrid2.xg[i][j] = x + distort * cos(argx) * cos(argy);
cgrid2.yg[i][j] = y - distort * cos(argx) * cos(argy);
}
}
/* Plot using identity transform */
pladv(0);
plvpor(0.1, 0.9, 0.1, 0.9);
plwind(-1.0, 1.0, -1.0, 1.0);
for (i = 0; i < NCONTR; i++) {
shade_min = zmin + (zmax - zmin) * i / (PLFLT) NCONTR;
shade_max = zmin + (zmax - zmin) * (i +1) / (PLFLT) NCONTR;
sh_color = i / (PLFLT) (NCONTR-1);
sh_width = 2;
plpsty(0);
plshade(z, XPTS, YPTS, NULL, -1., 1., -1., 1.,
shade_min, shade_max,
sh_cmap, sh_color, sh_width,
min_color, min_width, max_color, max_width,
plfill, 1, NULL, NULL);
}
plcol(1);
plbox("bcnst", 0.0, 0, "bcnstv", 0.0, 0);
plcol(2);
/*
plcont(w, XPTS, YPTS, 1, XPTS, 1, YPTS, clevel, NCONTR, mypltr, NULL);
*/
pllab("distance", "altitude", "Bogon density");
/* Clean up */
plFree2dGrid(z, XPTS, YPTS);
plFree2dGrid(w, XPTS, YPTS);
plFree2dGrid(cgrid2.xg, XPTS, YPTS);
plFree2dGrid(cgrid2.yg, XPTS, YPTS);
}
int plp_draw(double *signal, int *signal_lengths, int ylog_scale) {
int count;
int i,j;
int col;
int dowind;
for (i=0;i<2*NOF_INPUT_ITF;i++) {
if (signal_lengths[i] > INPUT_MAX_SAMPLES) {
moderror_msg("plplot buffer configured for %d samples but received %d in signal %d\n",
INPUT_MAX_SAMPLES,signal_lengths[i],i);
return -1;
}
}
dowind=0;
xmax=-1;
for(i=0;i<2*NOF_INPUT_ITF;i++) {
if (signal_lengths[i]) {
dowind=1;
xmax = (PLFLT) MAX(xmax,signal_lengths[i]);
for (j=0;j<signal_lengths[i];j++) {
ymin = (PLFLT) MIN(ymin,signal[i*INPUT_MAX_SAMPLES+j]);
ymax = (PLFLT) MAX(ymax,signal[i*INPUT_MAX_SAMPLES+j]);
}
}
}
if (!dowind) {
xmin=0;
xmax=100;
ymin=-1;
ymax=1;
}
plclear();
plscolbg(255, 255, 255);
plvsta();
plwid(1);
plwind(xmin, xmax, ymin*1.1, ymax*1.1);
plcol0(1);
if (ylog_scale) {
plbox(logaxis_x, 0., 0, logaxis_y, 0., 0);
} else {
plbox(axis_x, 0., 0, axis_y, 0., 0);
}
plcol0(4);
plbox("g", 0, 0, "g", 0, 0);
plcol0(1);
pllab(xlabel, ylabel, "");
draw_legend();
plwid(4);
col=3;
for (i=0;i<2*NOF_INPUT_ITF;i++) {
if (signal_lengths[i]) {
plcol0(line_colors[i]);
plline(signal_lengths[i], t, &signal[i*INPUT_MAX_SAMPLES]);
col++;
if (col==4) col++;
}
}
plflush(); // force an update of the tk driver
}
void plotall(int nlyr, double* T, double* plyr, double* z, double* deltaTday) {
#ifndef _NOPLOT
/* Plot T against p */
pladv(1); /* select subpage 1 */
plvsta(); /* standard viewport */
plclear(); /* clear subpage */
plcol0 (15); /* color black */
plwind( 0, 400, PSURF, 0 ); /* xmin, xmax, ymin, ymax */
plbox( "bcnst", 100, 0, "bcnst", 150.0, 0 );
pllab ("temperature [K]", "p [hPa]", ""); /* axis labels */
plcol0 (14); /* color blue */
plline (nlyr, T, plyr); /* plot temperature profile */
plcol0 (15); /* color black */
/* Plot T against z */
pladv(3); /* select subpage 1 */
plvsta(); /* standard viewport */
plclear(); /* clear subpage */
plcol0 (15); /* color black */
plwind( 0, 400, 0, 40000 ); /* xmin, xmax, ymin, ymax */
plbox( "bcnst", 100, 0, "bcnst", 5000.0, 0 );
pllab ("temperature [K]", "z [m]", ""); /* axis labels */
plcol0 (14); /* color blue */
plline (nlyr, T, z); /* plot temperature profile */
plcol0 (15); /* color black */
/* Plot Heating rate against p */
pladv(2); /* select subpage 1 */
plvsta(); /* standard viewport */
plclear(); /* clear subpage */
plcol0 (15); /* color black */
plwind( -20, 20, PSURF, 0 ); /* xmin, xmax, ymin, ymax */
plbox( "bcnst", 2, 0, "bcnst", 150.0, 0 );
pllab ("Heating Rate [T/day]", "p [hPa]", ""); /* axis labels */
plcol0 (12); /* color blue */
plline (nlyr, deltaTday, plyr); /* plot temperature profile */
plcol0 (15); /* color black */
/* Plot Heating rate against z */
pladv(4); /* select subpage 1 */
plvsta(); /* standard viewport */
plclear(); /* clear subpage */
plcol0 (15); /* color black */
plwind( -20, 20, 0, 40000 ); /* xmin, xmax, ymin, ymax */
plbox( "bcnst", 2, 0, "bcnst", 5000.0, 0 );
pllab ("Heating Rate [T/day]", "z [m]", ""); /* axis labels */
plcol0 (12); /* color blue */
plline (nlyr, deltaTday, z); /* plot temperature profile */
plcol0 (15); /* color black */
#endif
}
void
plot1( int type, const char *x_label, const char *y_label, const char *alty_label,
const char * legend_text[], const char *title_label, const char *line_label )
{
int i;
static PLFLT freql[101], ampl[101], phase[101];
PLFLT f0, freq;
PLINT nlegend = 2;
PLINT opt_array[2];
PLINT text_colors[2];
PLINT line_colors[2];
PLINT line_styles[2];
PLFLT line_widths[2];
PLINT symbol_numbers[2], symbol_colors[2];
PLFLT symbol_scales[2];
const char *symbols[2];
PLFLT legend_width, legend_height;
pladv( 0 );
// Set up data for log plot
f0 = 1.0;
for ( i = 0; i <= 100; i++ )
{
freql[i] = -2.0 + i / 20.0;
freq = pow( 10.0, freql[i] );
ampl[i] = 20.0 * log10( 1.0 / sqrt( 1.0 + pow( ( freq / f0 ), 2. ) ) );
phase[i] = -( 180.0 / M_PI ) * atan( freq / f0 );
}
plvpor( 0.15, 0.85, 0.1, 0.9 );
plwind( -2.0, 3.0, -80.0, 0.0 );
// Try different axis and labelling styles.
plcol0( 1 );
switch ( type )
{
case 0:
plbox( "bclnst", 0.0, 0, "bnstv", 0.0, 0 );
break;
case 1:
plbox( "bcfghlnst", 0.0, 0, "bcghnstv", 0.0, 0 );
break;
}
// Plot ampl vs freq
plcol0( 2 );
plline( 101, freql, ampl );
plcol0( 2 );
plptex( 1.6, -30.0, 1.0, -20.0, 0.5, line_label );
// Put labels on
plcol0( 1 );
plmtex( "b", 3.2, 0.5, 0.5, x_label );
plmtex( "t", 2.0, 0.5, 0.5, title_label );
plcol0( 2 );
plmtex( "l", 5.0, 0.5, 0.5, y_label );
// For the gridless case, put phase vs freq on same plot
if ( type == 0 )
{
plcol0( 1 );
plwind( -2.0, 3.0, -100.0, 0.0 );
plbox( "", 0.0, 0, "cmstv", 30.0, 3 );
plcol0( 3 );
plline( 101, freql, phase );
plstring( 101, freql, phase, "#(728)" );
plcol0( 3 );
plmtex( "r", 5.0, 0.5, 0.5, alty_label );
}
// Draw a legend
// First legend entry.
opt_array[0] = PL_LEGEND_LINE;
text_colors[0] = 2;
line_colors[0] = 2;
line_styles[0] = 1;
line_widths[0] = 1.;
// note from the above opt_array the first symbol (and box) indices
// do not have to be specified
// Second legend entry.
opt_array[1] = PL_LEGEND_LINE | PL_LEGEND_SYMBOL;
text_colors[1] = 3;
line_colors[1] = 3;
line_styles[1] = 1;
line_widths[1] = 1.;
symbol_colors[1] = 3;
symbol_scales[1] = 1.;
symbol_numbers[1] = 4;
symbols[1] = "#(728)";
// from the above opt_arrays we can completely ignore everything
// to do with boxes.
plscol0a( 15, 32, 32, 32, 0.70 );
pllegend( &legend_width, &legend_height,
PL_LEGEND_BACKGROUND | PL_LEGEND_BOUNDING_BOX, 0,
0.0, 0.0, 0.10, 15,
1, 1, 0, 0,
nlegend, opt_array,
1.0, 1.0, 2.0,
1., text_colors, (const char **) legend_text,
NULL, NULL, NULL, NULL,
line_colors, line_styles, line_widths,
symbol_colors, symbol_scales, symbol_numbers, (const char **) symbols );
}
