  .Net GDI+
[40 mn de lecture - paru le 4/15/2004 4:43:05 PM - Public : Confirmé]
|
 
|
Auteur
3. Chargement, Enregistrement, Visualisation
3.1. Création de la Classe traitementImage
Dans votre Projet Visual vous devez ajouter une nouvelle Classe que vous intitulez "traitementImage"
Placez les nameSpaces suivants dans l'entête :
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using imagetest = System.Drawing; // on crée un alias pour éviter toutes ambiguïté
Et vous ajouter ces données membres de la classe en privée pour qu'elles ne soient pas accessible :
private Image monImage; // l'image en cours
private String imageNom = ""; //nom de l'image
private ImageFormat imageFormat; // format de l'image
3.2. Chargement de l'image
Au chargement de l'image il ne faut pas oublie d'appeler la méthode Dispose des images pour garantir une libération des ressources, au cas où la classe contiendrait déjà une image.
/// <summary>
/// libérer les ressources allouées
/// </summary>
public void Dispose()
{
if(monImage != null)
monImage.Dispose();
}
Pour charger l'image on crée un objet Image du fichier source en utilisant Les méthodes FromFile ou FromHbitmap ou FromStream.
/// <summary>
/// charge l'image spécifié
/// </summary>
/// <param name="cheminImage">
/// ce parametre donne le chemin de l'image à charger
/// </param>
public void chargementImage(string cheminImage)
{
if(monImage != null) monImage.Dispose();
monImage = Image.FromFile(cheminImage);
imageNom = cheminImage;
imageFormat = monImage.RawFormat;
}
3.3. Enregistrement de l'image
La classe Imaging elle-même effectue le gros du travail d'enregistrement de l'image.
Bien que le garbage-collector puisse lui-même libérer les ressources, il n'est pas garanti qu'il le fasse et cela peut conduire à réduire sensiblement les ressources disponibles pour le système lui-même. Le nom de fichier qui est stocké peut servir de référence lors des prochaines opérations d'enregistrement.
La méthode Save sous-traite à la méthode des images en utilisant le nom de fichier d'origine précédemment stocké.
La méthode SaveAs se décline en deux surcharges.
/// <summary>
/// Enregistre l'image sur son nom image
/// </summary>
public void SaveImage()
{
monImage.Save(imageNom,imageFormat);
}
/// <summary>
/// Enregistrement de l'image courante sous un nouveau nom
/// </summary>
/// <param name="nouveauNom">
/// nouveau nom de l'image
/// </param>
public void SaveImageAs(String nouveauNom)
{
monImage.Save(nouveauNom,imageFormat);
}
/// <summary>
/// Enregistrement de l'image courante sous un nouveau nom
/// </summary>
/// <param name="nouveauNom">
/// nouveau nom de l'image
/// </param>
/// <param name="format">
/// nouveauFormat (gif, jpg, bmp, tiff, etc.)
/// </param>
public void SaveImageAs(String nouveauNom,ImageFormat nouveauFormat)
{
monImage.Save(nouveauNom,nouveauFormat);
}
3.4. Propriété de l'image
Nous allons établir plusieurs méthodes nous permettants d'avoir le maximum d'information sur la photo que nous voulons traiter : la taille(largeur, hauteur), résolution, format...
/// <summary>
/// Retourne la largeur de l'image
/// </summary>
public int Width
{
get
{
return monImage.Width;
}
}
/// <summary>
/// Retourne la hauteur de l'image
/// </summary>
public int Height
{
get
{
return monImage.Height;
}
}
/// <summary>
/// retourne la taille de l'image
/// </summary>
public Size Size
{
get
{
return monImage.Size;
}
}
/// <summary>
/// retourne la résolution Horizontal de l'image
/// </summary>
public float HorizontalResolution
{
get
{
return monImage.HorizontalResolution;
}
}
/// <summary>
/// retourne la résolution Vertical de l'image
/// </summary>
public float VerticalResolution
{
get
{
return monImage.VerticalResolution;
}
}
/// <summary>
/// retourne la format de l'image
/// </summary>
public string RawFormat
{
get
{
return monImage.RawFormat.ToString();
}
}
/// <summary>
/// Retourne le type de l'image, en nombre de pixel. PixelFormat peut prendre l'une des valeurs de l'énumération de PixelFormat
/// </summary>
public string PixelFormat
{
get
{
return monImage.PixelFormat.ToString();
}
}
3.5. Poids de l'image
Pour le poid je fait une petite appartée pour vous donnée une astuce afin de connaitre le poid d'une photo (c'est la même chose pour n'importe quel fichier)
N'oubliez pas d'importer using System.IO; C'est le nameSpace qui gére les fichiers
/// <summary>
/// retourne le poid de l'image et l'arrondi en Mo, Ko ou Octect
/// </summary>
/// <param name="cheminImage">
/// chemin de l'image
/// </param>
public string poidImage(string cheminImage)
{
FileInfo monImagePoid = new FileInfo(cheminImage);// on instancie la propriété du nameSpace IO
if(monImagePoid.Length > 1000000)
{
return (monImagePoid.Length /1000000) + " Mo";// retourne le poid en Mo
}
else
{
if(monImagePoid.Length > 1000)
{
return (monImagePoid.Length /1000) + " Ko";// retourne le poid en ko
}
else
{
return monImagePoid.Length + " octets";// retourne le poid en octect
}
}
}
3.6. Intanciation de la Classe traitementImage
Nous allons établir plusieurs méthodes nous permettants d'avoir le maximum d'information sur la photo que nous voulons traiter : la taille(largeur, hauteur), résolution, format...
dans la page aspx placez deux contrôle : un Label et un ImageButton que vous nomerez respectivement infoLabel et ImageButton1 :
<asp:Label id="infoLabel" runat=server/>
<asp:ImageButton id="ImageButton1" runat=server ImageUrl="fille:///E:\photo.JPG"/>
dans le code Behind :
private void Page_Load(object sender, System.EventArgs e)
{
String path = ImageButton1.ImageUrl.Replace("file:///","").ToString();
traitementImage monImage = new traitementImage();// on instancie notre classe traitementImage
monImage.chargementImage(path);// on charge l'image
/* revoie dans le label toutes le propriété que l'on a besion*/
infoLabel.Text="<u>Propriété de l'image </u><br>";
infoLabel.Text=infoLabel.Text + "<br>HorizontalResolution : " + monImage.HorizontalResolution;
infoLabel.Text=infoLabel.Text + "<br>VerticalResolution : " + monImage.VerticalResolution;
infoLabel.Text=infoLabel.Text + "<br>RawFormat : " + monImage.RawFormat;
infoLabel.Text=infoLabel.Text + "<br>PixelFormat : " + monImage.PixelFormat;
infoLabel.Text=infoLabel.Text + "<br>tailleImage : " + monImage.tailleImage;
infoLabel.Text=infoLabel.Text + "<br>Poid mon image :" + monImage.poidImage(path);// notre bonus le poids de l'image
}
Ce qui donne :
|
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]