Set Barcode Image Kind

This documentation provides an overview of how to use the Aspose.BarCode.Cloud SDK for Node.js to set the type of barcode image for recognition. Setting the correct RecognitionImageKind is essential for optimizing the recognition process and ensuring high accuracy, particularly when dealing with diverse barcode types or varying image qualities.

Introduction

The Aspose.BarCode.Cloud SDK for Node.js allows for flexible barcode scanning and recognition from different image sources. One of the features in this API is the ability to specify the RecognitionImageKind based on the source of the barcode image. This improves accuracy by guiding the recognition engine with additional context about the image.

Usage in API Requests

The RecognitionImageKind parameter is optional and can be set in several requests within the API. It is available in the following request classes:

recognize
recognizeBase64
recognizeMultipart

Image Kind Options

The RecognitionImageKind enum provides three options:

Photo: Use this option when recognizing barcodes from smartphone cameras. High resolution. Barcode is a large part of the image.
ScannedDocument: Select this for scanned documents pages. Medium resolution. Barcode is a small part of the image.
ClearImage: Ideal for clean, digitally-rendered barcode images with minimal background noise or preprocessed photos. Low resolution. The barcode is almost the entire image.

Examples

Below are examples of using the RecognitionImageKind setting with various API methods.

Using `recognize`

The recognize method allows for barcode recognition using a GET request.

const fs = require('fs');
const path = require('path');
const Barcode = require('aspose-barcode-cloud-node');

function makeConfiguration() {
    const envToken = process.env['TEST_CONFIGURATION_ACCESS_TOKEN'];
    if (!envToken) {
        return new Barcode.Configuration(
            'Client Id from https://dashboard.aspose.cloud/applications',
            'Client Secret from https://dashboard.aspose.cloud/applications',
            null,
            null
        );
    } else {
        return new Barcode.Configuration(null, null, null, envToken);
    }
}
const config = makeConfiguration();

async function recognizeBarcode(api) {
    const request = new Barcode.RecognizeRequestWrapper(
        Barcode.DecodeBarcodeType.Qr,
        'https://products.aspose.app/barcode/scan/img/how-to/scan/step2.png'
    );
    request.recognitionMode = Barcode.RecognitionMode.Fast;
    request.recognitionImageKind = Barcode.RecognitionImageKind.Photo;

    const result = await api.recognize(request);
    return result.body.barcodes;
}

const recognizeApi = new Barcode.RecognizeApi(config);

recognizeBarcode(recognizeApi)
    .then((barcodes) => {
        console.log(`File recognized, result: '${barcodes[0].barcodeValue}'`);
    })
    .catch((err) => {
        console.error('Error: ' + JSON.stringify(err, null, 2));
        process.exitCode = 1;
    });

Using `recognizeBase64`

For recognition using a POST request with JSON or XML, use recognizeBase64:

const fs = require('fs');
const path = require('path');
const Barcode = require('aspose-barcode-cloud-node');

function makeConfiguration() {
    const envToken = process.env['TEST_CONFIGURATION_ACCESS_TOKEN'];
    if (!envToken) {
        return new Barcode.Configuration(
            'Client Id from https://dashboard.aspose.cloud/applications',
            'Client Secret from https://dashboard.aspose.cloud/applications',
            null,
            null
        );
    } else {
        return new Barcode.Configuration(null, null, null, envToken);
    }
}
const config = makeConfiguration();

async function recognizeBarcode(api, fileName) {
    const imageBytes = fs.readFileSync(fileName);
    const imageBase64 = Buffer.from(imageBytes).toString('base64');

    const recognizeBase64Request = new Barcode.RecognizeBase64Request();
    recognizeBase64Request.barcodeTypes = [Barcode.DecodeBarcodeType.Aztec, Barcode.DecodeBarcodeType.Qr];
    recognizeBase64Request.fileBase64 = imageBase64;
    const RecognizeRequestWrapper = new Barcode.RecognizeBase64RequestWrapper(recognizeBase64Request);
    const result = await api.recognizeBase64(RecognizeRequestWrapper);

    return result.body.barcodes;
}

const recognizeApi = new Barcode.RecognizeApi(config);

const fileName = path.resolve('testdata', 'QR_and_Code128.png');

recognizeBarcode(recognizeApi, fileName)
    .then((barcodes) => {
        console.log('Recognized barcodes are:');
        console.log(`File '${fileName}' recognized, result: '${barcodes[0].barcodeValue}'`);
    })
    .catch((err) => {
        console.error('Error: ' + JSON.stringify(err, null, 2));
        process.exitCode = 1;
    });

Using `recognizeMultipart`

For file uploads with multipart form data, recognizeMultipart is used:

const fs = require('fs');
const path = require('path');
const Barcode = require('aspose-barcode-cloud-node');

function makeConfiguration() {
    const envToken = process.env['TEST_CONFIGURATION_ACCESS_TOKEN'];
    if (!envToken) {
        return new Barcode.Configuration(
            'Client Id from https://dashboard.aspose.cloud/applications',
            'Client Secret from https://dashboard.aspose.cloud/applications',
            null,
            null
        );
    } else {
        return new Barcode.Configuration(null, null, null, envToken);
    }
}
const config = makeConfiguration();

async function recognizeBarcode(api, fileName) {
    const imageBuffer = fs.readFileSync(fileName);

    const RecognizeRequestWrapper = new Barcode.RecognizeMultipartRequestWrapper(
        Barcode.DecodeBarcodeType.MostCommonlyUsed,
        imageBuffer
    );
    RecognizeRequestWrapper.recognitionImageKind = Barcode.RecognitionImageKind.ClearImage;

    const result = await api.recognizeMultipart(RecognizeRequestWrapper);

    return result.body.barcodes;
}

const recognizeApi = new Barcode.RecognizeApi(config);

const fileName = path.resolve('testdata', 'Pdf417.png');

recognizeBarcode(recognizeApi, fileName)
    .then((barcodes) => {
        console.log(`File '${fileName}' recognized, result: '${barcodes[0].barcodeValue}'`);
    })
    .catch((err) => {
        console.error('Error: ' + JSON.stringify(err, null, 2));
        process.exitCode = 1;
    });

Conclusion

The Barcode Recognition API provides flexible options to recognize barcodes in various formats including photos, scanned documents, and clear images. By setting the RecognitionImageKind, developers can enhance recognition accuracy, particularly when working with diverse image sources. Supported barcode types include popular formats like QR Code, Aztec, Pdf417, and many more. The API allows integration with GET and POST methods, supporting JSON, XML, and multipart form data formats.

For high accuracy, configure the RecognitionImageKind parameter based on your image source. This small adjustment can lead to faster processing times and better recognition results across all supported barcode types.

Set Target Barcode Types Set Recognition Quality and Speed