Plus vite le contraste de l'algorithme pour une image bitmap

J'ai un outil de trackbar contrôles de curseur utilisé pour ajuster automatiquement la luminosité de l'image, contraste, gamma, etc.

J'essaie d'obtenir en temps réel des mises à jour de mon image, tandis que l'utilisateur fait glisser le curseur. La luminosité et le gamma algorithmes sont une vitesse acceptable (autour de 170 ms). Mais le contraste de l'algorithme est d'environ 380ms.

Fondamentalement, mon formulaire est un outil de la fenêtre à l'aide des curseurs. Chaque fois que l'image est mise à jour, il envoie un événement pour le parent qui retrace la nouvelle image. La fenêtre de l'outil conserve l'image originale non modifiée verrouillé en mémoire donc j'ai toujours accès aux octets d'elle. Donc, fondamentalement, je le fais à chaque fois que l'événement ValueChanged pour un curseur (tels que le curseur de Contraste) est modifié.

LockBits de travail (destination) bitmap comme Format24bppRgb (bitmap d'origine dans Format32bppPArgb)
Maréchal.Copier les bits d'un octet tableau []
Vérifier l'opération pour laquelle je suis en train de faire (curseur qui a été choisi)
Utiliser le code suivant pour le Contraste:

Code:

double newValue = 0;
double c = (100.0 + contrast) / 100.0;

c *= c;

for (int i = 0; i < sourcePixels.Length; i++)
{
    newValue = sourcePixels[i];

    newValue /= 255.0;
    newValue -= 0.5;
    newValue *= c;
    newValue += 0.5;
    newValue *= 255;

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

    destPixels[i] = (byte)newValue;
}

J'ai lu une fois sur l'utilisation d'entiers à la place des valeurs à virgule flottante à une augmentation de la vitesse de contraste, mais je ne pouvais pas trouver que l'article de nouveau.

J'ai essayé d'utiliser le code unsafe (pointeurs) mais effectivement remarqué une diminution de la vitesse. Je suppose que c'était parce que le code est à l'aide de boucles for imbriquées pour itérer x et y, au lieu d'une seule boucle.

double possible de Ajuster le contraste d'une image en C# efficacement
Le code unsafe dans la question liée à la, quand je l'ai tester avec la même image que j'utilisais avec mon code, prend le relais de 900ms par la routine. Bien sûr, je l'ai modifié de sorte qu'il n'est pas de cloner ou créer de nouvelles images bitmaps, c'est juste la boucle imbriquée avec des pointeurs et des mathématiques à virgule flottante. Il est trop lent.
Peut-être que vous pouvez modifier votre code pour utiliser des pointeurs plutôt que dans le code unsafe.

InformationsquelleAutor Trevor Elliott | 2012-01-24

bitmap c#contrast performance

10

En fonction de la machine que vous utilisez cette fonction est activée, votre technique pourrait être assez lente. Si vous utilisez un système de BRAS sans FPU, chacune de ces opérations serait prendre un certain temps. Puisque vous êtes la même opération pour chaque octet, une technique plus rapide serait de créer un 256 entrées de la table de choix pour le niveau de contraste et de traduire chaque image octet à travers la table. Votre boucle, pourrait alors ressembler à ceci:
```
byte contrast_lookup[256];
double newValue = 0;
double c = (100.0 + contrast) / 100.0;

c *= c;

for (int i = 0; i < 256; i++)
{
    newValue = (double)i;
    newValue /= 255.0;
    newValue -= 0.5;
    newValue *= c;
    newValue += 0.5;
    newValue *= 255;

    if (newValue < 0)
        newValue = 0;
    if (newValue > 255)
        newValue = 255;
    contrast_lookup[i] = (byte)newValue;
}

for (int i = 0; i < sourcePixels.Length; i++)
{
    destPixels[i] = contrast_lookup[sourcePixels[i]];
}
```
- Beaucoup plus rapide. Qui a la vitesse de 380ms à propos de 155ms. Merci!!!!
- Il est intéressant de noter que vous pouvez également appliquer cette même approche pour votre la luminosité et le gamma algorithmes pour les rendre encore plus rapide.
- Je le croyais et que j'allais l'essayer. Cette méthode échelles vraiment bien avec la haute résolution des images bitmap comme le 2976x1536 fichiers que je m'occupe.
- Si vous avez vraiment besoin de plus de vitesse, vous pouvez envisager d'utiliser le NÉON (BRAS) ou de l'ESS (x86) les instructions et les convertir afin d'utiliser les opérations sur entiers. Avec l'un de ces jeux d'instructions, vous pouvez traiter jusqu'à 16 octets en même temps (en parallèle).
- puis-je faire quelque chose comme cela dans Unity3D?
- J - désolé, je n'ai pas utiliser Unity3D, donc je ne peux pas commenter sur ce point.
InformationsquelleAutor BitBank

@BitBank répond à votre question, comme demandé, je voulais ajouter que si vous êtes après les performances, pensez à votre code qui est d'obtenir les données de pixel et la valeur par la suite.

Travail plein de code à l'aide de pointeurs (accessoires @BitBank sur le for code de boucle):

private unsafe void ApplyContrast(double contrast, Bitmap bmp)
{
byte[] contrast_lookup = new byte[256];
double newValue = 0;
double c = (100.0 + contrast) / 100.0;
c *= c;
for (int i = 0; i < 256; i++)
{
newValue = (double)i;
newValue /= 255.0;
newValue -= 0.5;
newValue *= c;
newValue += 0.5;
newValue *= 255;
if (newValue < 0)
newValue = 0;
if (newValue > 255)
newValue = 255;
contrast_lookup[i] = (byte)newValue;
}
var bitmapdata = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), 
System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
int PixelSize = 4;
for (int y = 0; y < bitmapdata.Height; y++)
{
byte* destPixels = (byte*)bitmapdata.Scan0 + (y * bitmapdata.Stride);
for (int x = 0; x < bitmapdata.Width; x++)
{
destPixels[x * PixelSize] = contrast_lookup[destPixels[x * PixelSize]]; //B
destPixels[x * PixelSize + 1] = contrast_lookup[destPixels[x * PixelSize + 1]]; //G
destPixels[x * PixelSize + 2] = contrast_lookup[destPixels[x * PixelSize + 2]]; //R
//destPixels[x * PixelSize + 3] = contrast_lookup[destPixels[x * PixelSize + 3]]; //A
}
}
bmp.UnlockBits(bitmapdata);
}

Si vous êtes à la définition de votre image en pixels des données à l'aide Marshal.Copy vous trouverez cela fonctionne mieux.

Cela devrait effectuer plus rapidement que votre code actuel, et vous également de réduire l'empreinte mémoire qui est bon lorsque vous traitez avec de très grandes images.

Il pourrait également être un peu plus rapide si vous n'avez échelle à partir et à revenir à 255. I. E. newValue = (double)i; newValue -= 128; newValue *= c; newValue += 128;
Une autre grande amélioration consisterait à calculer x* PixelSize une fois au lieu de 6 fois à l'intérieur pour

InformationsquelleAutor Seph

Vous devez vous connecter pour publier un commentaire.