Tgrafico3d.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//
// Name:        Tgrafico3d.cpp
// Author:      Alex Carpentieri
// Created:     7/17/2004 12:11:38 AM
// Copyright:
//
//------------------------------------------------------------------------------

#include "../../include/Grafico3d/Tgrafico3d.hpp"


#define MINORE 2
#define UGUALE 1
#define MAGGIORE 0

//------------------------------------------------------------------------------
//
//                            CARICO TABELLe EVENTI
//
//------------------------------------------------------------------------------

BEGIN_EVENT_TABLE(WxGrafico,wxGLCanvas)

     EVT_SIZE(WxGrafico::OnSize)

     EVT_CHAR(WxGrafico::OnChar)
     EVT_MOUSE_EVENTS(WxGrafico::OnMouseEvent)
     EVT_PAINT(WxGrafico::OnPaint)
     EVT_MENU(6000,WxGrafico::click_menu_popup_opz)
     EVT_LEFT_DOWN(WxGrafico::GraficoLeftDown)
     EVT_RIGHT_DOWN(WxGrafico::GraficoRightDown)
 EVT_ERASE_BACKGROUND(WxGrafico::OnEraseBackGround)
END_EVENT_TABLE()

//------------------------------------------------------------------------------
//
//          IMPLEMENTAZIONE METODI DI WxGrafico
//
//------------------------------------------------------------------------------


WxGrafico::WxGrafico(wxWindow *parent,
                     const wxSize& size,
                     int* gl_attrib,
                     wxWindowID id,
                     const wxPoint& pos,
                     long style,
                     const wxString& name
                    ):  wxGLCanvas(parent,
                                                  id,
                                                  pos,
                                                  size,
                                                  style,
                                                  name,
                                                  gl_attrib){


         zoom=-20;
         assex=assey=assez=0.0;
         opzAperta=0;
         this->initGL();
         Lista3d =  new wxMenu(_T("") );
         Lista3d->Append( 6000,
                          (_T("Opzioni...")),
                          (_T("Modifica e aggiuni funzioni 3d")),
                          wxITEM_NORMAL);
         Refresh();

}
//______________________________________________________________________________
WxGrafico::~WxGrafico(void){


     while (opzioni.numeroelementi)
     opzioni.RimuoviNodo(1);



}

 void WxGrafico::OnEraseBackGround(wxEraseEvent& event)
  {

  }
//______________________________________________________________________________
void WxGrafico::initGL(void){
     this->SetCurrent();
     wxPaintDC dc(this);
     glShadeModel(GL_SMOOTH);
     glClearColor(0,0,0,0);

    //per disegnare poligoni in ordine corretto
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL | GL_POLYGON_SMOOTH);//indico di che tipo sono
                                                   //le facce dei poligoni
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-5,5,-5,5,5,5);
    // glFrustum(xmin,xmax,zmin,zmax,ymax,ymin);
    glMatrixMode(GL_MODELVIEW);
    //InitMaterials();
    glTranslatef( 0.0,0.0, -6.0 );

}
//______________________________________________________________________________
void WxGrafico::drawGL(void){

    this->SetCurrent();
    glClearColor(1.0, 1.0, 1.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
    glPushMatrix();
    glLoadIdentity (); /* pulisci la matrice */
    glOrtho(-5/2,5/2,-5/2,5/2,5/2,-5/2);
    //glOrtho(xmin/2,xmax/2,zmin/2,zmax/2,ymax/2,ymin/2);

    glTranslatef (0,0, 5+zoom); /* posizione della telecamera*/

    glRotated( assey,  //ruoto l'immagine di g gradi rispetto
               0,
               1,
               0);

     glRotated( assex,  //ruoto l'immagine di g gradi rispetto
                1,
                0,
                0);

     glRotated( assez,  //ruoto l'immagine di g gradi rispetto
                0,
                0,
                1);


      glScalef (1.0, 1.0, 1.0);      /* trasformazione nulla */

      disegna_assi();


      int i;
      pr *ptrAppo;
      if(!opzAperta)
      for (i=1;i<=opzioni.numeroelementi;i++){
          ptrAppo=opzioni.EstraiPtr(i);
          if (ptrAppo->flagdisegno){
             if (ptrAppo->griglia)
             disegna_griglia(ptrAppo->valori);
             disegna_grafico( ptrAppo);
          }

      }


     glPopMatrix();
     glFlush();
     SwapBuffers();
     Refresh();
}
//______________________________________________________________________________

void WxGrafico::disegna_assi(){

     double xmax=opzioni.xmax;
     double xmin=opzioni.xmin;
     double ymax=opzioni.ymax;
     double ymin=opzioni.ymin;
     double zmax=opzioni.zmax;
     double zmin=opzioni.zmin;
     float zerox=5-((xmax-0)*10)/(xmax-xmin);
     float zeroy=5-((ymax-0)*10)/(ymax-ymin);
     float zeroz=5-((zmax-0)*10)/(zmax-zmin);

     this->SetCurrent();
     wxPaintDC dc(this);
     glColor3f(1,0,0);
     glBegin(GL_LINES);
     if (zerox<=5 && zerox>=-5){
        glVertex3f((float)-5,zeroz,zeroy);//assex
        glVertex3f((float)5,zeroz,zeroy);
     }
     if (zeroy<=5 && zeroy>=-5){
        glVertex3f(zerox,zeroz,-5);//assey
        glVertex3f(zerox,zeroz,5);
     }

     if (zeroz<=5 && zeroz>=-5){
        glVertex3f(zerox,-5,zeroy);//assez
        glVertex3f(zerox,5,zeroy);
     }
     glColor3f(0,0,0);
        //cubo di visualizazione

    glVertex3f((float)-5,(float)5,(float)-5);
    glVertex3f((float)5,(float)5,(float)-5);

    glVertex3f((float)-5,(float)-5,(float)-5);
    glVertex3f((float)5,(float)-5,(float)-5);

    glVertex3f((float)-5,(float)5,(float)5);
    glVertex3f((float)5,(float)5,(float)5);

    glVertex3f((float)-5,(float)-5,(float)5);
    glVertex3f((float)5,(float)-5,(float)5);

    glVertex3f((float)-5,(float)5,(float)-5);
    glVertex3f((float)-5,(float)5,(float)5);

    glVertex3f((float)5,(float)5,(float)-5);
    glVertex3f((float)5,(float)5,(float)5);

    glVertex3f((float)-5,(float)-5,(float)-5);
    glVertex3f((float)-5,(float)-5,(float)5);

    glVertex3f((float)5,(float)-5,(float)-5);
    glVertex3f((float)5,(float)-5,(float)5);

    glVertex3f((float)-5,(float)5,(float)-5);
    glVertex3f((float)-5,(float)-5,(float)-5);

    glVertex3f((float)5,(float)5,(float)-5);
    glVertex3f((float)5,(float)-5,(float)-5);

    glVertex3f((float)-5,(float)5,(float)5);
    glVertex3f((float)-5,(float)-5,(float)5);

    glVertex3f((float)5,(float)5,(float)5);
    glVertex3f((float)5,(float)-5,(float)5);

    glEnd();
    glFlush();

}
//______________________________________________________________________________

void WxGrafico::disegna_grafico(pr* funz){

     int risoluzione_r=opzioni.risoluzione_r;
     int risoluzione_c=opzioni.risoluzione_c;
     int r,c;
     float colore=1,colore2=1,colore3=1,colore4=1;
     char noMonoCromo=funz->sfumatura;
     float clr_r,clr_g,clr_b;
     float appo;

     appo=funz->maxRel-funz->minRel;
     clr_r=funz->colore.red;
     clr_r/=255;
     clr_g=funz->colore.green;
     clr_g/=255;
     clr_b=funz->colore.blue;
     clr_b/=255;

     glBegin(GL_QUADS);
     for (r=0;r<risoluzione_r;r++){
         for (c=0;c+1<risoluzione_c;c++){
             if ( funz->valori[r*risoluzione_r+c][1]>=-5 &&
                  funz->valori[r*risoluzione_r+c][1]<=5 &&
                  funz->valori[(r+1)*risoluzione_r+c][1]>=-5 &&
                  funz->valori[(r+1)*risoluzione_r+c][1]<=5  &&
                  funz->valori[(r+1)*risoluzione_r+(c+1)][1]>=-5 &&
                  funz->valori[(r+1)*risoluzione_r+(c+1)][1]<=5  &&
                  funz->valori[r*risoluzione_r+c+1][1]>=-5 &&
                  funz->valori[r*risoluzione_r+c+1][1]<=5 ){

                                    if (noMonoCromo){
                                       colore= (funz->valori[r*risoluzione_r+c][1]-funz->minRel)/(appo);
                                       colore2=(funz->valori[(r+1)*risoluzione_r+c][1]-funz->minRel)/(appo);
                                       colore3=(funz->valori[(r+1)*risoluzione_r+c+1][1]-funz->minRel)/(appo);
                                       colore4=(funz->valori[r*risoluzione_r+c+1][1]-funz->minRel)/(appo);

                                       glColor3f( clr_r*colore,
                                                  clr_g*colore,
                                                  clr_b*colore);
                                       glVertex3fv(funz->valori[r*risoluzione_r+c]);

                                       glColor3f( clr_r*colore2,
                                                  clr_g*colore2,
                                                  clr_b*colore2);
                                       glVertex3fv(funz->valori[(r+1)*risoluzione_r+c]);

                                       glColor3f( clr_r*colore3,
                                                  clr_g*colore3,
                                                  clr_b*colore3);
                                      glVertex3fv(funz->valori[(r+1)*risoluzione_r+(c+1)]);

                                      glColor3f( clr_r*colore4,
                                                 clr_g*colore4,
                                                 clr_b*colore4);
                                      glVertex3fv(funz->valori[r*risoluzione_r+c+1]);
                                     }
                                 else{
                                      glColor3f( clr_r,clr_g,clr_b);
                                      glVertex3fv(funz->valori[r*risoluzione_r+c]);
                                      glVertex3fv(funz->valori[(r+1)*risoluzione_r+c]);
                                      glVertex3fv(funz->valori[(r+1)*risoluzione_r+(c+1)]);
                                      glVertex3fv(funz->valori[r*risoluzione_r+c+1]);
                                 }
                 }
           }

      }
      glEnd();
      glFlush();
}
//______________________________________________________________________________

void WxGrafico::disegna_griglia(float **punti){

    int risoluzione_r=opzioni.risoluzione_r;
    int risoluzione_c=opzioni.risoluzione_c;

    int r,c;

     glColor3f( 0.0,
                0.0,
                0.0);
     for (r=0;r<=risoluzione_r;r+=5){
                    glBegin(GL_LINE_STRIP);
            for(c=0;c<risoluzione_c;c++){

                if(   punti[r*risoluzione_r+c][1]>=-5 &&
                      punti[r*risoluzione_r+c][1]<=5  &&
                      punti[(r+1)*risoluzione_r+c][1]>=-5 &&
                      punti[(r+1)*risoluzione_r+c][1]<=5   &&
                      punti[(r+1)*risoluzione_r+(c+1)][1]>=-5 &&
                      punti[(r+1)*risoluzione_r+(c+1)][1]<=5   &&
                      punti[r*risoluzione_r+c+1][1]>=-5 &&
                      punti[r*risoluzione_r+c+1][1]<=5 ){

                                     glVertex3fv(punti[r*risoluzione_r+c]);


                           }
                  else{
                                 glEnd();
                         glBegin(GL_LINE_STRIP);
                  }

            }
            glEnd();
      }

      for (c=0;c<=risoluzione_c;c+=5){
                   glBegin(GL_LINE_STRIP);
           for(r=0;r<risoluzione_r;r++){


                if(   punti[r*risoluzione_r+c][1]>=-5 &&
                      punti[r*risoluzione_r+c][1]<=5  &&
                      punti[(r+1)*risoluzione_r+c][1]>=-5 &&
                      punti[(r+1)*risoluzione_r+c][1]<=5   &&
                      punti[(r+1)*risoluzione_r+(c+1)][1]>=-5 &&
                      punti[(r+1)*risoluzione_r+(c+1)][1]<=5   &&
                      punti[r*risoluzione_r+c+1][1]>=-5 &&
                      punti[r*risoluzione_r+c+1][1]<=5 ){


                                     glVertex3fv(punti[r*risoluzione_r+c]);


                          }
                 else{
                        glEnd();
                        glBegin(GL_LINE_STRIP);
                  }
            }
            glEnd();
       }
     glFlush();
}
//------------------------------------------------------------------------------
//
//          EVENTI A CUI WxGrafico RISPONDE
//
//------------------------------------------------------------------------------
void WxGrafico::GraficoLeftDown(wxMouseEvent& event)
{
 SetFocus();
((TBasePanel*)GetParent())->ImpostaBordi();

 event.Skip();

}


void WxGrafico::GraficoRightDown(wxMouseEvent& event)
{
 SetFocus();
((TBasePanel*)GetParent())->ImpostaBordi();

 PopupMenu(Lista3d);
 event.Skip();
}




void WxGrafico::OnChar(wxKeyEvent& event){

     switch(event.m_keyCode) {
          case WXK_LEFT:
            assey += 1.0;
          break;
          case WXK_RIGHT:
             assey -= 1.0;
          break;
          case WXK_UP:
            assex -= 1.0;
          break;

          case WXK_DOWN:
             assex += 1.0;
          break;
          case 'z':
               zoom++;
          break;
          case 'x':
               zoom--;
     }

          drawGL();
         event.Skip();

    }
//______________________________________________________________________________

void WxGrafico::OnMouseEvent(wxMouseEvent& event){

         char dis=0;
         wxPoint posizione_mouse;
         posizione_mouse=event.GetPosition();
     if (event.ButtonIsDown(wxMOUSE_BTN_LEFT)&& !event.m_controlDown){

          if (posizione_mouse.x+1<cur_x){
              dis=1;
              assey-=3.0;
              }
          else
              if (posizione_mouse.x-1>cur_x){
                 assey+=3.0;
                 dis=1;
              }
          if (posizione_mouse.y+1<cur_y){
              assex-=3.0;
              dis=1;
          }
          else
               if (posizione_mouse.y-1>cur_y){
                  assex+=3.0;
                  dis=1;
               }
       }


if(dis==1) drawGL();
        cur_x=posizione_mouse.x;
        cur_y=posizione_mouse.y;
            event.Skip();

      /*   long x,y,dx,dy;
         char dis=0;
         wxCursor cursore();
         event.GetPosition(&x,&y);
       if (event.ButtonIsDown(wxMOUSE_BTN_LEFT)&& event.m_controlDown){
          dx=delta(x,cur_x);
          dy=delta(y,cur_y);
          switch (dx) {
                 case MAGGIORE:
                      ruota_sinistra(&assex,&assey,&assez);
                      dis=1;
                 break;
                 case  MINORE:
                       ruota_destra(&assex,&assey,&assez);
                       dis=1;
                 break;
                 case  UGUALE:
                 break;
          }
          switch (dy) {
              case  MAGGIORE:
                    ruota_su(&assex,&assey,&assez);
                    dis=1;
              break;
              case   MINORE:
                     ruota_giu(&assex,&assey,&assez);
                     dis=1;
              break;
              case    UGUALE:
              break;
          }
       }

       if (event.RightDown()) this->PopupMenu(Lista3d);

       if(dis==1) drawGL();

       cur_x=x;
       cur_y=y;
       event.Skip();*/
    }
//______________________________________________________________________________
void WxGrafico::OnPaint(wxPaintEvent& event){
        int width, height;

        GetClientSize(& width, & height);
        SetCurrent();


        glMatrixMode (GL_PROJECTION); /* preparazione matrice in modalità
                                      projection,determino come l'immagine deve
                                      essere caricata nello  schermo*/

        glLoadIdentity ();               /*pulisce a carica la nuova matrice */
        glFrustum (-1.0, 1.0, -1.0, 1.0, /* trasformazione */
                   1.5, 20.0);
        glMatrixMode (GL_MODELVIEW);  /* ritorno alla vista della matrice */
        glViewport (0, 0, width, height);/* definisco la grandezza della fotografia */
        SwapBuffers();
         drawGL();
        // Refresh();
        event.Skip();
    }
//______________________________________________________________________________
void WxGrafico::OnSize(wxSizeEvent& event){
       this->SetCurrent();
       int width, height;
        GetClientSize(& width, & height);
        glMatrixMode (GL_PROJECTION); /* preparazione matrice in modalità
                                         projection,determino come l'immagine
                                         deve essere caricata nello  schermo*/

        glLoadIdentity ();               /*pulisce a carica la nuova matrice */
        glFrustum (-1.0, 1.0, -1.0, 1.0, /* trasformazione */
                  1.5, 20.0);
        glMatrixMode (GL_MODELVIEW);  /* ritorno alla vista della matrice */
        glViewport (0, 0, width, height);/* definisco la grandezza della fotografia*/
        this->SwapBuffers();
        drawGL();
        Refresh();
        event.Skip();
    }


 //______________________________________________________________________________

 void WxGrafico::click_menu_popup_opz(wxCommandEvent& Event){
      Opz3dDlg* finOpzioni;
      opzAperta=1;
      finOpzioni= new Opz3dDlg(this->GetParent(),&opzioni);
      finOpzioni->ShowModal();
      finOpzioni->Destroy();
      opzAperta=0;
     /* xmin=opzioni.xmin;
      xmax=opzioni.xmax;
      ymin=opzioni.ymin;
      ymax=opzioni.ymax;
      zmin=opzioni.zmin;
      zmax=opzioni.zmax;
      risoluzione_r=opzioni.risoluzione_r;
      risoluzione_c=opzioni.risoluzione_c;*/

      Refresh();
      Event.Skip();
      }
 //______________________________________________________________________________

char WxGrafico::delta(long x1,long x2){
     if (x1-x2<0)
        return 0;
     else
         if (x1-x2==0)
            return 1;
     return 2;
}
//______________________________________________________________________________

void WxGrafico::ruota_destra(double *assex,double *assey,double *assez){
     float deltay;
    /* if (*assez>=90 && *assez<=270)
        deltay=-3.0;
     else*/
         deltay=3.0;
     *assey+=deltay;
     if (*assey>=360)
        *assey=*assey-360;
}
//______________________________________________________________________________

void WxGrafico::ruota_sinistra(double *assex,double *assey,double *assez){
     float deltay;
    /* if (*assez>=90 && *assez<=270)
        deltay=+3.0;
     else*/
         deltay=-3.0;
     *assey+=deltay;
     if (*assey>=360)
        *assey=*assey-360;
}
//______________________________________________________________________________

void WxGrafico::ruota_su(double *assex,double *assey,double *assez){
     float deltax;

      if (*assey>=90 && *assey<=270)
         deltax=+3;
      else
          deltax=-3;
      *assex+=deltax;
      if (*assex>=360)
         *assex=*assex-360;
}
//______________________________________________________________________________

void WxGrafico::ruota_giu(double *assex,double *assey,double *assez){
     float deltax;

      if (*assey>=90 && *assey<=270)
         deltax=-3;
      else
         deltax=+3;
      *assex+=deltax;
      if (*assex<=0)
        *assex=360-*assex;
}

//______________________________________________________________________________

wxMenu* WxGrafico::GetPopUp()
{ return Lista3d;
}

//------------------------------------------------------------------------------
//
//                              FINE FILE
//
//------------------------------------------------------------------------------