Home

Les Opérations sur les Bitmaps

 

Introduction à la zone de l'image

 

Description

Vous pouvez afficher une image directement sur un formulaire. Néanmoins, pour vous donner un espace plus confortable pour afficher une image, le .NET Framework fournit un contrôle Windows nommé PicturePox.

Comme la plupart des contrôles que nous avons décrits dans notre introduction pour le contrôle de la conception, pour obtenir un bloc d'image, de la boìte à outils, vous pouvez cliquer sur le contrôle PictureBox PictureBox et cliquez sur le formulaire. Pour obtenir le contrôle de programmation, vous pouvez créer une poignée à la classe PictureBox. Avant d'utiliser le contrôle, assurez-vous que vous l'ajoutez à la liste des contrôles du formulaire qui sera l'hòte. Voici un exemple :

using System;  
using System.Windows.Forms;    

public class Exercise : Form  
{
	private PictureBox pctBox;        
  
	public Exercise()      
	{      
	}
 
	private void InitializeComponents()      
	{          
		pctBox = new PictureBox();          
		Controls.Add(pctBox);      
	}  
} 
 
public class Program  
{      
	public static int Main()      
	{          
		Application.Run(new Exercise());          
		return 0;      
	}  
}

Introduction aux caractéristiques d'une zone de l'image

Comme un contrôle visuel régulier, après qu'un bloc d'image ait été ajouté à un formulaire, il suppose une taille par défaut (sauf si vous vous faites glisser et avez attiré lors de leur ajout). Vous pouvez ensuite déplacer ou redimensionner à l'aide de techniques de conception d'applications que nous avons examinées dans les leçons 3 et 4. Bien entendu, vous pouvez également spécifier l'emplacement et la taille du contrôle par programmation. Voici un exemple :

using System;  
using System.Drawing;  
using System.Windows.Forms;    
 
 
public class Exercise : Form  
{      
	 private PictureBox pctBox;        
 
 
	 public Exercise()      
	 {          
		 InitializeComponents();      
	}        
 
	
	private void InitializeComponents()      
	{          
		pctBox = new PictureBox();          
		pctBox.Location = new Point(10, 10);          
		pctBox.Size = new Size(200, 150);          
		Controls.Add(pctBox);      
	}  
}    
 
 
public class Program  
{      
	 public static int Main()      
	 {          
		 Application.Run(new Exercise());          
		 return 0;      
	 }  
}

Le style de bordure d'une zone de l'image

Par défaut, lorsque vous avez ajouté une zone d'image à un formulaire, il apparaìt sans frontières. Au moment de l'exécution, le concepteur du formulaire montrerait les bordures de sorte que vous pouvez facilement le déplacer ou le redimensionner :

Picture Box

Au moment de l'exécution, sauf si vous dessinez une forme, ou affichez un objet dans la zone image, l'utilisateur ne sait pas où commence la zone de l'image ni où elle se termine :

Picture Box

Il n'existe aucun moyen de savoir que le formulaire ci-dessus contient une zone de l'image. Si vous souhaitez que la zone de l'image affiche ses frontières à l'utilisateur, vous pouvez utiliser la propriété BorderStyle. Nous avons décrit cette propriété dans la Leçon 5.

L'image d'une zone d'image

Comme indiqué dans l'introduction, l'objectif principal d'une zone d'image est d'afficher une image. Pour cela, la classe PictureBox est équipée d'une propriété appelée Image. Cette propriété est de type Image. Au moment du design, pour spécifier l'image que ce contrôle tiendra, cliquez tout d'abord la zone de l'image sur l'écran pour sélectionner :

  • Cliquez sur le bouton triangulaire dans la ligne du haut :
     

     
    et cliquez sur Choisir une image
  • Cliquez sur le bouton de sélection du champ Image dans la fenêtre Propriétés

Dans les deux cas, une boìte de dialogue viendra pour vous aider à localiser en sélectionnant une image.

Par programmation, spécifiez l'image à afficher, affectez un objet Image à l'instance de la classe PictureBox. Voici un exemple :

using System;  
using System.Drawing;  
using System.Windows.Forms;    

public class Exercise : Form  
{      
	private PictureBox pctBox;

	public Exercise()      
	{
		InitializeComponents();   
	}        
 
 
	private void InitializeComponents()      
	{          
		pctBox = new PictureBox();          
		pctBox.Location = new Point(10, 10);          
		pctBox.Size = new Size(200, 150);          
		pctBox.Image = Image.FromFile(@"E:\Programs\Person.bmp");          
		Controls.Add(pctBox);      
	}  
}    
 
public class Program  
{      
	public static int Main()      
	{          
		Application.Run(new Exercise());          
		return 0;      
	}  
}

Si vous décidez de spécifier l'image par programmation, veillez à fournir une image valide ou un chemin valide à l'image ; dans le cas contraire vous recevrez une erreur si l'application ne peut pas trouver l'image.

L'emplacement de l'image de l'image d'une zone de l'image

Outre la propriété PictureBox.Image, pour vous aider à spécifier l'image à afficher, la classe de contrôle PictureBox fournit une propriété nommée ImageLocation. Cette propriété, qui est de type String, attend soit le chemin vers le fichier ou l'URL de l'image. Au moment du design, la différence avec la propriété image est que vous n'êtes pas invité à sélectionner une image mais à donner son emplacement. Par conséquent, pour l'utiliser, dans la fenêtre Propriétés, tapez le chemin d'accès complet :

Properties Window 


N'oubliez pas que vous pouvez également fournir une URL de l'image :

Properties Windows

Dans les deux cas, si vous fournissez un chemin d'accès incorrect ou un lien rompu, c'est-à-dire si le compilateur ne peut pas trouver l'image, la zone image affiche une icòne X sur son corps.

Au moment de l'exécution, vous pouvez également spécifier le chemin ou l'URL de l'image en l'affectant à la propriété PictureBox.ImageLocation. Voici un exemple :

public class Exercise : Form  
{      
	private PictureBox pctBox;        
 
 
	public Exercise()      
	{          
		InitializeComponents();      
	}        
 
 
	private void InitializeComponents()      
	{          
		pctBox = new PictureBox();          
		pctBox.Location = new Point(10, 10);          
		pctBox.Size = new Size(200, 150);          
		pctBox.ImageLocation = "http://www.functionx.com/design/une1.gif";          
		Controls.Add(pctBox);     
 	}  
}

Après l'affectation d'une chaìne à la propriété ImageLocation, vous pouvez appeler la méthode PictureBox.Load() pour réellement afficher l'image. Cette méthode est surchargée avec deux versions.


Lorsque vous accédez à cette propriété, si vous utilisez un événement comme l'événement Paint de la zone de l'image ou l'événement Click d'un bouton, vous n'avez pas à appeler la méthode Load() pour afficher l'image ; mais elle est plus efficace et plus rapide.

Au lieu d'affecter une chaìne à la propriété PictureBox.ImageLocation et appeler la méthode de PictureBox.Load() sans paramètre, vous pouvez appeler l'autre version de la méthode. Sa syntaxe est la suivante :

public void Load(string url);

Cette version prend comme argument l'URL, ou le chemin d'accès à l'image. Voici un exemple :

public class Exercise : Form  
{ 
	private PictureBox pctBox; 
 
	public Exercise()      
	{          
		InitializeComponents();      
	}        
	
	private void InitializeComponents()      
	{          
		pctBox = new PictureBox();          
		pctBox.Location = new Point(10, 10);          
		pctBox.Size = new Size(200, 150);          
		pctBox.Load(@"E:\Programs\person.bmp");          
		Controls.Add(pctBox);      
	}  
}

Une fois que vous avez spécifié l'image qui affiche la zone de l'image, par défaut, il est situé dans le coin supérieur gauche du contrôle. Dans certains cas, par exemple, si la taille de l'image est inférieure à celle du contrôle, ce serait bien et vous ne devrez pas vous préoccuper de ce qui suit :

La zone de l'image permet d'afficher uniquement ce qui concerne sa taille. Si une image va au-delà du contrôle, ses parties seraient masquées. Dans certains cas, l'image peut apparaìtre trop large, trop étroite, trop longue ou trop courte pour la zone de l'image. Et, dans certains cas, si la taille de l'image est supérieure à la zone de l'image, le contrôle n'afficherait pas certains aspects importants. Par conséquent, dans certains cas, vous souhaitez redimensionner l'image pour ajuster le contrôle, soit le contrôle pour ajuster l'image. Dans certains cas, vous pouvez par programmation redimensionner un contrôle en changeant sa propriété de taille. D'autre part, vous pouvez scale une image que nous avons apprise avec bitmap. La classe PictureBox constitue une alternative.

Le mode de la taille d'une zone de l'image

La propriété SizeMode de la classe PictureBox permet de spécifier comment s'affiche l'image dans le contrôle. Cette propriété est basée sur l'énumération PictureBoxSizeMode et ses membres sont les suivants :

  • Normal : l'image est placée dans le coin supérieur gauche du contrôle comme dans le formulaire ci-dessus
  • CenterImage : la photo est positionnée dans le milieu-centre du contrôle
     

     
    Si vous donnez à l'utilisateur la possibilité de redimensionner la zone de l'image, lorsque cela est fait, l'image serait toujours tracée dans le milieu-centre du contrôle
  • StretchImage : la photo est ajustée au contrôle. N'importe quelle dimension de l'image qui est inférieure à son équivalent sur le contrôle est augmentée à correspondre à son équivalent. N'importe quelle dimension de l'image qui est supérieure à son équivalent sur le contrôle est diminuée pour correspondre à son équivalent :
      

Avant

Après

Avant

Après

  • Si vous donnez à l'utilisateur la possibilité de redimensionner la zone de l'image, lorsque cela est fait, l'image serait toujours redimensionnée elle-même en fonction de la taille du contrôle
  • Zoom : l'image est positionnée dans le milieu du contrôle, mais elle est également redimensionnée après un certain algorithme :
    • Si l'image est plus grande que le contrôle, l'image devient redimensionnée pour être plus petite pour sa nouvelle largeur et la hauteur peut être logée dans le contrôle et le rapport Bitmap.Width / Bitmap.Height ratio est respecté. Voici un exemple.
       

      Avant

      Après

    • Si l'image est plus large que le contrôle, l'image devient redimensionnée pour être suffisamment petite pour sa nouvelle largeur et la hauteur peut être logée dans le contrôle et le rapport Bitmap.Width / Bitmap.Height est respecté. Voici un exemple.
       

      Avant

      Après

    • Imaginez que l'image est plus petite que le contrôle :
       


      Dans ce cas, la largeur de l'image et la hauteur pourraient être augmentées mais le rapport Bitmap.Width / Bitmap.Height est conservé.
      Pour redimensionner l'image, le compilateur trouve tout d'abord quelle dimension est plus proche de son équivalent du contrôle :
      • Si le ration PictureBox.Height / Bitmap.Height est inférieur au ratio PictureBox.Width / Bitmap.Width, alors la hauteur de l'image serait tout d'abord augmentée pour correspondre à la hauteur de la zone de l'image. Puis le compilateur utiliserait le ratio Bitmap.Width / Bitmap.Height pour calculer et appliquer la nouvelle largeur de l'image. Voici un exemple :
         

        Avant

        Après

      • Si le ratio PictureBox.Width / Bitmap.Width est inférieur au ratio PictureBox.Height / Bitmap.Height, alors la largeur de l'image serait tout d'abord augmentée pour correspondre à la largeur de la zone de l'image. Puis le compilateur utiliserait alors le ratio Bitmap.Width / Bitmap.Height pour calculer et appliquer la nouvelle hauteur de l'image. Voici un exemple :
         

        Avant

        Après

  • Si vous donnez à l'utilisateur la possibilité de redimensionner la zone de l'image, chaque fois que cela est fait, le compilateur utiliserait les descriptions ci-dessus pour redimensionner et positionner l'image à l'intérieur du contrôle
  • AutoSize : la taille du contrôle serait modifiée pour s'adapter à l'image :
    • Si l'image est plus petite que le contrôle, la taille du contrôle pourrait être augmentée pour afficher l'image entière
       

      Avant

      Après

    • Si l'image est plus grande que le contrôle, la taille du contrôle de zone de l'image devrait être diminuée pour ajuster l'image
       

Avant

Après

  • Si vous avez donné à l'utilisateur la possibilité de redimensionner la zone de l'image, elle ne peut pas être redimensionnée et la taille de l'image ne peut pas être modifiée.

La Mise à l'échelle, en miroir, inversion et rotation d'une image

 

La Copie d'une image

La Copie d'une image est le processus d'obtention de chaque pixel d'une image à partir d'un document, la source et la reproduction sur un autre document, la cible :
Copying a Picture
Cet opérateur est facile. obtenez les coordonnées d'un pixel à partir de la source, (x, y) et affectez-la à la coordonnée correspondante (x, y) sur le document cible. Cela peut être fait comme suit :

private void btnCopy_Click(object sender, EventArgs e)  
{      
	Graphics graph = pbxSource.CreateGraphics();      
	Bitmap bmpSource = (Bitmap)pbxSource.Image;      
	Bitmap bmpDestination = new Bitmap(pbxDestination.ClientSize.Width,                             
				pbxDestination.ClientSize.Height);        
 
 
	int width = bmpSource.Width;      
	int height = bmpSource.Height;        
 
 
	for (int x = 0; x < width; x++)      
	{          
	  	for (int y = 0; y < height; y++)          
	  	{              
			 Color clr = bmpSource.GetPixel(x, y);              
			 bmpDestination.SetPixel(x, y, clr);          
	  	}      
	}        
	
	pbxDestination.Image = bmpDestination;  
}

La Mise à l'échelle d'une image

La Mise à l'échelle d'une image consiste à changer sa taille, l'élargir, agrandir, affiner, sensibiliser ou la réduire. Bien qu'il existe différents algorithmes complexes que vous pouvez utiliser pour effectuer cette opération, la classe bitmap fournit un raccourci. Bien entendu, afin de mettre à l'échelle une image, vous devez tout d'abord en disposer.

Pour soutenir l'image mise à l'échelle, la classe bitmap fournit le constructeur suivant :

public Bitmap(Image original, int width,  int height);

L'argument d'origine est l' Image, comme un objet bitmap que vous souhaitez mettre à l'échelle. Les arguments Largeur et hauteur représentent la nouvelle taille que vous souhaitez appliquer à l'image. Après que ce constructeur a été utilisé, vous obtenez un bitmap avec la nouvelle taille. Voici un exemple d'utilisation :

Picture Normal Size


using System;  
using System.Collections.Generic;  
using System.ComponentModel;  
using System.Data;  
using System.Drawing;  
using System.Linq;  
using System.Text;  
using System.Windows.Forms;    
 
 
namespace ExoPicture1  
{      
    public partial class Form1 : Form      
    {          
	Bitmap bmpPicture;            
 
	public Form1()          
	{              
		InitializeComponent();          
	}            
 
	private void Form1_Load(object sender, EventArgs e)          
	{              
		bmpPicture = new Bitmap(10, 10);          
	}            
 
	private void Form1_Paint(object sender, PaintEventArgs e)          
	{              
		e.Graphics.DrawImage(bmpPicture, 120, 12);          
	}            
 
	private void btnLoadPicture_Click(object sender, EventArgs e)          
	{              
		OpenFileDialog dlgOpen = new OpenFileDialog();                
 
		if (dlgOpen.ShowDialog() == DialogResult.OK)              
		{                  
			String strFilename = dlgOpen.FileName;                  
			bmpPicture = new Bitmap(strFilename);                  
			int width = bmpPicture.Width;                  
			int height = bmpPicture.Height;                    
 
			textBox1.Text = width.ToString();                  
			textBox2.Text = height.ToString();                    
 
			Invalidate();              
		}          
	}            
 
	private void btnResize_Click(object sender, EventArgs e)          
	{              
		int width  = 0,                  
		height = 0;                
 
		try              
		{                  
			width = int.Parse(textBox1.Text);              
		}              
		catch (FormatException)              
		{                  
		MessageBox.Show("The value you entered for the width is not valid");              
		}                
 
	    try              
	    {                  
		height = int.Parse(textBox2.Text);              
	    }              
	    catch (FormatException)              
	    {                  
		MessageBox.Show("The value you entered for the height is not valid");              
	    }    
	                
	    Bitmap bmpNew = new Bitmap(bmpPicture, width, height);              
	    bmpPicture = bmpNew;              
	    Invalidate();          
	}      
    }  
}

Picture Resized

Vous pouvez également spécifier tant la largeur que la hauteur de la taille. Pour ce faire, vous pouvez utiliser le constructeur suivant :

public Bitmap(Image original, Size newSize);

Comme vous pouvez le voir, l'opération de mise à l'échelle peut produire une sorte d'image déformée. Une alternative consisterait à conserver la ration de deux dimensions lors de la modification de la valeur d'une.

La Mise en miroir d'une image

La Mise en miroir d'une image consiste à changer la direction horizontale d'une image. Cela se fait par le transfert de chaque pixel de la source de l'image à une image cible du còté opposé :

Mirror
Pour mettre en miroir une image, recevez chacun de ses pixels d'un còté de sa position horizontale et transférez-le vers le còté opposé de la position horizontale. La position verticale de chaque pixel reste la même. Cela peut être fait comme suit :

Mirroring a Picture


using System;  
using System.Collections.Generic;  
using System.ComponentModel;  
using System.Data;  
using System.Drawing;  
using System.Linq;  
using System.Text;  
using System.Windows.Forms;    
 
 
namespace Mirror  
{      
	public partial class Exercise : Form      
	{          
		public Exercise()          
		{              
			InitializeComponent();          
		}            
 
 
		private void btnMirror_Click(object sender, EventArgs e)          
		{              
			Graphics graph = pbxSource.CreateGraphics();              
			Bitmap bmpSource = (Bitmap)pbxSource.Image;              
			Bitmap bmpDestination =                  
				new Bitmap(pbxDestination.ClientSize.Width,                             
					   pbxDestination.ClientSize.Height);                
 
 
			int width = bmpSource.Width;              
			int height = bmpSource.Height;                
 
 
			for (int x = 0; x < width; x++)              
			{                  
				for (int y = 0; y < height; y++)                  
				{                      
				Color clr = bmpSource.GetPixel(x, y);                      
				bmpDestination.SetPixel(width - x - 1, y, clr);                  
				}              
			}                
 
			pbxDestination.Image = bmpDestination;          
		}      
	}  
}

Mirroring a Picture

Au lieu d'écrire votre propre code, pour vous aider avec l'image mise en miroir, la classe bitmap hérite d'une méthode nommée RotateFlip de son parent de classe de l'image. Sa syntaxe est la suivante :

public void RotateFlip(RotateFlipType rotateFlipType);

Cette fonction prend un argument qui spécifie l'option de mise en miroir par le biais de l'énumération RotateFlipType. Les membres de l'énumération RotateFlipType qui peuvent être utilisés pour la mise en miroir d'une image sont RotateNoneFlipX et Rotate180FlipY. Voici un exemple de mise en miroir d'une image :

private void btnManipulate_Click(object sender, EventArgs e)  
{          
		 Bitmap bmpPicture = new Bitmap("person.jpg");          
		 bmpPicture.RotateFlip(RotateFlipType.RotateNoneFlipX);          
		CreateGraphics().DrawImage(bmpPicture, 10, 10);  
}

Lorsque cette méthode est appelée, la direction horizontale de bitmap serait modifiée.

Le Retournement d'une image

Le Retournement d'une image consiste à changer son orientation verticale. Par exemple, vous pouvez avoir une image qui semble être orientée vers le bas. Par symétrie, vous pouvez rendre l'image vers le haut :

Flipping a Picture
Pour retourner une image, obtenez chacun de ses pixels d'un còté de sa position verticale et transférez-le vers la position verticale ci-contre. La position horizontale de chaque pixel reste la même. Cela peut être fait comme suit :

Flipping a Picture

using System;  
using System.Collections.Generic;  
using System.ComponentModel;  
using System.Data;  
using System.Drawing;  
using System.Linq;  
using System.Text;  
using System.Windows.Forms;    
 
 
namespace Flip  
{      
	public partial class Exercise : Form      
	{          
		public Exercise()          
		{              
			InitializeComponent();          
		}            
 
 
		private void btnFlip_Click(object sender, EventArgs e)          
		{              
			Graphics graph = pbxSource.CreateGraphics();              
			Bitmap bmpSource = (Bitmap)pbxSource.Image;              
			Bitmap bmpDestination =                  
				new Bitmap(pbxDestination.ClientSize.Width,                             
						   pbxDestination.ClientSize.Height);                
		
			int width = bmpSource.Width;              
			int height = bmpSource.Height;              
			for (int x = 0; x < width; x++)              
			{                  
				for (int y = 0; y < height; y++)                  
				{                      
					Color clr = bmpSource.GetPixel(x, y);                      
					bmpDestination.SetPixel(x, height - y - 1, clr);                  
				}              
			}                
			pbxDestination.Image = bmpDestination;          
		}      
	}  
}

Flip

Afin de soutenir l'image de retournement, vous pouvez appeler la même méthode RotateFlip() de la classe image. Cette fois-ci, vous utiliserez une valeur différente pour l'argument. Le membre de l'énumération RotateFlipType utilisée pour retourner une image est RotateNoneFlipY. Voici un exemple de symétrie d'une image

private void btnManipulate_Click(object sender, EventArgs e)  
{          
		 Bitmap bmpPicture = new Bitmap("Pushpin.jpg");          
		 bmpPicture.RotateFlip(RotateFlipType.RotateNoneFlipY);          
		 CreateGraphics().DrawImage(bmpPicture, 10, 10);  
}

La Rotation d'une image

La Rotation d'une image consiste à changer son orientation angulaire. La classe image prend en charge cette opération (avec options quelque peu limitées) par le biais de sa méthode RotateFlip(). Comme mentionné pour la mise en miroir et la symétrie, la valeur que vous transmettez comme argument aurait à déterminer comment s'effectue l'opération.

Les membres de l'énumération RotateFlipType qui sont utilisés pour faire pivoter une image sont :

  • RotateNoneFlipNone : Rien ne se passerait.
  • Rotate90FlipNone : la photo est tournée à 90 ° dans le sens des aiguilles d'une montre. Par conséquent, après l'appel de la méthode avec ce membre, ce qui est sur la gauche de l'image d'origine serait placée dans la partie supérieure de l'image. Voici un exemple :
     

    Langue source

    Après l'appel de la méthode.

    = >

    Rotation

    Notez que, après que la méthode ait été appelée, la personne tient enfoncée la télécommande avec sa main droite. Voici un exemple :
    private void btnRotate_Click(object sender, EventArgs e)  
    {          
            Bitmap bmpPicture = new Bitmap("person1.gif");          
            bmpPicture.RotateFlip(RotateFlipType.Rotate90FlipNone);          
            CreateGraphics().DrawImage(bmpPicture, 10, 10);  
    }
  • Rotate180FlipNone : la photo est tournée à 90 ° dans le sens des aiguilles d'une montre. Cela signifie que l'image est tout d'abord une rotation à 90 °, puis tournée à nouveau à 90 °. Par conséquent, après l'appel de la méthode avec ce membre, ce qui est sur la gauche de l'image d'origine serait placé dans la section de droite, mais ce qui est en haut serait placé à la partie inférieure de l'image. Voici un exemple :

Langue source

Après l'appel de la méthode.

    Notez que, après que la méthode ait été appelée, la personne tient toujours enfoncée la télécommande avec sa main droite. Par conséquent, la télécommande est sur les sites opposés des images, indiquant qu'il s'agit de la même main.

    Vous pouvez obtenir le même résultat en appelant la méthode deux fois avec le membre Rotate90FlipNone à chaque fois :

    private void btnRotate_Click(object sender, EventArgs e)  
    {          
            Bitmap bmpPicture = new Bitmap("person1.gif");          
            bmpPicture.RotateFlip(RotateFlipType.Rotate90FlipNone);         
            bmpPicture.RotateFlip(RotateFlipType.Rotate90FlipNone);          
            CreateGraphics().DrawImage(bmpPicture, 10, 10);  
    }
  • Rotate270FlipNone : la photo est tournée à 90 ° dans le sens des aiguilles d'une montre à trois reprises. Cela signifie que l'image est d'abord tournée à 90 °, puis tournée à nouveau à 90 ° et puis tournée à nouveau à 90 °. Voici un exemple :

Langue source

Après l'appel de la méthode.

= >

Rotation

Notez que, après que la méthode ait été appelée, la personne tient toujours enfoncée la télécommande avec sa main droite.
Vous pouvez obtenir le même résultat en appelant la méthode trois fois avec le membre Rotate90FlipNone chaque fois :

private void btnRotate_Click(object sender, EventArgs e)  
{          
		 Bitmap bmpPicture = new Bitmap("person1.gif");          
		 bmpPicture.RotateFlip(RotateFlipType.Rotate90FlipNone);          
		 bmpPicture.RotateFlip(RotateFlipType.Rotate90FlipNone);          
		 bmpPicture.RotateFlip(RotateFlipType.Rotate90FlipNone);          
		 CreateGraphics().DrawImage(bmpPicture, 10, 10);  
}
  • Rotate180FlipXY : sans changement réel. Effectivement, l'image est tournée à 90 ° quatre fois et revient ensuite à son orientation et à la position d'origine :
     

Langue source

Après l'appel de la méthode.

  • Rotate90FlipX : la photo est mise en miroir, puis tournée à 90 ° dans le sens inverse des aiguilles d'une montre (ou rotation à 90 ° dans le sens contraire des aiguilles d'une montre puis mis en miroir) :
     

Langue source

Après l'appel de la méthode.

= >

Notez que, après que la méthode ait été appelée, la personne tient désormais la télécommande avec sa main gauche

  • Rotate180FlipX : la photo est mise en miroir, puis tournée à 180 ° dans le sens inverse des aiguilles d'une montre deux fois (ou pivoter à 180 ° dans le sens contraire des aiguilles d'une montre deux fois puis mise en miroir) :
     

Langue source

Après l'appel de la méthode.

Notez que, après que la méthode ait été appelée, la personne tient désormais la télécommande avec sa main gauche. En conséquence, la télécommande est du même còté que l'écran sur les deux images (comparer avec Rotate180FlipNone)

  • Rotate270FlipX : la photo est mise en miroir, puis tournée à 90 ° dans le sens inverse des aiguiles d'une montre trois fois (ou tournée à 90 ° dans le sens inverse des aiguilles d'une montre trois fois puis mise en miroir) :
     

Langue source

Après l'appel de la méthode.

= >

Rotation

Notez que, après que la méthode ait été appelée, la personne tient désormais la télécommande avec sa main gauche

  • Rotate90FlipY : produit le même résultat que Rotate270FlipX  
  • Rotate270FlipY : produit le même résultat que Rotate90FlipX
  • Rotate90FlipXY : produit le même résultat que Rotate270FlipNone
  • Rotate270FlipXY : produit le même résultat que Rotate90FlipNone
  • RotateNoneFlipXY : produit le même résultat que Rotate180FlipNone
 
 
 
 

Précédent Copyright © 2009-2011, yevol.com Suivant