ZXing (& Zèbre Crossing & # 8220;) en C #

Question

Je recherche une bonne bibliothèque open source capable de rechercher et de lire un code-barres à partir d’une image (par opposition à l’utilisation d’un scanner de codes-barres). D'après d'autres questions sur le dépassement de capacité, j'ai constaté que ZXing (" Zebra Crossing ") c'est assez bon. Bien qu’il soit conçu pour Java, il existe un port C #, mais j’estime qu’il pourrait ne pas être complet. Pensez-vous que cela est fiable suffisant pour analyser un code-barres dans une telle situation, ou une autre bibliothèque est-elle meilleure?

MODIFIER: Comme l'a souligné Ed dans ses commentaires, je devrais d'abord l'essayer. Wow, je n'ai pas pensé à ça. :) mais je suppose que ma question est de savoir si le port partiel est suffisamment fiable - si l’un d’entre vous l’a déjà utilisé, peut-il scanner avec compétence?

Answer 1

Cela dépend de votre utilisation, bien sûr. Même la version Java de zxing présente des limitations importantes et des problèmes de performances. Par exemple, il ne peut trouver qu'un seul code à barres sur une page. De plus, les algorithmes utilisés pour localiser le code à barres 1-D sur la page ne sont pas particulièrement efficaces (aucune idée des algorithmes pour les codes à barres 2-D - cela ne faisait pas partie des exigences du projet sur lequel je travaillais). Tout cela peut être résolu - j'ai commencé une amélioration il y a quelques mois et j'ai pu améliorer considérablement les performances et la fiabilité des emplacements 1-D, mais nos priorités en matière de développement ont changé et je n'y ai donc pas travaillé depuis.

Pour ce qui est de savoir si le port partiel vers C # est bon, si vous souhaitez publier vos différences, nous nous ferons un plaisir de les commenter.

EDIT - voici une partie de la refactorisation que j'ai effectuée:

D'abord, factorisez RowNumberStrategy comme suit:

public interface RowNumberStrategy {
public int getNextRowNumber();

public class OriginalRowStrategy implements RowNumberStrategy{
    int middle;
    boolean tryHarder = false;
    int rowStep;
    int maxLines;
    int maxRows;

    int x;

    public OriginalRowStrategy(int maxRows, boolean tryHarder) {
        this.x = 0;
        this.maxRows = maxRows;
        this.middle = maxRows >> 1; // divide by 2
        this.tryHarder = tryHarder;
        rowStep = Math.max(1, maxRows >> (tryHarder ? 7 : 4));
        if (tryHarder) {
          maxLines = maxRows; // Look at the whole image, not just the center
        } else {
          maxLines = 9; // Nine rows spaced 1/16 apart is roughly the middle half of the image
        }
    }

    public int getNextRowNumber() {
        if (x > maxLines)
            return -1;

        int rowStepsAboveOrBelow = (x + 1) >> 1;
        boolean isAbove = (x & 0x01) == 0; // i.e. is x even?
        int rowNumber = middle + rowStep * (isAbove ? rowStepsAboveOrBelow : -rowStepsAboveOrBelow);
        if (rowNumber < 0 || rowNumber >= maxRows) {
          // Oops, if we run off the top or bottom, stop
          return -1;
        }

        x = x + 1;

        return rowNumber;
    }

}

public class LinearScanRowStrategy implements RowNumberStrategy{
    private final int maxRows;
    private int currentRow;
    public LinearScanRowStrategy(int totalRows) {
        maxRows = totalRows;
        currentRow = 0;
    }

    public int getNextRowNumber() {
        if (currentRow > maxRows)
            return -1;

        return maxRows - 1 - currentRow++;
    }

}

public class ProgressiveScanRowStrategy implements RowNumberStrategy{
    private final int maxRows;
    private int currentStepSize;
    private int currentStep;

    public ProgressiveScanRowStrategy(int totalRows) {
        maxRows = totalRows;
        currentStep = 0;
        currentStepSize = maxRows;
    }

    public int getNextRowNumber() {
        int nextRow = (currentStep++) * currentStepSize;
        if (nextRow < maxRows)
            return nextRow;

        currentStepSize = currentStepSize >> 1;
        if (currentStepSize <= 0)
            return -1;
        currentStep = 1;

        nextRow = currentStep * currentStepSize;

        return nextRow;
    }

}



}

alors la partie supérieure de doDecode devient la suivante:

private Result doDecode(MonochromeBitmapSource image, Hashtable hints) throws ReaderException {


int width = image.getWidth();
int height = image.getHeight();
BitArray row = new BitArray(width);
boolean tryHarder = hints != null && hints.containsKey(DecodeHintType.TRY_HARDER);
RowNumberStrategy rowProvider = new RowNumberStrategy.ProgressiveScanRowStrategy(height);  

int rowNumber;
while ((rowNumber = rowProvider.getNextRowNumber()) != -1){
...
}

finalement, cela devrait être quelque chose qui peut être défini via un DecodeHintType, mais nous avons constaté que la stratégie progressive est plus rapide que l'ancienne stratégie dans tous les cas où nous pourrions la lancer (et pas seulement un peu plus rapidement - beaucoup plus vite).

Answer 2

J'utilise la version java depuis plus d'un an, avec environ 100 analyses par jour, et cela fonctionne très bien. Je ne vois aucune raison pour laquelle la version c # serait pire.

Answer 3

Essayez de compiler la version Java avec ikvmc , puis accédez-y à partir de votre code C #. .