ZXing ( “Crossing Zebra”) em C #
Pergunta
Eu estou procurando uma boa biblioteca de código aberto que pode encontrar e ler um código de barras de uma imagem (versus usando um scanner de código de barras). De outras perguntas sobre estouro de pilha, eu descobri que ZXing ( "Zebra Crossing") é muito bom. Embora ela é feita para Java, há uma porta C # - no entanto, eu acredito que ele pode não ser completa. Você acha que isso é confiável o suficiente para analisar um código de barras a partir de tal situação um, ou alguma outra biblioteca melhor?
EDIT: Como Ed apontou nos comentários, eu deveria apenas experimentá-lo primeiro. Uau, eu não tinha pensado nisso. :) mas eu acho que a minha pergunta é se a porta parcial é suficiente confiável -? Se algum de vocês têm usado isso antes, ele pode verificar com proficiência
Solução
Isso depende do que você está usando para isso, é claro. Mesmo a versão Java do ZXing tem algumas limitações importantes e problemas de desempenho. Por exemplo, só pode encontrar um código de barras em uma página. Além disso, os algoritmos que utiliza para localizar 1-D de código de barras na página não são particularmente eficientes (nenhuma idéia sobre os algoritmos de códigos de barras 2-D - que não fazia parte das exigências do projeto que eu estava trabalhando). Isto é tudo coisas que podem ser abordados -. Eu comecei uma melhoria há alguns meses e foi capaz de melhorar significativamente 1-D desempenho e confiabilidade localização, mas as nossas prioridades dev mudaram então eu não tenho trabalhado nele desde então
Quanto a saber se a porta parcial para C # é bom, se você quiser enviar de volta com o que as diferenças são, eu ficaria feliz em comentários.
EDIT - aqui é um pouco da refatoração que eu fiz:
Em primeiro lugar, o fator fora RowNumberStrategy da seguinte forma:
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;
}
}
}
, em seguida, a parte superior do doDecode torna-se o seguinte:
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){
...
}
Em última análise, isso deve ser algo que pode ser definido através de um DecodeHintType, mas descobrimos que a estratégia progressiva é mais rápido do que a velha estratégia em cada caso, poderíamos jogar nele (e não apenas um pouco mais rápido - muito mais rápido).
Outras dicas
Estou usando a versão Java para mais de um ano, a digitalização de cerca de 100 por dia, e ele funciona muito bem. Não vejo razão do c # versão seria pior.
Tente compilar a versão java com ikvmc , do que acessá-lo de seu código C # .