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);
}
void
rotate_z(GtkWidget *button, gpointer data)
{
if(!GTK_IS_PLOT3D(active_plot)) return;
gtk_plot3d_rotate_z(GTK_PLOT3D(active_plot), 10.);
gtk_plot_canvas_paint(GTK_PLOT_CANVAS(data));
gtk_plot_canvas_refresh(GTK_PLOT_CANVAS(data));
}
static void
gtk_plot_bar_draw_symbol(GtkPlotData *dataset,
gdouble x, gdouble y, gdouble z, gdouble a,
gdouble dx, gdouble dy, gdouble dz, gdouble da)
{
GtkPlot *plot;
GtkPlotBar *bar;
GdkRectangle area, clip_area;
gdouble px, py, px0, py0;
gdouble x1 = 0.0, y1 = 0.0, width = 0.0, height = 0.0;
gdouble ex, ey;
bar = GTK_PLOT_BAR(dataset);
plot = dataset->plot;
area.x = GTK_WIDGET(plot)->allocation.x;
area.y = GTK_WIDGET(plot)->allocation.y;
area.width = GTK_WIDGET(plot)->allocation.width;
area.height = GTK_WIDGET(plot)->allocation.height;
clip_area.x = area.x + roundint(plot->x * area.width);
clip_area.y = area.y + roundint(plot->y * area.height);
clip_area.width = roundint(plot->width * area.width);
clip_area.height = roundint(plot->height * area.height);
gtk_plot_pc_clip(plot->pc, &clip_area);
if(GTK_IS_PLOT3D(plot)){
} else {
switch(bar->orientation){
case GTK_ORIENTATION_VERTICAL:
gtk_plot_get_pixel(plot, x-bar->width, y, &px, &py);
gtk_plot_get_pixel(plot, x+bar->width, MAX(0., plot->ymin), &px0, &py0);
if(dataset->show_yerrbars)
gtk_plot_get_pixel(plot, x, y + dy, &ex, &ey);
break;
case GTK_ORIENTATION_HORIZONTAL:
gtk_plot_get_pixel(plot, y, x+bar->width, &px, &py);
gtk_plot_get_pixel(plot, MAX(0., plot->xmin), x-bar->width, &px0, &py0);
if(dataset->show_xerrbars)
gtk_plot_get_pixel(plot, y + dy, x, &ex, &ey);
break;
}
x1 = MIN(px, px0);
y1 = MIN(py, py0);
if(GTK_IS_PLOT_PS(plot->pc)){
width = fabs(px - px0);
height = fabs(py0 - py);
}
else
{
width = abs(roundint(px - px0));
height = abs(roundint(py0 - py));
}
if(dataset->symbol.symbol_style == GTK_PLOT_SYMBOL_OPAQUE){
gtk_plot_pc_set_color(plot->pc, &plot->background);
gtk_plot_pc_draw_rectangle (plot->pc,
TRUE,
x1, y1, width, height);
}
gtk_plot_pc_set_lineattr (plot->pc, dataset->symbol.border.line_width,
0, 0, 0);
gtk_plot_pc_set_dash (plot->pc, 0, 0, 0);
if(dataset->symbol.symbol_style == GTK_PLOT_SYMBOL_FILLED){
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.color);
gtk_plot_pc_draw_rectangle (plot->pc,
TRUE,
x1, y1, width, height);
}
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.border.color);
gtk_plot_pc_draw_rectangle (plot->pc,
FALSE,
x1, y1, width, height);
if(dataset->show_yerrbars){
gtk_plot_pc_draw_line(plot->pc, ex, py, ex, ey);
gtk_plot_pc_draw_line(plot->pc, px, ey, px0, ey);
}
if(dataset->show_xerrbars){
gtk_plot_pc_draw_line(plot->pc, px, ey, ex, ey);
gtk_plot_pc_draw_line(plot->pc, ex, py, ex, py0);
}
}
gtk_plot_pc_clip(plot->pc, NULL);
}
static void
gtk_plot_candle_draw_symbol(GtkPlotData *dataset,
gdouble x, gdouble y, gdouble z, gdouble a,
gdouble dx, gdouble dy, gdouble dz, gdouble da)
{
GtkPlot *plot;
GtkPlotCandle *box = NULL;
gdouble px, py, pz, ex, ey, ez;
gdouble x1 = 0.0, y1 = 0.0, width = 0.0, height = 0.0;
gdouble m;
gboolean filled;
gdouble a_scale;
g_return_if_fail(GTK_IS_PLOT_CANDLE(dataset));
box = GTK_PLOT_CANDLE(dataset);
g_return_if_fail(dataset->plot != NULL);
plot = dataset->plot;
a_scale = gtk_plot_data_get_a_scale(dataset);
m = plot->magnification * a_scale;
gtk_plot_pc_set_lineattr (plot->pc, dataset->symbol.border.line_width,
0, 0, 0);
gtk_plot_pc_set_dash (plot->pc, 0, 0, 0);
if(x >= plot->xmin && x <= plot->xmax){
if(GTK_IS_PLOT3D(plot)){
}else if(dataset->show_zerrbars){
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.border.color);
gtk_plot_get_pixel(plot, x, y, &px, &py);
gtk_plot_get_pixel(plot, x, z, &px, &pz);
width = m * dataset->symbol.size / 2;
x1 = px - width;
y1 = MIN(py, pz);
filled = z < y;
height = abs(py - pz);
gtk_plot_get_pixel(plot, x, dy, &ex, &ey);
gtk_plot_get_pixel(plot, x, dz, &ex, &ez);
gtk_plot_pc_draw_line(plot->pc, px, py, px, ey);
gtk_plot_pc_draw_line(plot->pc, px, pz, px, ez);
if(!filled && dataset->symbol.symbol_style != GTK_PLOT_SYMBOL_EMPTY){
gtk_plot_pc_set_color(plot->pc, &plot->background);
gtk_plot_pc_draw_rectangle (plot->pc,
TRUE,
x1, y1, width * 2, height);
}
if(dataset->symbol.symbol_style == GTK_PLOT_SYMBOL_EMPTY){
GtkPlotPoint lines[4];
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.color);
lines[0].x = px - width;
lines[0].y = py;
lines[1].x = px;
lines[1].y = py;
lines[2].x = px;
lines[2].y = pz;
lines[3].x = px + width;
lines[3].y = pz;
gtk_plot_pc_draw_lines(plot->pc, lines, 4);
} else {
if(filled){
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.color);
gtk_plot_pc_draw_rectangle (plot->pc,
TRUE,
x1, y1, width * 2, height);
}
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.border.color);
gtk_plot_pc_draw_rectangle (plot->pc,
FALSE,
x1, y1, width * 2, height);
}
}
}
}
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);
}
static void
gtk_plot_flux_draw_symbol(GtkPlotData *dataset,
gdouble x, gdouble y, gdouble z, gdouble a,
gdouble dx, gdouble dy, gdouble dz, gdouble da)
{
GtkPlot *plot;
GtkPlotFlux *flux = NULL;
//GdkRectangle area; //, clip_area;
gdouble m;
gdouble x1 = 0.0, y1 = 0.0, x2 = 0.0, y2=0.0;
gdouble factor, size, xm;
GtkAllocation allocation;
g_return_if_fail(GTK_IS_PLOT_FLUX(dataset));
flux = GTK_PLOT_FLUX(dataset);
g_return_if_fail(dataset->plot != NULL);
g_return_if_fail(gtk_widget_get_visible(GTK_WIDGET(dataset->plot)));
plot = dataset->plot;
m = plot->magnification;
gtk_widget_get_allocation( GTK_WIDGET(plot), &allocation);
//area.x = allocation.x;
//area.y = allocation.y;
//area.width = allocation.width;
//area.height = allocation.height;
/*
clip_area.x = area.x + roundint(plot->x * area.width);
clip_area.y = area.y + roundint(plot->y * area.height);
clip_area.width = roundint(plot->width * area.width);
clip_area.height = roundint(plot->height * area.height);
gtk_plot_pc_clip(plot->pc, &clip_area);
*/
if(GTK_IS_PLOT3D(plot)){
gdouble z1;
xm = sqrt(dx * dx + dy * dy + dz * dz);
factor = xm / flux->scale_max;
size = factor * flux->size_max;
x2 = size * dx / xm;
y2 = size * dy / xm;
gtk_plot3d_get_pixel(GTK_PLOT3D(plot), x, y, z,
&x1, &y1, &z1);
}else{
if(plot->clip_data &&
(x < plot->xmin || x > plot->xmax || y < plot->ymin || y > plot->ymax))
return;
xm = sqrt(dx * dx + dy * dy);
factor = xm / flux->scale_max;
size = factor * flux->size_max;
gtk_plot_get_pixel(plot, x, y, &x1, &y1);
if (xm > 0.0) {
x2 = size * dx / xm;
y2 = size * dy / xm;
/* check for NaN */
if (x2 == x2 && y2 == y2)
gtk_plot_flux_draw_arrow (flux, x1, y1, x1+x2*m, y1-y2*m);
}
gtk_plot_data_draw_symbol(dataset, x1, y1);
}
/*
gtk_plot_pc_clip(plot->pc, NULL);
*/
}
