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 PlPlotWidget::plotLinearFit(int size, std::vector<double> &xp,std::vector<double> &yp,std::vector<double> &yp_err, double m, double c){ plot->clearWidget(); //plot->setBackgroundColor(255,255,255,1); int i; double max_x, max_y; std::vector<double>::iterator result_min_x, result_max_x; std::vector<double>::iterator result_min_y, result_max_y; PLFLT *x = new PLFLT[size]; PLFLT *y = new PLFLT[size]; PLFLT *y_fit = new PLFLT[size]; PLFLT *y_err_hi = new PLFLT[size]; PLFLT *y_err_lo = new PLFLT[size]; for(i=0;i<size;i++){ // is there a better way with first value x[i]=xp[i]; y[i]=yp[i]; y_fit[i]=m*xp[i]+c; y_err_hi[i]=yp[i]+yp_err[i]; y_err_lo[i]=yp[i]-yp_err[i]; } result_min_x = std::min_element(xp.begin(), xp.end()); result_max_x = std::max_element(xp.begin(), xp.end()); result_min_y = std::min_element(yp.begin(), yp.end()); result_max_y = std::max_element(yp.begin(), yp.end()); max_x = (*result_max_x)*(1.2); //sets the axis to be 20% larger than the max value max_y = (*result_max_y)*(1.2); plcol0( 14 ); plenv( 0, max_x, 0, max_y, 0, 1 ); plcol0( 1 ); pllab( "time (s)", "\gl", "FRAP DATA" ); plcol0( 14 ); plwid( 2 ); plpoin( size, x, y, 20); plerry( size, x, y_err_hi,y_err_lo); plwid( 1 ); plcol0( 14 ); plwid( 2 ); plline( size, x, y_fit ); plwid( 1 ); delete[] x; delete[] y; delete[] y_fit; delete[] y_err_hi; delete[] y_err_lo; }
/* basic "plot one line" atom */ static void plotOneLine( uint32_t numSamples, PLFLT *fx, LineDef *lineDef, bool plotPoints, /* true: plot points */ bool plotLine) /* true: plot line */ { /* set drawing color - set the value for color map 0[1], then set it */ const RGB *rgb = &plColors[lineDef->color]; plscol0(1, rgb->r, rgb->g, rgb->b); plcol0(1); if(plotPoints) { plpoin(numSamples, fx, lineDef->fy, lineDef->pointCode); } if(plotLine) { plline(numSamples, fx, lineDef->fy); } }
void plot1( void ) { int i; PLFLT xmin, xmax, ymin, ymax; for ( i = 0; i < 60; i++ ) { x[i] = xoff + xscale * ( i + 1 ) / 60.0; y[i] = yoff + yscale * pow( x[i], 2. ); } xmin = x[0]; xmax = x[59]; ymin = y[0]; ymax = y[59]; for ( i = 0; i < 6; i++ ) { xs1[i] = x[i * 10 + 3]; ys1[i] = y[i * 10 + 3]; } // Set up the viewport and window using PLENV. The range in X is // 0.0 to 6.0, and the range in Y is 0.0 to 30.0. The axes are // scaled separately (just = 0), and we just draw a labelled // box (axis = 0). plcol0( 1 ); plenv( xmin, xmax, ymin, ymax, 0, 0 ); plcol0( 6 ); pllab( "(x)", "(y)", "#frPLplot Example 1 - y=x#u2" ); // Plot the data points plcol0( 9 ); plpoin( 6, xs1, ys1, 9 ); // Draw the line through the data plcol0( 4 ); plline( 60, x, y ); }
void plplot_plot_xy(plot_driver_type * driver , const char * label , double_vector_type * x , double_vector_type * y , plot_style_type style , line_attribute_type line_attr , point_attribute_type point_attr) { int size = double_vector_size( x ); plplot_logtransform_x( driver , x ); plplot_logtransform_y( driver , y ); /* Special case: ------------- If only one single point AND plot_style == LINE, we effectively change the plot_style to POINTS (and use the line_color) - otherwise the single point will not be visible. */ if ((style == LINE) && (size == 1)) { style = POINTS; point_attr.point_color = line_attr.line_color; } if (style & LINE) { plplot_setup_linestyle( line_attr ); plline(size , double_vector_get_ptr(x) , double_vector_get_ptr(y)); } if (style & POINTS) { plplot_setup_pointstyle( point_attr ); plpoin(size , double_vector_get_ptr(x) , double_vector_get_ptr(y) , point_attr.symbol_type); } }
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); }
void plot1( int do_test ) { int i; PLFLT xmin, xmax, ymin, ymax; for ( i = 0; i < 60; i++ ) { x[i] = xoff + xscale * ( i + 1 ) / 60.0; y[i] = yoff + yscale * pow( x[i], 2. ); } xmin = x[0]; xmax = x[59]; ymin = y[0]; ymax = y[59]; for ( i = 0; i < 6; i++ ) { xs[i] = x[i * 10 + 3]; ys[i] = y[i * 10 + 3]; } // Set up the viewport and window using PLENV. The range in X is // 0.0 to 6.0, and the range in Y is 0.0 to 30.0. The axes are // scaled separately (just = 0), and we just draw a labelled // box (axis = 0). // plcol0( 1 ); plenv( xmin, xmax, ymin, ymax, 0, 0 ); plcol0( 2 ); pllab( "(x)", "(y)", "#frPLplot Example 1 - y=x#u2" ); // Plot the data points plcol0( 4 ); plpoin( 6, xs, ys, 9 ); // Draw the line through the data plcol0( 3 ); plline( 60, x, y ); // xor mode enable erasing a line/point/text by replotting it again // it does not work in double buffering mode, however if ( do_test && test_xor ) { #ifdef PL_HAVE_NANOSLEEP PLINT st; struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = 50000000; plxormod( 1, &st ); // enter xor mode if ( st ) { for ( i = 0; i < 60; i++ ) { plpoin( 1, x + i, y + i, 9 ); // draw a point nanosleep( &ts, NULL ); // wait a little plflush(); // force an update of the tk driver plpoin( 1, x + i, y + i, 9 ); // erase point } plxormod( 0, &st ); // leave xor mode } #else printf( "The -xor command line option can only be exercised if your " "system\nhas nanosleep(), which does not seem to happen.\n" ); #endif } }
int main(int argc, char **argv) { SNDFILE *file1, *file2; SF_INFO info1, info2; double *in1, *in2; int min_frames, i; int like = 0, unlike = 0; int total = 0; int max1, max2; struct fft_average *avg; memset(&info1, 0, sizeof(SF_INFO)); memset(&info2, 0, sizeof(SF_INFO)); if (argc < 3) { printf("compare file1 file2"); return 1; } file1 = sf_open(argv[1], SFM_READ, &info1); if (!file1) { printf("Error opening wave file %s\n", argv[1]); exit(1); } file2 = sf_open(argv[2], SFM_READ, &info2); if (!file2) { printf("Error opening wave file %s\n", argv[2]); sf_close(file2); exit(1); } /* seconds = (float)info1.frames/(float)info1.samplerate; printf("Opened %s\n", argv[1]); printf("frames: %d\n", info1.frames); printf("samplerate: %d\n", info1.samplerate); printf("length (in seconds): %f\n", seconds); printf("channels: %d\n", info1.channels); printf("format: %x\n", info1.format); printf("sections: %d\n", info1.sections); printf("seekable: %d\n", info1.seekable); */ in1 = (double *)malloc(sizeof(double) * info1.frames); if (!in1) { printf("Failed to allocate input array\n"); sf_close(file1); sf_close(file2); return 1; } in2 = (double *)malloc(sizeof(double) * info2.frames); if (!in2) { printf("Failed to allocate input array\n"); free(in1); sf_close(file1); sf_close(file2); return 1; } normalize_wave(file1, in1, info1.frames, info1.channels); normalize_wave(file2, in2, info2.frames, info2.channels); max1 = shift_wave(in1, info1.frames); max2 = shift_wave(in2, info2.frames); // max1 = find_max(in1, info1.frames); // max2 = find_max(in2, info2.frames); /* shift_wave(in1, info1.frames); shift_wave(in2, info2.frames); */ plsdev("xwin"); plinit(); plenv(0.0f, info1.frames, -1, 1, 0, 0); for (i = 0; i < info1.frames; i++) { PLFLT x; PLFLT sample = i; if (in1[i] == -2) continue; x = in1[i]; plpoin(1, &sample, &x, 1); } plend(); plsdev("xwin"); plinit(); plenv(0.0f, info2.frames, -1, 1, 0, 0); for (i = 0; i < info2.frames; i++) { PLFLT x; PLFLT sample = i; if (in2[i] == -2) continue; x = in2[i]; plpoin(1, &sample, &x, 1); } plend(); avg = do_fft(in1, max1); printf("yavg = %f, xavg=%f\n", avg->yavg, avg->xavg); free(avg); avg = do_fft(in2, max2); printf("yavg = %f, xavg=%f\n", avg->yavg, avg->xavg); free(avg); min_frames = (info1.frames < info2.frames) ? info1.frames : info2.frames; for (i = 0; i < min_frames; i++) { double diff; if (in1[i] == -2 || in2[i] == -2) break; if (in1[i] > in2[i]) diff = in1[i] - in2[i]; else diff = in2[i] - in1[i]; if (diff <= 0.05) like++; else unlike++; total++; } printf("Minimum frames: %d\n", min_frames); printf("Total compares: %d\n", total); printf("Like: %d\n", like); printf("Unlike: %d\n", unlike); printf("Percentage alike: %f\n", ((double)like / (double)total) * 100); printf("Max1: %d\n", max1); printf("Max2: %d\n", max2); free(in1); free(in2); sf_close(file1); sf_close(file2); return 0; }
struct fft_average *do_fft(double *in, int max) { fftw_complex *out; double *fft_in; fftw_plan p; int i; double xmax = 0, xmin = 0, ymin = 0, ymax = 0; double average = 0; struct fft_average *avg; avg = malloc(sizeof(struct fft_average)); if (!avg) exit(1); fft_in = (double *)fftw_malloc(sizeof(double) * max); out = (fftw_complex *)fftw_malloc(sizeof(fftw_complex) * max); p = fftw_plan_dft_r2c_1d(max, fft_in, out, FFTW_PRESERVE_INPUT); for (i = 0; i < max; i++) fft_in[i] = in[i]; // memcpy(fft_in, in, sizeof(double) * max); fftw_execute(p); for (i = 0; i < max; i++) { double *d; d = out[i]; if (d[0] > xmax) xmax = d[0]; else if (d[0] < xmin) xmin = d[0]; if (d[1] > ymax) ymax = d[1]; else if (d[1] < ymin) ymin = d[1]; } plsdev("xwin"); plinit(); plenv(-1, 1, -1, 1, 0, 0); for (i = 0; i < max; i++) { PLFLT x; PLFLT y; double *d; d = out[i]; if (d[0] < 0) { x = d[0] / -xmin; avg->xavg += (d[0] / -xmin); if (i > 0) avg->xavg /= 2; } else { x = d[0] / xmax; avg->xavg += (d[0] / xmax); if (i > 0) avg->xavg /= 2; } if (d[1] < 0) { y = d[1] / -ymin; avg->yavg += (d[1] / -ymin); if (i > 0) avg->yavg /= 2; } else { y = d[1] / ymax; avg->yavg += (d[1] / ymax); if (i > 0) avg->yavg /= 2; } plpoin(1, &x, &y, 1); } plend(); fftw_destroy_plan(p); fftw_free(fft_in); fftw_free(out); return avg; }
int main(int argc, char *argv[]) { PLFLT *x, *y, *z, *clev; PLFLT *xg, *yg, **zg, **szg; PLFLT zmin, zmax, lzm, lzM; long ct; int i, j, k; PLINT alg; char ylab[40], xlab[40]; char *title[] = {"Cubic Spline Approximation", "Delaunay Linear Interpolation", "Natural Neighbors Interpolation", "KNN Inv. Distance Weighted", "3NN Linear Interpolation", "4NN Around Inv. Dist. Weighted"}; PLFLT opt[] = {0., 0., 0., 0., 0., 0.}; xm = ym = -0.2; xM = yM = 0.8; plMergeOpts(options, "x21c options", NULL); plparseopts(&argc, argv, PL_PARSE_FULL); opt[2] = wmin; opt[3] = (PLFLT) knn_order; opt[4] = threshold; /* Initialize plplot */ plinit(); create_data(&x, &y, &z, pts); /* the sampled data */ zmin = z[0]; zmax = z[0]; for (i=1; i<pts; i++) { if (z[i] > zmax) zmax = z[i]; if (z[i] < zmin) zmin = z[i]; } create_grid(&xg, xp, &yg, yp); /* grid the data at */ plAlloc2dGrid(&zg, xp, yp); /* the output grided data */ clev = (PLFLT *) malloc(nl * sizeof(PLFLT)); sprintf(xlab, "Npts=%d gridx=%d gridy=%d", pts, xp, yp); plcol0(1); plenv(xm, xM, ym, yM, 2, 0); plcol0(15); pllab(xlab, "", "The original data"); plcol0(2); plpoin(pts, x, y, 5); pladv(0); plssub(3,2); for (k=0; k<2; k++) { pladv(0); for (alg=1; alg<7; alg++) { ct = clock(); plgriddata(x, y, z, pts, xg, xp, yg, yp, zg, alg, opt[alg-1]); sprintf(xlab, "time=%d ms", (clock() - ct)/1000); sprintf(ylab, "opt=%.3f", opt[alg-1]); /* - CSA can generate NaNs (only interpolates?!). * - DTLI and NNI can generate NaNs for points outside the convex hull * of the data points. * - NNLI can generate NaNs if a sufficiently thick triangle is not found * * PLplot should be NaN/Inf aware, but changing it now is quite a job... * so, instead of not plotting the NaN regions, a weighted average over * the neighbors is done. */ if (alg == GRID_CSA || alg == GRID_DTLI || alg == GRID_NNLI || alg == GRID_NNI) { int ii, jj; PLFLT dist, d; for (i=0; i<xp; i++) { for (j=0; j<yp; j++) { if (isnan(zg[i][j])) { /* average (IDW) over the 8 neighbors */ zg[i][j] = 0.; dist = 0.; for (ii=i-1; ii<=i+1 && ii<xp; ii++) { for (jj=j-1; jj<=j+1 && jj<yp; jj++) { if (ii >= 0 && jj >= 0 && !isnan(zg[ii][jj])) { d = (abs(ii-i) + abs(jj-j)) == 1 ? 1. : 1.4142; zg[i][j] += zg[ii][jj]/(d*d); dist += d; } } } if (dist != 0.) zg[i][j] /= dist; else zg[i][j] = zmin; } } } } plMinMax2dGrid(zg, xp, yp, &lzM, &lzm); plcol0(1); pladv(alg); if (k == 0) { lzm = MIN(lzm, zmin); lzM = MAX(lzM, zmax); for (i=0; i<nl; i++) clev[i] = lzm + (lzM-lzm)/(nl-1)*i; plenv0(xm, xM, ym, yM, 2, 0); plcol0(15); pllab(xlab, ylab, title[alg-1]); plshades(zg, xp, yp, NULL, xm, xM, ym, yM, clev, nl, 1, 0, 1, plfill, 1, NULL, NULL); plcol0(2); } else { for (i=0; i<nl; i++) clev[i] = lzm + (lzM-lzm)/(nl-1)*i; cmap1_init(); plvpor(0.0, 1.0, 0.0, 0.9); plwind(-1.0, 1.0, -1.0, 1.5); /* * For the comparition to be fair, all plots should have the * same z values, but to get the max/min of the data generated * by all algorithms would imply two passes. Keep it simple. * * plw3d(1., 1., 1., xm, xM, ym, yM, zmin, zmax, 30, -60); */ plw3d(1., 1., 1., xm, xM, ym, yM, lzm, lzM, 30, -60); plbox3("bnstu", ylab, 0.0, 0, "bnstu", xlab, 0.0, 0, "bcdmnstuv", "", 0.0, 4); plcol0(15); pllab("", "", title[alg-1]); plot3dc(xg, yg, zg, xp, yp, DRAW_LINEXY | MAG_COLOR | BASE_CONT, clev, nl); } } } plend(); free_data(x, y, z); free_grid(xg, yg); free((void *)clev); plFree2dGrid(zg, xp, yp); }
int main( int argc, char **argv ) { PLFLT minx, maxx, miny, maxy; PLFLT x, y; //variables for the shapelib example const PLINT nbeachareas = 2; const PLINT beachareas[] = { 23, 24 }; const PLINT nwoodlandareas = 94; PLINT woodlandareas[94]; const PLINT nshingleareas = 22; const PLINT shingleareas[] = { 0, 1, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 217, 2424, 2425, 2426, 2427, 2428, 2491, 2577 }; const PLINT ncragareas = 2024; PLINT cragareas[2024]; const PLINT majorroads[] = { 33, 48, 71, 83, 89, 90, 101, 102, 111 }; int i; // Parse and process command line arguments (void) plparseopts( &argc, argv, PL_PARSE_FULL ); // Longitude (x) and latitude (y) miny = -70; maxy = 80; plinit(); // Cartesian plots // Most of world minx = -170; maxx = minx + 360; // Setup a custom latitude and longitude-based scaling function. plslabelfunc( geolocation_labeler, NULL ); plcol0( 1 ); plenv( minx, maxx, miny, maxy, 1, 70 ); plmap( NULL, "usaglobe", minx, maxx, miny, maxy ); // The Americas minx = 190; maxx = 340; plcol0( 1 ); plenv( minx, maxx, miny, maxy, 1, 70 ); plmap( NULL, "usaglobe", minx, maxx, miny, maxy ); // Clear the labeling function plslabelfunc( NULL, NULL ); // Polar, Northern hemisphere minx = 0; maxx = 360; plenv( -75., 75., -75., 75., 1, -1 ); plmap( mapform19, "globe", minx, maxx, miny, maxy ); pllsty( 2 ); plmeridians( mapform19, 10.0, 10.0, 0.0, 360.0, -10.0, 80.0 ); // Polar, Northern hemisphere, this time with a PLplot-wide transform minx = 0; maxx = 360; plstransform( map_transform, NULL ); pllsty( 1 ); plenv( -75., 75., -75., 75., 1, -1 ); // No need to set the map transform here as the global transform will be // used. plmap( NULL, "globe", minx, maxx, miny, maxy ); pllsty( 2 ); plmeridians( NULL, 10.0, 10.0, 0.0, 360.0, -10.0, 80.0 ); // Show Baltimore, MD on the map plcol0( 2 ); plssym( 0.0, 2.0 ); x = -76.6125; y = 39.2902778; plpoin( 1, &x, &y, 18 ); plssym( 0.0, 1.0 ); plptex( -76.6125, 43.0, 0.0, 0.0, 0.0, "Baltimore, MD" ); // For C, this is how the global transform is cleared plstransform( NULL, NULL ); // An example using shapefiles. The shapefiles used are from Ordnance Survey, UK. // These were chosen because they provide shapefiles for small grid boxes which // are easilly manageable for this demo. pllsty( 1 ); minx = 240570; maxx = 621109; miny = 87822; maxy = 722770; plscol0( 0, 255, 255, 255 ); plscol0( 1, 0, 0, 0 ); plscol0( 2, 150, 150, 150 ); plscol0( 3, 0, 50, 200 ); plscol0( 4, 50, 50, 50 ); plscol0( 5, 150, 0, 0 ); plscol0( 6, 100, 100, 255 ); minx = 265000; maxx = 270000; miny = 145000; maxy = 150000; plscol0( 0, 255, 255, 255 ); //white plscol0( 1, 0, 0, 0 ); //black plscol0( 2, 255, 200, 0 ); //yelow for sand plscol0( 3, 60, 230, 60 ); // green for woodland plscol0( 4, 210, 120, 60 ); //brown for contours plscol0( 5, 150, 0, 0 ); //red for major roads plscol0( 6, 180, 180, 255 ); //pale blue for water plscol0( 7, 100, 100, 100 ); //pale grey for shingle or boulders plscol0( 8, 100, 100, 100 ); //dark grey for custom polygons - generally crags plcol0( 1 ); plenv( minx, maxx, miny, maxy, 1, -1 ); pllab( "", "", "Martinhoe CP, Exmoor National Park, UK (shapelib only)" ); //Beach plcol0( 2 ); plmapfill( NULL, "ss/ss64ne_Landform_Area", minx, maxx, miny, maxy, beachareas, nbeachareas ); //woodland plcol0( 3 ); for ( i = 0; i < nwoodlandareas; ++i ) woodlandareas[i] = i + 218; plmapfill( NULL, "ss/ss64ne_Landform_Area", minx, maxx, miny, maxy, (PLINT_VECTOR) woodlandareas, nwoodlandareas ); //shingle or boulders plcol0( 7 ); plmapfill( NULL, "ss/ss64ne_Landform_Area", minx, maxx, miny, maxy, shingleareas, nshingleareas ); //crags plcol0( 8 ); for ( i = 0; i < ncragareas; ++i ) cragareas[i] = i + 325; plmapfill( NULL, "ss/ss64ne_Landform_Area", minx, maxx, miny, maxy, (PLINT_VECTOR) cragareas, ncragareas ); //draw contours, we need to separate contours from high/low coastline //draw_contours(pls, "ss/SS64_line", 433, 20, 4, 3, minx, maxx, miny, maxy ); plcol0( 4 ); plmapline( NULL, "ss/ss64ne_Height_Contours", minx, maxx, miny, maxy, NULL, 0 ); //draw the sea and surface water plwidth( 0.0 ); plcol0( 6 ); plmapfill( NULL, "ss/ss64ne_Water_Area", minx, maxx, miny, maxy, NULL, 0 ); plwidth( 2.0 ); plmapfill( NULL, "ss/ss64ne_Water_Line", minx, maxx, miny, maxy, NULL, 0 ); //draw the roads, first with black and then thinner with colour to give an //an outlined appearance plwidth( 5.0 ); plcol0( 1 ); plmapline( NULL, "ss/ss64ne_Road_Centreline", minx, maxx, miny, maxy, NULL, 0 ); plwidth( 3.0 ); plcol0( 0 ); plmapline( NULL, "ss/ss64ne_Road_Centreline", minx, maxx, miny, maxy, NULL, 0 ); plcol0( 5 ); plmapline( NULL, "ss/ss64ne_Road_Centreline", minx, maxx, miny, maxy, majorroads, 9 ); //draw buildings plwidth( 1.0 ); plcol0( 1 ); plmapfill( NULL, "ss/ss64ne_Building_Area", minx, maxx, miny, maxy, NULL, 0 ); //labels plsfci( 0x80000100 ); plschr( 0, 0.8 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "MARTINHOE CP", minx, maxx, miny, maxy, 202 ); plschr( 0, 0.7 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "Heale\nDown", minx, maxx, miny, maxy, 13 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "South\nDown", minx, maxx, miny, maxy, 34 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "Martinhoe\nCommon", minx, maxx, miny, maxy, 42 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "Woody Bay", minx, maxx, miny, maxy, 211 ); plschr( 0, 0.6 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "Mill Wood", minx, maxx, miny, maxy, 16 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "Heale Wood", minx, maxx, miny, maxy, 17 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 1.0, "Bodley", minx, maxx, miny, maxy, 31 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.0, "Martinhoe", minx, maxx, miny, maxy, 37 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "Woolhanger\nCommon", minx, maxx, miny, maxy, 60 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "West Ilkerton\nCommon", minx, maxx, miny, maxy, 61 ); plmaptex( NULL, "ss/ss64ne_General_Text", 1.0, 0.0, 0.5, "Caffyns\nHeanton\nDown", minx, maxx, miny, maxy, 62 ); plend(); exit( 0 ); }