Encore une form aeroglass sans api avec effet flou

Soyez le premier à donner votre avis sur cette source.

Vue 9 909 fois - Téléchargée 1 356 fois

Description

Voila c'est un composant à glisser dans une form pour la transformer en aeroglass.
le code est en pure .net et j' ai utiliser la classe filtre ecrite en csharp trouvé sur le site code projet sous le nom csharpfilters pour les effets de flou,eau... cette classe est aussi en pure .net biensur. Ce code est beaucoup moins gourmand en ressource memoire que ce que j'ai pu trouver sur la toile.
L'idee generale ici n' est pas de rendre la form transparente, mais de copier la partie de l'ecran dessous la form la traiter puis la desinner sur la form. Toutefois la form doit quand meme etre transparente pour que la form elle meme n'appaisse pas pendant l'execution de la fonction CopyFromScreen.

Voila testez, notez, commentez.

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
2
Date d'inscription
lundi 8 décembre 2003
Statut
Membre
Dernière intervention
13 juin 2007

c'est super lent !!
y a des méthodes pour faire ca mieux je pense
deja avec 3 lignes en plus genre le doublebuffer et c'est deja moins pire
mais ca reste inutilisable...
Messages postés
1
Date d'inscription
samedi 11 janvier 2003
Statut
Membre
Dernière intervention
11 décembre 2006

L'auteur à fait plusieurs articles sur CodeProject à ce sujet, normalement celle concernant cette source est la N°2: http://www.codeproject.com/cs/media/csharpfilters.asp

Pour ceux qui veulent plus d'infos, c'est tout sur le profil de l'auteur dans la section GDI+:

http://www.codeproject.com/script/Articles/list_articles.asp?userid=6556
Messages postés
193
Date d'inscription
jeudi 4 décembre 2003
Statut
Membre
Dernière intervention
12 août 2010

Peut-on avoir le lien svp ?
Messages postés
1
Date d'inscription
mardi 27 avril 2004
Statut
Membre
Dernière intervention
10 décembre 2006

Salut BIBELEBONS comme je l'ai dit plus haut c'est une classe C# pris sur le site code project, je n'ai pas reussi a la traduire en vbnet.
voila je mes le contenu de la classe ci dessous .

using System;
using System.Drawing;
using System.Drawing.Imaging;

namespace CSharpFilters
{
public class ConvMatrix
{
public int TopLeft 0, TopMid 0, TopRight = 0;
public int MidLeft 0, Pixel 1, MidRight = 0;
public int BottomLeft 0, BottomMid 0, BottomRight = 0;
public int Factor = 1;
public int Offset = 0;
public void SetAll(int nVal)
{
TopLeft TopMid TopRight = MidLeft = Pixel = MidRight = BottomLeft = BottomMid = BottomRight = nVal;
}
}


public class BitmapFilter
{
public static bool Invert(Bitmap b)
{
// GDI+ still lies to us - the return format is BGR, NOT RGB.
BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

int stride = bmData.Stride;
System.IntPtr Scan0 = bmData.Scan0;

unsafe
{
byte * p = (byte *)(void *)Scan0;

int nOffset = stride - b.Width*3;
int nWidth = b.Width * 3;

for(int y=0;y 255)
return false;

// GDI+ still lies to us - the return format is BGR, NOT RGB.
BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

int stride = bmData.Stride;
System.IntPtr Scan0 = bmData.Scan0;

int nVal = 0;

unsafe
{
byte * p = (byte *)(void *)Scan0;

int nOffset = stride - b.Width*3;
int nWidth = b.Width * 3;

for(int y=0;y 255) nVal = 255;

p[0] = (byte)nVal;

++p;
}
p += nOffset;
}
}

b.UnlockBits(bmData);

return true;
}

public static bool Contrast(Bitmap b, sbyte nContrast)
{
if (nContrast < -100) return false;
if (nContrast > 100) return false;

double pixel 0, contrast (100.0+nContrast)/100.0;

contrast *= contrast;

int red, green, blue;

// GDI+ still lies to us - the return format is BGR, NOT RGB.
BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

int stride = bmData.Stride;
System.IntPtr Scan0 = bmData.Scan0;

unsafe
{
byte * p = (byte *)(void *)Scan0;

int nOffset = stride - b.Width*3;

for(int y=0;y 255) pixel = 255;
p[2] = (byte) pixel;

pixel = green/255.0;
pixel -= 0.5;
pixel *= contrast;
pixel += 0.5;
pixel *= 255;
if (pixel < 0) pixel = 0;
if (pixel > 255) pixel = 255;
p[1] = (byte) pixel;

pixel = blue/255.0;
pixel -= 0.5;
pixel *= contrast;
pixel += 0.5;
pixel *= 255;
if (pixel < 0) pixel = 0;
if (pixel > 255) pixel = 255;
p[0] = (byte) pixel;

p += 3;
}
p += nOffset;
}
}

b.UnlockBits(bmData);

return true;
}

public static bool Gamma(Bitmap b, double red, double green, double blue)
{
if (red < .2 || red > 5) return false;
if (green < .2 || green > 5) return false;
if (blue < .2 || blue > 5) return false;

byte [] redGamma = new byte [256];
byte [] greenGamma = new byte [256];
byte [] blueGamma = new byte [256];

for (int i = 0; i< 256; ++i)
{
redGamma[i] = (byte)Math.Min(255, (int)(( 255.0 * Math.Pow(i/255.0, 1.0/red)) + 0.5));
greenGamma[i] = (byte)Math.Min(255, (int)(( 255.0 * Math.Pow(i/255.0, 1.0/green)) + 0.5));
blueGamma[i] = (byte)Math.Min(255, (int)(( 255.0 * Math.Pow(i/255.0, 1.0/blue)) + 0.5));
}

// GDI+ still lies to us - the return format is BGR, NOT RGB.
BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

int stride = bmData.Stride;
System.IntPtr Scan0 = bmData.Scan0;

unsafe
{
byte * p = (byte *)(void *)Scan0;

int nOffset = stride - b.Width*3;

for(int y=0;y 255) return false;
if (green < -255 || green > 255) return false;
if (blue < -255 || blue > 255) return false;

// GDI+ still lies to us - the return format is BGR, NOT RGB.
BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

int stride = bmData.Stride;
System.IntPtr Scan0 = bmData.Scan0;

unsafe
{
byte * p = (byte *)(void *)Scan0;

int nOffset = stride - b.Width*3;
int nPixel;

for(int y=0;y 255) nPixel = 255;

p[5 + stride]= (byte)nPixel;

nPixel = ( ( ( (pSrc[1] * m.TopLeft) + (pSrc[4] * m.TopMid) + (pSrc[7] * m.TopRight) +
(pSrc[1 + stride] * m.MidLeft) + (pSrc[4 + stride] * m.Pixel) + (pSrc[7 + stride] * m.MidRight) +
(pSrc[1 + stride2] * m.BottomLeft) + (pSrc[4 + stride2] * m.BottomMid) + (pSrc[7 + stride2] * m.BottomRight)) / m.Factor) + m.Offset);

if (nPixel < 0) nPixel = 0;
if (nPixel > 255) nPixel = 255;

p[4 + stride] = (byte)nPixel;

nPixel = ( ( ( (pSrc[0] * m.TopLeft) + (pSrc[3] * m.TopMid) + (pSrc[6] * m.TopRight) +
(pSrc[0 + stride] * m.MidLeft) + (pSrc[3 + stride] * m.Pixel) + (pSrc[6 + stride] * m.MidRight) +
(pSrc[0 + stride2] * m.BottomLeft) + (pSrc[3 + stride2] * m.BottomMid) + (pSrc[6 + stride2] * m.BottomRight)) / m.Factor) + m.Offset);

if (nPixel < 0) nPixel = 0;
if (nPixel > 255) nPixel = 255;

p[3 + stride] = (byte)nPixel;

p += 3;
pSrc += 3;
}

p += nOffset;
pSrc += nOffset;
}
}

b.UnlockBits(bmData);
bSrc.UnlockBits(bmSrc);

return true;
}
public static bool Smooth(Bitmap b, int nWeight /* default to 1 */)
{
ConvMatrix m = new ConvMatrix();
m.SetAll(1);
m.Pixel = nWeight;
m.Factor = nWeight + 8;

return BitmapFilter.Conv3x3(b, m);
}

public static bool GaussianBlur(Bitmap b, int nWeight /* default to 4*/)
{
ConvMatrix m = new ConvMatrix();
m.SetAll(1);
m.Pixel = nWeight;
m.TopMid m.MidLeft m.MidRight = m.BottomMid = 2;
m.Factor = nWeight + 30;

return BitmapFilter.Conv3x3(b, m);
}
public static bool MeanRemoval(Bitmap b, int nWeight /* default to 9*/ )
{
ConvMatrix m = new ConvMatrix();
m.SetAll(-1);
m.Pixel = nWeight;
m.Factor = nWeight - 8;

return BitmapFilter.Conv3x3(b, m);
}
public static bool Sharpen(Bitmap b, int nWeight /* default to 11*/ )
{
ConvMatrix m = new ConvMatrix();
m.SetAll(0);
m.Pixel = nWeight;
m.TopMid m.MidLeft m.MidRight = m.BottomMid = -2;
m.Factor = nWeight - 8;

return BitmapFilter.Conv3x3(b, m);
}
public static bool EmbossLaplacian(Bitmap b)
{
ConvMatrix m = new ConvMatrix();
m.SetAll(-1);
m.TopMid m.MidLeft m.MidRight = m.BottomMid = 0;
m.Pixel = 4;
m.Offset = 127;

return BitmapFilter.Conv3x3(b, m);
}
public static bool EdgeDetectQuick(Bitmap b)
{
ConvMatrix m = new ConvMatrix();
m.TopLeft m.TopMid m.TopRight = -1;
m.MidLeft m.Pixel m.MidRight = 0;
m.BottomLeft m.BottomMid m.BottomRight = 1;

m.Offset = 127;

return BitmapFilter.Conv3x3(b, m);
}
}
}
Messages postés
8
Date d'inscription
samedi 28 janvier 2006
Statut
Membre
Dernière intervention
10 décembre 2006

C'est vrai que l'interface graphique est bien même si parfois la transparence se voit ralentir. Par contre j'aimerai savoir ce que contient la DLL "Filtre.dll"
Afficher les 7 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.