void
gtk_plot_surface_construct_function(GtkPlotSurface *surface,
GtkPlotFunc3D function)
{
GTK_PLOT_DATA(surface)->is_function = TRUE;
GTK_PLOT_DATA(surface)->function3d = function;
}
gdouble *
gtk_plot_surface_get_z(GtkPlotSurface *dataset, gint *nx, gint *ny)
{
*nx = dataset->nx;
*ny = dataset->ny;
return(GTK_PLOT_DATA(dataset)->z);
}
void
build_example1(GtkWidget *active_plot)
{
GdkColor color;
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.2, .4, .5, .35, .30, .40};
static gdouble px2[]={.12, .22, .27, .12, .052, .42};
static gdouble py2[]={.0, .05, .12, .22, .16, .1};
dataset[0] = GTK_PLOT_DATA(gtk_plot_segment_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, px2, py2, 6);
/*
gtk_plot_segment_center(GTK_PLOT_SEGMENT(dataset[0]), FALSE);
*/
gdk_color_parse("red", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_CIRCLE,
GTK_PLOT_SYMBOL_OPAQUE,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color);
gtk_plot_data_set_legend(dataset[0], "Vector");
}
static void
gtk_plot_surface_draw (GtkWidget *widget, GdkRectangle *area)
{
if(!GTK_WIDGET_VISIBLE(widget)) return;
gtk_plot_surface_draw_private(GTK_PLOT_DATA(widget));
}
void
gtk_plot_surface_recalc_nodes(GtkPlotSurface *surface)
{
GtkPlotData *data;
GtkPlot *plot;
gint i;
data = GTK_PLOT_DATA(surface);
if(!data->plot) return;
plot = data->plot;
for(i= surface->dt->node_0; i < surface->dt->node_cnt; i++){
GtkPlotDTnode *node;
node = gtk_plot_dt_get_node(surface->dt,i);
if(GTK_IS_PLOT3D(plot)){
gtk_plot3d_get_pixel(GTK_PLOT3D(plot),
node->x, node->y, node->z,
&node->px, &node->py, &node->pz);
} else {
gtk_plot_get_pixel(plot,
node->x, node->y,
&node->px, &node->py);
node->pz = 0.0;
}
}
surface->dt->triangles = g_list_sort(surface->dt->triangles, (GCompareFunc)compare_func);
}
static void
gtk_plot_surface_real_build_mesh(GtkPlotSurface *surface)
{
GtkPlotData *data;
GtkPlot *plot;
gint i;
data = GTK_PLOT_DATA(surface);
if(!data->plot) return;
plot = data->plot;
if(data->num_points == 0) return;
gtk_plot_dt_clear(surface->dt);
for(i = 0; i < data->num_points; i++){
GtkPlotDTnode node;
node.x = data->x[i];
node.y = data->y[i];
node.z = 0.0;
if(data->z) node.z = data->z[i];
gtk_plot_dt_add_node(surface->dt, node);
}
gtk_plot_dt_triangulate(surface->dt);
gtk_plot_surface_recalc_nodes(surface);
surface->recalc_dt = FALSE;
}
void
build_example2(GtkWidget *active_plot)
{
GdkColor color;
static gdouble px1[]={-0., -0.2, -0.4, -0.6, -0.8, -1.0};
static gdouble py1[]={-.2, -.4, -.5, -.35, -.30, -.40};
static gdouble px2[]={-.12, -.22, -.27, -.12, -.052, -.42};
static gdouble py2[]={-.0, -.05, -.12, -.22, -.16, -.1};
dataset[1] = GTK_PLOT_DATA(gtk_plot_segment_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[1]);
gtk_widget_show(GTK_WIDGET(dataset[1]));
gtk_plot_data_set_points(dataset[1], px1, py1, px2, py2, 6);
gtk_plot_segment_set_relative(GTK_PLOT_SEGMENT(dataset[1]), TRUE);
/*
gtk_plot_segment_center(GTK_PLOT_SEGMENT(dataset[0]), FALSE);
*/
gdk_color_parse("blue", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_symbol(dataset[1],
GTK_PLOT_SYMBOL_NONE,
GTK_PLOT_SYMBOL_OPAQUE,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset[1],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color);
gtk_plot_segment_set_arrow (GTK_PLOT_SEGMENT(dataset[1]), 0, 10, GTK_PLOT_SYMBOL_EMPTY);
gtk_plot_segment_set_arrow_mask (GTK_PLOT_SEGMENT(dataset[1]), GTK_PLOT_ARROW_ORIGIN|GTK_PLOT_ARROW_END);
gtk_plot_data_set_legend(dataset[1], "Segment");
}
void
build_example1(GtkWidget *active_plot,GtkPlotDT *data, gint num)
{
GdkColor color;
gdouble *px1= (gdouble *)g_malloc(sizeof(gdouble)*num*3);
gdouble *py1= (gdouble *)g_malloc(sizeof(gdouble)*num*3);
gdouble *px2= (gdouble *)g_malloc(sizeof(gdouble)*num*3);
gdouble *py2= (gdouble *)g_malloc(sizeof(gdouble)*num*3);
gdouble ax,ay,bx,by,cx,cy;
GtkPlotDTtriangle *t= NULL;
GList *list = NULL;
gint i = 0;
list = data->triangles;
while(list){
t = (GtkPlotDTtriangle *)list->data;
ax= gtk_plot_dt_get_node(data,t->a)->x;
ay= gtk_plot_dt_get_node(data,t->a)->y;
bx= gtk_plot_dt_get_node(data,t->b)->x;
by= gtk_plot_dt_get_node(data,t->b)->y;
cx= gtk_plot_dt_get_node(data,t->c)->x;
cy= gtk_plot_dt_get_node(data,t->c)->y;
px1[i*3+0]= ax; py1[i*3+0]= ay;
px2[i*3+0]= bx-ax; py2[i*3+0]= by-ay;
px1[i*3+1]= bx; py1[i*3+1]= by;
px2[i*3+1]= cx-bx; py2[i*3+1]= cy-by;
px1[i*3+2]= cx; py1[i*3+2]= cy;
px2[i*3+2]= ax-cx; py2[i*3+2]= ay-cy;
i++;
list = list->next;
}
fprintf(stderr,"%d triangles, %d points\n",num,num*3);
dataset[0] = GTK_PLOT_DATA(gtk_plot_flux_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, px2, py2, num*3);
gtk_plot_flux_center(GTK_PLOT_FLUX(dataset[0]), FALSE);
gdk_color_parse("red", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_flux_set_arrow(GTK_PLOT_FLUX(dataset[0]), 0, 0, 0);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_CIRCLE,
GTK_PLOT_SYMBOL_OPAQUE,
0,1, &color, &color);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, &color);
gtk_plot_data_set_legend(dataset[0], "Delaunay triangulization");
}
static void
gtk_plot_surface_draw_private (GtkPlotData *data)
{
GtkPlot *plot;
GtkPlotSurface *surface;
g_return_if_fail(GTK_IS_PLOT_SURFACE(data));
surface = GTK_PLOT_SURFACE(data);
data = GTK_PLOT_DATA(surface);
g_return_if_fail(GTK_PLOT_DATA(data)->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(GTK_PLOT_DATA(data)->plot));
if(data->redraw_pending) gtk_plot_surface_update_range(data);
plot = GTK_PLOT(data->plot);
gtk_plot_surface_real_draw(surface);
}
static void
gtk_plot_bar_init (GtkPlotBar *dataset)
{
GtkWidget *widget;
GdkColor black, white;
GdkColormap *colormap;
GtkPlotArray *dim;
widget = GTK_WIDGET(dataset);
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
GTK_PLOT_DATA(dataset)->symbol.symbol_style = GTK_PLOT_SYMBOL_FILLED;
GTK_PLOT_DATA(dataset)->symbol.color = white;
GTK_PLOT_DATA(dataset)->line.line_style = GTK_PLOT_LINE_SOLID;
GTK_PLOT_DATA(dataset)->line.line_width = 1;
GTK_PLOT_DATA(dataset)->line.color = black;
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "y");
gtk_plot_array_set_label(dim, "Size");
gtk_plot_array_set_description(dim, "Bar size");
dataset->width = .05;
}
void
build_example1(GtkWidget *active_plot)
{
GdkColormap *colormap;
GdkPixmap *pixmap;
GdkBitmap *mask;
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.2, .4, .5, .35, .30, .40};
static gdouble px2[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py2[]={.12, .22, .27, .12, .52, .62};
colormap = gdk_colormap_get_system();
pixmap = gdk_pixmap_colormap_create_from_xpm(NULL, colormap, &mask, NULL,
"cloud.xpm");
dataset[0] = GTK_PLOT_DATA(gtk_plot_pixmap_new(pixmap, mask));
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, px2, py2, 6);
gtk_plot_data_set_legend(dataset[0], "Pixmap 1");
gdk_pixmap_unref(pixmap);
gdk_bitmap_unref(mask);
pixmap = gdk_pixmap_colormap_create_from_xpm(NULL, colormap, &mask, NULL,
"suncloud.xpm");
dataset[1] = GTK_PLOT_DATA(gtk_plot_pixmap_new(pixmap, mask));
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[1]);
gtk_widget_show(GTK_WIDGET(dataset[1]));
gtk_plot_data_set_points(dataset[1], px2, py2, NULL, NULL, 6);
gtk_plot_data_set_legend(dataset[1], "Pixmap 2");
gdk_pixmap_unref(pixmap);
gdk_bitmap_unref(mask);
}
void
build_example2(GtkWidget *active_plot)
{
GdkColor color1, color2;
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.56, .12, .12, .5, .2, .21}; /* Open */
static gdouble pz1[]={.60, .22, .27, .45, .22, .18}; /* Close */
static gdouble dy1[]={.52, .10, .12, .40, .16, .16}; /* Low */
static gdouble dz1[]={.62, .24, .30, .54, .24, .22}; /* High */
dataset[0] = GTK_PLOT_DATA(gtk_plot_candle_new());
/*
dataset[0] = GTK_PLOT_DATA(gtk_plot_data_new());
gtk_plot_autoscale(GTK_PLOT(active_plot));
*/
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, NULL, dy1, 6);
gtk_plot_data_set_z(dataset[0], pz1);
gtk_plot_data_set_dz(dataset[0], dz1);
gtk_plot_data_show_zerrbars(dataset[0]);
gdk_color_parse("black", &color1);
gdk_color_alloc(gdk_colormap_get_system(), &color1);
gdk_color_parse("red", &color2);
gdk_color_alloc(gdk_colormap_get_system(), &color2);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_CIRCLE,
GTK_PLOT_SYMBOL_FILLED,
10, 1, &color2, &color1);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color1);
/*
gtk_plot_data_set_x_attributes(dataset[0],
GTK_PLOT_LINE_SOLID,
0, &active_plot->style->black);
gtk_plot_data_set_y_attributes(dataset[0],
GTK_PLOT_LINE_SOLID,
0, &active_plot->style->black);
*/
gtk_plot_data_set_legend(dataset[0], "Japanese Candles");
}
static void
gtk_plot_surface_real_draw (GtkPlotSurface *surface)
{
GtkWidget *widget;
GtkPlot *plot = NULL;
GtkPlotData *dataset;
GList *list;
g_return_if_fail(GTK_IS_PLOT_SURFACE(surface));
dataset = GTK_PLOT_DATA(surface);
g_return_if_fail(GTK_PLOT_DATA(dataset)->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(GTK_PLOT_DATA(dataset)->plot));
plot = dataset->plot;
widget = GTK_WIDGET(plot);
gtk_plot_pc_gsave(plot->pc);
if(!GTK_WIDGET_DRAWABLE(widget)) return;
if(!GTK_WIDGET_VISIBLE(widget)) return;
gtk_plot_set_line_attributes(plot, surface->mesh_line);
list = surface->dt->triangles;
while(list){
GtkPlotDTtriangle *t;
t = (GtkPlotDTtriangle *)list->data;
GTK_PLOT_SURFACE_CLASS(GTK_OBJECT(surface)->klass)->draw_triangle(surface, t, -1.);
list = list->next;
}
gtk_plot_pc_grestore(plot->pc);
}
void
build_example1(GtkWidget *active_plot)
{
GdkColor color;
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.2, .4, .5, .35, .30, .40};
static gdouble px2[]={.12, .22, .27, .12, .052, .42};
static gdouble py2[]={.0, .05, .12, .22, .16, .1};
/*
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.2, .4, .5, .35, .30, .40};
static gdouble px2[]={.02, 0, -.02, 0, .052, .42};
static gdouble py2[]={.0, .05, .0, -0.02, .16, .1};
*/
dataset[0] = GTK_PLOT_DATA(gtk_plot_flux_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, px2, py2, 6);
gtk_plot_flux_set_size_max(GTK_PLOT_FLUX(dataset[0]), 50);
gtk_plot_flux_set_scale_max(GTK_PLOT_FLUX(dataset[0]), 0.5);
/*
gtk_plot_flux_set_labels_prefix(GTK_PLOT_FLUX(dataset[0]), "A");
gtk_plot_flux_set_labels_suffix(GTK_PLOT_FLUX(dataset[0]), "B");
*/
/*
gtk_plot_flux_center(GTK_PLOT_FLUX(dataset[0]), FALSE);
*/
gdk_color_parse("red", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_NONE,
GTK_PLOT_SYMBOL_OPAQUE,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color);
gtk_plot_data_set_legend(dataset[0], "Flux");
}
static void
gtk_plot_candle_init (GtkPlotCandle *dataset)
{
GtkWidget *widget;
GdkColor black, white;
GdkColormap *colormap;
GtkPlotArray *dim;
widget = GTK_WIDGET(dataset);
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
GTK_PLOT_DATA(dataset)->symbol.symbol_style = GTK_PLOT_SYMBOL_FILLED;
GTK_PLOT_DATA(dataset)->symbol.color = white;
GTK_PLOT_DATA(dataset)->line.line_style = GTK_PLOT_LINE_SOLID;
GTK_PLOT_DATA(dataset)->line.line_width = 1;
GTK_PLOT_DATA(dataset)->line.color = black;
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "y");
gtk_plot_array_set_label(dim, "Open");
gtk_plot_array_set_description(dim, "Open");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "z");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "Close");
gtk_plot_array_set_description(dim, "Close");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "dy");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "Min");
gtk_plot_array_set_description(dim, "Minimum");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "dz");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "Max");
gtk_plot_array_set_description(dim, "Maximum");
}
void
gtk_plot_surface_set_points(GtkPlotSurface *data,
gdouble *x, gdouble *y, gdouble *z,
gdouble *dx, gdouble *dy, gdouble *dz,
gint nx, gint ny)
{
GTK_PLOT_DATA(data)->x = x;
GTK_PLOT_DATA(data)->y = y;
GTK_PLOT_DATA(data)->z = z;
GTK_PLOT_DATA(data)->dx = dx;
GTK_PLOT_DATA(data)->dy = dy;
GTK_PLOT_DATA(data)->dz = dz;
data->nx = nx;
data->ny = ny;
GTK_PLOT_DATA(data)->num_points = nx * ny;
gtk_plot_surface_build_mesh(data);
}
void
gtk_plot_surface_get_points(GtkPlotSurface *data,
gdouble **x, gdouble **y, gdouble **z,
gdouble **dx, gdouble **dy, gdouble **dz,
gint *nx, gint *ny)
{
*x = GTK_PLOT_DATA(data)->x;
*y = GTK_PLOT_DATA(data)->y;
*z = GTK_PLOT_DATA(data)->z;
*dx = GTK_PLOT_DATA(data)->dx;
*dy = GTK_PLOT_DATA(data)->dy;
*dz = GTK_PLOT_DATA(data)->dz;
*nx = data->nx;
*ny = data->ny;
}
void
gtk_plot_surface_set_y(GtkPlotSurface *data,
gdouble *y)
{
GTK_PLOT_DATA(data)->y = y;
}
int main(int argc, char *argv[]){
GtkWidget *window1;
GtkWidget *vbox1;
GtkWidget *scrollw1;
GtkWidget *canvas;
GtkWidget *button;
GtkWidget *surface;
gdouble *x,*y,*z,*a;
gint cnt= 0;
gint page_width, page_height;
gfloat scale = 1.;
char buffer[1000];
FILE *f;
gdouble xmin=1e99;
gdouble xmax=-1e99;
gdouble ymin=1e99;
gdouble ymax=-1e99;
gdouble zmin=1e99;
gdouble zmax=-1e99;
gdouble dx,dy,dz;
gint n, nx, ny;
GtkPlotCanvasChild *child;
page_width = GTK_PLOT_LETTER_W * scale;
page_height = GTK_PLOT_LETTER_H * scale;
gtk_init(&argc,&argv);
window1=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window1), "GtkPlot3D Demo");
gtk_widget_set_usize(window1,550,650);
gtk_container_border_width(GTK_CONTAINER(window1),0);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC (quit), NULL);
vbox1=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window1),vbox1);
scrollw1=gtk_scrolled_window_new(NULL, NULL);
gtk_container_border_width(GTK_CONTAINER(scrollw1),0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollw1),
GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox1),scrollw1, TRUE, TRUE,0);
canvas = gtk_plot_canvas_new(page_width, page_height, 1.);
GTK_PLOT_CANVAS_SET_FLAGS(GTK_PLOT_CANVAS(canvas), GTK_PLOT_CANVAS_DND_FLAGS);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollw1), canvas);
/*
gdk_color_parse("light blue", &color);
gdk_color_alloc(gtk_widget_get_colormap(canvas), &color);
gtk_plot_canvas_set_background(GTK_PLOT_CANVAS(canvas), &color);
*/
active_plot = new_layer(canvas);
child = gtk_plot_canvas_plot_new(GTK_PLOT(active_plot));
gtk_plot_canvas_put_child(GTK_PLOT_CANVAS(canvas), child, .10, .06, .85, .85);
x = (gdouble *)g_malloc(1600 * sizeof(gdouble));
y = (gdouble *)g_malloc(1600 * sizeof(gdouble));
z = (gdouble *)g_malloc(1600 * sizeof(gdouble));
a = (gdouble *)g_malloc(1600 * sizeof(gdouble));
n = 0;
for(nx = 0; nx < 40; nx++)
for(ny = 0; ny < 40; ny++)
{
x[n]=0.025*(gdouble)nx;
y[n]=0.025*(gdouble)ny;
z[n]=cos(((x[n]-0.5)*(x[n]-0.5) + (y[n]-0.5)*(y[n]-0.5))*24) / 4. + .5;
a[n]=(x[n]-0.5)*(x[n]-0.5) + (y[n]-0.5)*(y[n]-0.5);
n++;
}
surface = gtk_plot_surface_new();
gtk_plot_surface_set_points(GTK_PLOT_SURFACE(surface),
x, y, z, NULL, NULL, NULL, 40, 40);
gtk_plot_data_set_legend(GTK_PLOT_DATA(surface), "cos ((r-r\\s0\\N)\\S2\\N)");
gtk_plot_surface_use_amplitud(GTK_PLOT_SURFACE(surface), TRUE);
gtk_plot_data_set_a(GTK_PLOT_DATA(surface), a);
gtk_plot_data_gradient_set_visible(GTK_PLOT_DATA(surface), TRUE);
/*
for(nx = 0; nx < 10; nx++)
for(ny = 0; ny < 10; ny++)
{
x[n]=(gdouble)0.1*(gdouble)nx;
y[n]=(gdouble)0.1*(gdouble)ny;
z[n]=(x[n]-0.5)*(x[n]-0.5) + (y[n]-0.5)*(y[n]-0.5);
n++;
}
surface = gtk_plot_surface_new();
gtk_plot_surface_set_points(GTK_PLOT_SURFACE(surface),
x, y, z, NULL, NULL, NULL, 10, 10);
*/
gtk_plot3d_set_minor_ticks(GTK_PLOT3D(active_plot), GTK_PLOT_AXIS_X, 1);
gtk_plot3d_set_minor_ticks(GTK_PLOT3D(active_plot), GTK_PLOT_AXIS_Y, 1);
gtk_plot3d_show_ticks(GTK_PLOT3D(active_plot),
GTK_PLOT_SIDE_XY,
GTK_PLOT_TICKS_OUT, GTK_PLOT_TICKS_OUT);
gtk_plot3d_show_ticks(GTK_PLOT3D(active_plot),
GTK_PLOT_SIDE_XZ,
GTK_PLOT_TICKS_OUT, GTK_PLOT_TICKS_OUT);
gtk_plot3d_show_ticks(GTK_PLOT3D(active_plot),
GTK_PLOT_SIDE_YX,
GTK_PLOT_TICKS_OUT, GTK_PLOT_TICKS_OUT);
gtk_plot3d_show_ticks(GTK_PLOT3D(active_plot),
GTK_PLOT_SIDE_YZ,
GTK_PLOT_TICKS_OUT, GTK_PLOT_TICKS_OUT);
gtk_plot3d_show_ticks(GTK_PLOT3D(active_plot),
GTK_PLOT_SIDE_ZX,
GTK_PLOT_TICKS_OUT, GTK_PLOT_TICKS_OUT);
gtk_plot3d_show_ticks(GTK_PLOT3D(active_plot),
GTK_PLOT_SIDE_ZY,
GTK_PLOT_TICKS_OUT, GTK_PLOT_TICKS_OUT);
/* if a file was specified on the commandline, try to open and display it: */
if (argc!=2 || !(f=fopen(argv[1],"r"))) {
/*
x= y= z= NULL;
surface = gtk_plot_surface_new_function((GtkPlotFunc3D) function);
gtk_plot_surface_set_xstep(GTK_PLOT_SURFACE(surface), .025);
gtk_plot_surface_set_ystep(GTK_PLOT_SURFACE(surface), .025);
gtk_plot_data_set_legend(GTK_PLOT_DATA(surface), "cos ((r-r\\s0\\N)\\S2\\N)");
*/
gtk_plot_add_data(GTK_PLOT(active_plot), GTK_PLOT_DATA(surface));
} else {
x= g_new(gdouble,MAXNODES);
y= g_new(gdouble,MAXNODES);
z= g_new(gdouble,MAXNODES);
while (fgets(buffer,1000,f) && cnt<MAXNODES)
if (sscanf(buffer,"%lf %lf %lf", &x[cnt], &y[cnt], &z[cnt])==3) {
z[cnt]*=10; /* REMOVE THIS BEFORE FLIGHT */
if (xmin>x[cnt]) xmin= x[cnt];
if (xmax<x[cnt]) xmax= x[cnt];
if (ymin>y[cnt]) ymin= y[cnt];
if (ymax<y[cnt]) ymax= y[cnt];
if (zmin>z[cnt]) zmin= z[cnt];
if (zmax<z[cnt]) zmax= z[cnt];
cnt++;
}
fclose(f);
dx= (xmax-xmin)*.02;
dy= (ymax-ymin)*.02;
dz= (zmax-zmin)*.02;
/* start the triangulation */
fprintf(stderr,"data ranges from (%g,%g) to (%g,%g)\n",
xmin,ymin,xmax,ymax);
/*
gtk_plot3d_set_xrange(GTK_PLOT3D(active_plot), xmin-dx, xmax+dx);
gtk_plot3d_set_yrange(GTK_PLOT3D(active_plot), ymin-dy, ymax+dy);
gtk_plot3d_set_zrange(GTK_PLOT3D(active_plot), zmin-dz, zmax+dz);
gtk_plot3d_set_ticks(GTK_PLOT3D(active_plot), GTK_PLOT_AXIS_X, (xmax-xmin)/10., 1);
gtk_plot3d_set_ticks(GTK_PLOT3D(active_plot), GTK_PLOT_AXIS_Y, (ymax-ymin)/10., 1);
gtk_plot3d_set_ticks(GTK_PLOT3D(active_plot), GTK_PLOT_AXIS_Z, (zmax-zmin)/10., 1);
*/
surface = gtk_plot_csurface_new();
gtk_plot_add_data(GTK_PLOT(active_plot), GTK_PLOT_DATA(surface));
gtk_plot_surface_set_points(GTK_PLOT_SURFACE(surface),
x, y, z, NULL, NULL, NULL, cnt, 1);
gtk_plot_data_set_legend(GTK_PLOT_DATA(surface), argv[1]);
gtk_plot_data_gradient_autoscale_z(GTK_PLOT_DATA(surface));
}
/*
gtk_plot_surface_use_height_gradient(GTK_PLOT_SURFACE(surface), TRUE);
gtk_plot_data_set_gradient(GTK_PLOT_DATA(surface), .2, .8, 6, 0);
*/
/*
gtk_plot_data_gradient_set_scale(GTK_PLOT_DATA(surface),GTK_PLOT_SCALE_LOG10);
*/
gtk_plot3d_autoscale(GTK_PLOT3D(active_plot));
// gtk_plot3d_set_xrange(GTK_PLOT3D(active_plot), -0.5,1);
// gtk_plot3d_set_yrange(GTK_PLOT3D(active_plot), -0.2,1);
// gtk_plot3d_set_zrange(GTK_PLOT3D(active_plot), 0.,1);
gtk_widget_show(surface);
button = gtk_button_new_with_label("Rotate X");
gtk_fixed_put(GTK_FIXED(canvas), button, 80, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(rotate_x), canvas);
button = gtk_button_new_with_label("Rotate Y");
gtk_fixed_put(GTK_FIXED(canvas), button, 160, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(rotate_y), canvas);
button = gtk_button_new_with_label("Rotate Z");
gtk_fixed_put(GTK_FIXED(canvas), button, 240, 0);
/*
gtk_plot3d_set_xfactor(GTK_PLOT3D(active_plot), 0.5);
*/
/*
gtk_plot3d_set_xrange(GTK_PLOT3D(active_plot), 0., 2.0);
*/
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(rotate_z), canvas);
gtk_widget_show_all(window1);
/*
gtk_plot_canvas_export_ps(GTK_PLOT_CANVAS(canvas), "demo3d.ps", 0, 0,
GTK_PLOT_LETTER);
*/
gtk_plot_canvas_export_ps_with_size(GTK_PLOT_CANVAS(canvas), "demo3d.ps",
0, 0, GTK_PLOT_PSPOINTS,
GTK_PLOT_LETTER_W, GTK_PLOT_LETTER_H);
gtk_main();
return(0);
}
void
gtk_plot_surface_build_mesh(GtkPlotSurface *surface)
{
GtkPlotData *data;
GtkPlot *plot;
data = GTK_PLOT_DATA(surface);
if(!data->plot) return;
plot = data->plot;
if(data->is_function){
gdouble xstep, ystep;
gdouble xmin, xmax, ymin, ymax;
gdouble x, y;
gdouble *fx = NULL, *fy = NULL, *fz = NULL;
gdouble *old_x, *old_y, *old_z;
gint nx, ny;
gint npoints;
xmin = GTK_PLOT(plot)->xmin;
xmax = GTK_PLOT(plot)->xmax;
ymin = GTK_PLOT(plot)->ymin;
ymax = GTK_PLOT(plot)->ymax;
xstep = surface->xstep;
surface->nx = roundint((xmax - xmin) / xstep) + 1;
ystep = surface->ystep;
surface->ny = roundint((ymax - ymin) / ystep) + 1;
npoints = surface->nx * surface->ny;
fx = (gdouble *)g_malloc((npoints + 1) * sizeof(gdouble));
fy = (gdouble *)g_malloc((npoints + 1) * sizeof(gdouble));
fz = (gdouble *)g_malloc((npoints + 1) * sizeof(gdouble));
npoints = 0;
y = ymin;
for(ny = 0; ny < surface->ny; ny++)
{
x = xmin;
for(nx = 0; nx < surface->nx; nx++)
{
gboolean error;
fx[npoints] = x;
fy[npoints] = y;
fz[npoints] = data->function3d(plot, data, x, y, &error);
x += xstep;
npoints++;
}
y += ystep;
}
old_x = data->x; old_y = data->y; old_z = data->z;
data->x = fx;
data->y = fy;
data->z = fz;
data->num_points = npoints;
gtk_plot_surface_real_build_mesh(surface);
g_free(fx);
g_free(fy);
g_free(fz);
}
else if(data->is_iterator){
gdouble x, y, z, a, dx, dy, dz, da;
gchar *label;
gdouble *fx = NULL, *fy = NULL, *fz = NULL;
gint iter;
if(data->iterator_mask & GTK_PLOT_DATA_X)
fx = g_new0(gdouble, data->num_points);
if(data->iterator_mask & GTK_PLOT_DATA_Y)
fy = g_new0(gdouble, data->num_points);
if(data->iterator_mask & GTK_PLOT_DATA_Z)
fz = g_new0(gdouble, data->num_points);
for(iter = 0; iter < data->num_points; iter++)
{
gboolean error;
data->iterator (plot, data, iter,
&x, &y, &z, &a, &dx, &dy, &dz, &da, &label, &error);
if(error)
{
break;
}
else
{
if(data->iterator_mask & GTK_PLOT_DATA_X) fx[iter] = x;
if(data->iterator_mask & GTK_PLOT_DATA_Y) fy[iter] = y;
if(data->iterator_mask & GTK_PLOT_DATA_Z) fz[iter] = z;
}
}
data->x = fx;
data->y = fy;
data->z = fz;
gtk_plot_surface_real_build_mesh(surface);
g_free(fx);
g_free(fy);
g_free(fz);
}
else
gtk_plot_surface_real_build_mesh(surface);
}
static void
gtk_plot_surface_draw_triangle (GtkPlotSurface *surface,
GtkPlotDTtriangle *triangle,
gint sign)
{
GtkPlot *plot;
GtkPlotVector side1, side2, light, normal;
GtkPlotVector points[3];
GtkPlotPoint t[3];
GdkDrawable *drawable;
GdkColor color, real_color;
gdouble factor, norm;
gboolean visible = TRUE;
plot = GTK_PLOT(GTK_PLOT_DATA(surface)->plot);
drawable = plot->drawable;
points[0].x = triangle->na->x;
points[0].y = triangle->na->y;
points[0].z = triangle->na->z;
points[1].x = triangle->nb->x;
points[1].y = triangle->nb->y;
points[1].z = triangle->nb->z;
points[2].x = triangle->nc->x;
points[2].y = triangle->nc->y;
points[2].z = triangle->nc->z;
t[0].x = triangle->na->px;
t[0].y = triangle->na->py;
t[1].x = triangle->nb->px;
t[1].y = triangle->nb->py;
t[2].x = triangle->nc->px;
t[2].y = triangle->nc->py;
side1.x = (points[1].x - points[0].x) * sign;
side1.y = (points[1].y - points[0].y) * sign;
side1.z = (points[1].z - points[0].z) * sign;
side2.x = (points[2].x - points[0].x) * sign;
side2.y = (points[2].y - points[0].y) * sign;
side2.z = (points[2].z - points[0].z) * sign;
if(surface->height_gradient){
gtk_plot_data_get_gradient_level(GTK_PLOT_DATA(surface),
(triangle->na->z +
triangle->nb->z +
triangle->nc->z) / 3.0,
&real_color);
}else{
color = surface->color;
light = surface->light;
norm = sqrt(light.x*light.x + light.y*light.y + light.z*light.z);
light.x /= norm;
light.y /= norm;
light.z /= norm;
if(GTK_IS_PLOT3D(plot)){
normal.x = side1.y * side2.z - side1.z * side2.y;
normal.y = side1.z * side2.x - side1.x * side2.z;
normal.z = side1.x * side2.y - side1.y * side2.x;
norm = sqrt(normal.x*normal.x + normal.y*normal.y + normal.z*normal.z);
factor = (normal.x*light.x + normal.y*light.y + normal.z*light.z) / norm;
} else {
factor = 1.0;
}
gtk_plot_surface_lighting(&color, &real_color,
factor, surface->ambient);
}
if(GTK_IS_PLOT3D(plot))
if(((t[1].x-t[0].x)*(t[2].y-t[0].y) - (t[1].y-t[0].y)*(t[2].x-t[0].x))*sign > 0)
visible = FALSE;
if(visible)
gtk_plot_pc_set_color(plot->pc, &real_color);
else
gtk_plot_pc_set_color(plot->pc, &surface->shadow);
gtk_plot_pc_draw_polygon(plot->pc, !surface->transparent, t, 3);
if(visible)
gtk_plot_pc_set_color(plot->pc, &surface->grid_foreground);
else
gtk_plot_pc_set_color(plot->pc, &surface->grid_background);
if(surface->show_mesh || !surface->dt->quadrilateral)
gtk_plot_pc_draw_polygon(plot->pc, FALSE, t, 3);
if(!surface->show_mesh && surface->show_grid && surface->dt->quadrilateral)
gtk_plot_pc_draw_line(plot->pc,
t[1].x, t[1].y, t[2].x, t[2].y);
}
gdouble *
gtk_plot_surface_get_dy(GtkPlotSurface *dataset)
{
return(GTK_PLOT_DATA(dataset)->dy);
}
gdouble *
gtk_plot_surface_get_x(GtkPlotSurface *dataset, gint *nx)
{
*nx = dataset->nx;
return(GTK_PLOT_DATA(dataset)->x);
}
void
gtk_plot_surface_set_dz(GtkPlotSurface *data,
gdouble *dz)
{
GTK_PLOT_DATA(data)->dz = dz;
}
void
gtk_plot_surface_set_dy(GtkPlotSurface *data,
gdouble *dy)
{
GTK_PLOT_DATA(data)->dy = dy;
}
void
gtk_plot_surface_set_dx(GtkPlotSurface *data,
gdouble *dx)
{
GTK_PLOT_DATA(data)->dx = dx;
}
void
gtk_plot_surface_set_x(GtkPlotSurface *data,
gdouble *x)
{
GTK_PLOT_DATA(data)->x = x;
}
int main(int argc, char *argv[]){
GtkWidget *window1;
GtkWidget *vbox1;
GtkWidget *scrollw1;
GtkWidget *canvas;
GtkWidget *button;
GtkWidget *surface;
GtkPlotCanvasChild *child;
gint page_width, page_height;
gfloat scale = 1.;
gint n;
static gdouble *x, *y, *z;
page_width = GTK_PLOT_LETTER_W * scale;
page_height = GTK_PLOT_LETTER_H * scale;
gtk_init(&argc,&argv);
window1=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window1), "GtkPlot3D Demo");
gtk_widget_set_usize(window1,550,650);
gtk_container_border_width(GTK_CONTAINER(window1),0);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC (quit), NULL);
vbox1=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window1),vbox1);
gtk_widget_show(vbox1);
scrollw1=gtk_scrolled_window_new(NULL, NULL);
gtk_container_border_width(GTK_CONTAINER(scrollw1),0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollw1),
GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox1),scrollw1, TRUE, TRUE,0);
gtk_widget_show(scrollw1);
canvas = gtk_plot_canvas_new(page_width, page_height, 1.);
GTK_PLOT_CANVAS_SET_FLAGS(GTK_PLOT_CANVAS(canvas), GTK_PLOT_CANVAS_DND_FLAGS);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollw1), canvas);
/*
gdk_color_parse("light blue", &color);
gdk_color_alloc(gtk_widget_get_colormap(canvas), &color);
gtk_plot_canvas_set_background(GTK_PLOT_CANVAS(canvas), &color);
*/
gtk_widget_show(canvas);
plot3d = GTK_PLOT3D(new_layer(canvas, GTK_TYPE_PLOT3D));
child = gtk_plot_canvas_plot_new(GTK_PLOT(plot3d));
gtk_plot_canvas_put_child(GTK_PLOT_CANVAS(canvas), child, .16, .05, .65, .45);
gtk_widget_show(GTK_WIDGET(plot3d));
x = (gdouble *)g_malloc(1600 * sizeof(gdouble));
y = (gdouble *)g_malloc(1600 * sizeof(gdouble));
z = (gdouble *)g_malloc(1600 * sizeof(gdouble));
n = 0;
/*
for(nx = 0; nx < 40; nx++)
for(ny = 0; ny < 40; ny++)
{
x[n]=0.025*(gdouble)nx;
y[n]=0.025*(gdouble)ny;
z[n]=cos(((x[n]-0.5)*(x[n]-0.5) + (y[n]-0.5)*(y[n]-0.5))*24) / 4. + .5;
n++;
}
surface = gtk_plot_csurface_new();
gtk_plot_surface_set_points(GTK_PLOT_SURFACE(surface),
x, y, z, NULL, NULL, NULL, 40, 40);
gtk_plot_data_set_legend(GTK_PLOT_DATA(surface), "cos ((r-r\\s0\\N)\\S2\\N)");
*/
/*
for(nx = 0; nx < 10; nx++)
for(ny = 0; ny < 10; ny++)
{
x[n]=(gdouble)0.1*(gdouble)nx;
y[n]=(gdouble)0.1*(gdouble)ny;
z[n]=(x[n]-0.5)*(x[n]-0.5) + (y[n]-0.5)*(y[n]-0.5);
z[n]=x[n]*x[n] + y[n]*y[n];
n++;
}
surface = gtk_plot_csurface_new();
gtk_plot_surface_set_points(GTK_PLOT_SURFACE(surface),
x, y, z, NULL, NULL, NULL, 10, 10);
*/
gtk_plot3d_set_minor_ticks(GTK_PLOT3D(plot3d), GTK_PLOT_AXIS_X, 3);
gtk_plot3d_set_minor_ticks(GTK_PLOT3D(plot3d), GTK_PLOT_AXIS_Y, 3);
gtk_plot3d_minor_grids_set_visible(GTK_PLOT3D(plot3d), FALSE, FALSE, FALSE);
surface = gtk_plot_csurface_new_function((GtkPlotFunc3D) function);
gtk_plot_surface_set_xstep(GTK_PLOT_SURFACE(surface), .05);
gtk_plot_surface_set_ystep(GTK_PLOT_SURFACE(surface), .05);
gtk_plot_data_set_legend(GTK_PLOT_DATA(surface), "cos ((r-r\\s0\\N)\\S2\\N)");
gtk_plot_add_data(GTK_PLOT(plot3d), GTK_PLOT_DATA(surface));
gtk_widget_show(surface);
gtk_plot_data_set_gradient(GTK_PLOT_DATA(surface), .2, .8, 6, 0);
/*
gtk_plot_surface_set_transparent(GTK_PLOT_SURFACE(surface), TRUE);
*/
gtk_plot_surface_set_transparent(GTK_PLOT_SURFACE(surface), FALSE);
gtk_plot_csurface_set_projection(GTK_PLOT_CSURFACE(surface), GTK_PLOT_PROJECT_EMPTY);
GTK_PLOT_CSURFACE(surface)->levels_line.line_style = GTK_PLOT_LINE_NONE;
GTK_PLOT_CSURFACE(surface)->sublevels_line.line_style = GTK_PLOT_LINE_NONE;
/*******************/
active_plot = new_layer(canvas, GTK_TYPE_PLOT);
child = gtk_plot_canvas_plot_new(GTK_PLOT(active_plot));
gtk_plot_canvas_put_child(GTK_PLOT_CANVAS(canvas), child, .26, .54, .65, .90);
gtk_plot_axis_set_minor_ticks(gtk_plot_get_axis(GTK_PLOT(active_plot), GTK_PLOT_AXIS_LEFT), 1);
gtk_plot_axis_set_minor_ticks(gtk_plot_get_axis(GTK_PLOT(active_plot), GTK_PLOT_AXIS_BOTTOM), 1);
surface = gtk_plot_csurface_new_function((GtkPlotFunc3D) function);
gtk_plot_surface_set_xstep(GTK_PLOT_SURFACE(surface), .050);
gtk_plot_surface_set_ystep(GTK_PLOT_SURFACE(surface), .050);
gtk_plot_data_set_legend(GTK_PLOT_DATA(surface), "cos ((r-r\\s0\\N)\\S2\\N)");
gtk_plot_add_data(GTK_PLOT(active_plot), GTK_PLOT_DATA(surface));
gtk_widget_show(surface);
gtk_plot_data_set_gradient(GTK_PLOT_DATA(surface), .2, .8, 3, 0);
gtk_plot_surface_set_grid_visible(GTK_PLOT_SURFACE(surface), FALSE);
gtk_plot_surface_set_transparent(GTK_PLOT_SURFACE(surface), TRUE);
gtk_plot_csurface_set_projection(GTK_PLOT_CSURFACE(surface), GTK_PLOT_PROJECT_FULL);
/*
gtk_plot_csurface_set_lines_visible(GTK_PLOT_CSURFACE(surface), FALSE);
*/
button = gtk_button_new_with_label("Rotate X");
gtk_fixed_put(GTK_FIXED(canvas), button, 80, 0);
gtk_widget_show(button);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(rotate_x), canvas);
button = gtk_button_new_with_label("Rotate Y");
gtk_fixed_put(GTK_FIXED(canvas), button, 160, 0);
gtk_widget_show(button);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(rotate_y), canvas);
button = gtk_button_new_with_label("Rotate Z");
gtk_fixed_put(GTK_FIXED(canvas), button, 240, 0);
gtk_widget_show(button);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(rotate_z), canvas);
gtk_signal_connect(GTK_OBJECT(canvas), "select_item",
(GtkSignalFunc) select_item, NULL);
gtk_widget_show(window1);
gtk_plot_canvas_export_ps(GTK_PLOT_CANVAS(canvas), "democsurface.ps", 0, 0,
GTK_PLOT_LETTER);
gtk_main();
return(0);
}
int main(int argc, char *argv[]){
GtkWidget *window1;
GtkWidget *vbox1;
GtkWidget *scrollw1;
GtkWidget *active_plot;
GdkColor color;
gint page_width, page_height;
gfloat scale = 1.;
page_width = GTK_PLOT_LETTER_W * scale;
page_height = GTK_PLOT_LETTER_H * scale;
gtk_init(&argc,&argv);
window1=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window1), "GtkPlot Real Time Demo");
gtk_widget_set_usize(window1,550,600);
gtk_container_border_width(GTK_CONTAINER(window1),0);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC (quit), NULL);
vbox1=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window1),vbox1);
gtk_widget_show(vbox1);
scrollw1=gtk_scrolled_window_new(NULL, NULL);
gtk_container_border_width(GTK_CONTAINER(scrollw1),0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollw1),
GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox1),scrollw1, TRUE, TRUE,0);
gtk_widget_show(scrollw1);
canvas = gtk_plot_canvas_new(page_width, page_height, 1.);
GTK_PLOT_CANVAS_UNSET_FLAGS(GTK_PLOT_CANVAS(canvas), GTK_PLOT_CANVAS_DND_FLAGS);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollw1), canvas);
gdk_color_parse("light blue", &color);
gdk_color_alloc(gtk_widget_get_colormap(canvas), &color);
gtk_plot_canvas_set_background(GTK_PLOT_CANVAS(canvas), &color);
gtk_widget_show(canvas);
active_plot = new_layer(canvas);
gdk_color_parse("light yellow", &color);
gdk_color_alloc(gtk_widget_get_colormap(active_plot), &color);
gtk_plot_set_background(GTK_PLOT(active_plot), &color);
gdk_color_parse("white", &color);
gdk_color_alloc(gtk_widget_get_colormap(canvas), &color);
gtk_plot_legends_set_attributes(GTK_PLOT(active_plot),
NULL, 0,
NULL,
&color);
gtk_plot_set_range(GTK_PLOT(active_plot), 0. ,20., 0., 1.);
gtk_plot_axis_set_ticks(GTK_PLOT(active_plot), GTK_PLOT_AXIS_X, 2, 1);
gtk_plot_axis_set_ticks(GTK_PLOT(active_plot), GTK_PLOT_AXIS_Y, .1, 1);
gtk_plot_axis_set_labels_numbers(GTK_PLOT(active_plot), 2, 0, 0);
gtk_plot_axis_set_labels_numbers(GTK_PLOT(active_plot), 3, 0, 0);
gtk_plot_axis_set_visible(GTK_PLOT(active_plot), GTK_PLOT_AXIS_TOP, TRUE);
gtk_plot_axis_set_visible(GTK_PLOT(active_plot), GTK_PLOT_AXIS_RIGHT, TRUE);
gtk_plot_grids_set_visible(GTK_PLOT(active_plot), TRUE, TRUE, TRUE, TRUE);
gtk_plot_canvas_add_plot(GTK_PLOT_CANVAS(canvas), GTK_PLOT(active_plot), .15, .15);
gtk_plot_axis_hide_title(GTK_PLOT(active_plot), GTK_PLOT_AXIS_TOP);
gtk_plot_axis_hide_title(GTK_PLOT(active_plot), GTK_PLOT_AXIS_RIGHT);
gtk_plot_axis_set_title(GTK_PLOT(active_plot), GTK_PLOT_AXIS_LEFT, "Intensity");
gtk_plot_axis_set_title(GTK_PLOT(active_plot), GTK_PLOT_AXIS_BOTTOM, "Point");
gtk_plot_set_legends_border(GTK_PLOT(active_plot), 2, 3);
gtk_plot_legends_move(GTK_PLOT(active_plot), .60, .10);
gtk_widget_show(active_plot);
gtk_widget_show(window1);
gtk_plot_canvas_put_text(GTK_PLOT_CANVAS(canvas), .45, .05,
"Times-BoldItalic", 20, 0, NULL, NULL, TRUE,
GTK_JUSTIFY_CENTER,
"Iterator Demo");
dataset = GTK_PLOT_DATA(gtk_plot_data_new_iterator((GtkPlotIterator)iter,
20,
GTK_PLOT_DATA_X|GTK_PLOT_DATA_Y|GTK_PLOT_DATA_LABELS));
gtk_plot_data_show_labels(dataset, TRUE);
gtk_plot_add_data(GTK_PLOT(active_plot), dataset);
gtk_widget_show(GTK_WIDGET(dataset));
gdk_color_parse("red", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_legend(dataset, "Iterator");
gtk_plot_data_set_symbol(dataset,
GTK_PLOT_SYMBOL_DIAMOND,
GTK_PLOT_SYMBOL_OPAQUE,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset,
GTK_PLOT_LINE_SOLID,
1, &color);
gtk_plot_canvas_paint(GTK_PLOT_CANVAS(canvas));
gtk_plot_canvas_refresh(GTK_PLOT_CANVAS(canvas));
/*
gtk_plot_clip_data(GTK_PLOT(active_plot), TRUE);
*/
gtk_main();
return(0);
}
void
gtk_plot_surface_set_z(GtkPlotSurface *data,
gdouble *z)
{
GTK_PLOT_DATA(data)->z = z;
}
