Segment en
8-connexitéUn programme de visualisation de segments de droite tracés au moyen de variantes de l'algorithme de Bresenham : Bresenham2D.java
Segment en
8-connexité
Pixels
inférieurs ajoutés
Dessin en
4-connexité
Pages WEB de référence au format Javadoc pour ces classes
/**
* La classe <code>Bresenham2D</code> implante un programme d'affichage
* de segments de droites 2D rasterises pour l'affichage.
*
* @author Nicolas Janey
* @author nicolas.janey@univ-fcomte.fr
* @version 1.0, 16/11/08
*/
public class Bresenham2D {
public static void main(String [] args) {
ApplicationFrame f;
f = new ApplicationFrame("Tracé de segment par algorithme de Bresenham");
f.add("Bresenham 2D en 4 connexité (1)",
(Afficheur) new Afficheur4Connexite1());
f.add("Bresenham 2D en 4 connexité (2)",
(Afficheur) new Afficheur4Connexite2());
f.add("Bresenham 2D en 4 connexité (1+2)",
(Afficheur) new Afficheur4Connexite1et2());
f.add("Bresenham 2D en 4 connexité",
(Afficheur) new Afficheur4Connexite());
f.add("Bresenham 2D en 8 connexité",
(Afficheur) new Afficheur8Connexite());
f.setSize(480,360);
f.setLocation(50,250);
f.setVisible(true);
}
}
Un Afficheur implantant l'algorithme de Bresenham pour la rasterisation en 8-connexité de segments de droite 2D : Afficheur8Connexite.java
import java.awt.*;
/**
* La classe <code>Afficheur8Connexite</code> implante l'interface {@link Afficheur Afficheur}
* pour developper une methode d'affichage d'un segment de droite 2D en 8-connexite
* au moyen de l'algorithme de Bresenham.
*
* @author Nicolas Janey
* @author nicolas.janey@univ-fcomte.fr
* @version 1.0, 12/11/08
*/
public class Afficheur8Connexite implements Afficheur {
private int tx;
private int ty;
private int zoom = 20;
private Graphics g;
/**
* Methode d'affichage executee en boucle infinie pour realiser l'affichage
* d'un objet en projection parallele orthographique.
*
* @param g l'objet <code>Graphics</code> d'affichage.
* @param numeroImage le nombre de fois ou cette methode a deja ete appelee.
* @param tx la largeur (en pixels) de la zone de dessin.
* @param ty la hauteur (en pixels) de la zone de dessin.
*/
public void paint(Graphics g,int numeroImage,int tx,int ty) {
g.drawString("8 connexité",10,20);
this.tx = tx;
this.ty = ty;
this.g = g;
ligne(2,2,21,13);
g.setColor(Color.yellow);
g.drawLine((int) (2.5*zoom),(int) (ty-1.5*zoom),
(int) (21.5*zoom),(int) (ty-12.5*zoom));
}
private void tracePixel(int x,int y,Color c) {
// System.out.format("%3d %3d\n",x,y);
g.setColor(c);
g.fillRect(x*zoom,ty-y*zoom,zoom,zoom);
g.setColor(Color.black);
g.drawRect(x*zoom,ty-y*zoom,zoom,zoom);
}
/* xf > xi */
/* yf > yi */
/* xf-xi > yf-yi */
private void ligne(int xi,int yi,int xf,int yf) {
int dx,dy;
int cumul;
int x,y;
x = xi;
y = yi;
dx = xf - xi;
dy = yf - yi;
tracePixel(x,y,Color.red);
cumul = dx >> 1;
for ( x = xi+1 ; x <= xf ; x++ ) {
cumul += dy;
if (cumul >= dx) {
cumul -= dx;
y += 1; }
tracePixel(x,y,Color.red); }
}
}
Un Afficheur implantant imparfaitement l'algorithme de Bresenham pour la rasterisation en 4-connexité de segments de droite 2D : Afficheur4Connexite1.java
import java.awt.*;
/**
* La classe <code>Afficheur4Connexite1</code> implante l'interface {@link Afficheur Afficheur}
* pour developper de maniere imparfaite une methode d'affichage d'un segment de droite 2D
* en 4-connexite au moyen de l'algorithme de Bresenham.
*
* @author Nicolas Janey
* @author nicolas.janey@univ-fcomte.fr
* @version 1.0, 12/11/08
*/
public class Afficheur4Connexite1 implements Afficheur {
private int tx;
private int ty;
private int zoom = 20;
private Graphics g;
/**
* Methode d'affichage executee en boucle infinie pour realiser l'affichage
* d'un objet en projection parallele orthographique.
*
* @param g l'objet <code>Graphics</code> d'affichage.
* @param numeroImage le nombre de fois ou cette methode a deja ete appelee.
* @param tx la largeur (en pixels) de la zone de dessin.
* @param ty la hauteur (en pixels) de la zone de dessin.
*/
public void paint(Graphics g,int numeroImage,int tx,int ty) {
g.drawString("4 connexité (1)",10,20);
this.tx = tx;
this.ty = ty;
this.g = g;
ligne(2,2,21,13);
g.setColor(Color.yellow);
g.drawLine((int) (2.5*zoom),(int) (ty-1.5*zoom),
(int) (21.5*zoom),(int) (ty-12.5*zoom));
}
private void tracePixel(int x,int y,Color c) {
// System.out.format("%3d %3d\n",x,y);
g.setColor(c);
g.fillRect(x*zoom,ty-y*zoom,zoom,zoom);
g.setColor(Color.black);
g.drawRect(x*zoom,ty-y*zoom,zoom,zoom);
}
/* xf > xi */
/* yf > yi */
/* xf-xi > yf-yi */
private void ligne(int xi,int yi,int xf,int yf) {
int dx,dy;
int cumul;
int x,y;
x = xi;
y = yi;
dx = xf - xi;
dy = yf - yi;
tracePixel(x,y,Color.red);
cumul = dx >> 1;
for ( x = xi+1 ; x <= xf ; x++ ) {
cumul += dy;
if (cumul >= dx) {
cumul -= dx;
y += 1;
tracePixel(x,y-1,Color.green); }
tracePixel(x,y,Color.red); }
}
}
Un autre Afficheur implantant imparfaitement l'algorithme de Bresenham pour la rasterisation en 4-connexité de segments de droite 2D : Afficheur4Connexite2.java
import java.awt.*;
/**
* La classe <code>Afficheur4Connexite2</code> implante l'interface {@link Afficheur Afficheur}
* pour developper de maniere imparfaite une methode d'affichage d'un segment de droite 2D
* en 4-connexite au moyen de l'algorithme de Bresenham.
*
* @author Nicolas Janey
* @author nicolas.janey@univ-fcomte.fr
* @version 1.0, 12/11/08
*/
public class Afficheur4Connexite2 implements Afficheur {
private int tx;
private int ty;
private int zoom = 20;
private Graphics g;
/**
* Methode d'affichage executee en boucle infinie pour realiser l'affichage
* d'un objet en projection parallele orthographique.
*
* @param g l'objet <code>Graphics</code> d'affichage.
* @param numeroImage le nombre de fois ou cette methode a deja ete appelee.
* @param tx la largeur (en pixels) de la zone de dessin.
* @param ty la hauteur (en pixels) de la zone de dessin.
*/
public void paint(Graphics g,int numeroImage,int tx,int ty) {
g.drawString("4 connexité (2)",10,20);
this.tx = tx;
this.ty = ty;
this.g = g;
ligne(2,2,21,13);
g.setColor(Color.yellow);
g.drawLine((int) (2.5*zoom),(int) (ty-1.5*zoom),
(int) (21.5*zoom),(int) (ty-12.5*zoom));
}
private void tracePixel(int x,int y,Color c) {
// System.out.format("%3d %3d\n",x,y);
g.setColor(c);
g.fillRect(x*zoom,ty-y*zoom,zoom,zoom);
g.setColor(Color.black);
g.drawRect(x*zoom,ty-y*zoom,zoom,zoom);
}
/* xf > xi */
/* yf > yi */
/* xf-xi > yf-yi */
private void ligne(int xi,int yi,int xf,int yf) {
int dx,dy;
int cumul;
int x,y;
x = xi;
y = yi;
dx = xf - xi;
dy = yf - yi;
tracePixel(x,y,Color.red);
cumul = dx >> 1;
for ( x = xi+1 ; x <= xf ; x++ ) {
cumul += dy;
if (cumul >= dx) {
cumul -= dx;
y += 1;
tracePixel(x-1,y,Color.blue); }
tracePixel(x,y,Color.red); }
}
}
Encore un autre Afficheur implantant imparfaitement l'algorithme de Bresenham pour la rasterisation en 4-connexité de segments de droite 2D : Afficheur4Connexite1et2.java
import java.awt.*;
/**
* La classe <code>Afficheur4Connexite1et2</code> implante l'interface {@link Afficheur Afficheur}
* pour developper de maniere imparfaite une methode d'affichage d'un segment de droite 2D
* en 4-connexite au moyen de l'algorithme de Bresenham.
*
* @author Nicolas Janey
* @author nicolas.janey@univ-fcomte.fr
* @version 1.0, 12/11/08
*/
public class Afficheur4Connexite1et2 implements Afficheur {
private int tx;
private int ty;
private int zoom = 20;
private Graphics g;
/**
* Methode d'affichage executee en boucle infinie pour realiser l'affichage
* d'un objet en projection parallele orthographique.
*
* @param g l'objet <code>Graphics</code> d'affichage.
* @param numeroImage le nombre de fois ou cette methode a deja ete appelee.
* @param tx la largeur (en pixels) de la zone de dessin.
* @param ty la hauteur (en pixels) de la zone de dessin.
*/
public void paint(Graphics g,int numeroImage,int tx,int ty) {
g.drawString("4 connexité (1 & 2)",10,20);
this.tx = tx;
this.ty = ty;
this.g = g;
ligne(2,2,21,13);
g.setColor(Color.yellow);
g.drawLine((int) (2.5*zoom),(int) (ty-1.5*zoom),
(int) (21.5*zoom),(int) (ty-12.5*zoom));
}
private void tracePixel(int x,int y,Color c) {
// System.out.format("%3d %3d\n",x,y);
g.setColor(c);
g.fillRect(x*zoom,ty-y*zoom,zoom,zoom);
g.setColor(Color.black);
g.drawRect(x*zoom,ty-y*zoom,zoom,zoom);
}
/* xf > xi */
/* yf > yi */
/* xf-xi > yf-yi */
private void ligne(int xi,int yi,int xf,int yf) {
int dx,dy;
int cumul;
int x,y;
x = xi;
y = yi;
dx = xf - xi;
dy = yf - yi;
tracePixel(x,y,Color.red);
cumul = dx >> 1;
for ( x = xi+1 ; x <= xf ; x++ ) {
cumul += dy;
if (cumul >= dx) {
cumul -= dx;
y += 1;
tracePixel(x-1,y,Color.blue);
tracePixel(x,y-1,Color.green); }
tracePixel(x,y,Color.red); }
}
}
Un Afficheur implantant correctement l'algorithme de Bresenham pour la rasterisation en 4-connexité de segments de droite 2D : Afficheur4Connexite.java
import java.awt.*;
/**
* La classe <code>Afficheur4Connexite</code> implante l'interface {@link Afficheur Afficheur}
* pour developper de maniere correcte une methode d'affichage d'un segment de droite 2D
* en 4-connexite au moyen de l'algorithme de Bresenham.
*
* @author Nicolas Janey
* @author nicolas.janey@univ-fcomte.fr
* @version 1.0, 12/11/08
*/
public class Afficheur4Connexite implements Afficheur {
private int tx;
private int ty;
private int zoom = 20;
private Graphics g;
/**
* Methode d'affichage executee en boucle infinie pour realiser l'affichage
* d'un objet en projection parallele orthographique.
*
* @param g l'objet <code>Graphics</code> d'affichage.
* @param numeroImage le nombre de fois ou cette methode a deja ete appelee.
* @param tx la largeur (en pixels) de la zone de dessin.
* @param ty la hauteur (en pixels) de la zone de dessin.
*/
public void paint(Graphics g,int numeroImage,int tx,int ty) {
g.drawString("4 connexité",10,20);
this.tx = tx;
this.ty = ty;
this.g = g;
ligne(2,2,21,13);
g.setColor(Color.yellow);
g.drawLine((int) (2.5*zoom),(int) (ty-1.5*zoom),
(int) (21.5*zoom),(int) (ty-12.5*zoom));
}
private void tracePixel(int x,int y,Color c) {
// System.out.format("%3d %3d\n",x,y);
g.setColor(c);
g.fillRect(x*zoom,ty-y*zoom,zoom,zoom);
g.setColor(Color.black);
g.drawRect(x*zoom,ty-y*zoom,zoom,zoom);
}
/* xf > xi */
/* yf > yi */
/* xf-xi > yf-yi */
private void ligne(int xi,int yi,int xf,int yf) {
int dx,dy;
int cumul;
int x,y;
x = xi;
y = yi;
dx = xf - xi;
dy = yf - yi;
tracePixel(x,y,Color.red);
cumul = dx >> 1;
for ( x = xi+1 ; x <= xf ; x++ ) {
cumul += dy;
if (cumul >= dx) {
cumul -= dx;
y += 1;
if ( cumul > (dy>>1) )
tracePixel(x-1,y,Color.blue);
else
tracePixel(x,y-1,Color.green); }
tracePixel(x,y,Color.red); }
}
}
RETOUR