Implémentation de l'algo de Brensenham qui permet à partir de deux points donnés de tracer la la droite qui relie ces 2 points en dessinant la droite point par point.
Source / Exemple :
#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#define xc_min 20 // on definit un carre en donnant 2 points
#define xc_max 140 // le coin superieure a gauche
#define yc_min 20 // et le coin inferieure a droite
#define yc_max 70
/*
Info.Graphique(Infographie) Brensenham : tracer des droites
http://www.Software-DS.com
Fonctionne sous Linux
Compilation : (Fonctionne sur MacOSX si vous avez installe X11)
gcc -o brensenham brensenham.c -L/usr/X11R6/lib -lX11
/* prototypes */
void contact_serveur();
void Creat_fenetre(void);
void gerer_evenement();
void Brensenham(int xa, int ya, int xb, int yb, int couleur);
/* variables globales */
GC gc;
Display *display;
int screen;
Window win,root;
int win_larg,win_haut;
unsigned long white_pixel, black_pixel;
/* ******************************************************************** */
void contact_serveur(){
if ((display = XOpenDisplay("")) == NULL) {
fprintf(stderr, "Can't open Display\n");
exit(1);
}
} /* contact_serveur */
/* ******************************************************************** */
void Creat_fenetre(void) {
short border_width;
screen = DefaultScreen(display);
root = RootWindow(display,screen);
white_pixel= WhitePixel(display,screen);
black_pixel= BlackPixel(display,screen);
border_width = 3;
win_larg = DisplayWidth(display,screen)/4;
win_haut = DisplayHeight(display,screen)/4;
win = XCreateSimpleWindow(display,root,0,0,win_larg,win_haut,
border_width,black_pixel,white_pixel);
gc=DefaultGC(display,screen);
XStoreName(display,win,"Brensenham - DS");
XMapWindow(display,win);
} /* Creat_fenetre */
/* ******************************************************************** */
void gerer_evenement() {
char *str1="
http://www.Software-DS.com";
int i,a,b,c,d;
XSelectInput(display,win,ExposureMask | KeyPressMask);
for(;;) {
XEvent ev;
XNextEvent(display,&ev);
switch(ev.type){
case Expose :
/* On va afficher des dessins ;) */
/* on dessine un carre ou rectangle */
Brensenham(xc_min, yc_min, xc_min, yc_max,0);
Brensenham(xc_max, yc_max, xc_min, yc_max,0);
Brensenham(xc_max, yc_max, xc_max, yc_min,0);
Brensenham(xc_min, yc_min, xc_max, yc_min,0);
/* on relie les diagonales */
Brensenham(xc_min, yc_min, xc_max, yc_max,0);
Brensenham(xc_min, yc_max, xc_max, yc_min,0);
break;
case KeyPress : // on appuie sur une touche pour quitter
XClearWindow(display,win);
XDrawString(display,win,gc,win_larg/5,win_haut*2/5,str1,strlen(str1));
XFlush(display);
sleep(4); // petite pause avant de fermer
XDestroyWindow(display,win);
XCloseDisplay(display);
exit(0);
break;
default :
fprintf(stderr,"J'ai recu un evt : %d\n",ev.type);
break;
} /* switch */
} /* for */
} /* gerer_evts */
/* ******************************************************************** */
void Brensenham(int xa, int ya, int xb, int yb, int couleur) {
/* pour tracer une droite a partir de 2 points : (xa,ya) et (xb,yb) */
int x,y,dx,dy,incrmX,incrmY,dp,NE,SE;
dx = xb-xa;
dy = yb-ya;
if (dx>0)
incrmX = 1;
else {
incrmX = -1;
dx *= -1;
}
if (dy>0)
incrmY = 1;
else {
incrmY = -1;
dy *= -1;
}
if (dx>=dy) {
dp=2*dy-dx;
SE=2*dy;
NE=2*(dy-dx);
y=ya;
for(x=xa;x!=xb;x+=incrmX) {
/* affichePixel(x,y,couleur) */
XDrawPoint(display,win,gc,x, y);
if (dp<=0) /* on choisit le pixel E */
dp += SE;
else {
dp += NE;
y+=incrmY;
}
}
}
else if (dx<dy) {
dp=2*dx-dy;
SE=2*dx;
NE=2*(dx-dy);
x=xa;
for(y=ya;y!=yb;y+=incrmY) {
/* affichePixel(x,y,couleur) */
XDrawPoint(display,win,gc,x, y);
if (dp<=0) /* on choisit le pixel E */
dp += SE;
else {
dp += NE;
x+=incrmX;
}
}
}
} /* Brensenham */
/* ******************************************************************** */
int main() {
contact_serveur();
Creat_fenetre();
gerer_evenement();
return 0;
}
Je trouve ce code très bien fait et compréhensible.
Néanmoins il reste quelque point que je ne comprend pas vraiment.
A quoi correspond exactement les variables dp, NE et SE ?
Merci d'une éventuelle réponse.
Cordialement,
Alexandre
Quand on trace une droite d'un point vers ce meme point il faut dessiner ce point !
excellent :)
tu ne le dis pas ici mais ça vaut la peine d'être mentionné: cet algo permet de tracer une droite sans aucune division et en n'utilisant QUE des variables ENTIERES! (pas de réels!). De plus les boucles ne contiennent que des additions/soustractions: une merveille d'optimisation ^^
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.