Lignes

Cette fiche présente la méthode de dessin des lignes utilisée par Up ! Picture lors de l'interprétation des ordres de dessin d'Up ! Graphical Engine.

Nous rappelons que, pour Up ! Graphical Engine, le repère de coordonnées est orienté de :

La gauche vers la droite en abscisse.
Le haut vers le bas en ordonnée.

Principe du dessin d'une ligne sur une image Bitmap

La méthode de calcul doit être la plus simple et la plus rapide possible. Pour cela, nous évitons au maximum les calculs en nombres réels, les multiplications et les divisions.

Modèle de l'image

L'objectif est de tracer une ligne sur une image qui est formée de pixels aux coordonnées entières.

Une image est Bitmap est organisée en lignes de pixels modélisées par un tableau d'octets. Selon la palette, un pixel nécessite d'une fraction d'octet à plusieurs octets.

De ce fait, il est plus simple et efficace de tracer :

Une ligne élémentaire horizontale qu'une suite de points contigus à l'horizontal.
Des lignes élémentaires horizontales que des lignes élémentaires verticales.

Ainsi, nous utiliserons deux fonctions :

DessinerLigneElementaire.
Elle permet de tracer une ligne élementaire horizontale sur l'image par calcul des valeurs des octets selon la palette.
DessinerPointElementaire.
Elle permet de tracer un point élementaire sur l'image par calcul des valeurs des octets selon la palette.

De plus, nous joignons les lignes élémentaires de même ordonnée pour n'en tracer qu'une seule.

Caractéristiques de la ligne

Soit la ligne à tracer du point P1 de coordonnées (P1.x, P1.y) au point P2 de coordonnées (P2.x, P2.y). Nous supposons que :

La ligne n'est pas horizontale.
Une ligne horizontale est caractérisée par P1.y==P2.y. Elle est triviale à tracer.
La ligne n'est pas verticale.
Une ligne verticale est caractérisée par P1.x==P2.x. Elle est triviale à tracer.
La ligne est descendante.
Une ligne montante est caractérisée par P1.x<P2.x Et P1.y<P2.y. Les autres cas de figure se déduisent par symétrie horizontale ou verticale.

Quitte à faire une translation de (P1.x, P1.y), l'équation de la droite est a*X + b*Y = 0.

Cela revient donc, après translation, à tracer la ligne du point de coordonnées (0, 0) au point de coordonnées (P2.x - P1.x, P2.y - P1.y). Nous prenons :

a = P2.y - P1.y = DeltaY.
b = -(P2.x - P1.x) = - DeltaX.

Nous constatons que :

a est positif.
b est négatif.

Ligne à parcours horizontal

Une ligne est dite à parcours horizontal si sa pente est inférieure ou égale à un. Elle s'étend donc plus en largeur qu'en hauteur i.e. DeltaX>DeltaY.

Pour la dessiner, les pixels sont parcourus de l'abscisse P1.x à P2.x. L'ordonnée du premier pixel commence à P1.y.

Pour un point (Pi.x, Pi.y) tracé, compte tenu de l'alignement sur la grille des pixels, la question est de savoir si le prochain point à tracer est soit :

(Pi.x + 1, Pi.y) - On reste sur la même ordonnée en se décalant à gauche.
(Pi.x + 1, Pi.y + 1) - On descend en se décalant à gauche.

Pour cela, nous évaluons une erreur d'alignement donnée par la distance à la ligne calculée par application de l'équation de la droite :

ErreurY(Pi.x + 1, Pi.y) = a * (Pi.x + 1) + b * Pi.y = (a * Pi.x + b * Pi.y) + a = ErreurY(Pi.x, Pi.y) + a.
ErreurY(Pi.x + 1, Pi.y + 1) = a * (Pi.x + 1) + b * (Pi.y + 1) = (a * Pi.x + b * Pi.y) + a = ErreurY(Pi.x, Pi.y) + a + b.

Donc :

ErreurY(Pi.x + 1, Pi.y) + b = ErreurY(Pi.x + 1, Pi.y + 1).
ErreurY(Pi.x + 1, Pi.y) < ErreurY(Pi.x + 1, Pi.y + 1) puisque b est négatif.

L'erreur moyenne est donc de -b/2 en valeur absolue. Le principe est alors :

Tant que l'erreur cumulée ne dépasse pas cette moyenne, nous choisissons le pixel (Pi.x + 1, Pi.y).
On reste sur la même ordonnée en se décalant à gauche et on cumule l'erreur.
Dès que l'erreur cumulée dépasse cette moyenne, nous choisissons le pixel (Pi.x + 1, Pi.y + 1).
On descend en se décalant à gauche et on recale l'erreur de b après cumul.

L'erreur initiale est initialisée à l'opposée de l'erreur moyenne, b/2. Elle est négative et elle augmente à chaque itération. Le test de dépassement devient Erreur >= 0.

Ligne à parcours vertical

Une ligne est dite à parcours vertical si sa pente est supérieure ou égale à un. Elle s'étend donc plus en hauteur qu'en largeur i.e. DeltaX<DeltaY.

Pour la dessiner, les pixels sont parcourus de l'ordonnée P1.y à P2.y. L'abscisse du premier pixel commence à P1.x.

Pour un point (Pi.x, Pi.y) tracé, compte tenu de l'alignement sur la grille des pixels, la question est de savoir si le prochain point à tracer est soit :

(Pi.x, Pi.y + 1) - On reste sur la même abscisse en descendant.
(Pi.x + 1, Pi.y + 1)- On se décale à gauche en descendant.

Pour cela, nous évaluons une erreur d'alignement donnée par la distance à la ligne calculée par application de l'équation de la droite :

ErreurX(Pi.x, Pi.y + 1) = a * Pi.x + b * (Pi.y + 1) = (a * Pi.x + b * Pi.y) + b = ErreurX(Pi.x, Pi.y) + b.
ErreurX(Pi.x + 1, Pi.y + 1) = a * (Pi.x + 1) + b * (Pi.y + 1) = (a * Pi.x + b * Pi.y) + a = ErreurX(Pi.x, Pi.y) + a + b.

Donc :

ErreurX(Pi.x, Pi.y + 1) + a = ErreurX(Pi.x + 1, Pi.y + 1).
ErreurX(Pi.x, Pi.y + 1) > ErreurX(Pi.x + 1, Pi.y + 1) puisque a est positif.

L'erreur moyenne est donc de a/2 en valeur absolue. Le principe est alors :

Tant que l'erreur cumulée ne dépasse pas cette moyenne, nous choisissons le pixel (Pi.x, Pi.y + 1).
On reste sur la même abscisse en descendant et on cumule l'erreur.
Dès que l'erreur cumulée dépasse cette moyenne, nous choisissons le pixel (Pi.x + 1, Pi.y + 1).
On se décalage à gauche en descendant et on recale l'erreur de a après cumul.

L'erreur initiale est initialisée à l'opposée de l'erreur moyenne -a/2. Elle est négative et elle augmente à chaque itération. Le test de dépassement devient Erreur >= 0.

Algorithme du dessin d'une ligne sur une image Bitmap

L'algorithme est écrit en Up ! 5GL pour faciliter sa lisibilité.

Procedure DessinerLigne(P1 : Nul Ou Point, P2 : Nul Ou Point) /***********************************************************/ Variable /******/


	DeltaX : Entier;

	DeltaY : Entier;

	X : Entier;

	X1 : Entier;

	X2 : Entier;

	Y : Entier;

	ProgressionX : Entier;

	ProgressionY : Entier;

	ErreurX : Entier;

	ErreurY : Entier;

	CorrectionErreurX : Entier;

	CorrectionErreurY : Entier;

	Longueur : Entier;




/* Calcul de DeltaY i.e. a. */

DeltaY=P2.Y-P1.Y;

Si DeltaY>0 Alors

	ProgressionY=1;

Sinon

	ProgressionY=-1;

	DeltaY=-DeltaY;

Fin Si



/* Calcul de DeltaX i.e. b. */

DeltaX=P2.X-P1.X;

Si DeltaX>0 Alors

	ProgressionX=1;

Sinon

	ProgressionX=-1;

	DeltaX=-DeltaX;

Fin Si



Si DeltaY==0 Alors

/* Cas trivial de la ligne horizontale. */


	X=P1.X;

	Y=P1.Y;

	Longueur=P2.X-P1.X+1;

	DessinerLigneElementaire(X, Y, Longueur);

	Retourner;


Fin Si



Si Delta==0 Alors

/* Cas trivial de la ligne verticale. */


	X=P1.X;

	Pour Y=P1.Y JusquA P2.Y Pas ProgressionY Faire
	
		DessinerPointElementaire(X, Y);

	
	Fin Pour

	Retourner;


Fin Si



Si DeltaX>DeltaY Alors

/* Ligne a parcours horizontal. */


	ErreurY=-DeltaX/2;

	X1=P1.X;

	X2=P1.X;

	Y=P1.Y;

	Pour X=P1.X JusquA P2.X Pas ProgressionX Faire
	
		/* Progression dans la ligne. */

		ErreurY+=DeltaY;

		Si ErreurY>=0 Alors
		
			/* Changement d'ordonnée. Vidage de la portion de ligne. */

			Si X1<Alors
			
				Longueur=X2-X1+1;

				DessinerLigneElementaire(X1, Y, Longueur);

			
			Sinon
			
				Longueur=X1-X2+1;

				DessinerLigneElementaire(X2, Y, Longueur);

			
			X1=P1.X;

			X2=P1.X;

			Y+=ProgressionY;

			ErreurY-=DeltaX;
		
		Sinon
		
			X2+=ProgressionX;
		
		Fin Si
	
	Fin Pour

	/* Vidage du résidu de la ligne. */

	Si X1<Alors
	
		Longueur=X2-X1+1;

		DessinerLigneElementaire(X1, Y, Longueur);

	
	Sinon
	
		Longueur=X1-X2+1;

		DessinerLigneElementaire(X2, Y, Longueur);

	

Sinon

/* Ligne a parcours vertical. */


	ErreurX=-DeltaY/2;

	X=P1.X;

	Pour Y=P1.Y JusquA P2.Y Pas ProgressionY Faire
	
		DessinerPointElementaire(X, Y);

		/* Progression dans la ligne. */

		ErreurX+=DeltaX;

		Si ErreurX>=0 Alors
		
			X+=ProgressionX;

			ErreurX-=DeltaY;
		
		Fin Si
	
	Fin Pour

Fin Si

Fin Procedure

Gestion de l'épaisseur d'une ligne sur une image Bitmap

L'algorithme précédent ne permet de tracer que des lignes épaisses d'un pixel, ce qui est rarement le cas !

Voici un exemple de quatre lignes épaissent de quatre pixels :

Les lignes rouges correspondent à ce que tracerait l'algorithme précédent.
Les lignes noires correspondent à ce qu'il faut tracer après modification de cet algorithme.
Les points bleus matérialise les points P1 et P2 délimitant le début et la fin d'une ligne.

L'épaisseur Epaisseur est répartie de part et d'autre de la ligne sur son orthogonale. Par convention, en cas d'un nombre pair de pixels, il y a une épaisseur de pixels de plus au dessous ou à gauche qu'au dessus ou à droite.

Nous supposons toujours que :

La ligne n'est pas horizontale.
La ligne n'est pas verticale.
La ligne est descendante.

Calcul des épaisseurs

La ligne est dessinée par épaisseur de lignes élémentaires de pixels. Chaque épaisseur est définie par deux abscisse X1 et X2 pour une ordonnée Y.

Chaque point à dessiner de l'algorithme DessinerLigne devient un ensemble d'épaisseurs à dessiner. Ces dernières se décalent de façon orthogonale au mouvement du curseur au point (X, Y) de la ligne. Ainsi, il y a un changement d'épaisseur quand il y a une variation de X.

Dans un premier temps, les épaisseurs de référence EpaisseursReference sont calculées à partir du principe de l'algorithme DessinerLigne à partir du point fictif (0, 0).

Le nombre d'épaisseurs est calculé avec la relation de Pythagore, à savoir X^2 + Y^2 = EpaisseurLigne^2.

En pratique, du fait des nombres entiers, nous minimisons |X^2 + Y^2 - EpaisseurLigne^2|. Le test d'arrêt est l'atteinte de ce minimum.

Ainsi, EpaisseursReference et EpaisseursADessiner sont des tableaux de taille au plus Epaisseur éléments.

Le tableau EpaisseursADessiner est exploité par rotation de l'index Index. Une place est libérée en traçant la plus veille épaisseur avant de mémoriser la plus récente.

Second algorithme du dessin d'une ligne sur une image Bitmap

L'algorithme est écrit en Up ! 5GL pour faciliter sa lisibilité.

Type Epaisseur Defaut /*******************/


	X1 : Entier;

	X2 : Entier;

	Y : Entier;

	Constructeur();


Fin Type



Procedure DessinerLigne(P1 : Nul Ou Point, P2 : Nul Ou Point, EpaisseurLigne : Entier=1)

/**************************************************************************************/

Variable

/******/

	DeltaX : Entier;

	DeltaY : Entier;

	X : Entier;

	X1 : Entier;

	X2 : Entier;

	Y : Entier;

	ProgressionX : Entier;

	ProgressionY : Entier;

	ErreurX : Entier;

	ErreurY : Entier;

	CorrectionErreurX : Entier;

	CorrectionErreurY : Entier;

	NbReferences : Entier;

	EpaisseursReference : Nul Ou TableauDe  Epaisseur;

	EpaisseursADessiner : Nul Ou TableauDe Epaisseur;

	EpaisseurCarre : Entier;

	Epaisseur1 : Entier;

	Epaisseur2 : Entier;

	Longueur : Entier;

	Index : Entier;

	IndexPrecedent : Entier;

	Distance : Entier;

	DistancePrecedente : Entier;

	DecalageX : Entier;

	DecalageY : Entier;

	I : Entier;



/* Calcul de DeltaY i.e. de a. */

DeltaY=P2.Y-P1.Y;

Si DeltaY>0 Alors

	ProgressionY=1;

Sinon

	ProgressionY=-1;

	DeltaY=-DeltaY;

Fin Si



/* Calcul de DeltaX i.e. de b. */

DeltaX=P2.X-P1.X;

Si DeltaX>0 Alors

	ProgressionX=1;

Sinon

	ProgressionX=-1;

	DeltaX=-DeltaX;

Fin Si



Si DeltaY==0 Alors

/* Cas trivial de la ligne horizontale. */


	Epaisseur1=EpaisseurLigne/2;

	Epaisseur2=EpaisseurLigne-Epaisseur1;

	Si P1.X<P2.X Alors
	
		X=P1.X;

		Longueur=P2.X-P1.X;
	
	Sinon
	
		X=P2.X;

		Longueur=P1.X-P2.X;
	
	Fin Si

	Y=P1.Y;

	Pour Y=P1.Y-Epaisseur1 JusquA P1.Y+Epaisseur2 Pas 1 Faire
	
		DessinerLigneElementaire(X, Y, Longueur);

	
	Fin Pour

	Retourner;


Fin Si



Si Delta==0 Alors

/* Cas trivial de la ligne verticale. */


	X=P1.X-EpaisseurLigne/2;

	Longueur=EpaisseurLigne;

	Pour Y=P1.Y JusquA P2.Y Pas ProgressionY Faire
	
		DessinerLigneElementaire(X, Y, Longueur);

	
	Fin Pour

	Retourner;


Fin Si



EpaisseursReference=Tableau(Epaisseur, EpaisseurLigne, Epaisseur());

EpaisseursADessiner=Tableau(Epaisseur, EpaisseurLigne, Epaisseur());

EpaisseurCarre=EpaisseurLigne*EpaisseurLigne;

/* Calcul des references des epaisseurs. */

X=0;

Y=0;

DistancePrecedente=EpaisseurCarre;

Si DeltaX>DeltaY Alors

/* Ligne a parcours horizontal. */


	NbReferences=-1;

	ErreurY=-DeltaX/2;

	TantQue Vrai Faire
	
		/* Calcul de la distance. */

		Distance=X^2 + Y^2 - EpaisseurCarre;

		Si Distance<0 Alors
		
			Distance=-Distance;
		
		Fin Si

		Si Distance>DistancePrecedente Alors

		/* Le minimum de la distance est atteint. */
		
			Arreter;
		
		Fin Si

		Distance=DistancePrecedente;

		EpaisseursReference[++NbReferences].X1=-Y;

		EpaisseursReference[NbReferences].X2=-Y;

		EpaisseursReference[NbReferences].Y=X;

		/* Progression dans la ligne. */

		ErreurY+=DeltaY;

		Si ErreurY>=0 Alors
		
			Y+=ProgressionY;

			ErreurY-=DeltaX;
		
		Fin Si

		X+=ProgressionX;

	
	Fin Pour

Sinon

/* Ligne a parcours vertical. */


	NbReferences=0;

	EpaisseursReference[0].X1=0;

	EpaisseursReference[0].X2=0;

	EpaisseursReference[0].Y=0;

	ErreurX=-DeltaY/2;

	TantQue Vrai Faire
	
		/* Calcul de la distance. */

		Distance=X^2 + Y^2 - EpaisseurCarre;

		Si Distance<0 Alors
		
			Distance=-Distance;
		
		Fin Si

		Si Distance>DistancePrecedente Alors

		/* Le minimum de la distance est atteint. */
		
			Arreter;
		
		Fin Si

		Distance=DistancePrecedente;

		/* Progression dans la ligne. */

		ErreurX+=DeltaX;

		Si ErreurX>=0 Alors
		
			EpaisseursReference[++NbReferences].X1=-Y;

			EpaisseursReference[NbReferences].X2=-Y;

			EpaisseursReference[NbReferences].Y=X;

			X+=ProgressionX;

			ErreurX-=DeltaY;

		
		Sinon
		
			EpaisseursReference[NbReferences].X2+=ProgressionX;

		
		Fin Si

		Y+=ProgressionY;

	
	Fin TantQue


Fin Si



/* Repartition des epaisseurs de part et d'autre de la ligne. */

Si NbReferences%2 Alors

	Index=(NbReferences/2)+1;


Sinon

	Index=NbReferences/2;


Fin Si

DecalageX=(EpaisseursReference[Index].X1+EpaisseursReference[Index].X2)/2;

DecalageY=EpaisseursReference[Index].Y/2;

Pour Index=0 JusquA NbReferences Pas 1 Faire

	EpaisseursReference[Index].X1-=DecalageX;

	EpaisseursReference[Index].X2-=DecalageX;

	EpaisseursReference[Index].Y-=DecalageY;

Fin Pour



/* Parcours de la ligne. */

Si DeltaX>DeltaY Alors

/* Ligne a parcours horizontal. */


	ErreurY=-DeltaX/2;

	X=P1.X;

	Y=P1.Y;

	/* Premieres epaisseurs. */

	Pour Index=0 JusquA NbReferences Pas 1 Faire
	
		EpaisseursADessiner[Index].X1=X+EpaisseursReference[Index].X1;

		EpaisseursADessiner[Index].X2=X+EpaisseursReference[Index].X2;

		EpaisseursADessiner[Index].Y=Y+EpaisseursReference[Index].Y;

	
	Fin Pour

	IndexPrecedent=-1;

	Pour X=P1.X JusquA P2.X Pas ProgressionX Faire
	
		/* Progression dans la ligne. */

		ErreurY+=DeltaY;

		Si ErreurY>=0 Alors
		
			/* Libere de la place pour la nouvelle epaisseur en vidant la plus ancienne. */

			Si IndexPrecedent==NbReferences Alors
			
				Index=0;
			
			Sinon
			
				Index=IndexPrecedent+1;
			
			Fin Si

			Si EpaisseursADessiner[Index].X1<EpaisseursADessiner[Index].X2 Alors
			
				Longueur=EpaisseursADessiner[Index].X2-EpaisseursADessiner[Index].X1+1;

				DessinerLigneElementaireHorizontale(EpaisseursADessiner[Index].X1, EpaisseursADessiner[Index].Y, Longueur);

			
			Sinon
			
				Longueur=EpaisseursADessiner[Index].X1-EpaisseursADessiner[Index].X2+1;

				DessinerLigneElementaireHorizontale(EpaisseursADessiner[Index].X2, EpaisseursADessiner[Index].Y, Longueur);

			
			Fin Si

			Y+=ProgressionY;

			ErreurY-=DeltaX;

			Si NbReferences>0 Alors

			/* Concatenation des epaisseurs precedentes et des courantes. */
			
				IndexPrecedent=Index;

				Pour I=0 JusquA NbReferences-1 Pas 1 Faire
				
					Si IndexPrecedent==NbReferences Alors
					
						IndexPrecedent=0;

					
					Sinon
					
						IndexPrecedent++;

					
					Fin Si

					X1=X+EpaisseursReference[I].X1;

					Si EpaisseursADessiner[IndexPrecedent].X1>X1 Alors
					
						EpaisseursADessiner[IndexPrecedent].X1=X1;
					
					Fin Si

					X2=X.EpaisseursReference[I].X2;

					Si EpaisseursADessiner[IndexPrecedent].X2<X2 Alors
					
						EpaisseursADessiner[IndexPrecedent].X2=X2;
					
					Fin Si

				
				Fin Pour
			
			Fin Si

			/* Ajout de la nouvelle epaisseur. */

			EpaisseursADessiner[Index].X1=X+PReference[NbReferences].X1;

			EpaisseursADessiner[Index].X2=X+PReference[NbReferences].X2;

			EpaisseursADessiner[Index].Y=Y+PReference[NbReferences].Y;

			IndexPrecedent=Index;
		
		SinonSi IndexPrecedent==-1 Alors
		
			IndexPrecedent=NbReferences;
		
		Sinon
		
			/* Prolongation des epaisseurs precedentes. */

			Pour I=0 JusquA NbReferences Pas 1 Faire
			
				EpaisseursADessiner[Index].X2+=ProgressionX;

			
			Fin Pour
		
		Fin Si
	
	Fin Pour

Sinon

/* Ligne a parcours vertical. */


	ErreurX=-DeltaY/2;

	X=P1.X;

	IndexPrecedent=-1;

	Pour Y=P1.Y JusquA P2.Y Pas ProgressionY Faire
	
		Si IndexPrecedent==-1 Alors
		
			/* Premieres epaisseurs. */

			Pour Index=0 JusquA NbReferences Pas 1 Faire
			
				EpaisseursADessiner[Index].X1=X+EpaisseursReference[Index].X1;

				EpaisseursADessiner[Index].X2=X+EpaisseursReference[Index].X2;

				EpaisseursADessiner[Index].Y=Y+EpaisseursReference[Index].Y;

			
			Fin Pour

			IndexPrecedent=NbReferences;
		
		Sinon
		
			/* Libere de la place pour la nouvelle epaisseur en vidant la plus ancienne. */

			Si IndexPrecedent==NbReferences Alors
			
				Index=0;
			
			Sinon
			
				Index=IndexPrecedent+1;
			
			Fin Si

			Si EpaisseursADessiner[Index].X1<EpaisseursADessiner[Index].X2 Alors
			
				Longueur=EpaisseursADessiner[Index].X2-EpaisseursADessiner[Index].X1+1;

				DessinerLigneElementaireHorizontale(EpaisseursADessiner[Index].X1, EpaisseursADessiner[Index].Y, Longueur);

			
			Sinon
			
				Longueur=EpaisseursADessiner[Index].X1-EpaisseursADessiner[Index].X2+1;

				DessinerLigneElementaireHorizontale(EpaisseursADessiner[Index].X2, EpaisseursADessiner[Index].Y, Longueur);

			
			Fin Si

			Si NbReferences>1 Alors

			/* Concatenation des epaisseurs precedentes et des courantes. */
			
				IndexPrecedent=Index;

				Pour I=0 JusquA NbReferences-1 Pas 1 Faire
				
					Si IndexPrecedent==NbReferences Alors
					
						IndexPrecedent=0;

					
					Sinon
					
						IndexPrecedent++;

					
					Fin Si

					X1=X+EpaisseursReference[I].X1;

					Si EpaisseursADessiner[IndexPrecedent].X1>X1 Alors
					
						EpaisseursADessiner[IndexPrecedent].X1=X1;
					
					Fin Si

					X2=X.EpaisseursReference[I].X2;

					Si EpaisseursADessiner[IndexPrecedent].X2<X2 Alors
					
						EpaisseursADessiner[IndexPrecedent].X2=X2;
					
					Fin Si

				
				Fin Pour
			
			Fin Si

			/* Ajout de la nouvelle epaisseur. */

			EpaisseursADessiner[Index].X1=X+EpaisseursReference[NbReferences].X1;

			EpaisseursADessiner[Index].X2=X+EpaisseursReference[NbReferences].X2;

			EpaisseursADessiner[Index].Y=Y+EpaisseursReference[NbReferences].Y;

			IndexPrecedent=Index;
		
		Fin Si

		/* Progression dans la ligne. */

		ErreurX+=DeltaX;

		Si ErreurX>=0 Alors
		
			X+=ProgressionX;

			ErreurX-=DeltaY;
		
		Fin Si
	
	Fin Pour


Fin Si



/* Vidage des epaisseurs residuelles. */

Pour I=0 JusquA NbReferences Pas 1 Faire

	Si IndexPrecedent==NbReferences Alors
	
		IndexPrecedent=0;

	
	Sinon
	
		IndexPrecedent++;

	
	Si EpaisseursADessiner[Index].X1<EpaisseursADessiner[Index].X2 Alors
	
		Longueur=EpaisseursADessiner[Index].X2-EpaisseursADessiner[Index].X1+1;

		DessinerLigneElementaireHorizontale(EpaisseursADessiner[Index].X1, EpaisseursADessiner[Index].Y, Longueur);

	
	Sinon
	
		Longueur=EpaisseursADessiner[Index].X1-EpaisseursADessiner[Index].X2+1;

		DessinerLigneElementaireHorizontale(EpaisseursADessiner[Index].X2, EpaisseursADessiner[Index].Y, Longueur);

	
	Fin Si

	IndexPrecdent=Index;

Fin Pour

Fin Procedure