Exemple #1
0
void go_plot_contours(
    char *device, char *title, char *xvar, char *yvar, char *topline,
    double **data, double xmin, double xmax, double ymin, double ymax,
    double dx, double dy, long nx, long ny,
    double *contour_level, long n_contours, long contour_label_interval,
    long contour_label_offset, long layout[2], long ix, long iy,
    char *shapes, int *pen, long flags, long pause_interval,
    SHAPE_DATA *shape, long nshapes, unsigned long long tsetFlags, double xlableScale, double ylabelScale)
{
    double map[4], average, spread;
    double pmin, pmax, qmin, qmax;
    double wpmin, wpmax=0, wqmin, wqmax=0;
    long title_at_top=0;
    char newLabel[50];
    time_t timeValue;

    if (!(flags&DEVICE_DEFINED)) 
      change_term(device, strlen(device));
    if ((ix == 0) && (iy == 0))
      graphics_on();
    if (layout[0] && layout[1]) {
      wpmin = (1.0*ix+0)/layout[0];
      wpmax = (1.0*ix+1)/layout[0];
      wqmin = (layout[1]*1.0 - 1 - iy)/layout[1];
      wqmax = (layout[1]*1.0 - 0 - iy)/layout[1];
      set_wspace(wpmin, wpmax, wqmin, wqmax);
      pmin = (wpmax - wpmin) * .15 + wpmin;
      pmax = wpmax - (wpmax - wpmin) * .1;
      qmin = (wqmax - wqmin) * .17 + wqmin;
      qmax = wqmax - (wqmax - wqmin) * .08;
      set_pspace(pmin, pmax, qmin, qmax);
    }

    if (contour_label_interval<0) {
      get_pspace(&pmin, &pmax, &qmin, &qmax);
      set_pspace(pmin, 0.9 * wpmax, qmin, 0.85 * wqmax);
    }
    if (flags&TITLE_AT_TOP) {
      /* adjust pspace to make room at top for the title */
      get_pspace(&pmin, &pmax, &qmin, &qmax);
      spread = qmax-qmin;
      qmax -= 0.04*spread;
      qmin -= 0.04*spread;
      /*    qmax -= 0.04;
            qmin -= 0.04;*/
      set_pspace(pmin, pmax, qmin, qmax);
      title_at_top = 1;
    }
    set_clipping(1, 1, 1);


    if (flags&EQUAL_ASPECT1) 
        set_aspect(1.0L);
    else if (flags&EQUAL_ASPECT_1)
        set_aspect(-1.0L);

    set_linetype(pen[0]);
    get_mapping(map, map+1, map+2, map+3);
    if (map[0]==map[1]) {
        average  = (xmax+xmin)/2;
        spread   = (xmax-xmin)/2;
        map[0]   = average - spread*1.05;
        map[1]   = average + spread*1.05;
        }
    if (map[2]==map[3]) {
        average  = (ymax+ymin)/2;
        spread   = (ymax-ymin)/2;
        map[2]   = average - spread*1.05;
        map[3]   = average + spread*1.05;
        }
    set_mapping(map[0], map[1], map[2], map[3]);
    get_pspace(&pmin, &pmax, &qmin, &qmax);
    get_wspace(&wpmin, &wpmax, &wqmin, &wqmax);

    if (!(flags&NO_BORDER)) {
      border();
      if (!(flags&NO_SCALES)) {
        if (tsetFlags&TICKSET_XTIME) {
          timeValue = map[0];
          if (timeValue!=DBL_MAX)
            sprintf(newLabel, "Time starting %s", ctime(&timeValue));
          else
            sprintf(newLabel, "Undefined time values!");
          delete_chars(newLabel, "\n");
          makeTimeScales(0, 0.02, 0, map[2], map[2], newLabel, 
                         0, 0.67*(qmin-wqmin)*(map[3]-map[2])/(qmax-qmin), 
                         0, 1, 1);
        } else {
          make_scales_with_label(0, 0, 1, 0.0, 0.02, 0.0, 
                                 0.0, 1.0, 0, 0, 
                                 0, 0, 0, 0, xvar, 0, 0, xlableScale);
        }
	if (!(flags&NO_YSCALES)) {
          if (tsetFlags&TICKSET_YTIME) {
            timeValue = map[2];
            if (timeValue!=DBL_MAX)
              sprintf(newLabel, "Time starting %s", ctime(&timeValue));
            else
              sprintf(newLabel, "Undefined time values!");
            delete_chars(newLabel, "\n");
            makeTimeScales(1, 0.0125, 0, map[0], map[0], newLabel, 
                           0, (pmin-wpmin)*(map[1]-map[0])/(pmax-pmin), 
                           0, 1, 1);
          } else {
            make_scales_with_label(1, 0, 1, 0.0, 0.0125, 0.0, 
                                   0.0, 1.0, 0, 0, 
                                   0, 0, 0, 0, yvar, 0, 0, ylabelScale);
          }
	}
      }
    }
    if (!(flags&NO_LABELS)) {
      plotTitle(title, 1, title_at_top, 1.0, 0.0, 0, 0);
      if (contour_label_interval>=0)
	plotTitle(topline, 0, 0, 1.0, 0.0, 0, 0);
    }
    set_linetype(pen[1]);
    draw_contours(data, xmin, xmax, ymin, ymax, nx, ny, contour_level, n_contours);
    if (contour_label_interval!=0) {
        set_linetype(pen[2]);
        label_contours(data, nx, ny, contour_level, n_contours,
            contour_label_interval, contour_label_offset,
            xmin, (double)dx, ymin, (double)dy);
        }
    set_linetype(pen[0]);

    if (nshapes)
      PlotShapesData(shape, nshapes, xmin, xmax, ymin, ymax);

    if (flags&DATE_STAMP)
        time_date_stamp();

    }
Exemple #2
0
gboolean
on_drawing3D_expose_event              (GtkWidget       *widget,
                                        GdkEventExpose  *event,
                                        gpointer         user_data)
{
  //Gets the 3D drawing context
  GdkGLContext  *glcontext  = gtk_widget_get_gl_context  (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  //If we can not draw, return
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return FALSE;

  if(flag_minMax==0)
    glClearColor(1.0,1.0,1.0,1.0);
  else
    glClearColor(0.0,0.0,0.0,0.0);
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


  if(flag_draw_3D)
    {
      setUpVolumeMatrices();
      if(drawCube_flag){
        /* cube->draw(rot3DX,rot3DY,200,3*flag_minMax,0); */
        for(int i = 0; i < toDraw.size(); i++){
          toDraw[i]->draw();
          setUpVolumeMatrices();
        }
      }
      setUpVolumeMatrices();
      if(flag_cube_transparency)
        glDisable(GL_DEPTH_TEST);
      else
        glEnable(GL_DEPTH_TEST);
      if(flag_draw_neuron && neuronita)
	neuronita->draw();
        //glCallList(1);
      draw_last_point();
      draw_contours();
      draw_graphcuts();
    }

  //Draws the XY view
  if(flag_draw_XY)
    {
      glEnable(GL_DEPTH_TEST);
      setUpMatricesXY(layerSpanViewZ);
      glColor3f(1.0,1.0,1.0);
      if(drawCube_flag)
        cube->draw_layer_tile_XY(layerToDrawXY);
      if(flag_cube_transparency)
        glDisable(GL_DEPTH_TEST);
      else
        glEnable(GL_DEPTH_TEST);
      if(flag_draw_neuron && neuronita)
	neuronita->draw();
      //glCallList(1);
      /* for(int i = 0; i < toDraw.size(); i++) */
        /* toDraw[i]->draw(); */
      draw_last_point();
      draw_contours();
      draw_graphcuts();
      glDisable(GL_DEPTH_TEST);
    }

  if(flag_draw_XZ)
    {
      glEnable(GL_DEPTH_TEST);
      setUpMatricesXZ(layerSpanViewZ);
      if(drawCube_flag)
        cube->draw_layer_tile_XZ(layerToDrawXZ);
      if(flag_cube_transparency)
        glDisable(GL_DEPTH_TEST);
      else
        glEnable(GL_DEPTH_TEST);
      if(flag_draw_neuron && neuronita)
	neuronita->draw();
      //glCallList(1);
      draw_last_point();
      draw_contours();
      draw_graphcuts();
      glDisable(GL_DEPTH_TEST);
    }

  if(flag_draw_YZ)
    {
      glEnable(GL_DEPTH_TEST);
      setUpMatricesYZ(layerSpanViewZ);
      if(drawCube_flag)
        cube->draw_layer_tile_YZ(layerToDrawYZ);
      if(flag_cube_transparency)
        glDisable(GL_DEPTH_TEST);
      else
        glEnable(GL_DEPTH_TEST);
      if(flag_draw_neuron && neuronita)
	neuronita->draw();
      //glCallList(1);
      draw_last_point();
      draw_contours();
      draw_graphcuts();
      glDisable(GL_DEPTH_TEST);
    }

  if(flag_draw_combo){
    setUpVolumeMatrices();
    glViewport ((GLsizei)0,(GLsizei)0,
                (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);

    if(drawCube_flag){
      for(int i = 0; i < toDraw.size(); i++){
        setUpVolumeMatrices();
        glViewport ((GLsizei)0,(GLsizei)0,
                    (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
        toDraw[i]->draw();
      }
/*       cube->draw(rot3DX,rot3DY,200,flag_minMax,0); */
      setUpVolumeMatrices();
      glViewport ((GLsizei)0,(GLsizei)0,
                  (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
      glEnable(GL_BLEND);
      setUpVolumeMatrices();
      cube->draw_layer_tile_XY(layerToDrawXY,1);
      cube->draw_layer_tile_XZ(layerToDrawXZ,1);
      cube->draw_layer_tile_YZ(layerToDrawYZ,1);
      glPushMatrix();
      glTranslatef(wx,wy,wz);
      glColor3f(0.0,1.0,1.0);
      glutSolidSphere(3, 10,10);
      glPopMatrix();
      glDisable(GL_BLEND);
    }
    if(flag_cube_transparency)
      glDisable(GL_DEPTH_TEST);
    else
      glEnable(GL_DEPTH_TEST);
    if(flag_draw_neuron && neuronita)
      neuronita->draw();
    //glCallList(1);
    draw_last_point();

    glEnable(GL_DEPTH_TEST);
    setUpMatricesXZ(100000);
    glViewport ((GLsizei)0,(GLsizei)widgetHeight/2,
                (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
    if(drawCube_flag){
      cube->draw_layer_tile_XY(layerToDrawXY,1);
      cube->draw_layer_tile_XZ(layerToDrawXZ,0);
      cube->draw_layer_tile_YZ(layerToDrawYZ,1);
      glEnable(GL_BLEND);
      glDisable(GL_DEPTH_TEST);
      glPushMatrix();
      glTranslatef(wx,wy,wz);
      glColor3f(0.0,1.0,1.0);
      glutSolidSphere(1, 10,10);
      glPopMatrix();
      glDisable(GL_BLEND);
    }
    if(flag_cube_transparency)
      glDisable(GL_DEPTH_TEST);
    else
      glEnable(GL_DEPTH_TEST);
    if(flag_draw_neuron){
      setUpMatricesXZ(layerSpanViewZ);
      glViewport ((GLsizei)0,(GLsizei)widgetHeight/2,
                  (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
      if(flag_draw_neuron && neuronita)
	neuronita->draw();
      //glCallList(1);
      draw_last_point();
    }

    glEnable(GL_DEPTH_TEST);
    setUpMatricesYZ(1000000);
    glViewport ((GLsizei)widgetWidth/2, (GLsizei)0,
                (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
    if(drawCube_flag){
      cube->draw_layer_tile_XY(layerToDrawXY,1);
      cube->draw_layer_tile_XZ(layerToDrawXZ,1);
      cube->draw_layer_tile_YZ(layerToDrawYZ,0);
      glEnable(GL_BLEND);
      glDisable(GL_DEPTH_TEST);
      glPushMatrix();
      glTranslatef(wx,wy,wz);
      glColor3f(0.0,1.0,1.0);
      glutSolidSphere(1, 10,10);
      glPopMatrix();
      glDisable(GL_BLEND);
    }
    if(flag_cube_transparency)
      glDisable(GL_DEPTH_TEST);
    else
      glEnable(GL_DEPTH_TEST);
    if(flag_draw_neuron){
      setUpMatricesYZ(layerSpanViewZ);
      glViewport ((GLsizei)widgetWidth/2, (GLsizei)0,
                  (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
      if(flag_draw_neuron && neuronita)
	neuronita->draw();
      //glCallList(1);
      draw_last_point();
    }

    glEnable(GL_DEPTH_TEST);
    setUpMatricesXY(1000000);
    glViewport ((GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2,
                (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
    if(drawCube_flag){
      cube->draw_layer_tile_XY(layerToDrawXY,0);
      cube->draw_layer_tile_XZ(layerToDrawXZ,1);
      cube->draw_layer_tile_YZ(layerToDrawYZ,1);
      glEnable(GL_BLEND);
      glDisable(GL_DEPTH_TEST);
      glPushMatrix();
      glTranslatef(wx,wy,wz);
      glColor3f(0.0,1.0,1.0);
      glutSolidSphere(1, 10,10);
      glPopMatrix();
      glDisable(GL_BLEND);
    }
      if(flag_cube_transparency)
        glDisable(GL_DEPTH_TEST);
      else
        glEnable(GL_DEPTH_TEST);
      if(flag_draw_neuron){
        setUpMatricesXY(layerSpanViewZ);
        glViewport ((GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2,
                    (GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
	if(flag_draw_neuron && neuronita)
	  neuronita->draw();
	//glCallList(1);
        draw_last_point();
      }
    glDisable(GL_DEPTH_TEST);
  }


  if(majorMode == MOD_ASCEDITOR){
    exposeAsc(widget, event, user_data);
  }


  //Show what has been drawn
  if (gdk_gl_drawable_is_double_buffered (gldrawable))
    gdk_gl_drawable_swap_buffers (gldrawable);
  else
    glFlush ();
  gdk_gl_drawable_gl_end (gldrawable);
  return TRUE;
}