Question 1

Question 2

void reshape(int w,int h) {
  glViewport(0,0,w,h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(15.0,(float) w/h,30.0,100.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt(0.0,30.0,50.0,0.0,0.0,0.0,0.0,1.0,0.0);
}

Il s'agit d'une fonction reshape classique à laquelle a été ajouté un appelle à gluLookAt en dernière fonction exécutée pour configurer la position de la caméra selon les caractéristiques de placement et d'orientation souhaitées. La configuration des caractéristique de visualisation est réalisée via l'appel à la fonction gluPerspective en mode GL_PROJECTION.

Question 3

void pixel(int x,int y,coord2D *c,int i) {
  c[i][0] = x;
  c[i][1] = y;
}

coord2D *calculLigne(coord2D p1,coord2D p2,int *l) {
  int dx,dy,i,xinc,yinc,cumul,x,y ;
  x = p1[0] ;
  y = p1[1] ;
  dx = p2[0] - p1[0] ;
  dy = p2[1] - p1[1] ;
  xinc = ( dx > 0 ) ? 1 : -1 ;
  yinc = ( dy > 0 ) ? 1 : -1 ;
  dx = abs(dx) ;
  dy = abs(dy) ;
  coord2D *p =(coord2D *) calloc(1+((dx > dy) ? dx : dy),
                                 sizeof(coord2D)) ;
  pixel(x,y,p,0) ;
  if ( dx > dy ) {
    *l = dx+1;
    cumul = dx / 2 ;
    for ( i = 1 ; i <= dx ; i++ ) {
      x += xinc ;
      cumul += dy ;
      if (cumul >= dx) {
        cumul -= dx ;
        y += yinc ; }
      pixel(x,y,p,i) ; } }
    else {
    *l = dy+1;
    cumul = dy / 2 ;
    for ( i = 1 ; i <= dy ; i++ ) {
      y += yinc ;
      cumul += dx ;
      if ( cumul >= dy ) {
        cumul -= dy ;
        x += xinc ; }
      pixel(x,y,p,i) ; } }
  return(p);
}

int testPixel(int x,int y,coord2D *p,int l) {
  for ( int i = 0 ; i < l ; i++ )
    if ( ( x == p[i][0] ) && ( y == p[i][1] ) )
      return(1);
  return(0);
}

int cherchePixelCommun(coord2D p1,coord2D p2,coord2D *p,int l) {
  int dx,dy,i,xinc,yinc,cumul,x,y ;
  x = p1[0] ;
  y = p1[1] ;
  dx = p2[0] - p1[0] ;
  dy = p2[1] - p1[1] ;
  xinc = ( dx > 0 ) ? 1 : -1 ;
  yinc = ( dy > 0 ) ? 1 : -1 ;
  dx = abs(dx) ;
  dy = abs(dy) ;
  if ( testPixel(x,y,p,l) )
    return(1) ;
  if ( dx > dy ) {
    cumul = dx / 2 ;
    for ( i = 1 ; i <= dx ; i++ ) {
      x += xinc ;
      cumul += dy ;
      if (cumul >= dx) {
        cumul -= dx ;
        y += yinc ; }
      if ( testPixel(x,y,p,l) )
        return(1) ; } }
    else {
    cumul = dy / 2 ;
    for ( i = 1 ; i <= dy ; i++ ) {
      y += yinc ;
      cumul += dx ;
      if ( cumul >= dy ) {
        cumul -= dy ;
        x += xinc ; }
      if ( testPixel(x,y,p,l) )
        return(1) ; } }
  return(0);
}

int testLignes(coord2D pi1,coord2D pf1,coord2D pi2,coord2D pf2) {
  int l;
  coord2D *p1 = calculLigne(pi1,pf1,&l);
  int v = cherchePixelCommun(pi1,pf2,p1,l);
  free(p1);
  return(v);
}

La fonction testLignes utilise deux variantes de l'algorithme de Bresenham.
La première permet de remplir un tableau de pixels pour déterminer tous les pixels qui seraient tracés lors du tracé du premier segment.
La seconde utilise ce tableau pour tester s'il présente un pixel commun avec ceux qui seraient tracés lors du tracé du second segment. Cette fonction s'arrète sitôt qu'une coïncidence est trouvée.

Question 4

Remarques, erreurs
nicolas.janey@univ-fcomte.fr