Bonjour,
Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
ByVal B As Integer)
Dim Width_Out As Integer
Dim Height_Out As Integer
Dim Bitmap_In As Bitmap
Dim Bitmap_Out As Bitmap
Dim Final_X As Integer
Dim Final_Y As Integer
'Creation du bitmap d'entrée
Bitmap_In = Image.FromFile(Source)
'Conservation du Ratio (OUI/NON)
If Not ConserverRatio Then
'Génération a la taille souhaitee
Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
AddressOf ThumbNailAbort, Nothing)
Else
'Calcul des dimensions de la miniature du bitmap d'entrée
'si Largeur fixe
If TailleY = "" And TailleX <> "" Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
Final_X = TailleX
Final_Y = Height_Out
Else
'si Hauteur fixe
If TailleX = "" And TailleY <> "" Then
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
Final_X = Width_Out
Final_Y = TailleY
Else
'si orientation = paysage
If Bitmap_In.Width >= Bitmap_In.Height Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height /
Else
'si orientation = portrait
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
End If
'Verification si la taille de la miniature est compatible avec
taille souhaitée
'si Width_Out > TailleX
If Width_Out > TailleX Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height /
End If
'si Height_Out > TailleY
If Height_Out > TailleY Then
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
End If
Final_X = TailleX
Final_Y = TailleY
End If
End If
End If
'Creation d'une miniature du bitmap d'entree à la taille souhaitée
Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
ThumbNailAbort, Nothing)
'Creation d'un bitmap de sortie
'Fond de couleur (OUI/NON)
If Not Fond Then
Bitmap_Out = Bitmap_In
Else
'Creation du bitmap de sortie
Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
'Defintition de la couleur d'arrière-plan
Dim Couleur As Color
Couleur = Color.FromArgb(255, R, V, B)
'Definition de la resolution (dpi)
Bitmap_Out.SetResolution(Resolution, Resolution)
'Calcul des décalages Haut et gauche pour centrer de l'image
Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
' Remplissage de tout les pixels de la couleur du fond
Dim Xcount As Integer
Dim Ycount As Integer
'boucle sur le nombre de colonnes
For Xcount = 0 To Bitmap_Out.Width - 1
'boucle sur le nombre de lignes
For Ycount = 0 To Bitmap_Out.Height - 1
'Defintion de la couleur du pixel
Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
Next Ycount
Next Xcount
' Recopie des pixels de mon image
'boucle sur le nombre de colonnes
For Xcount = 0 To Bitmap_In.Width - 1
'boucle sur le nombre de lignes
For Ycount = 0 To Bitmap_In.Height - 1
'Defintion de la couleur du pixel (couleur du pixel de la
miniature du bitmap d'entrée)
Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
Bitmap_In.GetPixel(Xcount, Ycount))
Next Ycount
Next Xcount
End If
'Sauvegarde du bitmap de sortie
Bitmap_Out.Save(Destination, ImageFormat.Tiff)
Bitmap_In = Nothing
Bitmap_Out = Nothing
End Sub
Cependant sur certaines images, le résultat est très décevant.
D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
D'avance Merci
Cédric
Bonjour,
Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
ByVal B As Integer)
Dim Width_Out As Integer
Dim Height_Out As Integer
Dim Bitmap_In As Bitmap
Dim Bitmap_Out As Bitmap
Dim Final_X As Integer
Dim Final_Y As Integer
'Creation du bitmap d'entrée
Bitmap_In = Image.FromFile(Source)
'Conservation du Ratio (OUI/NON)
If Not ConserverRatio Then
'Génération a la taille souhaitee
Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
AddressOf ThumbNailAbort, Nothing)
Else
'Calcul des dimensions de la miniature du bitmap d'entrée
'si Largeur fixe
If TailleY = "" And TailleX <> "" Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
Final_X = TailleX
Final_Y = Height_Out
Else
'si Hauteur fixe
If TailleX = "" And TailleY <> "" Then
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
Final_X = Width_Out
Final_Y = TailleY
Else
'si orientation = paysage
If Bitmap_In.Width >= Bitmap_In.Height Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height /
Else
'si orientation = portrait
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
End If
'Verification si la taille de la miniature est compatible avec
taille souhaitée
'si Width_Out > TailleX
If Width_Out > TailleX Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height /
End If
'si Height_Out > TailleY
If Height_Out > TailleY Then
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
End If
Final_X = TailleX
Final_Y = TailleY
End If
End If
End If
'Creation d'une miniature du bitmap d'entree à la taille souhaitée
Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
ThumbNailAbort, Nothing)
'Creation d'un bitmap de sortie
'Fond de couleur (OUI/NON)
If Not Fond Then
Bitmap_Out = Bitmap_In
Else
'Creation du bitmap de sortie
Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
'Defintition de la couleur d'arrière-plan
Dim Couleur As Color
Couleur = Color.FromArgb(255, R, V, B)
'Definition de la resolution (dpi)
Bitmap_Out.SetResolution(Resolution, Resolution)
'Calcul des décalages Haut et gauche pour centrer de l'image
Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
' Remplissage de tout les pixels de la couleur du fond
Dim Xcount As Integer
Dim Ycount As Integer
'boucle sur le nombre de colonnes
For Xcount = 0 To Bitmap_Out.Width - 1
'boucle sur le nombre de lignes
For Ycount = 0 To Bitmap_Out.Height - 1
'Defintion de la couleur du pixel
Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
Next Ycount
Next Xcount
' Recopie des pixels de mon image
'boucle sur le nombre de colonnes
For Xcount = 0 To Bitmap_In.Width - 1
'boucle sur le nombre de lignes
For Ycount = 0 To Bitmap_In.Height - 1
'Defintion de la couleur du pixel (couleur du pixel de la
miniature du bitmap d'entrée)
Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
Bitmap_In.GetPixel(Xcount, Ycount))
Next Ycount
Next Xcount
End If
'Sauvegarde du bitmap de sortie
Bitmap_Out.Save(Destination, ImageFormat.Tiff)
Bitmap_In = Nothing
Bitmap_Out = Nothing
End Sub
Cependant sur certaines images, le résultat est très décevant.
D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
D'avance Merci
Cédric
Bonjour,
Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
ByVal B As Integer)
Dim Width_Out As Integer
Dim Height_Out As Integer
Dim Bitmap_In As Bitmap
Dim Bitmap_Out As Bitmap
Dim Final_X As Integer
Dim Final_Y As Integer
'Creation du bitmap d'entrée
Bitmap_In = Image.FromFile(Source)
'Conservation du Ratio (OUI/NON)
If Not ConserverRatio Then
'Génération a la taille souhaitee
Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
AddressOf ThumbNailAbort, Nothing)
Else
'Calcul des dimensions de la miniature du bitmap d'entrée
'si Largeur fixe
If TailleY = "" And TailleX <> "" Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
Final_X = TailleX
Final_Y = Height_Out
Else
'si Hauteur fixe
If TailleX = "" And TailleY <> "" Then
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
Final_X = Width_Out
Final_Y = TailleY
Else
'si orientation = paysage
If Bitmap_In.Width >= Bitmap_In.Height Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height /
Else
'si orientation = portrait
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
End If
'Verification si la taille de la miniature est compatible avec
taille souhaitée
'si Width_Out > TailleX
If Width_Out > TailleX Then
Width_Out = CInt(TailleX)
Height_Out = CInt(TailleX) * Bitmap_In.Height /
End If
'si Height_Out > TailleY
If Height_Out > TailleY Then
Height_Out = CInt(TailleY)
Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
End If
Final_X = TailleX
Final_Y = TailleY
End If
End If
End If
'Creation d'une miniature du bitmap d'entree à la taille souhaitée
Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
ThumbNailAbort, Nothing)
'Creation d'un bitmap de sortie
'Fond de couleur (OUI/NON)
If Not Fond Then
Bitmap_Out = Bitmap_In
Else
'Creation du bitmap de sortie
Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
'Defintition de la couleur d'arrière-plan
Dim Couleur As Color
Couleur = Color.FromArgb(255, R, V, B)
'Definition de la resolution (dpi)
Bitmap_Out.SetResolution(Resolution, Resolution)
'Calcul des décalages Haut et gauche pour centrer de l'image
Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
' Remplissage de tout les pixels de la couleur du fond
Dim Xcount As Integer
Dim Ycount As Integer
'boucle sur le nombre de colonnes
For Xcount = 0 To Bitmap_Out.Width - 1
'boucle sur le nombre de lignes
For Ycount = 0 To Bitmap_Out.Height - 1
'Defintion de la couleur du pixel
Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
Next Ycount
Next Xcount
' Recopie des pixels de mon image
'boucle sur le nombre de colonnes
For Xcount = 0 To Bitmap_In.Width - 1
'boucle sur le nombre de lignes
For Ycount = 0 To Bitmap_In.Height - 1
'Defintion de la couleur du pixel (couleur du pixel de la
miniature du bitmap d'entrée)
Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
Bitmap_In.GetPixel(Xcount, Ycount))
Next Ycount
Next Xcount
End If
'Sauvegarde du bitmap de sortie
Bitmap_Out.Save(Destination, ImageFormat.Tiff)
Bitmap_In = Nothing
Bitmap_Out = Nothing
End Sub
Cependant sur certaines images, le résultat est très décevant.
D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
D'avance Merci
Cédric
Décevent à quel point de vue ? Performances ?
La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais par
exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
comme transparente et il suffirait ensuite de copier ce bitmap vers un
bitmap uni (dont la couleur est définie en traçant un rectangle de la bonne
couleur plutôt qu'en modifiant chaque point individuellement).
--
Patrice
"Cedric" a écrit dans le message de
news:
> Bonjour,
>
> Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
>
> Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
> String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
As
> Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
> System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
Integer,
> ByVal B As Integer)
> Dim Width_Out As Integer
> Dim Height_Out As Integer
> Dim Bitmap_In As Bitmap
> Dim Bitmap_Out As Bitmap
> Dim Final_X As Integer
> Dim Final_Y As Integer
> 'Creation du bitmap d'entrée
> Bitmap_In = Image.FromFile(Source)
> 'Conservation du Ratio (OUI/NON)
> If Not ConserverRatio Then
> 'Génération a la taille souhaitee
> Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
> AddressOf ThumbNailAbort, Nothing)
> Else
> 'Calcul des dimensions de la miniature du bitmap d'entrée
> 'si Largeur fixe
> If TailleY = "" And TailleX <> "" Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> Final_X = TailleX
> Final_Y = Height_Out
> Else
> 'si Hauteur fixe
> If TailleX = "" And TailleY <> "" Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> Final_X = Width_Out
> Final_Y = TailleY
> Else
> 'si orientation = paysage
> If Bitmap_In.Width >= Bitmap_In.Height Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> Else
> 'si orientation = portrait
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> 'Verification si la taille de la miniature est compatible avec
la
> taille souhaitée
> 'si Width_Out > TailleX
> If Width_Out > TailleX Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> End If
> 'si Height_Out > TailleY
> If Height_Out > TailleY Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> Final_X = TailleX
> Final_Y = TailleY
> End If
> End If
> End If
> 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
AddressOf
> ThumbNailAbort, Nothing)
> 'Creation d'un bitmap de sortie
> 'Fond de couleur (OUI/NON)
> If Not Fond Then
> Bitmap_Out = Bitmap_In
> Else
> 'Creation du bitmap de sortie
> Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> 'Defintition de la couleur d'arrière-plan
> Dim Couleur As Color
> Couleur = Color.FromArgb(255, R, V, B)
> 'Definition de la resolution (dpi)
> Bitmap_Out.SetResolution(Resolution, Resolution)
> 'Calcul des décalages Haut et gauche pour centrer de l'image
> Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> ' Remplissage de tout les pixels de la couleur du fond
> Dim Xcount As Integer
> Dim Ycount As Integer
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_Out.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_Out.Height - 1
> 'Defintion de la couleur du pixel
> Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> Next Ycount
> Next Xcount
> ' Recopie des pixels de mon image
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_In.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_In.Height - 1
> 'Defintion de la couleur du pixel (couleur du pixel de la
> miniature du bitmap d'entrée)
> Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> Bitmap_In.GetPixel(Xcount, Ycount))
> Next Ycount
> Next Xcount
> End If
> 'Sauvegarde du bitmap de sortie
> Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> Bitmap_In = Nothing
> Bitmap_Out = Nothing
> End Sub
>
> Cependant sur certaines images, le résultat est très décevant.
> D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
>
> D'avance Merci
>
> Cédric
Par décevant, j'entendait la qualité du rendu de la miniature (pixelisation). Cependant, la gestion pixel par pixel peut etre modifée, mais la n'est pas forcément le problème. merci pour cettte information.
Décevent à quel point de vue ? Performances ?
La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais par
exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
comme transparente et il suffirait ensuite de copier ce bitmap vers un
bitmap uni (dont la couleur est définie en traçant un rectangle de la bonne
couleur plutôt qu'en modifiant chaque point individuellement).
--
Patrice
"Cedric" <Cedric@discussions.microsoft.com> a écrit dans le message de
news:FC675E3A-DD80-496C-B311-E7796A7BB758@microsoft.com...
> Bonjour,
>
> Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
>
> Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
> String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
As
> Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
> System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
Integer,
> ByVal B As Integer)
> Dim Width_Out As Integer
> Dim Height_Out As Integer
> Dim Bitmap_In As Bitmap
> Dim Bitmap_Out As Bitmap
> Dim Final_X As Integer
> Dim Final_Y As Integer
> 'Creation du bitmap d'entrée
> Bitmap_In = Image.FromFile(Source)
> 'Conservation du Ratio (OUI/NON)
> If Not ConserverRatio Then
> 'Génération a la taille souhaitee
> Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
> AddressOf ThumbNailAbort, Nothing)
> Else
> 'Calcul des dimensions de la miniature du bitmap d'entrée
> 'si Largeur fixe
> If TailleY = "" And TailleX <> "" Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> Final_X = TailleX
> Final_Y = Height_Out
> Else
> 'si Hauteur fixe
> If TailleX = "" And TailleY <> "" Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> Final_X = Width_Out
> Final_Y = TailleY
> Else
> 'si orientation = paysage
> If Bitmap_In.Width >= Bitmap_In.Height Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> Else
> 'si orientation = portrait
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> 'Verification si la taille de la miniature est compatible avec
la
> taille souhaitée
> 'si Width_Out > TailleX
> If Width_Out > TailleX Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> End If
> 'si Height_Out > TailleY
> If Height_Out > TailleY Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> Final_X = TailleX
> Final_Y = TailleY
> End If
> End If
> End If
> 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
AddressOf
> ThumbNailAbort, Nothing)
> 'Creation d'un bitmap de sortie
> 'Fond de couleur (OUI/NON)
> If Not Fond Then
> Bitmap_Out = Bitmap_In
> Else
> 'Creation du bitmap de sortie
> Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> 'Defintition de la couleur d'arrière-plan
> Dim Couleur As Color
> Couleur = Color.FromArgb(255, R, V, B)
> 'Definition de la resolution (dpi)
> Bitmap_Out.SetResolution(Resolution, Resolution)
> 'Calcul des décalages Haut et gauche pour centrer de l'image
> Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> ' Remplissage de tout les pixels de la couleur du fond
> Dim Xcount As Integer
> Dim Ycount As Integer
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_Out.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_Out.Height - 1
> 'Defintion de la couleur du pixel
> Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> Next Ycount
> Next Xcount
> ' Recopie des pixels de mon image
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_In.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_In.Height - 1
> 'Defintion de la couleur du pixel (couleur du pixel de la
> miniature du bitmap d'entrée)
> Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> Bitmap_In.GetPixel(Xcount, Ycount))
> Next Ycount
> Next Xcount
> End If
> 'Sauvegarde du bitmap de sortie
> Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> Bitmap_In = Nothing
> Bitmap_Out = Nothing
> End Sub
>
> Cependant sur certaines images, le résultat est très décevant.
> D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
>
> D'avance Merci
>
> Cédric
Par décevant, j'entendait la qualité du rendu de la miniature (pixelisation). Cependant, la gestion pixel par pixel peut etre modifée, mais la n'est pas forcément le problème. merci pour cettte information.
Décevent à quel point de vue ? Performances ?
La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais par
exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
comme transparente et il suffirait ensuite de copier ce bitmap vers un
bitmap uni (dont la couleur est définie en traçant un rectangle de la bonne
couleur plutôt qu'en modifiant chaque point individuellement).
--
Patrice
"Cedric" a écrit dans le message de
news:
> Bonjour,
>
> Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
>
> Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
> String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
As
> Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
> System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
Integer,
> ByVal B As Integer)
> Dim Width_Out As Integer
> Dim Height_Out As Integer
> Dim Bitmap_In As Bitmap
> Dim Bitmap_Out As Bitmap
> Dim Final_X As Integer
> Dim Final_Y As Integer
> 'Creation du bitmap d'entrée
> Bitmap_In = Image.FromFile(Source)
> 'Conservation du Ratio (OUI/NON)
> If Not ConserverRatio Then
> 'Génération a la taille souhaitee
> Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
> AddressOf ThumbNailAbort, Nothing)
> Else
> 'Calcul des dimensions de la miniature du bitmap d'entrée
> 'si Largeur fixe
> If TailleY = "" And TailleX <> "" Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> Final_X = TailleX
> Final_Y = Height_Out
> Else
> 'si Hauteur fixe
> If TailleX = "" And TailleY <> "" Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> Final_X = Width_Out
> Final_Y = TailleY
> Else
> 'si orientation = paysage
> If Bitmap_In.Width >= Bitmap_In.Height Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> Else
> 'si orientation = portrait
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> 'Verification si la taille de la miniature est compatible avec
la
> taille souhaitée
> 'si Width_Out > TailleX
> If Width_Out > TailleX Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> End If
> 'si Height_Out > TailleY
> If Height_Out > TailleY Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> Final_X = TailleX
> Final_Y = TailleY
> End If
> End If
> End If
> 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
AddressOf
> ThumbNailAbort, Nothing)
> 'Creation d'un bitmap de sortie
> 'Fond de couleur (OUI/NON)
> If Not Fond Then
> Bitmap_Out = Bitmap_In
> Else
> 'Creation du bitmap de sortie
> Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> 'Defintition de la couleur d'arrière-plan
> Dim Couleur As Color
> Couleur = Color.FromArgb(255, R, V, B)
> 'Definition de la resolution (dpi)
> Bitmap_Out.SetResolution(Resolution, Resolution)
> 'Calcul des décalages Haut et gauche pour centrer de l'image
> Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> ' Remplissage de tout les pixels de la couleur du fond
> Dim Xcount As Integer
> Dim Ycount As Integer
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_Out.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_Out.Height - 1
> 'Defintion de la couleur du pixel
> Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> Next Ycount
> Next Xcount
> ' Recopie des pixels de mon image
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_In.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_In.Height - 1
> 'Defintion de la couleur du pixel (couleur du pixel de la
> miniature du bitmap d'entrée)
> Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> Bitmap_In.GetPixel(Xcount, Ycount))
> Next Ycount
> Next Xcount
> End If
> 'Sauvegarde du bitmap de sortie
> Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> Bitmap_In = Nothing
> Bitmap_Out = Nothing
> End Sub
>
> Cependant sur certaines images, le résultat est très décevant.
> D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
>
> D'avance Merci
>
> Cédric
Par décevant, j'entendait la qualité du rendu de la miniature (pixelisation). Cependant, la gestion pixel par pixel peut etre modifée, mais la n'est pas forcément le problème. merci pour cettte information.
"Patrice" a écrit :
> Décevent à quel point de vue ? Performances ?
>
> La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais
> exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
> comme transparente et il suffirait ensuite de copier ce bitmap vers un
> bitmap uni (dont la couleur est définie en traçant un rectangle de la
> couleur plutôt qu'en modifiant chaque point individuellement).
>
> --
> Patrice
>
> "Cedric" a écrit dans le message de
> news:
> > Bonjour,
> >
> > Voulant créer la miniature d'un image, j'utilise le bout de code
> >
> > Public Sub GenererMiniature(ByVal Source As String, ByVal Destination
> > String, ByVal TailleX As String, ByVal TailleY As String, ByVal
> As
> > Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> > PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat
> > System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
> Integer,
> > ByVal B As Integer)
> > Dim Width_Out As Integer
> > Dim Height_Out As Integer
> > Dim Bitmap_In As Bitmap
> > Dim Bitmap_Out As Bitmap
> > Dim Final_X As Integer
> > Dim Final_Y As Integer
> > 'Creation du bitmap d'entrée
> > Bitmap_In = Image.FromFile(Source)
> > 'Conservation du Ratio (OUI/NON)
> > If Not ConserverRatio Then
> > 'Génération a la taille souhaitee
> > Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX),
> > AddressOf ThumbNailAbort, Nothing)
> > Else
> > 'Calcul des dimensions de la miniature du bitmap d'entrée
> > 'si Largeur fixe
> > If TailleY = "" And TailleX <> "" Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> > Final_X = TailleX
> > Final_Y = Height_Out
> > Else
> > 'si Hauteur fixe
> > If TailleX = "" And TailleY <> "" Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > Final_X = Width_Out
> > Final_Y = TailleY
> > Else
> > 'si orientation = paysage
> > If Bitmap_In.Width >= Bitmap_In.Height Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > Else
> > 'si orientation = portrait
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > 'Verification si la taille de la miniature est compatible
> la
> > taille souhaitée
> > 'si Width_Out > TailleX
> > If Width_Out > TailleX Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > End If
> > 'si Height_Out > TailleY
> > If Height_Out > TailleY Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > Final_X = TailleX
> > Final_Y = TailleY
> > End If
> > End If
> > End If
> > 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> > Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
> AddressOf
> > ThumbNailAbort, Nothing)
> > 'Creation d'un bitmap de sortie
> > 'Fond de couleur (OUI/NON)
> > If Not Fond Then
> > Bitmap_Out = Bitmap_In
> > Else
> > 'Creation du bitmap de sortie
> > Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> > 'Defintition de la couleur d'arrière-plan
> > Dim Couleur As Color
> > Couleur = Color.FromArgb(255, R, V, B)
> > 'Definition de la resolution (dpi)
> > Bitmap_Out.SetResolution(Resolution, Resolution)
> > 'Calcul des décalages Haut et gauche pour centrer de l'image
> > Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> > Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> > ' Remplissage de tout les pixels de la couleur du fond
> > Dim Xcount As Integer
> > Dim Ycount As Integer
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_Out.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_Out.Height - 1
> > 'Defintion de la couleur du pixel
> > Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> > Next Ycount
> > Next Xcount
> > ' Recopie des pixels de mon image
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_In.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_In.Height - 1
> > 'Defintion de la couleur du pixel (couleur du pixel de la
> > miniature du bitmap d'entrée)
> > Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> > Bitmap_In.GetPixel(Xcount, Ycount))
> > Next Ycount
> > Next Xcount
> > End If
> > 'Sauvegarde du bitmap de sortie
> > Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> > Bitmap_In = Nothing
> > Bitmap_Out = Nothing
> > End Sub
> >
> > Cependant sur certaines images, le résultat est très décevant.
> > D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
> >
> > D'avance Merci
> >
> > Cédric
>
>
> Par décevant, j'entendait la qualité du rendu de la miniature
"Patrice" a écrit :
> Décevent à quel point de vue ? Performances ?
>
> La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais
> exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
> comme transparente et il suffirait ensuite de copier ce bitmap vers un
> bitmap uni (dont la couleur est définie en traçant un rectangle de la
> couleur plutôt qu'en modifiant chaque point individuellement).
>
> --
> Patrice
>
> "Cedric" <Cedric@discussions.microsoft.com> a écrit dans le message de
> news:FC675E3A-DD80-496C-B311-E7796A7BB758@microsoft.com...
> > Bonjour,
> >
> > Voulant créer la miniature d'un image, j'utilise le bout de code
> >
> > Public Sub GenererMiniature(ByVal Source As String, ByVal Destination
> > String, ByVal TailleX As String, ByVal TailleY As String, ByVal
> As
> > Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> > PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat
> > System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
> Integer,
> > ByVal B As Integer)
> > Dim Width_Out As Integer
> > Dim Height_Out As Integer
> > Dim Bitmap_In As Bitmap
> > Dim Bitmap_Out As Bitmap
> > Dim Final_X As Integer
> > Dim Final_Y As Integer
> > 'Creation du bitmap d'entrée
> > Bitmap_In = Image.FromFile(Source)
> > 'Conservation du Ratio (OUI/NON)
> > If Not ConserverRatio Then
> > 'Génération a la taille souhaitee
> > Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX),
> > AddressOf ThumbNailAbort, Nothing)
> > Else
> > 'Calcul des dimensions de la miniature du bitmap d'entrée
> > 'si Largeur fixe
> > If TailleY = "" And TailleX <> "" Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> > Final_X = TailleX
> > Final_Y = Height_Out
> > Else
> > 'si Hauteur fixe
> > If TailleX = "" And TailleY <> "" Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > Final_X = Width_Out
> > Final_Y = TailleY
> > Else
> > 'si orientation = paysage
> > If Bitmap_In.Width >= Bitmap_In.Height Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > Else
> > 'si orientation = portrait
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > 'Verification si la taille de la miniature est compatible
> la
> > taille souhaitée
> > 'si Width_Out > TailleX
> > If Width_Out > TailleX Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > End If
> > 'si Height_Out > TailleY
> > If Height_Out > TailleY Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > Final_X = TailleX
> > Final_Y = TailleY
> > End If
> > End If
> > End If
> > 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> > Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
> AddressOf
> > ThumbNailAbort, Nothing)
> > 'Creation d'un bitmap de sortie
> > 'Fond de couleur (OUI/NON)
> > If Not Fond Then
> > Bitmap_Out = Bitmap_In
> > Else
> > 'Creation du bitmap de sortie
> > Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> > 'Defintition de la couleur d'arrière-plan
> > Dim Couleur As Color
> > Couleur = Color.FromArgb(255, R, V, B)
> > 'Definition de la resolution (dpi)
> > Bitmap_Out.SetResolution(Resolution, Resolution)
> > 'Calcul des décalages Haut et gauche pour centrer de l'image
> > Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> > Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> > ' Remplissage de tout les pixels de la couleur du fond
> > Dim Xcount As Integer
> > Dim Ycount As Integer
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_Out.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_Out.Height - 1
> > 'Defintion de la couleur du pixel
> > Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> > Next Ycount
> > Next Xcount
> > ' Recopie des pixels de mon image
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_In.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_In.Height - 1
> > 'Defintion de la couleur du pixel (couleur du pixel de la
> > miniature du bitmap d'entrée)
> > Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> > Bitmap_In.GetPixel(Xcount, Ycount))
> > Next Ycount
> > Next Xcount
> > End If
> > 'Sauvegarde du bitmap de sortie
> > Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> > Bitmap_In = Nothing
> > Bitmap_Out = Nothing
> > End Sub
> >
> > Cependant sur certaines images, le résultat est très décevant.
> > D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
> >
> > D'avance Merci
> >
> > Cédric
>
>
> Par décevant, j'entendait la qualité du rendu de la miniature
"Patrice" a écrit :
> Décevent à quel point de vue ? Performances ?
>
> La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais
> exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
> comme transparente et il suffirait ensuite de copier ce bitmap vers un
> bitmap uni (dont la couleur est définie en traçant un rectangle de la
> couleur plutôt qu'en modifiant chaque point individuellement).
>
> --
> Patrice
>
> "Cedric" a écrit dans le message de
> news:
> > Bonjour,
> >
> > Voulant créer la miniature d'un image, j'utilise le bout de code
> >
> > Public Sub GenererMiniature(ByVal Source As String, ByVal Destination
> > String, ByVal TailleX As String, ByVal TailleY As String, ByVal
> As
> > Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> > PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat
> > System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
> Integer,
> > ByVal B As Integer)
> > Dim Width_Out As Integer
> > Dim Height_Out As Integer
> > Dim Bitmap_In As Bitmap
> > Dim Bitmap_Out As Bitmap
> > Dim Final_X As Integer
> > Dim Final_Y As Integer
> > 'Creation du bitmap d'entrée
> > Bitmap_In = Image.FromFile(Source)
> > 'Conservation du Ratio (OUI/NON)
> > If Not ConserverRatio Then
> > 'Génération a la taille souhaitee
> > Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX),
> > AddressOf ThumbNailAbort, Nothing)
> > Else
> > 'Calcul des dimensions de la miniature du bitmap d'entrée
> > 'si Largeur fixe
> > If TailleY = "" And TailleX <> "" Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> > Final_X = TailleX
> > Final_Y = Height_Out
> > Else
> > 'si Hauteur fixe
> > If TailleX = "" And TailleY <> "" Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > Final_X = Width_Out
> > Final_Y = TailleY
> > Else
> > 'si orientation = paysage
> > If Bitmap_In.Width >= Bitmap_In.Height Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > Else
> > 'si orientation = portrait
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > 'Verification si la taille de la miniature est compatible
> la
> > taille souhaitée
> > 'si Width_Out > TailleX
> > If Width_Out > TailleX Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > End If
> > 'si Height_Out > TailleY
> > If Height_Out > TailleY Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > Final_X = TailleX
> > Final_Y = TailleY
> > End If
> > End If
> > End If
> > 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> > Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
> AddressOf
> > ThumbNailAbort, Nothing)
> > 'Creation d'un bitmap de sortie
> > 'Fond de couleur (OUI/NON)
> > If Not Fond Then
> > Bitmap_Out = Bitmap_In
> > Else
> > 'Creation du bitmap de sortie
> > Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> > 'Defintition de la couleur d'arrière-plan
> > Dim Couleur As Color
> > Couleur = Color.FromArgb(255, R, V, B)
> > 'Definition de la resolution (dpi)
> > Bitmap_Out.SetResolution(Resolution, Resolution)
> > 'Calcul des décalages Haut et gauche pour centrer de l'image
> > Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> > Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> > ' Remplissage de tout les pixels de la couleur du fond
> > Dim Xcount As Integer
> > Dim Ycount As Integer
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_Out.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_Out.Height - 1
> > 'Defintion de la couleur du pixel
> > Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> > Next Ycount
> > Next Xcount
> > ' Recopie des pixels de mon image
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_In.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_In.Height - 1
> > 'Defintion de la couleur du pixel (couleur du pixel de la
> > miniature du bitmap d'entrée)
> > Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> > Bitmap_In.GetPixel(Xcount, Ycount))
> > Next Ycount
> > Next Xcount
> > End If
> > 'Sauvegarde du bitmap de sortie
> > Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> > Bitmap_In = Nothing
> > Bitmap_Out = Nothing
> > End Sub
> >
> > Cependant sur certaines images, le résultat est très décevant.
> > D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
> >
> > D'avance Merci
> >
> > Cédric
>
>
> Par décevant, j'entendait la qualité du rendu de la miniature
Décevent à quel point de vue ? Performances ?
La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais par
exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
comme transparente et il suffirait ensuite de copier ce bitmap vers un
bitmap uni (dont la couleur est définie en traçant un rectangle de la bonne
couleur plutôt qu'en modifiant chaque point individuellement).
--
Patrice
"Cedric" a écrit dans le message de
news:
> Bonjour,
>
> Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
>
> Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
> String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
As
> Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
> System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
Integer,
> ByVal B As Integer)
> Dim Width_Out As Integer
> Dim Height_Out As Integer
> Dim Bitmap_In As Bitmap
> Dim Bitmap_Out As Bitmap
> Dim Final_X As Integer
> Dim Final_Y As Integer
> 'Creation du bitmap d'entrée
> Bitmap_In = Image.FromFile(Source)
> 'Conservation du Ratio (OUI/NON)
> If Not ConserverRatio Then
> 'Génération a la taille souhaitee
> Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
> AddressOf ThumbNailAbort, Nothing)
> Else
> 'Calcul des dimensions de la miniature du bitmap d'entrée
> 'si Largeur fixe
> If TailleY = "" And TailleX <> "" Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> Final_X = TailleX
> Final_Y = Height_Out
> Else
> 'si Hauteur fixe
> If TailleX = "" And TailleY <> "" Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> Final_X = Width_Out
> Final_Y = TailleY
> Else
> 'si orientation = paysage
> If Bitmap_In.Width >= Bitmap_In.Height Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> Else
> 'si orientation = portrait
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> 'Verification si la taille de la miniature est compatible avec
la
> taille souhaitée
> 'si Width_Out > TailleX
> If Width_Out > TailleX Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> End If
> 'si Height_Out > TailleY
> If Height_Out > TailleY Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> Final_X = TailleX
> Final_Y = TailleY
> End If
> End If
> End If
> 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
AddressOf
> ThumbNailAbort, Nothing)
> 'Creation d'un bitmap de sortie
> 'Fond de couleur (OUI/NON)
> If Not Fond Then
> Bitmap_Out = Bitmap_In
> Else
> 'Creation du bitmap de sortie
> Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> 'Defintition de la couleur d'arrière-plan
> Dim Couleur As Color
> Couleur = Color.FromArgb(255, R, V, B)
> 'Definition de la resolution (dpi)
> Bitmap_Out.SetResolution(Resolution, Resolution)
> 'Calcul des décalages Haut et gauche pour centrer de l'image
> Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> ' Remplissage de tout les pixels de la couleur du fond
> Dim Xcount As Integer
> Dim Ycount As Integer
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_Out.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_Out.Height - 1
> 'Defintion de la couleur du pixel
> Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> Next Ycount
> Next Xcount
> ' Recopie des pixels de mon image
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_In.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_In.Height - 1
> 'Defintion de la couleur du pixel (couleur du pixel de la
> miniature du bitmap d'entrée)
> Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> Bitmap_In.GetPixel(Xcount, Ycount))
> Next Ycount
> Next Xcount
> End If
> 'Sauvegarde du bitmap de sortie
> Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> Bitmap_In = Nothing
> Bitmap_Out = Nothing
> End Sub
>
> Cependant sur certaines images, le résultat est très décevant.
> D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
>
> D'avance Merci
>
> Cédric
Décevent à quel point de vue ? Performances ?
La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais par
exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
comme transparente et il suffirait ensuite de copier ce bitmap vers un
bitmap uni (dont la couleur est définie en traçant un rectangle de la bonne
couleur plutôt qu'en modifiant chaque point individuellement).
--
Patrice
"Cedric" <Cedric@discussions.microsoft.com> a écrit dans le message de
news:FC675E3A-DD80-496C-B311-E7796A7BB758@microsoft.com...
> Bonjour,
>
> Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
>
> Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
> String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
As
> Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
> System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
Integer,
> ByVal B As Integer)
> Dim Width_Out As Integer
> Dim Height_Out As Integer
> Dim Bitmap_In As Bitmap
> Dim Bitmap_Out As Bitmap
> Dim Final_X As Integer
> Dim Final_Y As Integer
> 'Creation du bitmap d'entrée
> Bitmap_In = Image.FromFile(Source)
> 'Conservation du Ratio (OUI/NON)
> If Not ConserverRatio Then
> 'Génération a la taille souhaitee
> Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
> AddressOf ThumbNailAbort, Nothing)
> Else
> 'Calcul des dimensions de la miniature du bitmap d'entrée
> 'si Largeur fixe
> If TailleY = "" And TailleX <> "" Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> Final_X = TailleX
> Final_Y = Height_Out
> Else
> 'si Hauteur fixe
> If TailleX = "" And TailleY <> "" Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> Final_X = Width_Out
> Final_Y = TailleY
> Else
> 'si orientation = paysage
> If Bitmap_In.Width >= Bitmap_In.Height Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> Else
> 'si orientation = portrait
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> 'Verification si la taille de la miniature est compatible avec
la
> taille souhaitée
> 'si Width_Out > TailleX
> If Width_Out > TailleX Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> End If
> 'si Height_Out > TailleY
> If Height_Out > TailleY Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> Final_X = TailleX
> Final_Y = TailleY
> End If
> End If
> End If
> 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
AddressOf
> ThumbNailAbort, Nothing)
> 'Creation d'un bitmap de sortie
> 'Fond de couleur (OUI/NON)
> If Not Fond Then
> Bitmap_Out = Bitmap_In
> Else
> 'Creation du bitmap de sortie
> Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> 'Defintition de la couleur d'arrière-plan
> Dim Couleur As Color
> Couleur = Color.FromArgb(255, R, V, B)
> 'Definition de la resolution (dpi)
> Bitmap_Out.SetResolution(Resolution, Resolution)
> 'Calcul des décalages Haut et gauche pour centrer de l'image
> Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> ' Remplissage de tout les pixels de la couleur du fond
> Dim Xcount As Integer
> Dim Ycount As Integer
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_Out.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_Out.Height - 1
> 'Defintion de la couleur du pixel
> Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> Next Ycount
> Next Xcount
> ' Recopie des pixels de mon image
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_In.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_In.Height - 1
> 'Defintion de la couleur du pixel (couleur du pixel de la
> miniature du bitmap d'entrée)
> Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> Bitmap_In.GetPixel(Xcount, Ycount))
> Next Ycount
> Next Xcount
> End If
> 'Sauvegarde du bitmap de sortie
> Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> Bitmap_In = Nothing
> Bitmap_Out = Nothing
> End Sub
>
> Cependant sur certaines images, le résultat est très décevant.
> D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
>
> D'avance Merci
>
> Cédric
Décevent à quel point de vue ? Performances ?
La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais par
exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
comme transparente et il suffirait ensuite de copier ce bitmap vers un
bitmap uni (dont la couleur est définie en traçant un rectangle de la bonne
couleur plutôt qu'en modifiant chaque point individuellement).
--
Patrice
"Cedric" a écrit dans le message de
news:
> Bonjour,
>
> Voulant créer la miniature d'un image, j'utilise le bout de code suivant :
>
> Public Sub GenererMiniature(ByVal Source As String, ByVal Destination As
> String, ByVal TailleX As String, ByVal TailleY As String, ByVal Resolution
As
> Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat As
> System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
Integer,
> ByVal B As Integer)
> Dim Width_Out As Integer
> Dim Height_Out As Integer
> Dim Bitmap_In As Bitmap
> Dim Bitmap_Out As Bitmap
> Dim Final_X As Integer
> Dim Final_Y As Integer
> 'Creation du bitmap d'entrée
> Bitmap_In = Image.FromFile(Source)
> 'Conservation du Ratio (OUI/NON)
> If Not ConserverRatio Then
> 'Génération a la taille souhaitee
> Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX), CInt(TailleY),
> AddressOf ThumbNailAbort, Nothing)
> Else
> 'Calcul des dimensions de la miniature du bitmap d'entrée
> 'si Largeur fixe
> If TailleY = "" And TailleX <> "" Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> Final_X = TailleX
> Final_Y = Height_Out
> Else
> 'si Hauteur fixe
> If TailleX = "" And TailleY <> "" Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> Final_X = Width_Out
> Final_Y = TailleY
> Else
> 'si orientation = paysage
> If Bitmap_In.Width >= Bitmap_In.Height Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> Else
> 'si orientation = portrait
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> 'Verification si la taille de la miniature est compatible avec
la
> taille souhaitée
> 'si Width_Out > TailleX
> If Width_Out > TailleX Then
> Width_Out = CInt(TailleX)
> Height_Out = CInt(TailleX) * Bitmap_In.Height /
Bitmap_In.Width
> End If
> 'si Height_Out > TailleY
> If Height_Out > TailleY Then
> Height_Out = CInt(TailleY)
> Width_Out = CInt(TailleY) * Bitmap_In.Width / Bitmap_In.Height
> End If
> Final_X = TailleX
> Final_Y = TailleY
> End If
> End If
> End If
> 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
AddressOf
> ThumbNailAbort, Nothing)
> 'Creation d'un bitmap de sortie
> 'Fond de couleur (OUI/NON)
> If Not Fond Then
> Bitmap_Out = Bitmap_In
> Else
> 'Creation du bitmap de sortie
> Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> 'Defintition de la couleur d'arrière-plan
> Dim Couleur As Color
> Couleur = Color.FromArgb(255, R, V, B)
> 'Definition de la resolution (dpi)
> Bitmap_Out.SetResolution(Resolution, Resolution)
> 'Calcul des décalages Haut et gauche pour centrer de l'image
> Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> ' Remplissage de tout les pixels de la couleur du fond
> Dim Xcount As Integer
> Dim Ycount As Integer
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_Out.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_Out.Height - 1
> 'Defintion de la couleur du pixel
> Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> Next Ycount
> Next Xcount
> ' Recopie des pixels de mon image
> 'boucle sur le nombre de colonnes
> For Xcount = 0 To Bitmap_In.Width - 1
> 'boucle sur le nombre de lignes
> For Ycount = 0 To Bitmap_In.Height - 1
> 'Defintion de la couleur du pixel (couleur du pixel de la
> miniature du bitmap d'entrée)
> Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> Bitmap_In.GetPixel(Xcount, Ycount))
> Next Ycount
> Next Xcount
> End If
> 'Sauvegarde du bitmap de sortie
> Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> Bitmap_In = Nothing
> Bitmap_Out = Nothing
> End Sub
>
> Cependant sur certaines images, le résultat est très décevant.
> D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
>
> D'avance Merci
>
> Cédric
Suite à la remarque voici, les modifications que j'ai apporté :
' Remplissage de tout les pixels de la couleur du fond
Dim MyGraphics As Graphics = Graphics.FromImage(Bitmap_Out)
Dim MyBackground As New SolidBrush(Couleur)
' Remplissage de tout les pixels de la couleur du fond
MyGraphics.FillRectangle(MyBackground, 0, 0, Bitmap_Out.Width,
Bitmap_Out.Height)
' Recopie du bitmap d'entrée en position centrée
MyGraphics.DrawImage(Bitmap_In, Left, Top, Bitmap_In.Width,
MyBackground = Nothing
MyGraphics = Nothing
Cependant la qualité de l'image de sortie (Miniature) ne s'est pas
Cédric
"Patrice" a écrit :
> Décevent à quel point de vue ? Performances ?
>
> La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais
> exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
> comme transparente et il suffirait ensuite de copier ce bitmap vers un
> bitmap uni (dont la couleur est définie en traçant un rectangle de la
> couleur plutôt qu'en modifiant chaque point individuellement).
>
> --
> Patrice
>
> "Cedric" a écrit dans le message de
> news:
> > Bonjour,
> >
> > Voulant créer la miniature d'un image, j'utilise le bout de code
> >
> > Public Sub GenererMiniature(ByVal Source As String, ByVal Destination
> > String, ByVal TailleX As String, ByVal TailleY As String, ByVal
> As
> > Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> > PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat
> > System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
> Integer,
> > ByVal B As Integer)
> > Dim Width_Out As Integer
> > Dim Height_Out As Integer
> > Dim Bitmap_In As Bitmap
> > Dim Bitmap_Out As Bitmap
> > Dim Final_X As Integer
> > Dim Final_Y As Integer
> > 'Creation du bitmap d'entrée
> > Bitmap_In = Image.FromFile(Source)
> > 'Conservation du Ratio (OUI/NON)
> > If Not ConserverRatio Then
> > 'Génération a la taille souhaitee
> > Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX),
> > AddressOf ThumbNailAbort, Nothing)
> > Else
> > 'Calcul des dimensions de la miniature du bitmap d'entrée
> > 'si Largeur fixe
> > If TailleY = "" And TailleX <> "" Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> > Final_X = TailleX
> > Final_Y = Height_Out
> > Else
> > 'si Hauteur fixe
> > If TailleX = "" And TailleY <> "" Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > Final_X = Width_Out
> > Final_Y = TailleY
> > Else
> > 'si orientation = paysage
> > If Bitmap_In.Width >= Bitmap_In.Height Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > Else
> > 'si orientation = portrait
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > 'Verification si la taille de la miniature est compatible
> la
> > taille souhaitée
> > 'si Width_Out > TailleX
> > If Width_Out > TailleX Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > End If
> > 'si Height_Out > TailleY
> > If Height_Out > TailleY Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > Final_X = TailleX
> > Final_Y = TailleY
> > End If
> > End If
> > End If
> > 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> > Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
> AddressOf
> > ThumbNailAbort, Nothing)
> > 'Creation d'un bitmap de sortie
> > 'Fond de couleur (OUI/NON)
> > If Not Fond Then
> > Bitmap_Out = Bitmap_In
> > Else
> > 'Creation du bitmap de sortie
> > Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> > 'Defintition de la couleur d'arrière-plan
> > Dim Couleur As Color
> > Couleur = Color.FromArgb(255, R, V, B)
> > 'Definition de la resolution (dpi)
> > Bitmap_Out.SetResolution(Resolution, Resolution)
> > 'Calcul des décalages Haut et gauche pour centrer de l'image
> > Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> > Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> > ' Remplissage de tout les pixels de la couleur du fond
> > Dim Xcount As Integer
> > Dim Ycount As Integer
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_Out.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_Out.Height - 1
> > 'Defintion de la couleur du pixel
> > Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> > Next Ycount
> > Next Xcount
> > ' Recopie des pixels de mon image
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_In.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_In.Height - 1
> > 'Defintion de la couleur du pixel (couleur du pixel de la
> > miniature du bitmap d'entrée)
> > Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> > Bitmap_In.GetPixel(Xcount, Ycount))
> > Next Ycount
> > Next Xcount
> > End If
> > 'Sauvegarde du bitmap de sortie
> > Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> > Bitmap_In = Nothing
> > Bitmap_Out = Nothing
> > End Sub
> >
> > Cependant sur certaines images, le résultat est très décevant.
> > D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
> >
> > D'avance Merci
> >
> > Cédric
>
>
>
Suite à la remarque voici, les modifications que j'ai apporté :
' Remplissage de tout les pixels de la couleur du fond
Dim MyGraphics As Graphics = Graphics.FromImage(Bitmap_Out)
Dim MyBackground As New SolidBrush(Couleur)
' Remplissage de tout les pixels de la couleur du fond
MyGraphics.FillRectangle(MyBackground, 0, 0, Bitmap_Out.Width,
Bitmap_Out.Height)
' Recopie du bitmap d'entrée en position centrée
MyGraphics.DrawImage(Bitmap_In, Left, Top, Bitmap_In.Width,
MyBackground = Nothing
MyGraphics = Nothing
Cependant la qualité de l'image de sortie (Miniature) ne s'est pas
Cédric
"Patrice" a écrit :
> Décevent à quel point de vue ? Performances ?
>
> La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais
> exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
> comme transparente et il suffirait ensuite de copier ce bitmap vers un
> bitmap uni (dont la couleur est définie en traçant un rectangle de la
> couleur plutôt qu'en modifiant chaque point individuellement).
>
> --
> Patrice
>
> "Cedric" <Cedric@discussions.microsoft.com> a écrit dans le message de
> news:FC675E3A-DD80-496C-B311-E7796A7BB758@microsoft.com...
> > Bonjour,
> >
> > Voulant créer la miniature d'un image, j'utilise le bout de code
> >
> > Public Sub GenererMiniature(ByVal Source As String, ByVal Destination
> > String, ByVal TailleX As String, ByVal TailleY As String, ByVal
> As
> > Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> > PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat
> > System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
> Integer,
> > ByVal B As Integer)
> > Dim Width_Out As Integer
> > Dim Height_Out As Integer
> > Dim Bitmap_In As Bitmap
> > Dim Bitmap_Out As Bitmap
> > Dim Final_X As Integer
> > Dim Final_Y As Integer
> > 'Creation du bitmap d'entrée
> > Bitmap_In = Image.FromFile(Source)
> > 'Conservation du Ratio (OUI/NON)
> > If Not ConserverRatio Then
> > 'Génération a la taille souhaitee
> > Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX),
> > AddressOf ThumbNailAbort, Nothing)
> > Else
> > 'Calcul des dimensions de la miniature du bitmap d'entrée
> > 'si Largeur fixe
> > If TailleY = "" And TailleX <> "" Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> > Final_X = TailleX
> > Final_Y = Height_Out
> > Else
> > 'si Hauteur fixe
> > If TailleX = "" And TailleY <> "" Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > Final_X = Width_Out
> > Final_Y = TailleY
> > Else
> > 'si orientation = paysage
> > If Bitmap_In.Width >= Bitmap_In.Height Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > Else
> > 'si orientation = portrait
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > 'Verification si la taille de la miniature est compatible
> la
> > taille souhaitée
> > 'si Width_Out > TailleX
> > If Width_Out > TailleX Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > End If
> > 'si Height_Out > TailleY
> > If Height_Out > TailleY Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > Final_X = TailleX
> > Final_Y = TailleY
> > End If
> > End If
> > End If
> > 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> > Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
> AddressOf
> > ThumbNailAbort, Nothing)
> > 'Creation d'un bitmap de sortie
> > 'Fond de couleur (OUI/NON)
> > If Not Fond Then
> > Bitmap_Out = Bitmap_In
> > Else
> > 'Creation du bitmap de sortie
> > Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> > 'Defintition de la couleur d'arrière-plan
> > Dim Couleur As Color
> > Couleur = Color.FromArgb(255, R, V, B)
> > 'Definition de la resolution (dpi)
> > Bitmap_Out.SetResolution(Resolution, Resolution)
> > 'Calcul des décalages Haut et gauche pour centrer de l'image
> > Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> > Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> > ' Remplissage de tout les pixels de la couleur du fond
> > Dim Xcount As Integer
> > Dim Ycount As Integer
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_Out.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_Out.Height - 1
> > 'Defintion de la couleur du pixel
> > Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> > Next Ycount
> > Next Xcount
> > ' Recopie des pixels de mon image
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_In.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_In.Height - 1
> > 'Defintion de la couleur du pixel (couleur du pixel de la
> > miniature du bitmap d'entrée)
> > Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> > Bitmap_In.GetPixel(Xcount, Ycount))
> > Next Ycount
> > Next Xcount
> > End If
> > 'Sauvegarde du bitmap de sortie
> > Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> > Bitmap_In = Nothing
> > Bitmap_Out = Nothing
> > End Sub
> >
> > Cependant sur certaines images, le résultat est très décevant.
> > D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
> >
> > D'avance Merci
> >
> > Cédric
>
>
>
Suite à la remarque voici, les modifications que j'ai apporté :
' Remplissage de tout les pixels de la couleur du fond
Dim MyGraphics As Graphics = Graphics.FromImage(Bitmap_Out)
Dim MyBackground As New SolidBrush(Couleur)
' Remplissage de tout les pixels de la couleur du fond
MyGraphics.FillRectangle(MyBackground, 0, 0, Bitmap_Out.Width,
Bitmap_Out.Height)
' Recopie du bitmap d'entrée en position centrée
MyGraphics.DrawImage(Bitmap_In, Left, Top, Bitmap_In.Width,
MyBackground = Nothing
MyGraphics = Nothing
Cependant la qualité de l'image de sortie (Miniature) ne s'est pas
Cédric
"Patrice" a écrit :
> Décevent à quel point de vue ? Performances ?
>
> La copie pixel par pixel est très consommatrice. Je n'ai pas fait mais
> exemple Bitmap.MakeTransparent devrait permettre de définir une couleur
> comme transparente et il suffirait ensuite de copier ce bitmap vers un
> bitmap uni (dont la couleur est définie en traçant un rectangle de la
> couleur plutôt qu'en modifiant chaque point individuellement).
>
> --
> Patrice
>
> "Cedric" a écrit dans le message de
> news:
> > Bonjour,
> >
> > Voulant créer la miniature d'un image, j'utilise le bout de code
> >
> > Public Sub GenererMiniature(ByVal Source As String, ByVal Destination
> > String, ByVal TailleX As String, ByVal TailleY As String, ByVal
> As
> > Integer, ByVal Fond As Boolean, ByVal ConserverRatio As Boolean, ByVal
> > PixelFormat As System.Drawing.Imaging.PixelFormat, ByVal ImageFormat
> > System.Drawing.Imaging.ImageFormat, ByVal R As Integer, ByVal V As
> Integer,
> > ByVal B As Integer)
> > Dim Width_Out As Integer
> > Dim Height_Out As Integer
> > Dim Bitmap_In As Bitmap
> > Dim Bitmap_Out As Bitmap
> > Dim Final_X As Integer
> > Dim Final_Y As Integer
> > 'Creation du bitmap d'entrée
> > Bitmap_In = Image.FromFile(Source)
> > 'Conservation du Ratio (OUI/NON)
> > If Not ConserverRatio Then
> > 'Génération a la taille souhaitee
> > Bitmap_In = Bitmap_In.GetThumbnailImage(CInt(TailleX),
> > AddressOf ThumbNailAbort, Nothing)
> > Else
> > 'Calcul des dimensions de la miniature du bitmap d'entrée
> > 'si Largeur fixe
> > If TailleY = "" And TailleX <> "" Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height / Bitmap_In.Width
> > Final_X = TailleX
> > Final_Y = Height_Out
> > Else
> > 'si Hauteur fixe
> > If TailleX = "" And TailleY <> "" Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > Final_X = Width_Out
> > Final_Y = TailleY
> > Else
> > 'si orientation = paysage
> > If Bitmap_In.Width >= Bitmap_In.Height Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > Else
> > 'si orientation = portrait
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > 'Verification si la taille de la miniature est compatible
> la
> > taille souhaitée
> > 'si Width_Out > TailleX
> > If Width_Out > TailleX Then
> > Width_Out = CInt(TailleX)
> > Height_Out = CInt(TailleX) * Bitmap_In.Height /
> Bitmap_In.Width
> > End If
> > 'si Height_Out > TailleY
> > If Height_Out > TailleY Then
> > Height_Out = CInt(TailleY)
> > Width_Out = CInt(TailleY) * Bitmap_In.Width /
> > End If
> > Final_X = TailleX
> > Final_Y = TailleY
> > End If
> > End If
> > End If
> > 'Creation d'une miniature du bitmap d'entree à la taille souhaitée
> > Bitmap_In = Bitmap_In.GetThumbnailImage(Width_Out, Height_Out,
> AddressOf
> > ThumbNailAbort, Nothing)
> > 'Creation d'un bitmap de sortie
> > 'Fond de couleur (OUI/NON)
> > If Not Fond Then
> > Bitmap_Out = Bitmap_In
> > Else
> > 'Creation du bitmap de sortie
> > Bitmap_Out = New Bitmap(Final_X, Final_Y, PixelFormat)
> > 'Defintition de la couleur d'arrière-plan
> > Dim Couleur As Color
> > Couleur = Color.FromArgb(255, R, V, B)
> > 'Definition de la resolution (dpi)
> > Bitmap_Out.SetResolution(Resolution, Resolution)
> > 'Calcul des décalages Haut et gauche pour centrer de l'image
> > Dim Top As Integer = (Bitmap_Out.Height - Bitmap_In.Height) / 2
> > Dim Left As Integer = (Bitmap_Out.Width - Bitmap_In.Width) / 2
> > ' Remplissage de tout les pixels de la couleur du fond
> > Dim Xcount As Integer
> > Dim Ycount As Integer
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_Out.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_Out.Height - 1
> > 'Defintion de la couleur du pixel
> > Bitmap_Out.SetPixel(Xcount, Ycount, Couleur)
> > Next Ycount
> > Next Xcount
> > ' Recopie des pixels de mon image
> > 'boucle sur le nombre de colonnes
> > For Xcount = 0 To Bitmap_In.Width - 1
> > 'boucle sur le nombre de lignes
> > For Ycount = 0 To Bitmap_In.Height - 1
> > 'Defintion de la couleur du pixel (couleur du pixel de la
> > miniature du bitmap d'entrée)
> > Bitmap_Out.SetPixel(Left + Xcount, Top + Ycount,
> > Bitmap_In.GetPixel(Xcount, Ycount))
> > Next Ycount
> > Next Xcount
> > End If
> > 'Sauvegarde du bitmap de sortie
> > Bitmap_Out.Save(Destination, ImageFormat.Tiff)
> > Bitmap_In = Nothing
> > Bitmap_Out = Nothing
> > End Sub
> >
> > Cependant sur certaines images, le résultat est très décevant.
> > D'ou peut venir le problème ? peut-on optimiser ce code un maximum ?
> >
> > D'avance Merci
> >
> > Cédric
>
>
>