Example #1
0
void show_label(double *px, double *py, LATTR *lattr, const char *text)
{
    double X = *px, Y = *py;
    int Xoffset, Yoffset;
    double xarr[5], yarr[5];
    double T, B, L, R;

    X = X + D_get_d_to_u_xconv() * 0.5 * lattr->size;
    Y = Y + D_get_d_to_u_yconv() * 1.5 * lattr->size;

    D_pos_abs(X, Y);
    D_get_text_box(text, &T, &B, &L, &R);

    /* Expand border 1/2 of text size */
    T = T - D_get_d_to_u_yconv() * lattr->size / 2;
    B = B + D_get_d_to_u_yconv() * lattr->size / 2;
    L = L - D_get_d_to_u_xconv() * lattr->size / 2;
    R = R + D_get_d_to_u_xconv() * lattr->size / 2;

    Xoffset = 0;
    Yoffset = 0;
    if (lattr->xref == LCENTER)
	Xoffset = -(R - L) / 2;
    if (lattr->xref == LRIGHT)
	Xoffset = -(R - L);
    if (lattr->yref == LCENTER)
	Yoffset = -(B - T) / 2;
    if (lattr->yref == LBOTTOM)
	Yoffset = -(B - T);

    if (lattr->has_bgcolor || lattr->has_bcolor) {
	xarr[0] = xarr[1] = xarr[4] = L + Xoffset;
	xarr[2] = xarr[3] = R + Xoffset;
	yarr[0] = yarr[3] = yarr[4] = B + Yoffset;
	yarr[1] = yarr[2] = T + Yoffset;

	if (lattr->has_bgcolor) {
	    D_RGB_color(lattr->bgcolor.R, lattr->bgcolor.G,
			lattr->bgcolor.B);
	    D_polygon_abs(xarr, yarr, 5);
	}

	if (lattr->has_bcolor) {
	    D_RGB_color(lattr->bcolor.R, lattr->bcolor.G,
			lattr->bcolor.B);
	    D_polyline_abs(xarr, yarr, 5);
	}
	D_RGB_color(lattr->color.R, lattr->color.G, lattr->color.B);
    }

    D_pos_abs(X + Xoffset, Y + Yoffset);
    D_text(text);
}
Example #2
0
static void symbol(const SYMBOL *Symb, double x0, double y0,
		   const RGBA_Color *fill_color,
		   const RGBA_Color *line_color,
		   const RGBA_Color *string_color)
{
    int i, j, k;
    const SYMBPART *part;
    const SYMBCHAIN *chain;
    double xp, yp;
    double *x, *y;
    double sx = D_get_d_to_u_xconv();
    double sy = D_get_d_to_u_yconv();

    G_debug(2, "D_symbol(): %d parts", Symb->count);

    for (i = 0; i < Symb->count; i++) {
	part = Symb->part[i];

	switch (part->type) {

	case S_POLYGON:
	    /* draw background fills */
	    if ((part->fcolor.color == S_COL_DEFAULT &&
		 fill_color->a != RGBA_COLOR_NONE) ||
		part->fcolor.color == S_COL_DEFINED) {
		if (part->fcolor.color == S_COL_DEFAULT)
		    D_RGB_color(fill_color->r, fill_color->g, fill_color->b);
		else
		    D_RGB_color(part->fcolor.r, part->fcolor.g,
				part->fcolor.b);

		for (j = 0; j < part->count; j++) {	/* for each component polygon */
		    chain = part->chain[j];

		    x = G_malloc(sizeof(double) * chain->scount);
		    y = G_malloc(sizeof(double) * chain->scount);

		    for (k = 0; k < chain->scount; k++) {
			x[k] = x0 + sx * chain->sx[k];
			y[k] = y0 - sy * chain->sy[k];
		    }
		    D_polygon_abs(x, y, chain->scount);

		    G_free(x);
		    G_free(y);
		}

	    }
	    /* again, to draw the lines */
	    if ((part->color.color == S_COL_DEFAULT &&
		 line_color->a != RGBA_COLOR_NONE) ||
		part->color.color == S_COL_DEFINED) {
		if (part->color.color == S_COL_DEFAULT)
		    D_RGB_color(line_color->r, line_color->g, line_color->b);
		else
		    D_RGB_color(part->color.r, part->color.g, part->color.b);

		for (j = 0; j < part->count; j++) {
		    chain = part->chain[j];

		    D_begin();
		    for (k = 0; k < chain->scount; k++) {
			xp = x0 + sx * chain->sx[k];
			yp = y0 - sy * chain->sy[k];
			if (k == 0)
			    D_move_abs(xp, yp);
			else
			    D_cont_abs(xp, yp);
		    }
		    D_end();
		    D_stroke();
		}
	    }
	    break;

	case S_STRING:
	    if (part->color.color == S_COL_NONE)
		break;
	    else if (part->color.color == S_COL_DEFAULT &&
		     string_color->a != RGBA_COLOR_NONE)
		D_RGB_color(string_color->r, string_color->g, string_color->b);
	    else
		D_RGB_color(part->color.r, part->color.g, part->color.b);

	    chain = part->chain[0];

	    D_begin();
	    for (j = 0; j < chain->scount; j++) {
		xp = x0 + sx * chain->sx[j];
		yp = y0 - sy * chain->sy[j];
		if (j == 0)
		    D_move_abs(xp, yp);
		else
		    D_cont_abs(xp, yp);
	    }
	    D_end();
	    D_stroke();
	    break;

	}			/* switch */
    }				/* for loop */
}
Example #3
0
File: main.c Project: caomw/grass
int main(int argc, char **argv)
{
    struct GModule *module;
    struct Option *map, *profile;
    struct Flag *stored;
    struct Cell_head window;
    struct point *points = NULL;
    int num_points, max_points = 0;
    double length;
    double t, b, l, r;
    int fd;
    int i;
    double sx;
    int last;

    /* Initialize the GIS calls */
    G_gisinit(argv[0]);

    /* Set description */
    module = G_define_module();
    G_add_keyword(_("display"));
    G_add_keyword(_("profile"));
    G_add_keyword(_("raster"));
    module->description = _("Plots profile of a transect.");

    /* set up command line */
    map = G_define_standard_option(G_OPT_R_INPUT);
    map->description = _("Raster map to be profiled");

    profile = G_define_option();
    profile->key = "profile";
    profile->type = TYPE_DOUBLE;
    profile->required = YES;
    profile->multiple = YES;
    profile->key_desc = "east,north";
    profile->description = _("Profile coordinate pairs");

    stored = G_define_flag();
    stored->key = 'r';
    stored->description = _("Use map's range recorded range");

    if (G_parser(argc, argv))
	exit(EXIT_FAILURE);

    mapname = map->answer;

    fd = Rast_open_old(mapname, "");

    if (stored->answer)
	get_map_range();
    else
	get_region_range(fd);

    G_get_window(&window);

    num_points = 0;
    length = 0;
    for (i = 0; profile->answers[i]; i += 2) {
	struct point *p;
	double x, y;

	if (num_points >= max_points) {
	    max_points = num_points + 100;
	    points = G_realloc(points, max_points * sizeof(struct point));
	}

	p = &points[num_points];

	G_scan_easting( profile->answers[i+0], &x, G_projection());
	G_scan_northing(profile->answers[i+1], &y, G_projection());

	p->x = Rast_easting_to_col (x, &window);
	p->y = Rast_northing_to_row(y, &window);

	if (num_points > 0) {
	    const struct point *prev = &points[num_points-1];
	    double dx = fabs(p->x - prev->x);
	    double dy = fabs(p->y - prev->y);
	    double d = sqrt(dx * dx + dy * dy);
	    length += d;
	    p->d = length;
	}

	num_points++;
    }
    points[0].d = 0;

    if (num_points < 2)
	G_fatal_error(_("At least two points are required"));

    /* establish connection with graphics driver */
    if (D_open_driver() != 0)
	G_fatal_error(_("No graphics device selected. "
			"Use d.mon to select graphics device."));
    
    D_setup2(1, 0, 1.05, -0.05, -0.15, 1.05);

    plot_axes();

    D_use_color(D_translate_color(DEFAULT_FG_COLOR));

    D_get_src(&t, &b, &l, &r);
    t -= 0.1 * (t - b);
    b += 0.1 * (t - b);
    l += 0.1 * (r - l);
    r -= 0.1 * (r - l);

    D_begin();

    i = 0;
    last = 0;
    for (sx = 0; sx < 1; sx += D_get_d_to_u_xconv()) {
	double d = length * (sx - l);
	const struct point *p, *next;
	double k, sy, x, y;
	DCELL v;

	for (;;) {
	    p = &points[i];
	    next = &points[i + 1];
	    k = (d - p->d) / (next->d - p->d);
	    if (k < 1)
		break;
	    i++;
	}

	x = p->x * (1 - k) + next->x * k;
	y = p->y * (1 - k) + next->y * k;

	if (!get_cell(&v, fd, x, y)) {
	    last = 0;
	    continue;
	}

	sy = (v - min) / (max - min);

	if (last)
	    D_cont_abs(sx, sy);
	else
	    D_move_abs(sx, sy);

	last = 1;
    }

    D_end();
    D_stroke();
    
    D_close_driver();

    exit(EXIT_SUCCESS);
}