[Résolu] Comment lisser une image ?

[Le Soldat Inconnu]

mais G-Rom
Si ton image est 2 fois plus grande que l'image dont tu as besoin, tu réduis par 2 et tu obtiens du lissage. mais tu n'agrandis pas l'image par la suite

C'est une façon simple de dessiner un cercle lisser par exemple.
Tu le dessine 2 fois plus grand et ensuite tu réduit l'image.

[Backup]

C'est une façon simple de dessiner un cercle lisser par exemple.
Tu le dessine 2 fois plus grand et ensuite tu réduit l'image.

ben c'est toujours pas du lissage , c'est de la perte de données ..
si l'oeil humain , vois ça comme un "lissage" , c'est du a son imperfection ..

un robot,(ou une loupe ) verra ça comme un truc crado ...


il suffit de partir d'un icone 32x32 ( c'est a dire que la taille d'origine est tres faible ... )
de le reduire , pour se rendre compt que deja ça ne ressemble plus trop a l'originale ...


le principe du lissage, (Anti-aliasing ) c'est ça :

image non lissé :


image Lissé


c'est a dire qu'on ne retire pas de l'information , on transforme l'information existante ! ...


si votre bidouilles de changer la taille ; fonctionne en partie c'est due a 2 choses

1- l'oeil humain est grave pas tres au point
2- le fait de sauver vos images apres bidouille , souvent la Sauvegarde ajoute un lissage , (qualité du Jpg,Png )
qui fait qu'on peux croire que c'est l'effet de réduction ... il n'en est rien !

il suffit de passer sur un monitor de tres hautre résolution , pour voir aparaitres les" Manques " d'information due a la perte pendant la réduction ....
c'est sur que sur un monitor pourrave, ça va passer

l'avantage de l'anti-alias , c'est qu'on peux Augmenter la taille sans risque de voir la supercherie .. (il ne manquera pas d'informations par rapport a l'image d'origine )

[Le Soldat Inconnu]

@Dobro : La réduction d'une image revient à un calcul d'anti-alias simplifié. Et je précise qu'il dessiner l'image deux fois trop grande.
Exemple :

Code : Tout sélectionner

; Auteur : Le Soldat Inconnu
; Version de PB : 4.60

; Explication du programme :
; Lissage par réduction image

; Création de la fenêtre
If OpenWindow(0, 0, 0, 1000, 600, "Test", #PB_Window_SystemMenu | #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget) = 0
	End
EndIf

LoadFont(1, "arial", 10, #PB_Font_HighQuality)
LoadFont(2, "arial", 20, #PB_Font_HighQuality)
LoadFont(3, "arial", 40, #PB_Font_HighQuality)

CreateImage(1, 500, 300)
StartDrawing(ImageOutput(1))
	Circle(150, 150, 70, $FFFFFF)
	Line(300, 50, 200, 100, $FFFFFF)
	DrawingFont(FontID(1))
	DrawText(0, 0, "Sans lissage")
StopDrawing()

CreateImage(2, 1000, 600)
StartDrawing(ImageOutput(2))
	Circle(300, 300, 140, $FFFFFF)
	Line(600, 100, 400, 200, $FFFFFF)
	Line(600, 101, 400, 200, $FFFFFF) ; Ligne plus épaisse
	DrawingFont(FontID(2))
	DrawText(0, 0, "Avec lissage x2")
StopDrawing()
ResizeImage(2, 500, 300, #PB_Image_Smooth)

CreateImage(3, 2000, 1200)
StartDrawing(ImageOutput(3))
	Circle(600, 600, 280, $FFFFFF)
	Line(1200, 200, 800, 400, $FFFFFF)
	Line(1200, 201, 800, 400, $FFFFFF) ; Ligne plus épaisse
	Line(1200, 202, 800, 400, $FFFFFF) ; Ligne plus épaisse
	Line(1200, 203, 800, 400, $FFFFFF) ; Ligne plus épaisse
	DrawingFont(FontID(3))
	DrawText(0, 0, "Avec lissage x4")
StopDrawing()
ResizeImage(3, 500, 300, #PB_Image_Smooth)

ImageGadget(1, 0, 0, 500, 300, ImageID(1))
ImageGadget(2, 0, 300, 500, 300, ImageID(2))
ImageGadget(3, 500, 300, 500, 300, ImageID(3))

Repeat
	Event = WaitWindowEvent()
	
	Select Event
		Case #PB_Event_Menu
			Select EventMenu() ; Menus
					
			EndSelect
			
		Case #PB_Event_Gadget
			Select EventGadget() ; Gadgets
					
			EndSelect
	EndSelect
	
Until Event = #PB_Event_CloseWindow

On ne dis pas que c'est parfait mais c'est une solution facile à mettre en œuvre

- La sauvegarde n'apporte pas de lissage mais une perte de qualité du à la compression utilisée; En aucun cas le format JPG fait du lissage.
- L'anti-alias ne permet pas d'augmenter la taille sans perte de qualité. Le principe n'est pas pour cela. Le principe de l'anti-alias est de lisser les lignes et les bords par interpolation entre les pixels

[Le Soldat Inconnu]

voici un exemple de lissage par réduction d'image, je trouve ça pas mal :
(ce code vient du sujet Taillage d'engrenage sur ce fofo)
Il faut attendre un peu pour que le lissage ce mette en place après un changement. On voit bien la différence. Dans cette exemple, l'image réduite est 4 fois plus grande que l'originale. pour changer, il faut modifier "FiltreAA = 4" au début du code

Code : Tout sélectionner

; Auteur : Le Soldat Inconnu
; Version de PB : 4.40

; Explication du programme :
; Dessiner un engrenage


; Le filtre permet d'émuler de l'antialiasing sur le dessin de l'engrenage, ne pas mettre au dessus de 8
Global FiltreAA = 4, Dessin_Angle.d, Dessin_Zoom.d, Dessin.i


Enumeration
	; Paramètres
	#G_Module
	#G_Z
	#G_Angle_Pression
	#G_D_primitif
	#G_D_pied
	#G_D_tete
	#G_H_dent
	#G_Pas
	#G_Deport
	; Norme
	#G_H_pied
	#G_H_tete
	#G_R_chanfrein
	
	; Autres
	#G_Onglet
	#G_Zoom
	#G_Dessin
	#G_Angle
	
EndEnumeration

#Engrenage_ResolutionDent = 314
#Equation_Degree = 1
#Cremaillere_NbEquation = 7
#Engrenage_Couleur = $FF00FFFF
#Engrenage_Diametre = $200000FF
#Engrenage2_Couleur = $FF0000FF
#Cremaillere_Couleur = $40FFFFFF
#Cremaillere_Hauteur = $400000FF
Structure Structure_Cercle
	x.d
	y.d
	R.d
	Interieur.b
	Exterieur.b
EndStructure
Structure Structure_Equation
	x1.d
	x2.d
	v.d[#Equation_Degree + 1]
	c.Structure_Cercle
EndStructure
Structure Structure_Rayon
	R.d
	Angle.d
	Zone.b
EndStructure
Structure Structure_Engrenage
	Module.d
	Z.d
	D_primitif.d
	D_tete.d
	D_pied.d
	H_dent.d
	Angle_pression.d
	Pas.d
	Deport.d
	H_tete.d
	H_pied.d
	R_chanfrein.d
	Contour.Structure_Rayon[#Engrenage_ResolutionDent]
	Cremaillere.Structure_Equation[#Cremaillere_NbEquation]
	Outil.Structure_Equation[#Cremaillere_NbEquation]
EndStructure

Global Engrenage.Structure_Engrenage

Procedure.s AfficheValeur(Valeur.d)
	ProcedureReturn RTrim(RTrim(RTrim(StrD(Valeur), "0"), "."), ",")
EndProcedure

Procedure Engrenage_Calcul(*Calcul.Structure_Engrenage)
	With *Calcul
		;- Paramètres de l'engrenage
		\D_primitif = \Z * \Module
		\D_tete = \D_primitif + 2 * \H_tete * \Module
		\D_pied = \D_primitif - 2 * \H_pied * \Module
		\Pas = #PI * \Module
		\H_dent = (\H_tete + \H_pied) * \Module
		;- Equation de la crémaillère
		Largeur_zone_tete.d = \Pas / 2 - 2 * \H_tete * \Module * Sin(\Angle_pression * (#PI / 180))
		Largeur_zone_cercle.d = \R_chanfrein * \Module * Cos(\Angle_pression * (#PI / 180))
		Hauteur_zone_cercle.d = \R_chanfrein * \Module * (1 - Sin(\Angle_pression * (#PI / 180)))
		Largeur_zone_inclinee.d = (\H_dent - Hauteur_zone_cercle) * Sin(\Angle_pression * (#PI / 180))
		Largeur_zone_pied.d = \Pas - Largeur_zone_tete - 2 * Largeur_zone_cercle - 2 * Largeur_zone_inclinee
		; Zone 1
		\Cremaillere[0]\x1 = 0
		\Cremaillere[0]\x2 = Largeur_zone_tete / 2
		\Cremaillere[0]\v[0] = \H_dent
		; zone 2
		\Cremaillere[1]\x1 = \Cremaillere[0]\x2
		\Cremaillere[1]\x2 = \Cremaillere[1]\x1 + Largeur_zone_inclinee
		\Cremaillere[1]\v[1] = -1 / Sin(\Angle_pression * (#PI / 180))
		\Cremaillere[1]\v[0] = \H_dent - \Cremaillere[1]\v[1] * \Cremaillere[1]\x1
		; zone 3
		\Cremaillere[2]\x1 = \Cremaillere[1]\x2
		\Cremaillere[2]\x2 = \Cremaillere[2]\x1 + Largeur_zone_cercle
		;\ Cremaillere[2]\v[0] = Hauteur_zone_cercle
		\Cremaillere[2]\c\x = \Cremaillere[2]\x2
		\Cremaillere[2]\c\y = \R_chanfrein * \Module
		\Cremaillere[2]\c\R = \R_chanfrein * \Module
		\Cremaillere[2]\c\Interieur = 1
		; zone 4
		\Cremaillere[3]\x1 = \Cremaillere[2]\x2
		\Cremaillere[3]\x2 = \Cremaillere[3]\x1 + Largeur_zone_pied
		\Cremaillere[3]\v[0] = 0
		; zone 5
		\Cremaillere[4]\x1 = \Cremaillere[3]\x2
		\Cremaillere[4]\x2 = \Cremaillere[4]\x1 + Largeur_zone_cercle
		\Cremaillere[4]\c\x = \Cremaillere[4]\x1
		\Cremaillere[4]\c\y = \R_chanfrein * \Module
		\Cremaillere[4]\c\R = \R_chanfrein * \Module
		\Cremaillere[4]\c\Interieur = 1
		; Zone 6
		\Cremaillere[5]\x1 = \Cremaillere[4]\x2
		\Cremaillere[5]\x2 = \Cremaillere[5]\x1 + Largeur_zone_inclinee
		\Cremaillere[5]\v[1] = 1 / Sin(\Angle_pression * (#PI / 180))
		\Cremaillere[5]\v[0] = Hauteur_zone_cercle - \Cremaillere[5]\v[1] * \Cremaillere[5]\x1
		; Zone 7
		\Cremaillere[6]\x1 = \Cremaillere[5]\x2
		\Cremaillere[6]\x2 = \Pas
		\Cremaillere[6]\v[0] = \H_dent
		
		
		;- Equation de l'outil
		Largeur_zone_pied.d = \Pas / 2 - 2 * \H_tete * \Module * Sin(\Angle_pression * (#PI / 180))
		Largeur_zone_cercle.d = \R_chanfrein * \Module * Cos(\Angle_pression * (#PI / 180))
		Hauteur_zone_cercle.d = \R_chanfrein * \Module * (1 - Sin(\Angle_pression * (#PI / 180)))
		Largeur_zone_inclinee.d = (\H_dent - Hauteur_zone_cercle) * Sin(\Angle_pression * (#PI / 180))
		Largeur_zone_tete.d = \Pas - Largeur_zone_pied - 2 * Largeur_zone_cercle - 2 * Largeur_zone_inclinee
		; Zone 1
		\Outil[0]\x1 = 0
		\Outil[0]\x2 = Largeur_zone_tete / 2
		\Outil[0]\v[0] = \H_dent + (\H_pied - \H_tete) * \Module
		; Zone 2
		\Outil[1]\x1 = \Outil[0]\x2
		\Outil[1]\x2 = \Outil[1]\x1 + Largeur_zone_cercle
		\Outil[1]\c\x = \Outil[1]\x1
		\Outil[1]\c\y = \H_dent + (\H_pied - \H_tete) * \Module - \R_chanfrein * \Module
		\Outil[1]\c\R = \R_chanfrein * \Module
		\Outil[1]\c\Exterieur = 1
		; zone 3
		\Outil[2]\x1 = \Outil[1]\x2
		\Outil[2]\x2 = \Outil[2]\x1 + Largeur_zone_inclinee
		\Outil[2]\v[1] = -1 / Sin(\Angle_pression * (#PI / 180))
		\Outil[2]\v[0] = \H_dent + (\H_pied - \H_tete) * \Module - Hauteur_zone_cercle - \Outil[2]\v[1] * \Outil[2]\x1
		; zone 4
		\Outil[3]\x1 = \Outil[2]\x2
		\Outil[3]\x2 = \Outil[3]\x1 + Largeur_zone_pied
		\Outil[3]\v[0] = (\H_pied - \H_tete) * \Module
		; Zone 5
		\Outil[4]\x1 = \Outil[3]\x2
		\Outil[4]\x2 = \Outil[4]\x1 + Largeur_zone_inclinee
		\Outil[4]\v[1] = 1 / Sin(\Angle_pression * (#PI / 180))
		\Outil[4]\v[0] = (\H_pied - \H_tete) * \Module - \Outil[4]\v[1] * \Outil[4]\x1
		; Zone 6
		\Outil[5]\x1 = \Outil[4]\x2
		\Outil[5]\x2 = \Outil[5]\x1 + Largeur_zone_cercle
		\Outil[5]\c\x = \Outil[5]\x2
		\Outil[5]\c\y = \H_dent + (\H_pied - \H_tete) * \Module - \R_chanfrein * \Module
		\Outil[5]\c\R = \R_chanfrein * \Module
		\Outil[5]\c\Exterieur = 1
		; Zone 7
		\Outil[6]\x1 = \Outil[5]\x2
		\Outil[6]\x2 = \Pas
		\Outil[6]\v[0] = \H_dent + (\H_pied - \H_tete) * \Module
		
		; CopyMemory(@\Cremaillere, @\Outil, SizeOf(Structure_Equation) * #Cremaillere_NbEquation)
		
		; Reset de la taille de l'engrenage
		For x = 0 To #Engrenage_ResolutionDent - 1
			\Contour[x]\R = \D_tete / 2
			\Contour[x]\Angle = x * 2 * #PI / #Engrenage_ResolutionDent / \Z
		Next
		
	EndWith
EndProcedure

Procedure Engrenage_Diametre(*Calcul.Structure_Engrenage)
	With *Calcul
		If \Module > 0 And \Z > 0 And \Angle_pression > 0 And \D_pied > 0
			
			;- Calcul des rayons avec l'angle par défaut
			For x = 0 To #Engrenage_ResolutionDent - 1
				\Contour[x]\Angle.d = x * (2 * #PI / #Engrenage_ResolutionDent) / \Z
				x_reel.d = \D_primitif * \Contour[x]\Angle / 2
				
				While x_reel >= \Pas And \Pas > 0
					x_reel - \Pas
				Wend
				If x_reel < 0
					x_reel = 0
				EndIf
				For n = 0 To #Cremaillere_NbEquation - 1
					If x_reel >= \Outil[n]\x1 And x_reel < \Outil[n]\x2
						If \Outil[n]\c\R ; Cercle
							y_reel.d = \Outil[n]\c\y + \Outil[n]\c\R * (\Outil[n]\c\Exterieur - \Outil[n]\c\Interieur) * Sin(ACos((x_reel - \Outil[n]\c\x) / (\R_chanfrein * \Module)))
						Else ; Courbe
							CompilerIf #Equation_Degree = 1
								y_reel.d = \Outil[n]\v[0] + \Outil[n]\v[1] * x_reel
							CompilerElse
								y_reel.d = \Outil[n]\v[0]
								For nn = 1 To #Equation_Degree
									y_reel.d + \Outil[n]\v[nn] * Pow(x_reel, nn)
								Next
							CompilerEndIf
						EndIf
						Break
					EndIf
				Next
				
				\Contour[x]\R = (\D_primitif / 2 + \H_pied * \Module) + \Deport * \Module - y_reel
				If \Contour[x]\R > \D_tete / 2 + \Deport * \Module
					\Contour[x]\R = \D_tete / 2 + \Deport * \Module
				EndIf
				If \Contour[x]\R < \D_pied / 2 + \Deport * \Module
					\Contour[x]\R = \D_pied / 2 + \Deport * \Module
				EndIf
				
				If \Contour[x]\Angle < #PI / \Z
					\Contour[x]\Zone = 1
				Else
					\Contour[x]\Zone = 2
				EndIf
				
			Next
			
			;- Correction de l'angle
			
			; Centre de l'engrenage
			x_reel.d = 0
			y_reel.d = (\D_primitif / 2 + \H_pied * \Module) + \Deport * \Module
			
			Correction.d = (1 / #Engrenage_ResolutionDent) / \Z
			
			Rotation.d = #Engrenage_ResolutionDent * \Z / 4
			If Rotation < #Engrenage_ResolutionDent * 2
				Rotation = #Engrenage_ResolutionDent * 2
			EndIf
			
			For Z = -Rotation To Rotation
				
				Angle.d = Z * (2 * #PI / #Engrenage_ResolutionDent) / \Z
				Avance.d = \D_primitif * Angle / 2
				
				For x = 0 To #Engrenage_ResolutionDent - 1
					If \Contour[x]\R
						
						Repeat
							
							Angle_reel.d = \Contour[x]\Angle + Angle
							x1_reel.d = x_reel + \Contour[x]\R * Sin(Angle_reel) - Avance
							y1_reel.d = y_reel - \Contour[x]\R * Cos(Angle_reel)
							
							While x1_reel < 0 And \Pas > 0
								x1_reel + \Pas
							Wend
							While x1_reel >= \Pas And \Pas > 0
								x1_reel - \Pas
							Wend
							For n = 0 To #Cremaillere_NbEquation - 1
								If x1_reel >= \Outil[n]\x1 And x1_reel < \Outil[n]\x2
									If \Outil[n]\c\R ; Cercle
										y2_reel.d = \Outil[n]\c\y + \Outil[n]\c\R * (\Outil[n]\c\Exterieur - \Outil[n]\c\Interieur) * Sin(ACos((x1_reel - \Outil[n]\c\x) / (\R_chanfrein * \Module)))
									Else ; Courbe
										CompilerIf #Equation_Degree = 1
											y2_reel.d = \Outil[n]\v[0] + \Outil[n]\v[1] * x1_reel
										CompilerElse
											y2_reel.d = \Outil[n]\v[0]
											For nn = 1 To #Equation_Degree
												y2_reel.d + \Outil[n]\v[nn] * Pow(x1_reel, nn)
											Next
										CompilerEndIf
									EndIf
									Break
								EndIf
							Next
							
							If y1_reel < y2_reel
								
								If \Contour[x]\Zone = 1
									\Contour[x]\Angle + Correction
									If \Contour[x]\Angle > #PI / \Z
										\Contour[x]\R = 0
									EndIf
								Else
									\Contour[x]\Angle - Correction
									If \Contour[x]\Angle < #PI / \Z
										\Contour[x]\R = 0
									EndIf
								EndIf
								
							EndIf
							
						Until y1_reel >= y2_reel
						
					EndIf
				Next
			Next
		EndIf
	EndWith
EndProcedure

Procedure Engrenage_Dessin(Gadget, Image, *Calcul.Structure_Engrenage, Angle.d, Zoom.d = 0)
	
	LoadFont(1, "Tahoma", 9 * FiltreAA, #PB_Font_HighQuality)
	
	With *Calcul
		Largeur = GadgetWidth(Gadget) * FiltreAA
		Hauteur = GadgetHeight(Gadget) * FiltreAA
		Echelle.d = (2 * \Pas * (1 - Zoom) + \D_tete * Zoom) / (Largeur - 32 * FiltreAA)
		x0 = Largeur / 2
		y0 = Hauteur / 3 - \H_pied * \Module / Echelle
		
		; De combien la crémaillère se déplace pour l'angle donné
		Avance.d = \D_primitif * Angle / 2
		
		CreateImage(Image, Largeur, Hauteur, 24)
		StartDrawing(ImageOutput(Image))
			DrawingMode(#PB_2DDrawing_AlphaBlend | #PB_2DDrawing_Transparent)
			Box(0, 0, Largeur, Hauteur, $FF000000)
			
			If \Module > 0 And \Z > 0 And \Angle_pression > 0 And \D_pied > 0
				
				If Dessin = 0 Or FiltreAA = 1
					; Centre de l'engrenage
					x_reel.d = 0
					y_reel.d = (\D_primitif / 2 + \H_pied * \Module) + \Deport * \Module
					; Dessin de l'engrenage
					Angle_reel.d = \Contour[0]\Angle + Angle
					x1_reel.d = x_reel + \Contour[0]\R * Sin(Angle_reel)
					y1_reel.d = y_reel - \Contour[0]\R * Cos(Angle_reel)
					For nn = 0 To \Z - 1
						For n = 1 To #Engrenage_ResolutionDent - 1
							If \Contour[n]\R
								Angle_reel.d = \Contour[n]\Angle + 2 * #PI * nn / \Z + Angle
								x2_reel.d = x_reel + \Contour[n]\R * Sin(Angle_reel)
								y2_reel.d = y_reel - \Contour[n]\R * Cos(Angle_reel)
								; Debug StrD(x2_reel, 4) + " / " + StrD(y2_reel, 4)
								LineXY(x0 + x1_reel / Echelle, y0 + y1_reel / Echelle, x0 + x2_reel / Echelle, y0 + y2_reel / Echelle, #Engrenage_Couleur)
								x1_reel = x2_reel
								y1_reel = y2_reel
							EndIf
						Next
					Next
					Angle_reel.d = \Contour[0]\Angle + Angle
					x2_reel.d = x_reel + \Contour[0]\R * Sin(Angle_reel)
					y2_reel.d = y_reel - \Contour[0]\R * Cos(Angle_reel)
					LineXY(x0 + x1_reel / Echelle, y0 + y1_reel / Echelle, x0 + x2_reel / Echelle, y0 + y2_reel / Echelle, #Engrenage_Couleur)
				EndIf
				
				If Dessin = 0 Or FiltreAA = 1
					; Remplissage de l'engrenage
					If y0 + y_reel / Echelle > Hauteur
						y = Hauteur - 1
					Else
						y = y0 + y_reel / Echelle
					EndIf
					FillArea(x0, y, #Engrenage_Couleur, #Engrenage_Couleur)
				EndIf
				
				If Dessin = 0 Or FiltreAA = 1
					; Dessin de la crémaillère et de l'outil
					For x = 0 To Largeur - 1
						x_reel.d = (x - x0) * Echelle - Avance
						While x_reel < 0 And \Pas > 0
							x_reel + \Pas
						Wend
						While x_reel >= \Pas And \Pas > 0
							x_reel - \Pas
						Wend
						
						; Dessin de la crémaillère
						For n = 0 To #Cremaillere_NbEquation - 1
							If x_reel >= \Cremaillere[n]\x1 And x_reel < \Cremaillere[n]\x2
								If \Cremaillere[n]\c\R ; Cercle
									y_reel = \Cremaillere[n]\c\y + \Cremaillere[n]\c\R * (\Cremaillere[n]\c\Exterieur - \Cremaillere[n]\c\Interieur) * Sin(ACos((x_reel - \Cremaillere[n]\c\x) / (\R_chanfrein * \Module)))
								Else ; Courbe
									CompilerIf #Equation_Degree = 1
										y_reel.d = \Cremaillere[n]\v[0] + \Cremaillere[n]\v[1] * x_reel
									CompilerElse
										y_reel.d = \Cremaillere[n]\v[0]
										For nn = 1 To #Equation_Degree
											y_reel.d + \Cremaillere[n]\v[nn] * Pow(x_reel, nn)
										Next
									CompilerEndIf
								EndIf
								Break
							EndIf
						Next
						y = y_reel / Echelle + y0
						LineXY(x, y, x, 0, #Cremaillere_Couleur)
						
						; Dessin de l'outil d'usinage
						For n = 0 To #Cremaillere_NbEquation - 1
							If x_reel >= \Outil[n]\x1 And x_reel < \Outil[n]\x2
								If \Outil[n]\c\R ; Cercle
									y_reel = \Outil[n]\c\y + \Outil[n]\c\R * (\Outil[n]\c\Exterieur - \Outil[n]\c\Interieur) * Sin(ACos((x_reel - \Outil[n]\c\x) / (\R_chanfrein * \Module)))
								Else ; Courbe
									CompilerIf #Equation_Degree = 1
										y_reel.d = \Outil[n]\v[0] + \Outil[n]\v[1] * x_reel
									CompilerElse
										y_reel.d = \Outil[n]\v[0]
										For nn = 1 To #Equation_Degree
											y_reel.d + \Outil[n]\v[nn] * Pow(x_reel, nn)
										Next
									CompilerEndIf
								EndIf
								Break
							EndIf
						Next
						y = y_reel / Echelle + y0
						LineXY(x, y, x, 0, #Cremaillere_Couleur)
						
					Next
				EndIf
				
				If Dessin = 0 Or FiltreAA = 1
					; Centre de l'engrenage
					x_reel.d = 0
					y_reel.d = (\D_primitif / 2 + \H_pied * \Module) + \Deport * \Module
					; Dessin du diametre de pied
					Circle(x0, y0 + y_reel / Echelle,(\D_pied / 2 + \Deport * \Module) / Echelle, #Engrenage_Diametre)
					; Box(0, y0 +(2.5 * \Module) / Echelle - FiltreAA / 2, Largeur, FiltreAA, #Cremaillere_Hauteur)
					; Dessin du diametre primitif
					Circle(x0, y0 + y_reel / Echelle,(\D_primitif / 2) / Echelle, #Engrenage_Diametre)
					Box(0, y0 + (\H_pied * \Module) / Echelle - FiltreAA / 2, Largeur, FiltreAA, #Cremaillere_Hauteur)
					Box(0, y0 + (\H_pied * \Module + \Deport * \Module) / Echelle - FiltreAA / 2, Largeur, FiltreAA, #Cremaillere_Hauteur)
					; Dessin du diametre de tête
					Circle(x0, y0 + y_reel / Echelle,(\D_tete / 2 + \Deport * \Module) / Echelle, #Engrenage_Diametre)
					; Box(0, y0 +(0.25 * \Module) / Echelle - FiltreAA / 2, Largeur, FiltreAA, #Cremaillere_Hauteur)
					; pied de la crémaillère
					; Box(0, y0 - FiltreAA / 2, Largeur, FiltreAA, #Cremaillere_Hauteur)
					; Tête de la crémaillère
					; Box(0, y0 +(2.25 * \Module) / Echelle - FiltreAA / 2, Largeur, FiltreAA, #Cremaillere_Hauteur)
					; centre
					Box(x0 - FiltreAA / 2, 0, FiltreAA, Hauteur, #Cremaillere_Hauteur)
				EndIf
				
				If Dessin = 0 Or FiltreAA = 1
					; Centre de l'engrenage
					x_reel.d = 0
					y_reel.d = (\H_pied * \Module - \D_primitif / 2) - \Deport * \Module
					; Dessin de l'engrenage
					Angle_reel.d = -\Contour[0]\Angle + Angle + #PI / \Z
					x1_reel.d = x_reel + \Contour[0]\R * Sin(Angle_reel)
					y1_reel.d = y_reel + \Contour[0]\R * Cos(Angle_reel)
					For nn = 0 To \Z - 1
						For n = 1 To #Engrenage_ResolutionDent - 1
							Angle_reel.d = \Contour[n]\Angle + (2 * #PI) * nn / \Z + Angle + #PI / \Z
							If \Contour[n]\R
								x2_reel.d = x_reel + \Contour[n]\R * Sin(Angle_reel)
								y2_reel.d = y_reel + \Contour[n]\R * Cos(Angle_reel)
								; Debug StrD(x2_reel, 4) + " / " + StrD(y2_reel, 4)
								LineXY(x0 + x1_reel / Echelle, y0 + y1_reel / Echelle, x0 + x2_reel / Echelle, y0 + y2_reel / Echelle, #Engrenage2_Couleur)
								x1_reel = x2_reel
								y1_reel = y2_reel
							EndIf
						Next
					Next
					Angle_reel.d = -\Contour[0]\Angle + Angle + #PI / \Z
					x2_reel.d = x_reel + \Contour[0]\R * Sin(Angle_reel)
					y2_reel.d = y_reel + \Contour[0]\R * Cos(Angle_reel)
					LineXY(x0 + x1_reel / Echelle, y0 + y1_reel / Echelle, x0 + x2_reel / Echelle, y0 + y2_reel / Echelle, #Engrenage2_Couleur)
				EndIf
				
				If Dessin = 0 Or FiltreAA = 1
					; Dessin de l'échelle
					DrawingFont(FontID(1))
					Longueur.d = 1 / Echelle
					Texte.s = "1 mm"
					If TextWidth(Texte + "  ") > Longueur
						Longueur.d = 5 / Echelle
						Texte.s = "5 mm"
					EndIf
					If TextWidth(Texte + "  ") > Longueur
						Longueur.d = 10 / Echelle
						Texte.s = "1 cm"
					EndIf
					If TextWidth(Texte + "  ") > Longueur
						Longueur.d = 50 / Echelle
						Texte.s = "5 cm"
					EndIf
					If TextWidth(Texte + "  ") > Longueur
						Longueur.d = 100 / Echelle
						Texte.s = "1 dm"
					EndIf
					If TextWidth(Texte + "  ") > Longueur
						Longueur.d = 500 / Echelle
						Texte.s = "5 dm"
					EndIf
					If TextWidth(Texte + "  ") > Longueur
						Longueur.d = 1000 / Echelle
						Texte.s = "1 m"
					EndIf
					DrawText(x0 + (Longueur - TextWidth(Texte)) / 2, Hauteur - 16 * FiltreAA - TextHeight(Texte), Texte, $FFFFFFFF)
					Box(x0, Hauteur - 16 * FiltreAA, Longueur, FiltreAA, $FFFFFFFF)
					Box(x0, Hauteur - 16 * FiltreAA - Longueur, FiltreAA, Longueur, $FFFFFFFF)
				EndIf
				
			EndIf
		StopDrawing()
		If Dessin = 0 Or FiltreAA = 1
			If FiltreAA > 1
				ResizeImage(Image, Largeur / FiltreAA, Hauteur / FiltreAA, #PB_Image_Smooth)
			EndIf
			SetGadgetState(#G_Dessin, ImageID(0))
		EndIf
		
		FreeFont(1)
		
	EndWith
EndProcedure

Procedure Affichage(Parametre.i)
	
	Repeat
		
		While Dessin = 0 And Compteur < 50
			Delay(20)
			If FiltreAA = 1
				Compteur + 1
			EndIf
		Wend
		
		If Dessin > 0
			Dessin = 0
			FiltreAA = 1
			Affichage = 1
		EndIf
		If Compteur >= 50
			FiltreAA = 4
			Compteur = 0
			Affichage = 1
		EndIf
		
		If Affichage
			Affichage = 0
			
			Engrenage_Dessin(#G_Dessin, 0, @Engrenage, Dessin_Angle, Dessin_Zoom)
			
		EndIf
		
	Until Dessin < 0
	MessageRequester("oups", "fin")
EndProcedure



; Création de la fenêtre et de la GadgetList
If OpenWindow(0, 0, 0, 800, 600, "Taillage d'engrenage", #PB_Window_SystemMenu | #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget) = 0
	End
EndIf

LoadFont(0, "Tahoma", 9, #PB_Font_HighQuality)
SetGadgetFont(#PB_Default, FontID(0))

Engrenage\Module = 1
Engrenage\Z = 15
Engrenage\Angle_pression = 20
Engrenage\H_tete = 1
Engrenage\H_pied = 1.25
Engrenage\R_chanfrein = 0.38
Engrenage_Calcul(@Engrenage)

x = 4
y = 4
Largeur = 200 - 8
PanelGadget(#G_Onglet, 4, 4, Largeur, 600 - 8 - 96 - 8)
	AddGadgetItem(#G_Onglet, -1, "Paramètres")
	Largeur2 = GetGadgetAttribute(#G_Onglet, #PB_Panel_ItemWidth) - 8
	x2 = 4
	y2 = 4
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Module")
	y2 + 16
	StringGadget(#G_Module, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\Module))
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Z (Nombre de dents)")
	y2 + 16
	StringGadget(#G_Z, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\Z))
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Angle de pression (en °)")
	y2 + 16
	StringGadget(#G_Angle_Pression, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\Angle_pression))
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Déport (* module)")
	y2 + 16
	StringGadget(#G_Deport, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\Deport))
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Diamètre primitif")
	y2 + 16
	StringGadget(#G_D_primitif, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\D_primitif), #PB_String_ReadOnly)
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Diamètre de tête")
	y2 + 16
	StringGadget(#G_D_tete, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\D_tete + 2 * Engrenage\Deport * Engrenage\Module), #PB_String_ReadOnly)
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Diamètre de pied")
	y2 + 16
	StringGadget(#G_D_pied, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\D_pied + 2 * Engrenage\Deport * Engrenage\Module), #PB_String_ReadOnly)
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Hauteur de dent")
	y2 + 16
	StringGadget(#G_H_dent, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\H_dent), #PB_String_ReadOnly)
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "Pas")
	y2 + 16
	StringGadget(#G_Pas, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\Pas), #PB_String_ReadOnly)
	y2 + 24
	y2 + 8
	
	
	AddGadgetItem(#G_Onglet, -1, "Norme")
	x2 = 4
	y2 = 4
	TextGadget(#PB_Any, x2, y2, Largeur2, 32, "Les paramètres suivants sont définis par la norme.")
	y2 + 32
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "H tête (* Module)")
	y2 + 16
	StringGadget(#G_H_tete, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\H_tete))
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "H pied (* Module)")
	y2 + 16
	StringGadget(#G_H_pied, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\H_pied))
	y2 + 24
	y2 + 8
	TextGadget(#PB_Any, x2, y2, Largeur2, 16, "R chanfrein (* Module)")
	y2 + 16
	StringGadget(#G_R_chanfrein, x2, y2, Largeur2, 24, AfficheValeur(Engrenage\R_chanfrein))
	y2 + 24
	y2 + 8
	
CloseGadgetList()
y + GadgetHeight(#G_Onglet)
y + 8

TextGadget(#PB_Any, x, y, Largeur, 16, "Zoom d'affichage")
y + 16
TrackBarGadget(#G_Zoom, x, y, Largeur, 32, 0, 10, #PB_TrackBar_Ticks)
Dessin_Zoom.d = 0
y + 32
TextGadget(#PB_Any, x, y, Largeur, 16, "Rotation de l'engrenage")
y + 16
TrackBarGadget(#G_Angle, x, y, Largeur, 32, 0, 72)
Dessin_Angle.d = 0
y + 32

CreateImage(0, 600 - 8, 600 - 8, 24)
ImageGadget(#G_Dessin, 204, 4, ImageWidth(0), ImageHeight(0), ImageID(0))

Engrenage_Diametre(@Engrenage)
Engrenage_Dessin(#G_Dessin, 0, @Engrenage, 0)

Dessin = 1
Thread = CreateThread(@Affichage(), 0)

Repeat
	Event = WaitWindowEvent()
	
	Select Event
		Case #PB_Event_Gadget
			Select EventGadget() ; Gadgets
				Case #G_Module, #G_Z, #G_Angle_Pression, #G_Deport, #G_H_tete, #G_H_pied, #G_R_chanfrein
					If EventType() = #PB_EventType_Change
						; Paramètres
						Engrenage\Module = ValD(GetGadgetText(#G_Module))
						Engrenage\Z = ValD(GetGadgetText(#G_Z))
						Engrenage\Angle_pression = ValD(GetGadgetText(#G_Angle_Pression))
						Engrenage\Deport = ValD(GetGadgetText(#G_Deport))
						; Norme
						Engrenage\H_tete = ValD(GetGadgetText(#G_H_tete))
						Engrenage\H_pied = ValD(GetGadgetText(#G_H_pied))
						Engrenage\R_chanfrein = ValD(GetGadgetText(#G_R_chanfrein))
						
						Engrenage_Calcul(@Engrenage)
						Engrenage_Diametre(@Engrenage)
						Dessin + 1
						; Affichage des résultats
						SetGadgetText(#G_D_primitif, AfficheValeur(Engrenage\D_primitif))
						SetGadgetText(#G_D_tete, AfficheValeur(Engrenage\D_tete + 2 * Engrenage\Deport * Engrenage\Module))
						SetGadgetText(#G_D_pied, AfficheValeur(Engrenage\D_pied + 2 * Engrenage\Deport * Engrenage\Module))
						SetGadgetText(#G_H_dent, AfficheValeur(Engrenage\H_dent))
						SetGadgetText(#G_Pas, AfficheValeur(Engrenage\Pas))
					EndIf
				Case #G_Zoom
					Dessin_Zoom = GetGadgetState(#G_Zoom) / 10
					Dessin + 1
				Case #G_Angle
					Dessin_Angle.d = GetGadgetState(#G_Angle) * 2 * #PI / (36 * Engrenage\Z)
					Dessin + 1
			EndSelect
	EndSelect
	
Until Event = #PB_Event_CloseWindow

[Backup]

En aucun cas le format JPG fait du lissage.

http://www.eric-bellot.fr/node/63

Facteur de lissage. Le JPEG gère mieux les changements de nuances doux que les transitions abruptes de couleurs. Le lissage, en adoucissant les contours de l'image, permet d'obtenir une meilleure compression. Toutefois, la perte visuelle peut être importante et le gain en poids de fichier est souvent négligeable.

renseigne toi avant d'affirmer un truc



et voici qui prouve que Anti-alias et Lissage , c'est la meme chose :
http://cerig.efpg.inpg.fr/Note/2003/opt ... ge_web.htm

il faut utiliser la technique du lissage (image de gauche), appelée anti-aliasing en anglais.

Le principe n'est pas pour cela. Le principe de l'anti-alias est de lisser les lignes et les bords par interpolation entre les pixels

ici
http://www.astrosurf.com/luxorion/apn-anti-aliasing.htm

il est clairement expliqué que l'antialiasing , se vois SURtout sur les Bords comme tu le precise , mais s'applique sur l'ensemble de l'image !
c'est bien un lissage de TOUTE l'image ,pas seulement des bords, ou des lignes ....

note qu'un Flou Gaussien , fait la meme chose



j'ai pris une portion d'image de ton prg d'engrenage
capture d'origine Apres Zoom par Photoshop ( photoshop n'applique pas de lissage sur le zoom .. alors q'un viewer d'image comme irfanview lui applique un lissage lorsqu'on zoom )
j'ai donc travaillé exclusivement avec Photoshop

voici l'image zoomé de ton prog d'engrenage
on voit effectivement quelques pixel qui sont "lissé" mais tres irégulierement ....


voici ce qu'un vrai lissage aurai donné :


j'ai gardé le format Bmp pou ne pas avoir de "lissage" due au format

je pense que c'est parlant

ps : remarque que le lissage ne s'aplique pas qu'a la frontière jaune et sombre , mais aussi sur les parties sombres ....

lorsque je parlais de zommage sur Antialias , bien sur , il s'agit de zoomer , et d'appliquer ensuite l'anti alias ..
mais il est de toute façon plus facile de supprimer un antialias , car aucun pixel ne disparait apres un anti-alias , ils changent seulement de couleur

alors qu'apres une réduction , tout zoom fait apparaitre les imperfections , c'est irréparable , une reduction = perte d'information !

d'un point de vue théorique j'ai raison , mais je dois admettre qu'une reduction de format ( un zoom négatif ) est un moyen de pseudo lisser

[djes]

Dobro, je suis désolé de te dire que tu mélanges absolument tout

[Backup]

ha ... bah je vais aller faire une sieste tiens ....

[reedit]

pour le jpg c'est le Sous-échantillonnage de la chrominance qui fait office de Lissage

[djes]

Ce n'est pas de ta faute, tu n'es pas le seul, il y a tellement d'amalgames un peu partout, des articles soi-disant techniques qui ne font que reprendre (mal) d'autres articles... Et puis la traduction qui nous joue des tours !

Si on veut bien comprendre, il faut repartir de zéro, la construction d'une image sur l'ordinateur, le vectoriel et le bitmap. Ca permet de comprendre qu'une image générée par ordinateur en 2D/3D n'a rien à voir avec une photo/image numérique bitmap, et que donc la notion d'aliasing (crénelage) est différente puisque ce sont deux contextes différents.

Dans tous les cas, l'antialiasing (anti-crénelage) définit ce qui permet d'éliminer l'effet d'escalier qui se produit sur des écrans quand la forme des pixels donne une irrégularité dans la continuité d'une figure telle qu'une ligne. Cela permet d'améliorer l'aspect entre une image réelle (au sens mathématique) et la version "discrète" donnée par des pixels. On connait d'autres façons d'améliorer cet aspect, par exemple en augmentant le contraste, en jouant sur certaines formes/positionnement pour contrecarrer la platitude du cadre...

Sur une image bitmap (qui est aussi la dernière étape d'un rendu 2D/3D), tous les procédés, tels le flou intégral (ou lissage comme vous l'appelez), ou dessiner une ligne sur deux (en augmentant sa luminosité ou en mettant l'autre en gris, ce que personne ne fait jamais) réduisent le crénelage. Le lissage n'est donc pas le seul procédé d'anticrénelage, et n'est donc pas synonyme.

Sur une figure 2D générée par ordinateur (sur nos écrans plats, la 2D est aussi le résultat d'un rendu 3D), certains procédés d'anticrénelage consistent en des algorithmes spécifiques aux formes à dessiner. (Le Soldat Inconnu en connait un rayon Les cartes 3D peuvent aussi travailler au niveau des polygones, ou sur la scène entière après coup, en prenant éventuellement en compte la profondeur. Sur une ligne, en fonction de la profondeur et de l'algo, les pixels alentours et les pixels eux-mêmes peuvent avoir leur couleur altérée (faire l'essai avec une ligne blanche qui file vers le fond de l'écran, son épaisseur apparente se réduisant avec la distance, on utilise la couleur pour simuler cette réduction : on imagine bien les "sous-pixels").

Quant aux JPEG, il est vrai qu'un flou va améliorer la compression et le rendu, mais c'est un flou qu'on applique avant la compression proprement dite : en réduisant ainsi les irrégularités, l'algo DCT (qui apprécie les "dégradés") donne de meilleurs résultats. A noter que le JPEG travaillant par blocs (et à perte), il crée d'autres irrégularités, notamment à la jonction des blocs.

My two cents (désolé pour les raccourcis, ce n'est pas exhaustif)

[Backup]

Le lissage n'est donc pas le seul procédé d'anticrénelage, et n'est donc pas synonyme.

j'ai bien relus plusieurs fois ce que tu ecris ...

c'est juste

mais cela ne démontre pas que je melange tout

lorsque tu ecris :

Le lissage n'est donc pas le seul procédé d'anticrénelage, et n'est donc pas synonyme.

qui a dit que c'etait le seul procédé d'anticrénelage ?

j'ai moi meme précisé qu'un flou Gaussien arrivait a la meme chose ...

hors , numérique , et avant l'apparition des micro-ordinateurs
en optique,
l'emploi de Filtre divers , comme le moirage , avec une toile fine (un Bas de Femme )(ou trame Mecanique ( un filtre sur Film )..) ( j'ai fais du laboratoire Photo industriel en Pro (reporteur photo mécanique) ) , le flou avec les doigts sur Ban Photo etc ...
arrivait au meme resultat ...

je sais donc tres bien, que ce n'est pas LA seule façon de faire ..

par contre c'est pas parce que ça n'est pas la seul façon de faire, qu'on ne peux pas dire que antialias = lissage ...

un paquebot, est différent d'un kayak , il n’empêche que ce sont tout les 2 des bateaux ...

de plus , tu parles , de dessin, Vectoriel ... oui

mais j'ai connu la micro informatique AVANT l'apparition du vectoriel dessus .. (je suis un Dinosaure n'oublie pas )

et on parlait deja d'anti-alias , et pour cause , la résolution des Ordinateurs de l’époque et du manque de couleurs....
nous avions des Fontes Bitmap !

Chez Atari Magazine , pour ne pas les Citer , avaientt fait toute une Serie d'articles sur la façon de dessiner sur Micro ordinateur
et l'antialiasing etait fait a la main ( des dégradés ) , ils montraient comment dessiner une courbes 'Adoucie'
par l'emploi de dégradés .... car les logiciels de dessins, qui exploitaient l'antialiasing , n’étaient deja pas tres courant ... voir inexistant ...
sur Atari , de memoire, il a fallut attendre Spectrum 512 pour avoir un anti-alias ...


definition :

Anti-aliasing :
Procédé de lissage des images pixelisées qui supprime l'effet d'escalier. L'anti-aliasing procède en traçant des valeurs intermédiaires entre les deux zones du tracé. On obtient cet effet avec un pixel de flou.

je ne dis rien d'autre (il n'y a qu'a regarder mes belles images depuis le debut du topic )

le Vectoriel est apparut , surtout pour le dessin des Fontes des softs de PAO comme Quark Xpress , le plus celebres d'entre eux ...
c'est vachement récent ....

en principe , pas besoin d'antialiasing sur du vectoriel ....

de plus ce Topic parle bien d'image Bitmap , et pas du Vectoriel ...
a te lire, on pourrai croire que l'antialiasing ne concerne finalement QUE le Vectoriel ...


bref, je cherche encore a comprendre ou , je me mélange les pinceaux ? ...

[djes]

j'ai bien relus plusieurs fois ce que tu ecris ...

c'est juste

Merci

qui a dit que c'etait le seul procédé d'anticrénelage ?

Et bien c'est toi, dans le post précédent, je te cite :

et voici qui prouve que Anti-alias et Lissage , c'est la meme chose :

je sais donc tres bien, que ce n'est pas LA seule façon de faire ..

Très bien.

par contre c'est pas parce que ça n'est pas la seul façon de faire, qu'on ne peux pas dire que antialias = lissage ...

un paquebot, est différent d'un kayak , il n’empêche que ce sont tout les 2 des bateaux ...

Tu admettras qu'il est différent de dire Bateau = Kayak, de dire Kayak et paquebot = bateaux. Dans le cas qui nous intéresse, le lissage est une technique qui peut être utilisée pour faire de l'anticrénelage, ce n'est pas la seule, et ce n'est pas forcément sa finalité. Donc non antialias!=lissage mais lissage => antialias. Tu vois la nuance ?

mais j'ai connu la micro informatique AVANT l'apparition du vectoriel dessus .. (je suis un Dinosaure n'oublie pas )

Moi aussi, je suis un dinosaure dans ce sens-là, même s'il y a sur ce forum des gens qui ont commencé bien avant nous... ! Et je peux te dire que le vectoriel a existé avant la micro :/

Chez Atari Magazine , pour ne pas les Citer , avaientt fait toute une Serie d'articles sur la façon de dessiner sur Micro ordinateur
et l'antialiasing etait fait a la main ( des dégradés ) , ils montraient comment dessiner une courbes 'Adoucie'
par l'emploi de dégradés .... car les logiciels de dessins, qui exploitaient l'antialiasing , n’étaient deja pas tres courant ... voir inexistant ...
sur Atari , de memoire, il a fallut attendre Spectrum 512 pour avoir un anti-alias ...

Je suis un ex-demomaker, alors l'antialias fait main, je ne connais que ça... Nous avons tous passé des heures à bricoler les pixels ! Et si tu te souviens bien, quand tu n'as pas assez de couleurs, il est tout aussi efficace d'enlever de temps en temps un pixel que d'en rajouter autour.

definition :
Citation:
Anti-aliasing :
Procédé de lissage des images pixelisées qui supprime l'effet d'escalier. L'anti-aliasing procède en traçant des valeurs intermédiaires entre les deux zones du tracé. On obtient cet effet avec un pixel de flou.

je ne dis rien d'autre (il n'y a qu'a regarder mes belles images depuis le debut du topic )

Ce n'est pas ce que tu avais dit avant, et la définition est correcte : procédé de lissage signifie bien qu'il s'agit d'un procédé parmi d'autres, mais pas que lissage = antialias

le Vectoriel est apparut , surtout pour le dessin des Fontes des softs de PAO comme Quark Xpress , le plus celebres d'entre eux ...
c'est vachement récent ....

Le vectoriel dans ce sens-là est apparu avec le Postscript, dont le standard (après d'autres travaux), remonte à 1982...

en principe , pas besoin d'antialiasing sur du vectoriel ....

Si tu m'avais bien lu, tu aurais compris qu'on utilise souvent l'anticrénelage pour une représentation plus fidèle et plus agréable du dessin vectoriel, notamment comme tu le cites dans les logiciels de DAO, mais aussi dans le dessin des polices à l'écran, ou sur imprimante.

de plus ce Topic parle bien d'image Bitmap , et pas du Vectoriel ...
a te lire, on pourrai croire que l'antialiasing ne concerne finalement QUE le Vectoriel ...

J'ai bien défini que l'antialias s'appliquait aussi bien aux images bitmap qu'au vectoriel, mais que du fait de techniques différentes, il ne fallait pas faire d'amalgames.

bref, je cherche encore a comprendre ou , je me mélange les pinceaux ? ...

J'espère que j'aurais réussi à te faire comprendre ; c'est surtout un problème de confusion entre les différents termes. En rangeant un peu mieux tout ça, c'est beaucoup plus clair, non ?

[Frenchy Pilou]

Au sujet du raffinement du dessin des lignes à l'écran, je vous suggère de regarder Moment of Inspiration Ze Zen Nurbs modeleur
(tout en français aussi même la doc et pour cause
(il y a une version de démo infinie dans le temps sans sauvegarde, mais le dessin des lignes à l'écran
est tellement soigné qu'un simple appui sur la touche "Imp écr" peut déjà faire du mal!
Et que ce petit script à mettre en raccourci permet de sortir une image à n'importe quelle dimension dans le presse-papiers (suivant la mémoire de sa carte graphique bien sûr)
en vue de n'importe quel programme graphique 2D, ici 2560*2560)

Code : Tout sélectionner

script:var v = moi.ui.getActiveViewport(); if ( v != null ) { moi.view.lineWidth = 4; v.renderToClipboard( 2560, 2560 ); moi.view.lineWidth = 1; }

C'est un des rare à prendre en compte ce confort de l'oeil

Regardez la pointe des angles aigus
Je ne crois pas que l'on trouve ça sur beaucoup de programme CAD en écran direct de travail!
La douceur ouatée des lignes surbrillantes jaunes à diffusions douces pour les romantiques
Et après la folie des variations de nature de lignes



by Marco Loisi

By PAQ

[djes]

Frenchy> J'adore quand tu es inspiré comme ça
Sinon, inkscape fait aussi dans le "lissage" (:P), et permet de jolis trucs une fois bien pris en main. Une bonne alternative à illustrator/corel

[Backup]

qui a dit que c'etait le seul procédé d'anticrénelage ?

Et bien c'est toi, dans le post précédent, je te cite :

et voici qui prouve que Anti-alias et Lissage , c'est la meme chose :

Rhooo ! ou lis-tu , que c'est le SEUL ? , je dis que c'est la même chose , je dis pas que c'est la Seule chose !!

en clair l'antialias, fait partie de la famille des Lissages .. voila c'est plus clair ?

bon je suis d'accords , le poids des mots ( et l'importance qu'on y donne ) a souvent été a la base de discutions stériles )

je me souviens effectivement d'avoir dégradé "flouté" des details d'une images ... il m'arrive encore de le faire avec Photoshop
et ses merveilleux outils D'estompage , de Clonages ...etc

Pour le Demo-making te concernant, je le savais deja ...
pour ma part, j'etais plutot dans le mauvais coté de la force

[djes]

djes a écrit:
Dobro a écrit:
qui a dit que c'etait le seul procédé d'anticrénelage ?

Et bien c'est toi, dans le post précédent, je te cite :
Dobro a écrit:
et voici qui prouve que Anti-alias et Lissage , c'est la meme chose :



Rhooo ! ou lis-tu , que c'est le SEUL ? , je dis que c'est la même chose , je dis pas que c'est la Seule chose !!

en clair l'antialias, fait partie de la famille des Lissages .. voila c'est plus clair ?

Sauf que moi je ne dis pas du tout ça ! Vous parliez de lissage pour parler d'un floutage (complet) d'une image bitmap, et l'antialias n'est pas du tout ça. Alors oui, l'antialias est un lissage, mais pas dans le sens floutage d'une image, et ce n'est pas forcément ça

bon je suis d'accords , le poids des mots ( et l'importance qu'on y donne ) a souvent été a la base de discutions stériles )

Ouch, m'en parle pas

Pour le Demo-making te concernant, je le savais deja ...
pour ma part, j'etais plutot dans le mauvais coté de la force

Bah ! Ca dépend, si tu ne te faisais pas d'argent sur le dos des copains, on était du même côté...

[Backup]

j'ai toujours été partisan du Freeware