  .Net GDI+
[40 mn de lecture - paru le 4/15/2004 4:43:05 PM - Public : Confirmé]
|
 
|
Auteur
4. Comment redimensionner
4.1. Redimensionner
Le redimensionnement d'une image se fait en deux étapes dans cette classe. D'abord, une nouvelle image est créée à la taille requise, sur la base de l'image d'origine. Ensuite, l'image originale est supprimée et remplacée par la nouvelle image.
///<summary>
/// Redimensionne l'image à la taille indiquée. L'allongement de l'image n'est pas respecté
/// </summary>
/// <param name="width">
/// largeur de l'image redimensionnée
/// </param>
/// <param name="height">
/// hauteur de l'image redimensionnée
/// </param>
public void Resize(int width, int height)
{
Size s = new Size(width, height);
Resize(s);
}
/// <summary>
/// Redimensionne l'image à la taille indiquée. L'allongement de l'image n'est pas respecté
/// </summary>
/// <param name="newSize">
/// specifie la nouvelle taille de l'image
/// </param>
public void Resize(Size newSize)
{
if(newSize.Width <= 0 || newSize.Height <= 0)
throw new ArgumentOutOfRangeException("Spécifie une taille dans l'image.");
Bitmap tempImage = new Bitmap(monImage,newSize);
monImage.Dispose();
monImage = tempImage;
}
Le redimensionnement effectif de l'image est réalisé durant la création de la nouvelle image, puisque l'une des options lors de la création d'une image est de la baser sur une image existante. Notez aussi que l'image d'origine appelle la méthode Dispose pour qu'elle libère les ressources devenues inutiles. Il existe deux versions de la fonction Resize, ce qui vous laisse le choix des types de paramètre.
4.2. Rogner
Rogner une image est légèrement plus compliqué que le redimensionnement. Ce n'est pas une méthode de GDI+.
Nous allons créer une méthodes rognage d'une image réduit la taille de l'image en coupant une partie de celle-ci. Il ne redimensionne pas le contenu de l'image d'origine.
Nous allons mettre en place deux versions de la fonction Rogner, chacune acceptant des paramètres différents. La première version prend une largeur et une hauteur. Ces dimensions sont ensuite centrées sur l'image et un rectangle de rognage est calculé. Ce dernier est ensuite transmis à la deuxième version de la fonction Crop pour effectuer le rognage de l'image.
/// <summary>
/// Rogne l'image par rapport au rectangle spécifiée
/// </summary>
/// <param name="cropRect">
/// dimensions de l'image rognée(du rectangle)
/// </param>
public void Rogner(Rectangle cropRect)
{
// créer la nouvelle image dans laquelle rogner l'image
Bitmap tempImage = new Bitmap( cropRect.Width,
cropRect.Height, monImage.PixelFormat);
Graphics g = Graphics.FromImage(tempImage);
g.DrawImage(monImage,
0,0,
cropRect,
GraphicsUnit.Pixel);
g.Dispose();
monImage.Dispose();
monImage = tempImage;
}
/// <summary>
/// Rogne l'image avec la largeur et la hauteur spécifiée
/// </summary>
/// <param name="width">
/// largeur à rogner
/// </param>
/// <param name="height">
/// hauteur à rogner
/// </param>
public void Rogner(int cropWidth,int cropHeight)
{
// rogner seulement si les dimensions spécifiées sont inférieures
// à celles de l'image d'origine
if(cropWidth > monImage.Width)
cropWidth = monImage.Width;
if(cropHeight > monImage.Height)
cropHeight = monImage.Height;
//calculer le rectangle de rognagee
int xStart = (monImage.Width - cropWidth);
if(xStart != 0)
xStart /= 2;
int yStart = (monImage.Height - cropHeight);
if(yStart != 0)
yStart /= 2;
Rectangle cropRect = new Rectangle(
xStart, yStart,
cropWidth, cropHeight);
//effectuer le rognage
Rogner(cropRect);
}
La deuxième méthodes Rogner surcharger prend un rectangle comme paramètre. Cela permet d'avoir un contrôle complet sur la zone à rogner de l'image.
Pour effectuer le rognage, une nouvelle image est créée à l'aide des dimensions spécifiées dans cropRect et le format pixel spécifié dans l'image d'origine (le format pixel fait référence à la profondeur de couleurs, telle que 256 couleurs, couleur 24 bits, couleur 32 bits, etc.)
Ensuite, un contexte graphique est créé sur la nouvelle image. Ce dernier est nécessaire pour effectuer toute opération de dessin dans .NET.
Reportez-vous à la classe .NET System.Drawing.Graphics pour plus d'informations sur les contextes graphiques. Comme le contexte graphique a été créé à partir de l'image, tout le dessin s'effectuera directement sur l'image.
Une fois le contexte graphique créé, l'image d'origine est ensuite dessinée sur la nouvelle image, ou du moins seule une partie de l'originale. L'un des paramètres que la fonction DrawImage peut accepter est un rectangle qui indique la zone à conserver. Ainsi, au lieu que l'image entière soit dessinée, seule la partie se trouvant dans les coordonnées du rectangle est conservée.
Une fois la nouvelle image créée, le contexte graphique est supprimé, et l'image d'origine est alors remplacée par l'image rognée.
4.3. Exemple d'image redimensionner
Pour notre exemple mettez dans votre page ASPX un Contrôle Bouton , double cliquez dessus.
Vous arrivez dans le code behind , dans la partie onClick insérer :
private void redimensionnerButton_Click(object sender, System.EventArgs e)
{
String path = ImageButton1.ImageUrl.Replace("file:///","").ToString();// on récupere le chemin de la photo
traitementImage monImage = new traitementImage();// on instancie la classe traitementImage
monImage.chargementImage(path);// chargement de l'image
monImage.Resize(100,100);// on redimensionne l'image de 100 en Largeur comme en Hauteur
String nouveaNom = Server.MapPath(Request.ApplicationPath) + "/miniaturePhoto.JPG";// on cherche le chemin du serveur et on donne un nouveau nom
monImage.SaveImageAs(nouveaNom);// on fait en Enregistrer Sous un nouveau nom
}
Comme vous pouvez le constatez l'image est diforme, pour réaliser la meilleur redimension vous devrez jongler entre la méthode Rogner et Resize.
4.4. Miniature
Et oui .Net à prévu une méthode pour générer des miniatures (vignette d'image JPG, GIF,TIFF...) : GetThumbnailImage
public void miniature()
{
Image.GetThumbnailImageAbort tnCallBack = new Image.GetThumbnailImageAbort(tnCallbackMethod);
// Get the thumbnail image
Image thumbNailImage = monImage.GetThumbnailImage (100, 100, tnCallBack, IntPtr.Zero);
// cree un objet graphic
Graphics g = Graphics.FromImage(monImage);
g.Clear(System.Drawing.Color.White);
// créer la miniature
g.DrawImage(thumbNailImage, 40, 20);
// libere les ressources de l'objet graphic
g.Dispose();
monImage.Dispose();
monImage = thumbNailImage;
}
// doit être appeler mais pas utilisé
public bool tnCallbackMethod()
{
return false;
}
|
829 Visites
Michel DEGREMONT
[15 mn de lecture - paru le 4/15/2004 11:08:32 AM - Public : Débutant]
[20 mn de lecture - paru le 4/14/2004 11:46:15 PM - Public : Débutant]