TEST ()
{
GeglBuffer *buffer, *sub, *subsub;
GeglRectangle subrect = {5, 5, 10, 10};
GeglRectangle rect = {0, 0, 20, 20};
test_start ();
buffer = gegl_buffer_new (&rect, babl_format ("Y float"));
sub = gegl_buffer_create_sub_buffer (buffer, &subrect);
fill (sub, 0.5);
subsub = g_object_new (GEGL_TYPE_BUFFER,
"source", sub,
"x", 3,
"y", 3,
"width", 4,
"height", 4,
"shift-x", 6,
"shift-y", 6,
NULL);
fill (subsub, 0.2);
print_buffer (buffer);
gegl_buffer_destroy (sub);
gegl_buffer_destroy (subsub);
gegl_buffer_destroy (buffer);
test_end ();
}
TEST ()
{
GeglBuffer *buffer, *sub1, *sub2, *sub3;
GeglRectangle subrect1 = {5, 5, 10, 10};
GeglRectangle subrect2 = {8, 8, 30, 30};
GeglRectangle subrect3 = {-2, -2, 24, 24};
GeglRectangle rect = {0, 0, 20, 20};
test_start ();
buffer = gegl_buffer_new (&rect, babl_format ("Y float"));
sub1 = gegl_buffer_create_sub_buffer (buffer, &subrect1);
sub2 = gegl_buffer_create_sub_buffer (buffer, &subrect2);
sub3 = gegl_buffer_create_sub_buffer (buffer, &subrect3);
fill (sub1, 0.5);
print (("root with sub1 filled in:\n"));
print_buffer (buffer);
print (("sub2 before fill:\n"));
print_buffer (sub2);
fill (sub2, 1.0);
print (("final root:\n"));
print_buffer (buffer);
print (("final sub1:\n"));
print_buffer (sub1);
print (("final sub3:\n"));
print_buffer (sub3);
gegl_buffer_destroy (sub1);
gegl_buffer_destroy (sub2);
gegl_buffer_destroy (sub3);
gegl_buffer_destroy (buffer);
test_end ();
}
TEST ()
{
GeglBuffer *buffer, *buffer2;
GeglRectangle bound = {0, 0, 20, 20};
test_start ();
buffer = gegl_buffer_new (&bound, babl_format ("Y float"));
vgrad (buffer);
buffer2 = gegl_buffer_dup (buffer);
gegl_buffer_destroy (buffer);
print_buffer (buffer2);
gegl_buffer_destroy (buffer2);
test_end ();
}
TEST ()
{
GeglBuffer *buffer;
GeglRectangle rect = {0, 0, 50, 50};
GeglRectangle getrect = {0, 0, 12, 8};
guchar *buf;
test_start ();
buffer = gegl_buffer_new (&rect, babl_format ("Y u8"));
checkerboard (buffer, 2, 0.0, 1.0);
buf = g_malloc (getrect.width*getrect.height*sizeof(gfloat));
{
gint i;
for (i=0; i<10; i++)
{
getrect.x=i;
/*getrect.y=i;*/
gegl_buffer_get (buffer, 1.2, &getrect, babl_format ("Y u8"), buf, 0);
print_linear_buffer_u8 (getrect.width, getrect.height, buf);
}
}
gegl_buffer_destroy (buffer);
g_free (buf);
test_end ();
}
TEST ()
{
GeglBuffer *buffer;
GeglBuffer *sub;
GeglRectangle extent = {0,0,20,20};
GeglRectangle sextent = {2,2,20,20};
GeglRectangle roi = {1,1,10,10};
test_start();
buffer = gegl_buffer_new (&extent, babl_format ("Y float"));
sub = gegl_buffer_create_sub_buffer (buffer, &sextent);
fill_rect (sub, &roi, 0.5);
print_buffer (buffer);
gegl_buffer_destroy (sub);
gegl_buffer_destroy (buffer);
test_end ();
}
TEST ()
{
GeglBuffer *buffer;
GeglRectangle extent = {0,0,40,20};
GeglRectangle roi = {1,1,30,10};
test_start();
buffer = gegl_buffer_new (&extent, babl_format ("Y float"));
fill_rect (buffer, &roi, 0.5);
roi.y+=3;
roi.x+=20;
{
gint rowstride;
gfloat *buf;
gint x, y, i;
buf = (gpointer)gegl_buffer_linear_open (buffer, &extent, &rowstride, NULL);
g_assert (buf);
i=0;
for (y=0;y<extent.height;y++)
for (x=0;x<extent.width;x++)
{
buf[i++]= ((x+y)*1.0) / extent.width;
}
gegl_buffer_linear_close (buffer, buf);
}
fill_rect (buffer, &roi, 0.2);
print_buffer (buffer);
gegl_buffer_destroy (buffer);
test_end ();
}
TEST ()
{
GeglBuffer *buffer, *buffer2;
GeglRectangle bound = {0, 0, 20, 20};
GeglRectangle source = {2, 2, 5, 5};
GeglRectangle dest = {10, 10, 5, 5};
test_start ();
buffer = gegl_buffer_new (&bound, babl_format ("Y float"));
buffer2 = gegl_buffer_new (&bound, babl_format ("Y float"));
vgrad (buffer);
gegl_buffer_copy (buffer, &source, buffer2, &dest);
print_buffer (buffer2);
gegl_buffer_destroy (buffer);
gegl_buffer_destroy (buffer2);
test_end ();
}
TEST ()
{
GeglBuffer *buffer;
GeglRectangle extent = {0,0,20,20};
GeglRectangle roi = {0,0,20,20};
test_start();
buffer = gegl_buffer_new (&extent, babl_format ("Y float"));
fill_rect (buffer, &roi, 0.5);
print_buffer (buffer);
gegl_buffer_destroy (buffer);
test_end ();
}
TEST ()
{
GeglBuffer *buffer;
GeglRectangle rect = {0, 0, 20, 20};
test_start ();
buffer = gegl_buffer_new (&rect, babl_format ("Y float"));
print_buffer (buffer);
gegl_buffer_destroy (buffer);
test_end ();
}
void dt_dev_pixelpipe_set_input(dt_dev_pixelpipe_t *pipe, dt_develop_t *dev, float *input, int width, int height)
{
pipe->changed = DT_DEV_PIPE_UNCHANGED;
pipe->iwidth = width;
pipe->iheight = height;
GeglRectangle rect = (GeglRectangle)
{
0, 0, width, height
};
if(pipe->input_buffer) gegl_buffer_destroy(pipe->input_buffer);
pipe->input_buffer = gegl_buffer_new(&rect, babl_format("RGB float"));
gegl_buffer_set(pipe->input_buffer, NULL, babl_format("RGB float"), input, GEGL_AUTO_ROWSTRIDE);
gegl_node_set(pipe->input, "buffer", pipe->input_buffer, NULL);
}
TEST ()
{
GeglBuffer *buffer;
GeglRectangle extent = {0,0, 10, 10};
gfloat *buf;
gint i;
test_start();
buf = g_malloc (sizeof (float) * 12 * 10);
for (i=0;i<120;i++)
buf[i]=i%12==5?0.5:0.0;
buffer = gegl_buffer_linear_new_from_data (buf, babl_format ("Y float"),
&extent,
12 * 4,
G_CALLBACK(g_free), /* destroy_notify */
NULL /* destroy_notify_data */);
print_buffer (buffer);
test_end ();
gegl_buffer_destroy (buffer);
}
gint
main (gint argc,
gchar **argv)
{
g_thread_init (NULL);
gtk_init (&argc, &argv);
gegl_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GEGL destructive painter");
if (argv[1] == NULL)
{
GeglRectangle rect = {0, 0, 512, 512};
gpointer buf;
/* XXX: for best overall performance, this format should probably
* be RaGaBaA float, overeager in-place processing code makes that fail though.
*/
buffer = gegl_buffer_new (&rect, babl_format("R'G'B' u8"));
/* it would be useful to have a programmatic way of doing this, filling
* with a given pixel value
*/
buf = gegl_buffer_linear_open (buffer, NULL, NULL, babl_format ("Y' u8"));
memset (buf, 255, 512 * 512);
gegl_buffer_linear_close (buffer, buf);
}
else
{
buffer = gegl_buffer_open (argv[1]);
}
gegl = gegl_node_new ();
{
GeglNode *loadbuf = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", buffer, NULL);
out = gegl_node_new_child (gegl, "operation", "gegl:nop", NULL);
gegl_node_link_many (loadbuf, out, NULL);
view = g_object_new (GEGL_TYPE_VIEW, "node", out, NULL);
top = loadbuf;
}
g_signal_connect (GTK_OBJECT (view), "motion-notify-event",
(GCallback) paint_motion, NULL);
g_signal_connect (GTK_OBJECT (view), "button-press-event",
(GCallback) paint_press, NULL);
g_signal_connect (GTK_OBJECT (view), "button-release-event",
(GCallback) paint_release, NULL);
gtk_widget_add_events (view, GDK_BUTTON_RELEASE_MASK);
gtk_container_add (GTK_CONTAINER (window), view);
gtk_widget_set_size_request (view, 512, 512);
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (gtk_main_quit), window);
gtk_widget_show_all (window);
gtk_main ();
g_object_unref (gegl);
gegl_buffer_destroy (buffer);
gegl_exit ();
return 0;
}
