Itérer sur les pixels d'une image avec emgu cv

Je veux itérer sur tous les pixels d'une image et de les comparer avec un modèle de recherche. Avec le meilleur rendement possible et en C#. J'ai trouvé emgu cv, un wrapper pour les Intels opencv. Mais je ne sais pas comment utiliser emgu correctement. Quelqu'un sait comment je peux faire cela? Qu'est-ce que la Propriété data de l'Image? Est-ce les données images? Si oui, laquelle valeur est quoi? Grâce

Mise à jour:

J'ai codé ma fonction en C# et il a bien fonctionné, mais beaucoup trop lent! J'avais déjà un algorhytm en c, j'ai traduit en C#. C# est 3 à 4 FOIS plus lent que le c! (Ma fonction parcourt presque chaque pixel d'une image à rechercher une forme dans une image. -> Hugh Transformation)

Bien, j'ai entendu dire que le code unsafe pourrait être plus rapide car il ne vérifie pas la matrice de limites et d'autres choses. Est-ce vrai? Exécute le code unsafe directement sur la physique de la machine?

De toute façon, j'ai essayé de mettre le code unsafe dans ma fonction. Mais je n'étais pas en mesure d'obtenir un pointeur vers mon 3D-array ou pour accéder à la 3D-tableau avec le pointeur. Comment puis-je réécrire ce code ci-dessus avec le code unsafe? Et ce serait apporter un supplément de gain de performances ou même courir aussi vite que du code c?

OriginalL'auteur Benks | 2011-02-24

c#image loops

46

Comme emgu site web de l'état il y a essentiellement deux stratégies:

Le coffre-fort (lente) de manière à

Supposons que vous travaillez sur un Image<Bgr, Byte>.
Vous pouvez obtenir le pixel sur la y-ième ligne et de la x-ème colonne en appelant
```
Bgr color = img[y, x];
```
Réglage du pixel sur l'axe y-ième ligne et de la x-ème colonne est aussi simple
```
img[y,x] = color;
```
La voie rapide

Les pixels de l'Image, les valeurs sont stockées dans les Données de propriété, un tableau 3D.
Ok, donc c'est vrai, mais ne dit pas comment le faire dans un véritable scénario. Donc, nous allons voir quelques-code de travail et ensuite discuter de la performance et de l'optimisation:
```
Image<Bgr, Byte> original = newImage<Bgr, byte>(1024, 768);
Stopwatch evaluator = newStopwatch(); 

int repetitions = 20;
Bgr color = newBgr(100, 40, 243);

evaluator.Start();

for (int run = 0; run < repetitions; run++)
{
    for (int j = 0; j < original.Cols; j++)
    {
        for (int i = 0; i < original.Rows; i++)
        {
            original[i, j] = color;
        }
    }
}

evaluator.Stop();
Console.WriteLine("Average execution time for {0} iteration \n using column per row access: {1}ms\n", repetitions, evaluator.ElapsedMilliseconds / repetitions);
```
Donc, c'est la moyenne des temps d'exécution que vous avez après 20 essais à l'aide de la lente de sécurité mode de réglage de l'image en pixels
Sur ma machine il faut 1021ms...

Donc 1021 millisecondes, le temps moyen pour faire une boucle et la fixation d'un nombre de pixels égal à 1024*768. Nous aurions pu faire un peu mieux en faisant une boucle sur la ligne par ligne

Donc, nous allons refactoriser un peu notre code et nous allons utiliser le plus rapide en utilisant directement l'Image.Les données de propriété:
```
evaluator.Reset();
evaluator.Start();

for (int run = 0; run < repetitions; run++)
{
    for (int i = 0; i < original.Rows; i++)
    {
        for (int j = 0; j < original.Cols; j++)
        {
            original.Data[i, j, 0] = 100;
            original.Data[i, j, 1] = 40;
            original.Data[i, j, 2] = 243;
        }
    }
}

evaluator.Stop();
Console.WriteLine("Average execution time for {0} iterations \n using Data property: {1}ms\n", repetitions, evaluator.ElapsedMilliseconds / repetitions);
```
Sur ma machine il faut 519ms.
Nous avons donc acquis un gain de performance de 50%. Le temps d'exécution a été diminué par un facteur de deux.

Alors qu'en regardant attentivement le code en gardant à l'esprit que nous sommes à l'aide de C#, nous pouvons faire un changement mineur qui va considérablement stimuler notre nouveau pixel de l'image réglage de la performance... nous ne devrions pas utiliser le c# de la propriété à l'intérieur d'une boucle!!!
```
evaluator.Reset();
evaluator.Start();

byte[,,] data = original.Data;

for (int run = repetitions - 1; run >= 0; run--)
{
    for (int i = original.Rows - 1; i >= 0; i--)
    {
        for (int j = original.Cols - 1; j >= 0; j--)
        {
            data[i, j, 0] = 100;
            data[i, j, 1] = 40;
            data[i, j, 2] = 243;
        }
    }
}

evaluator.Stop();
```
Avec ce dernier morceau de code, vous aurez un énorme gain de performance (73ms) en raison de l'utilisation correcte du langage C#.

Merci beaucoup pour cette réponse détaillée! Je ne savais pas que la règle, de ne pas utiliser les Propriétés dans une boucle. Une autre question: que veut dire: "pas sûrs de données de propriété". Dangereux de quelle manière? Quels sont les risques?
Il n'y a rien de dangereux à l'aide de données de la propriété. Le développeur a besoin de plus d'attention en spécifiant l'index approprié pour obtenir ou définir la valeur correcte, car les Données de la propriété 3 dimensions tableau
Je vous serais reconnaissant si vous pouviez partager les bout de combien de temps il prend dans le dernier (pas à l'aide de la propriété)
Veli: - je modifier la réponse et ajoutez combien de temps faut-il pour le dernier exemple
Pourquoi avez-vous flip la gamme? c'est à dire dans le premier extrait que vous itéré de [0 à lignes] et puis vous itération à partir de [ligne pour 0]

OriginalL'auteur Luca Del Tongo

Vous devez vous connecter pour publier un commentaire.