Faire des jolies traits

[TrizoLakai]

Bonjour :)
Je n'arive pas a tracer des traits sous SDL. Existe t-il une commande toute simple ou non?

Sinon voila le résultat que je vourdrai avoir
http://img65.imageshack.us/img65/8177/droite0kb.th.png (http://img65.imageshack.us/my.php?image=droite0kb.png)
(je vous conseil d'agrandir).
La grille représente les pixels de votre écran, la ligne rougle la droite d'équation y = 3/4x et en vert les pixels qui devraient être allumés.

Voila où je me trouve dans mes recherche. Cette technique ne fonctionne que quand la droite s'approche relativement prés des axes.

Pour y = (56/429)x :

56/429 = 0,13
1 - 0,13 = 0,9

Résultat : On avance de 9 pixels quand on descend de 1pixel.

A savoir que la méthode fonctionne pour les nombres > 0. Dans ce cas on inverse la fraction, on applique la même méthode mais la phrase de fin est inversé.


Voila, j'aimerais avoir vos siggestions et idées ici. Merci de votre aide.

[MrCool]

Non, il n'y a pas de fonctions pour tracer directement une ligne mais les surcouches de SDL doivent le gérer (cf site officiel).

Au pire ça se code soit-même avec l'algorithme du point milieu (google est ton ami!).

Et tant qu'on y est un livre que j'ai beaucoup aimé: Algorithmes pour la synthèse d'image et l'animation 3d (Rémy Malgouyres chez Dunod).

[TrizoLakai]

Merci, je crois avoir trouvé un site de maths qui explique cela :

http://www-fourier.ujf-grenoble.fr/~parisse/giac/doc/fr/casrouge/node255.html

Je l'étudierai ce soir ;)

[HanLee]

Est ce que l'algorithme du point milieu est l'autre nom de l'algorithme de Bresenham ?

[remram44]

Tracer une ligne (made in me, citation du code source de SRT) :

// Fonction qui retourne max(abs(a),abs(b))
int abs_max(int a,int b)
{
if(a<0)
a=-a;
if(b<0)
b=-b;
return (a<b)?b:a;
}

// Fonction qui dessine un pixel
void dot(SDL_Surface * surf,int x,int y,Uint32 color)
{
SDL_Rect rect;
rect.x=x;
rect.y=y;
rect.w=1;
rect.h=1;

SDL_FillRect(surf,&rect,color);
}

// Fonction pour tracer une ligne droite
void DrawLine(SDL_Surface * surf,int x1,int y1,int x2,int y2,Uint32 color)
{
int div,i;

// Pos contient la position actuelle sur la ligne
// Move contient le vecteur qui est ajouté à pos pour passer au pixel suivant
f_vecteur2D pos,move;

// Position de départ
pos.x=x1;
pos.y=y1;

// Déplacement maxi
move.x=x2-x1;
move.y=y2-y1;

// On divise ce déplacement par la plus grande différence de coordonnées
div = abs_max(x2-x1,y2-y1);
move.x=move.x/div;
move.y=move.y/div;

// Maintenant, on boucle DIV fois
for(i=0;i<div;i+=1)
{
// Point
dot(surf,(int)pos.x,(int)pos.y,color);

// On avance
pos.x+=move.x;
pos.y+=move.y;
}
}

[MrCool]

L'algo de Bresenham semble être celui dont je parle. Il s'approche également de ce que fait remram je pense (dsl je manque de temps pour voir cela en détail ^^).

[bougie]

y'as SDL_gfx qui permet de faire ça :)

[remram44]

Franchement pour un algo aussi simple... Je pense que le faire soi-même n'est pas une mauvaise solution.
(bon, d'accord, je refais beaucoup de choses moi-même mais...)

Sinon, pour mon algo, je connais pas ceux dont vous parlez, le mien je l'ai fais au filling', mais ça me paraissait le plus simple et le plus rapide.

[HanLee]

Franchement pour un algo aussi simple... Je pense que le faire soi-même n'est pas une mauvaise solution.
(bon, d'accord, je refais beaucoup de choses moi-même mais...)

Sinon, pour mon algo, je connais pas ceux dont vous parlez, le mien je l'ai fais au filling', mais ça me paraissait le plus simple et le plus rapide.

Aussi simple... cet algo il est pas forcément évident pour tout le monde, parce que c'est faire le lien entre le discret et le continu... On cherche le truc qui se rapproche le plus de la représentation réelle...
T'as calculé comme quoi ton algo donnait la représentation la plus proche possible ? ;)

[TrizoLakai]

J'aurai peut etre quelque question à poser :D
Avant : Remram où pèches tu cela : f_vecteur2D ?


merci pour toute vos réponses ;)

[remram44]

f_vecteur2D est une structure toute simple (excuse-moi, c'est une structure maison, et comme j'ai pris un bout d'un jeu j'ai oublié de regarder les dépendances) :

// Version C++
class f_vecteur2D {
public:
double x,y;
};

// Version C
typedef struct {
double x,y;
} f_vecteur2D;

[TrizoLakai]

Daccord merci.

[MrCool]

Juste un mot pour ajouter qu'utiliser des double dans ce type d'operation ne me semble pas interessant: cela va fortement ralentir le trace (les calculs sur les float sont plus couteux que sur les int)... :)

[TrizoLakai]

J'avais vu mais merci de ton intention. ;)

[remram44]

Juste un mot pour ajouter qu'utiliser des double dans ce type d'operation ne me semble pas interessant: cela va fortement ralentir le trace (les calculs sur les float sont plus couteux que sur les int)... :)

Ici, avec un int ça marche pas :D Regarde mon algo ou teste, et tu vas comprendre.

[TrizoLakai]

Je l'ai compilé sous windows et il s'est bien lancé. :00000010:

[TrizoLakai]

Je ne comprend pas ce qu'est signe dans l'algo qui est la :

class Droite{
private:
int dx, dy, x, y, s1, s2;
bool PluscourtChemin();
void AllumerPixel();
public:
Droite();
void TracerDroite(int x1, int y1, int x2, int y2);
};

bool Droite::PluscourtChemin(){
if(dy > dx){
tmp = dx;
dx = dy;
dy = tmp;
e = 2*dy - dx
return true;
}

e = 2*dy - dx
return false;
}

void Droite::TracerDroite(int x1, int y1, int x2, int y2){
bool Echange = false;

x = x1;
y = y1;
dx = abs(x2-x1);
dy = abs(y2-y1);
s1 = signe(x2-x1); //Quesque signe?
s2 = signe(y2-y1); //Quesque signe?

Echange = PluscourtChemin();

for(int i = 0; i < dx; ++i){
AllumerPixel(x, y);
while(e > 0){
if(Echange){
x = x + s1;
}
else y = y + s2;
e = e - 2 * dx;
}
if(Echange)y = y + s2;
else x = x + s1;
e = e + 2 * dy;
}
}

Merci de bien vouloir m'expliquer. Cette algo est une adaptation de celui-ci :
http://fr.wikipedia.org/wiki/Algorithme_de_trac%C3%A9_de_segment_de_Bresenham

[TrizoLakai]

:lol: c'est bon. Voila le code pour ceux que ça interesse :

http://cppdesbwa.freezee.org/ClassesOutils/Droite