.NET

Présentation du format de fichier XML d'Excel

Grégory Ghez — Wed, 05 Oct 2005 22:23:00 GMT

Je viens de terminer la rédaction d'un article sur ce sujet, disponible dès à présent sur le site du laboratoire .net à cette adresse : http://www.labo-dotnet.com/Articles/Office/Spreadsheet%20ML%20et%20génération%20de%20fichier%20Excel/0/1547.aspx

Manipuler le contenu d'une image en .NET

Grégory Ghez — Mon, 12 Sep 2005 17:18:00 GMT

Je sais déjà que je vais me retrouver comme avec mon post sur le goto avec des 10aines de commentaires de défenseur des principes divins du .NET, mais çà m'est égal, j'adore vous voir dans cet état :)

Je me lance, dans ce post je vais vous montrer comment manipuler le contenu d'une image en .NET de la manière la plus rapide qu'il me semble faisable de faire: l'utilisation de code unsafe (pointeurs) mais toujours dans le but de gagner en performance et non d'obscurcir le code.

En effet, il existe une méthode de traitement dans la classe Bitmap qui permet de récupérer les données de l'image en mémoire. Il s'agit de la méthode LockBits :

Rectangle bmpRect = new Rectangle(0, 0, bmp.Width, bmp.Height); // bmp est de type Bitmap
BitmapData bmpData = bmp.LockBits(bmpRect, ImageLockMode.ReadOnly, bmp.PixelFormat);

L'objet BitmapData contient les données internes de l'image et notament un pointeur vers le début des données de l'image en mémoire. La propriété Scan0 remplit ce rôle:

byte* data = (byte*)bmpData.Scan0;

Inutile de préciser qu'à partir de ce moment, nous passons en mode non managé car nous faisons un accès direct à la mémoire via data. C'est pourquoi la méthode contenant ce code doit comporter le mot clé unsafe (Le projet doit également être compilé avec l'attribut /unsafe afin d'accepter ce code, voir les propriétés du projet dans VS.NET).

Nous avons donc accès à une zone mémoire linéaire qu'il va falloir comprendre comme un tableau à deux dimensions contenant les pixels aux coordonnées x,y de notre image. Voici comment est stockée l'image en mémoire et la relation entre cette représentation et les propriétés Stride et Scan0 de la classe BitmapData:

(source: http://www.bobpowell.net/lockingbits.htm)

On utilisera donc le code suivant pour parcourir les pixels de notre image:

int i = 0;
for (int x=0; x<bmp.Width; x++)
{
   for (int y=0; y<bmp.Height; y++)
   {
      i = y * bmpData.Stride + x * 3;
      // manipulation du pixel ;)
   }
}

Il suffit donc d'indexer notre pointeur que l'on peut considérer comme un tableau afin d'obtenir les nuances rouge, vert et bleu (et alpha éventuellement) de notre pixel. Dans le cas présent mon image est enregistré en 24bpp donc les pixels se trouvent tous les x * 3 bytes.

data[i+2] // rouge
data[i+1] // vert
data[i] // bleu

Remarque: Lorsque vous créez une image avec l'instruction new Bitmap(...) sans préciser le paramètre PixelFormat, l'image est créée en 32bpp et il faut donc utiliser x * 4 pour parcourir l'image dans la formule précédente pour i (data[i+3] représente alors la nuance alpha).
Si vous souhaitez changer le contenu de data, cela est possible, il faut préciser le paramètre ImageLockMode de LockBits à ImageLockMode.ReadWrite ou ImageLockMode.WriteOnly.

Une fois que vous avez fini votre traitement, n'oubliez surtout pas d'appeler la méthode UnlockBits afin de permettre au Garbage Collector de disposer de cet espace mémoire à sa guise pour sa gestion.

bmp.UnlockBits(bmpData);

Voici la manière la plus simple en code managé pour parcourir une image:

for (int x=0; x<bmp.Width; x++)
{
   for (int y=0; y<bmp.Height; y++)
   {
      Color c = bmp.GetPixel(x, y);
      // code de manipulation
   }
}

Le problème avec cette méthode se pose lorsque l'on doit manipuler des images de grande taille. On se trouve alors à effectuer bmp.Width * bmp.Height appels à la méthode GetPixel() ce qui ralentit considérablement l'éxécution de la routine.

Une autre méthode encore consiste à parcourir les informations accessibles par Scan0 via la méthode System.Runtime.InteropServices.Marshal.ReadByte(bmpData.Scan0, i). Mais vous voyez que le problème de GetPixel se retrouve ici car pour chaque nuance il va falloir faire appel à cette méthode.

N'hésitez pas à me soumettre vos idées sur le sujet.

L'instruction goto en C#

Grégory Ghez — Sun, 11 Sep 2005 02:37:00 GMT

Il s'agit d'une instruction très peu utilisée mais qui peut s'avérer fort utile dans certains cas.
goto sert à faire saut non-conditionnel vers un label référencé autre part dans le code.

Exemple:

string[] tab = {"Bonjour", "les", "gens"};
foreach (string s in tab)
{
   foreach (char c in s)
   {
      if (c == 'e')
         goto Suite;
   }
}
return;
Suite:
   MessageBox.Show("Le caractère 'e' a été trouvé dans une des chaînes.");

Dans cet exemple, on comprends bien l'intérêt du goto, qui permet de passer directement à la suite du code si le test est concluant. Si nous n'avions pas utiliser le goto, on aurait eu la construction suivante:

string[] tab = {"Bonjour", "les", "gens"};
bool present = false;

foreach (string s in tab)
{
   foreach (char c in s)
   {
      if (c == 'e')
      {
         present = true;
         break;
      }
   }

   if (present)
      break;
}

if (present)
   MessageBox.Show("Le caractère 'e' a été trouvé dans une des chaînes.");

On voit bien qu'au niveau de la lisibilité et des performances, l'instruction goto l'emporte, en effet, vous évitez un saut non-conditionnel ainsi qu'un test conditionnel. Vous gagnez également quelques lignes de code, ce qui n'est pas pour déplaire lorsque l'on traite avec des fichiers contenant plusieurs milliers de lignes.

Remarques:
Lorsque vous déclarez un label (Suite dans notre exemple), vous devez impérativement le faire suivre d'une instruction. En effet, s'il n'y avait pas d'instruction entre le label et la fin de notre méthode, cela reviendrait à faire appel à l'instruction return directement.
Vous ne pouvez pas non plus faire un saut non-conditionnel goto vers un endroit du code qui ne serait pas dans la portée du code éxécutant l'instruction goto (On ne peut pas faire un saut du dehors d'une boucle vers l'intérieure de celle-ci par exemple).

Lien MSDN

Apprendre les transformations de bases en GDI+

Grégory Ghez — Mon, 05 Sep 2005 16:46:00 GMT

En surfant un peu sur Internet et plus particulièrement sur le site MSDN, je suis tombé sur un lot de 3 articles très intéressants pour ceux d'entre vous qui souhaiteraient apprendre à utiliser les transformations et les matrices en GDI+.

Types of Coordinate Systems

Matrix Representation of Transformations

Global and Local Transformations

On vous explique par exemple comment ces deux cercles ci-dessous ont été dessinés par le même appel de méthode en ayant entre chaque appliquer une série de transformations.

Code: myGraphics.DrawEllipse(myPen, 0, 0, 100, 50);

Bonne lecture !

Nouvelle version de 3DLib

Grégory Ghez — Mon, 05 Sep 2005 02:45:00 GMT

Je continue à développer cette librairie avec passion, et rien que pour vous, ce nouveau volet de 3DLib:

http://blogs.labo-dotnet.com/gg00xiv/articles/9613.aspx

Récupérer les données d'Outlook dans un DataSet

Grégory Ghez — Fri, 02 Sep 2005 16:12:00 GMT

Il existe une classe développée par Mathias Taylor sur www.codeproject.com qui permet en effet, de récupérer les informations de contacts, calendrier, mails, etc... dans un objet facilement manipulable en .NET, le DataSet.

Personnellement je l'utilise assez souvent désormais vu qu'il devient très facile de lire et d'afficher les infos de mes contacts.

Ce composant requiert l'installation de Office version 10 (XP) minimum car vous devez posséder l'objet COM d'Outlook.

Voici le lien de cet outils dont le code source est disponible: http://www.codeproject.com/csharp/OutlookConnector.asp

Mise à jour: J'ai rajouté dans un feedback le code pour créer un contact dans Outlook.

Programmation 3D avec GDI+

Grégory Ghez — Thu, 25 Aug 2005 01:15:00 GMT

Dans cet article vous découvrirez les bases de la programmation 3D en .NET avec la technologie GDI+.

http://blogs.labo-dotnet.com/gg00xiv/articles/8855.aspx

Différences entre tableau[][] et tableau[,]

Grégory Ghez — Sun, 22 May 2005 23:52:00 GMT

Vous connaissiez le tableau de tableau en C++, il s'agissait de ce que l'on appelait un tableau à deux dimensions.

Malheureusement, en C#, un int[][] n'est pas un tableau à 2 dimensions, mais à 1 dimension, chaque élément étant lui même un tableau à 1 dimension.

Voyez plûtot avec cet exemple :

int[][] tab = new int[][]

{

new int[2],

new int[6]

};

int[,] tab2 = new int[2, 6];

Console.WriteLine("Taille de tab : {0}", tab.Length);

Console.WriteLine("Taille de tab2: {0}", tab2.Length);

Console.WriteLine("tab[1][3] = {0}", tab[1][3]);

Console.WriteLine("tab2[1, 3]= {0}", tab2[1, 3]);

Console.WriteLine("Dimensions de tab : {0}", tab.Rank);

Console.WriteLine("Dimensions de tab2: {0}", tab2.Rank);

Dont le résultat à l'affichage donne :

On constate donc que l'on ne peut pas accéder à un tableau[][] de la même façon qu'un tableau[,] et surtout que ce sont des types complétement différents.

Notez aussi que l'écriture avec [][] n'est pas en accord avec les règles de la CLS (Common Language Specification). Vous pouvez donc ne pas retrouver d'équivalent dans d'autres langages supportant le Framework .NET.

De plus, les performances sont sévèrement diminuée avec l'utilisation d'un tableau [][] comparé à un tableau [,] (cf.: http://msdn.microsoft.com/msdnmag/issues/04/03/ScientificC/).

Nouvel article GDI+ sur Labo-Dotnet

Grégory Ghez — Thu, 12 May 2005 15:59:00 GMT

La plupart des applications Windows que vous rencontrez présentent quelques animations de l’interface aux réactions de l’utilisateur ou non. Prenez par exemple Internet Explorer et le petit drapeau Windows en haut à droite qui tourne montrant que l’application accède à Internet.

Les animations sont un agrément et ne proposent généralement aucune fonctionnalité. Cependant ils permettent souvent de mettre en valeur des parties du programme et de rendre plus conviviale votre application.

Dans cet article, je vais vous présenter comment réaliser une animation en C# en utilisant les techniques GDI+ et la programmation des Threads.

http://www.labo-dotnet.com/Articles/Csharp/Animation%20GDI+%20utilisant%20des%20Threads/Introduction/0/1495.aspx

ASP.NET: Passage de la Beta 1 à la Beta 2

Grégory Ghez — Sat, 30 Apr 2005 14:02:00 GMT

Je crée ce post à destination de ceux qui voudraient migrer tout comme moi leur projet réalisé avec la beta1 du framework 2.0 vers la beta2 nouvellement sortie.

Voici quelques tips vous permettant d'éviter bien des heures de recherches. Certains de ces tips ont été récupérés sur le net sur des forums, certains viennent de mon acharnement à comprendre pourquoi ca ne marche plus...

Les voici:

AVANT: <@Page CompileWith="..." ClassName="..."

MAINTENANT: <@Page CodeFile="..." Inherits="..."

AVANT: Les évènements générés dans le fichier .cs étaient déclarés en void uniquement

MAINTENANT: Il faut faire précéder void par protected (l'absence de modificateur d'accès revient à écrire un private).

AVANT: Les dossiers spéciaux étaient : Code, LocalResources, etc...

MAINTENANT: Faîtes précéder ces noms de dossiers par "App_" : App_Code, App_LocalResources, etc...

AVANT: Dans vos SqlDataAdapter vous n'aviez qu'à préciser SelectCommand="...." et le nom de votre précédure stockée.

MAINTENANT: Vous devez obligatoirement préciser SelectCommandType="StoredProcedure" si votre requête admet un ou plusieurs paramètres.

AVANT: Vous n'aviez plus besoin de faire hériter votre classe partial de Page

MAINTENANT: Vous devez impérativement mettre vous même la classe de base après la déclaration de votre classe de page, usercontrol ou masterpage (Default_aspx: Page, MonUserControl_ascx: UserControl, Master.master: MasterPage)

Voilà, bon courage !