ENCORE UNE FORM AEROGLASS SANS API AVEC EFFET FLOU

Signaler
Messages postés
1447
Date d'inscription
jeudi 2 novembre 2000
Statut
Membre
Dernière intervention
23 septembre 2007
-
Messages postés
2
Date d'inscription
lundi 8 décembre 2003
Statut
Membre
Dernière intervention
13 juin 2007
-
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.

https://codes-sources.commentcamarche.net/source/40585-encore-une-form-aeroglass-sans-api-avec-effet-flou

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);
}
}
}
Afficher les 7 commentaires