Beispiel #1
0
int main() {
	{
		TimeCheck time;
		auto surface = create_surface(CAIRO_FORMAT_ARGB32, SURFACE_SIZE{ 256, 256 });
		auto cr = create(surface);
		
		line_width(cr, 30.0);
		line_cap(cr, CAIRO_LINE_CAP_BUTT); /* default */
		move_to(cr, POINT{ 64.0, 50.0 }); line_to(cr, POINT{ 64.0, 200.0 });
		stroke(cr);

		line_cap(cr, CAIRO_LINE_CAP_ROUND);
		move_to(cr, POINT{ 128.0, 50.0 }); line_to(cr, POINT{ 128.0, 200.0 });
		stroke(cr);

		line_cap(cr, CAIRO_LINE_CAP_SQUARE);
		move_to(cr, POINT{ 192.0, 50.0 }); line_to(cr, POINT{ 192.0, 200.0 });
		stroke(cr);

		/* draw helping lines */
		source(cr, RGB{ 1, 0.2, 0.2 });
		line_width(cr, 2.56);
		move_to(cr, POINT{ 64.0, 50.0 }); line_to(cr, POINT{ 64.0, 200.0 });
		move_to(cr, POINT{ 128.0, 50.0 });  line_to(cr, POINT{ 128.0, 200.0 });
		move_to(cr, POINT{ 192.0, 50.0 }); line_to(cr, POINT{ 192.0, 200.0 });
		stroke(cr);

		write_to_png(surface, "image.png");
	}
	return 0;
}
Beispiel #2
0
int main() {
	{
		TimeCheck time;

		auto surface = create_surface(CAIRO_FORMAT_ARGB32, SURFACE_SIZE{ 256, 256 });
		auto cr = create(surface);

		arc(cr, POINT{ 128.0, 128.0 }, 76.8, DEGRESS{ 0 }, DEGRESS{ 360 });
		clip(cr);

		new_path(cr);  /* current path is not  consumed by cairo_clip() */
		rectangle(cr, POINT{ 0, 0 }, SIZE{ 255, 255 });
		fill(cr);
		
		source(cr, RGB{ 0, 1, 0 });
		move_to(cr, POINT{ 0, 0 });
		line_to(cr, POINT{ 256, 256 });
		move_to(cr, POINT{ 256, 0 });
		line_to(cr, POINT{ 0, 256 });
		line_width(cr, 10.0);
		stroke(cr);
		
		write_to_png(surface, "image.png");
	}
	return 0;
}
Beispiel #3
0
int main() {
	{
		TimeCheck time;

		constexpr int WIDTH = 175;
		constexpr int HEIGHT = 175;
		constexpr int STRIDE = WIDTH * 4;

		std::vector<unsigned char> datas(HEIGHT*STRIDE);
		auto surface = create_surface(datas, CAIRO_FORMAT_ARGB32, SURFACE_SIZE{ WIDTH, HEIGHT }, STRIDE);
		auto cr = create(surface);

		rectangle(cr, POINT{ 0,0 }, SIZE{ WIDTH, HEIGHT });
		source(cr, RGB{ 0,0,0 });
		fill(cr);

		draw(cr, WIDTH, HEIGHT);

		write_to_png(surface, "image.png"); 
	}
	return 0;
}
Beispiel #4
0
int main() {
	{
		TimeCheck time;
		constexpr int WIDTH = 450;
		constexpr int HEIGHT = 900;
		constexpr int STRIDE = WIDTH * 4;

		std::vector<unsigned char> datas(HEIGHT*STRIDE);
		auto surface = create_surface(datas, CAIRO_FORMAT_ARGB32, SURFACE_SIZE{ WIDTH, HEIGHT }, STRIDE);
		auto cr = create(surface);

		rectangle(cr, POINT{ 0,0 }, SIZE{ WIDTH ,HEIGHT });
		source(cr, RGB{ 1,1,1 });
		fill(cr);
		
		source(cr, RGB{ 0,0,0 });
		font_face(cr, u8"serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
		font_size(cr, 40);
		translate(cr, POINT{ 40, 40 });

		
		font_face(cr, u8"mono", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
		font_size(cr, 12);
		show_text(cr, u8"+CTM rotation");

		constexpr auto NUM_STRINGS = 3;
		save(cr); 
		{
			font_face(cr, u8"serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
			font_size(cr, 40);
			for (int i = 0; i < NUM_STRINGS; ++i) {
				RADIAN angle{ i * 0.5*pi<double> / double(NUM_STRINGS - 1) };
				save(cr);
				rotate(cr, angle);
				move_to(cr, POINT{ 100, 0 });
				show_text(cr, u8"Text");
				restore(cr);
			}
		}
		restore(cr);

		translate(cr, POINT{ 0, HEIGHT / 3 });
		move_to(cr, POINT{ 0, 0 });
		show_text(cr, u8"+CTM rotation");
		rel_move_to(cr, POINT{ 0, 12 });
		show_text(cr, u8"-font rotation");

		save(cr);
		font_face(cr, u8"serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
		font_size(cr, 40);
		{
			cairo_matrix_t mat{};
			for (int i = 0; i < NUM_STRINGS; ++i) {
				RADIAN angle{ i * 0.5*pi<double> / double(NUM_STRINGS - 1) };
				save(cr);
				rotate(cr, angle);
				identity(mat);
				scale(mat, SCALE{ 40,40 });
				rotate(mat, -angle);
				font_matrix(cr, mat);
				move_to(cr, POINT{ 100, 0 });
				show_text(cr, u8"Text");
				restore(cr);
			}
		}
		restore(cr);

		translate(cr, POINT{ 0, HEIGHT / 3 });
		move_to(cr, POINT{ 0, 0 });
		show_text(cr, u8"+CTM rotation");
		rel_move_to(cr, POINT{ 0, 12 });
		show_text(cr, u8"-CTM rotation");

		save(cr);
		font_face(cr, u8"serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
		font_size(cr, 40);
		{
			for (int i = 0; i < NUM_STRINGS; ++i) {
				RADIAN angle{ i * 0.5*pi<double> / double(NUM_STRINGS - 1) };
				save(cr);
				rotate(cr, angle);
				move_to(cr, POINT{ 100, 0 });
				rotate(cr, -angle);
				show_text(cr, u8"Text");
				restore(cr);
			}
		}
		restore(cr);
		
		write_to_png(surface, "image.png"); 
	}
	return 0;
}
Beispiel #5
0
int main(int argc, char *argv[]) {     
    int fd;                      /* fd to Erlang node */
    unsigned char buf[BUFSIZE];  /* Buffer for incoming message */
    ErlMessage emsg;             /* Incoming message */
    int c_node;                   /* C-Node number */
    char cookie[EI_MAX_COOKIE_SIZE+1];  /* Shared cookie */
    short creation;              /* ?? */
    char *erlang_node;           /* Erlang node to connect to */
	 char *cookie_opt;				/* Where to source our cookie */
	 char *cookie_data;				/* Either the filename or literal cookie */
    ETERM *fromp, *msgp, *fnp, *argp, *resp;
    int received, loop = 1;
    
    if (argc < 5) {
        quit_with_error("invalid_args");
    }
    
    c_node = atoi(argv[1]);
    cookie_opt = argv[2];
	 cookie_data = argv[3];
    creation = 0;
    erlang_node = argv[4];
    
    erl_init(NULL, 0);

	 get_cookie(cookie_opt, cookie_data, cookie);
    
    if (!erl_connect_init(c_node, cookie, creation)) {
        quit_with_error("erl_connect_init");
    }
    
    if ((fd = erl_connect(erlang_node)) < 0) {
        quit_with_error("erl_connect"); 
    }
       
    while (loop) {
        received = erl_receive_msg(fd, buf, BUFSIZE, &emsg);

    if (received == ERL_TICK) {
        /* ignore */    
    } else if (received == ERL_ERROR) {
        loop = 0;
    } else {
        if (emsg.type == ERL_REG_SEND) {          
            fromp = erl_element(2, emsg.msg);
            msgp = erl_element(3, emsg.msg);
            fnp = erl_element(1, msgp);
            argp = erl_element(2, msgp);  
            
            if (is_function(fnp, "stop")) {
                loop = 0;
                resp = erl_format("{c_node, ~i, ok}", c_node);
            } else if (is_function(fnp, "new_image_blank")) { 
                resp = new_image_blank(argp, c_node); 
            } else if (is_function(fnp, "write_to_png")) {
                resp = write_to_png(argp, c_node);
            } else if (is_function(fnp, "close_image")) {
                resp = close_image(argp, c_node);
            } else if (is_function(fnp, "save")) {
                resp = save(argp, c_node);
            } else if (is_function(fnp, "restore")) {
                resp = restore(argp, c_node);
            } else if (is_function(fnp, "set_line_width")) {
                resp = set_line_width(argp, c_node);
            } else if (is_function(fnp, "set_source_rgba")) {
                resp = set_source_rgba(argp, c_node);	
	        } else if (is_function(fnp, "set_operator")) {
                resp = set_operator(argp, c_node);
            } else if (is_function(fnp, "move_to")) {
                resp = move_to(argp, c_node);
            } else if (is_function(fnp, "line_to")) {
                resp = line_to(argp, c_node);
            } else if (is_function(fnp, "curve_to")) {
                resp = curve_to(argp, c_node);
            } else if (is_function(fnp, "rel_move_to")) {
                resp = rel_move_to(argp, c_node);
            } else if (is_function(fnp, "rel_line_to")) {
                resp = rel_line_to(argp, c_node);
            } else if (is_function(fnp, "rel_curve_to")) {
                resp = rel_curve_to(argp, c_node);
            } else if (is_function(fnp, "rectangle")) {
                resp = rectangle(argp, c_node);
            } else if (is_function(fnp, "arc")) {
                resp = arc(argp, c_node);
            } else if (is_function(fnp, "arc_negative")) {
                resp = arc_negative(argp, c_node);
            } else if (is_function(fnp, "close_path")) {
                resp = close_path(argp, c_node);
            } else if (is_function(fnp, "paint")) {
                resp = paint(argp, c_node);
            } else if (is_function(fnp, "fill")) {
                resp = fill(argp, c_node);
            } else if (is_function(fnp, "fill_preserve")) {
                resp = fill_preserve(argp, c_node);
            } else if (is_function(fnp, "stroke")) {
                resp = stroke(argp, c_node);
            } else if (is_function(fnp, "stroke_preserve")) {
                resp = stroke_preserve(argp, c_node);
            } else if (is_function(fnp, "translate")) {
                resp = translate(argp, c_node);
            } else if (is_function(fnp, "scale")) {
                resp = scale(argp, c_node);
            } else if (is_function(fnp, "rotate")) {
                resp = rotate(argp, c_node);
            } else if (is_function(fnp, "select_font")) {
                resp = select_font_face(argp, c_node);
            } else if (is_function(fnp, "set_font_size")) {
                resp = set_font_size(argp, c_node);
            } else if (is_function(fnp, "show_text")) {
                resp = show_text(argp, c_node);
            } else if (is_function(fnp, "text_extents")) {
                resp = text_extents(argp, c_node);          
            } else if (is_function(fnp, "surface_create_from_png")) {
                resp = surface_create_from_png(argp, c_node);
            } else if (is_function(fnp, "surface_create_from_png_stream")) {
                resp = surface_create_from_png_stream(argp, c_node);
            } else if (is_function(fnp, "surface_get_width")) {
                resp = surface_get_width(argp, c_node);          
            } else if (is_function(fnp, "surface_get_height")) {
                resp = surface_get_height(argp, c_node);          
            } else if (is_function(fnp, "surface_destroy")) {
                resp = surface_destroy(argp, c_node);          
            } else if (is_function(fnp, "set_source_surface")) {
                resp = set_source_surface(argp, c_node);          
            } else if (is_function(fnp, "write_to_png_stream")) {
                resp = write_to_png_stream(argp, c_node);          
            } else {
                resp = erl_format("{c_node, ~i, {error, '~s'}}", c_node, "unknown command");
            }         
            erl_send(fd, fromp, resp);           
            erl_free_term(emsg.from); 
            erl_free_term(emsg.msg);
            erl_free_term(fromp); 
            erl_free_term(msgp);
            erl_free_term(fnp); 
            erl_free_term(argp);
            erl_free_term(resp);
      }
    }
  }
  exit(EXIT_SUCCESS);
}