AZTEC 2D Decoder Library for Polish Vehicle ID Cards

//
// include decoder module for the Node.js (installed with "npm install aztec-decoder" command)
//
var AZTecDecoder = require('aztec-decoder');

// initialize the decoder (using our license key)
AZTecDecoder.SetApiKey("ABCD-ABCD-ABCD-ABCD");

//
// 1. Decode data directly from the image file, return result as an array of JSON items
//
AZTecDecoder.DecodeImageFromFile("C:\\vehicle-id-image.jpg", function(DecodedArray) {

    // check the decoding result
    if (DecodedArray !== null && DecodedArray["Status"] === true)
    {
        // display decoded data (which is stored as an associative array of JSON items)
        console.log(JSON.stringify(DecodedArray, null, "\t"));
    }
});

//
// 2. Decode data directly from the image file, return result as an array of JSON items
//
AZTecDecoder.DecodeImageFromFile("C:\\aztec-code-photo-2d.png", function(DecodedJSON) {

    if (DecodedJSON !== null)
    {
        console.log(JSON.stringify(DecodedJSON, null, "\t"));
    }
});

//
// 3. Decode data from pre-scanned code in text format (e.g. using hand scanner)
//
// encoded data read from the vehicle ID certificate
var szValue = "ggMAANtYAAJD...";

AZTecDecoder.DecodeText(szValue, function(DecodedText) {

    if (DecodedText !== null)
    {
        console.log(JSON.stringify(DecodedText, null, "\t"));
    }
});

//
// 4. Decode data from pre-scanned code (e.g. using hand scanner) in text format stored in a file
//
AZTecDecoder.DecodeTextFromFile("C:\\scanned-aztec-2d-code-as-text.txt", function(DecodedTextFile) {

    if (DecodedTextFile !== null)
    {
        console.log(JSON.stringify(DecodedTextFile, null, "\t"));
    }
});

//
// include decoder class (installed with 'php composer.phar require --prefer-dist pelock/aztec-decoder "*"' command)
//
include_once "AZTecDecoder.php";

//
// create a decoder class (we use our license key to initialize it)
//
$myAZTecDecoder = new PELock\AZTecDecoder("ABCD-ABCD-ABCD-ABCD");

//
// 1. Decode data directly from the image file, return result as an array
//
$DecodedArray = $myAZTecDecoder->DecodeImageFromFile("vehicle-id-image.jpg");

// check the decoding result
if ($DecodedArray !== false && $DecodedArray["Status"] === true)
{
	// display decoded data (which is stored as an associative array)
	var_dump($DecodedArray);
}

//
// 2. Decode data directly from the image file, return result as an JSON string
//
$DecodedJSON = $myAZTecDecoder->DecodeImageFromFile("aztec-code-photo-2d.png", false);

if ($DecodedJSON !== false)
{
	echo $DecodedJSON;
}

//
// 3. Decode data from pre-scanned code in text format (e.g. using hand scanner)
//
$DecodedText = $myAZTecDecoder->DecodeText("ggMAANtYAAJD...");

if ($DecodedText !== false)
{
	var_dump($DecodedText);
}

//
// 4. Decode data from pre-scanned code (e.g. using hand scanner) in text format stored in a file
//
$DecodedTextFile = $myAZTecDecoder->DecodeTextFromFile('/path/scanned-aztec-2d-code-as-text.txt');

if ($DecodedTextFile !== false)
{
	var_dump($DecodedTextFile);
}

//
// include decoder class (installed as a NuGet package "PM> Install-Package AZTecDecoder")
//
using PELock;

private void AZTecDecoderTest()
{
    //
    // create a decoder class (we use our license key to initialize it)
    //
    var myAZTecDecoder = new AZTecDecoder("ABCD-ABCD-ABCD-ABCD");

    //
    // 1. Decode data directly from the image file, return result as an array of JSON items
    //
    var decodedArray = myAZTecDecoder.DecodeImageFromFile(@"C:\path\vehicle-id-image.jpg");

    // check the decoding result
    if (decodedArray != null && decodedArray["Status"] == true)
    {
	// display the decoded data (which is stored as a table of JsonValue elements)
	textOutput.Text = decodedArray.ToString();
    }

    //
    // 2. Decode data directly from the image file, return result as an array of JSON items
    //
    var decodedFromImage = myAZTecDecoder.DecodeImageFromFile(@"C:\path\aztec-code-photo-2d.png");

    if (decodedFromImage != null)
    {
	MessageBox.Show(decodedFromImage.ToString());
    }

    //
    // 3. Decode data from pre-scanned code in text format (e.g. using hand scanner)
    //
    // encoded data read from the vehicle ID certificate
    var szValue = "ggMAANtYAAJD...";

    var decodedText = myAZTecDecoder.DecodeText(szValue);

    if (decodedText != null)
    {
	MessageBox.Show(decodedFromImage.ToString());
    }

    //
    // 4. Decode data from pre-scanned code (e.g. using hand scanner) in text format stored in a file
    //
    var DecodedTextFile = myAZTecDecoder.DecodeTextFromFile(@"C:\path\scanned-aztec-2d-code-as-text.txt");

    if (DecodedTextFile != null)
    {
	MessageBox.Show(DecodedTextFile.ToString());
    }
}

#
#  include decoder module (installed with "pip install aztecdecoder" command)
#
from pelock import aztecdecoder
from pprint import pprint

# create a decoder class (we use our license key to initialize it)
aztec_decoder = aztecdecoder.AZTecDecoder("ABCD-ABCD-ABCD-ABCD")

#
# 1. Decode data directly from the image file, return result as an array of JSON items
#
decoded_array = aztec_decoder.decode_image_from_file("C:\\path\\vehicle-id-image.jpg")

# check the decoding result
if decoded_array and "Status" in decoded_array:

    # // display decoded data (which is stored as an associative array of JSON items)
    pprint(decoded_array)

#
# 2. Decode data directly from the image file, return result as an array of JSON items
#
decoded_json = aztec_decoder.decode_image_from_file("C:\\path\\aztec-code-photo-2d.png")

if decoded_json:

    pprint(decoded_json)

#
# 3. Decode data from pre-scanned code in text format (e.g. using hand scanner)
#
# encoded data read from the vehicle ID certificate
value = "ggMAANtYAAJD...";

decoded_text = aztec_decoder.decode_text(value)

if decoded_text:

    pprint(decoded_text)

#
# 4. Decode data from pre-scanned code (e.g. using hand scanner) in text format stored in a file
#
decoded_text_file = aztec_decoder.decode_text_from_file('C:\\path\\scanned-aztec-2d-code-as-text.txt')

if decoded_text_file:

    pprint(decoded_text_file)

// decoding function declaration for Delphi
function DecodeValue(Value: WideString): WideString; stdcall; external 'AZTecDecoder.dll';

procedure TFormMain.ButtonDecodeClick(Sender: TObject);
var
  DecodedXml: WideString;
begin

  // decode data (read it from the Memo control)
  Decoded := DecodeValue(MemoEncoded.Text);

  // exit on error
  if Decoded = '' then Exit;

  // write XML dump of the decoded data
  WStrToFile('XmlUnicode.xml', Decoded);

end;

' decoding function declaration for Visual Basic / VBA
Private Declare Function DecodeValueVBA Lib "AZTecDecoder.dll" (ByVal Value As String, ByRef Output As String) As Integer

Sub AztecDecoder_Test()

  Dim Value As String
  Dim Xml As String
  Dim Result As Integer

  ' Scanned AZTEC 2D code as an ASCII string
  Value = "gQMAANtYA..."

  ' Decode data
  Result = DecodeValueVBA(Value, Xml)

  ' Display XML dump of the decoded data
  MsgBox (Xml)

End Sub

#include "AZTecDecoder.h"

int main(void)
{
	/* scanned AZTEC 2D code in ASCII form */
	const wchar_t wszValue[] = L"gQMAANtYA...";

	/* output buffer pointer for the decoded data */
	wchar_t *wszDecoded = NULL;

	/* decode scanned data into XML dump */
	wszDecoded = DecodeValue(wszValue);

	/* display XML dump of the decoded data on success */
	if (wszDecoded != NULL)
	{
		wprintf(wszDecoded);

		/* release memory buffer */
		free(wszDecoded);
	}
	else
	{
		wprintf(L"Cannot decode the data!");
	}

	return 0;
}

#define UNICODE
#include <stdlib.h>
#include <stdio.h>
#include <tchar.h>
#include <conio.h>

#include "AZTecDecoder.h"

int DecoderTest()
{
	HMODULE hAZTecDecoder = NULL;
	DECODEVALUECPPSIZE pDecodeValueCPPSize = NULL;
	DECODEVALUECPP pDecodeValueCPP = NULL;

	unsigned int dwBufferSize = 0;
	unsigned int dwResult = 0;

	wchar_t wszValue[] = _T("gQMAANtYA...");
	wchar_t *wszXml = NULL;

	// load AZTec Decoder library
	hAZTecDecoder = LoadLibrary(_T("AZTecDecoder.dll"));

	pDecodeValueCPPSize = (DECODEVALUECPPSIZE)GetProcAddress(hAZTecDecoder, "DecodeValueCPPSize");
	pDecodeValueCPP = (DECODEVALUECPP)GetProcAddress(hAZTecDecoder, "DecodeValueCPP");

	// get the output buffer size for the decoded data
	dwBufferSize = pDecodeValueCPPSize(wszValue);

	if (dwBufferSize == 0) return 1;

	// allocate memory for the output XML dump
	wszXml = malloc(sizeof(wchar_t) * dwBufferSize);

	// decode data
	dwResult = pDecodeValueCPP(wszValue, wszXml);

	// display XML dump of the decoded data on success
	if (dwResult == 0)
	{
		wprintf(wszXml);

		// release memory
		free(wszXml);

		return 0;
	}

	// release memory
	free(wszXml);

	return 1;
}

[DllImportAttribute("AZTecDecoder.dll", EntryPoint = "DecodeValueCPPSize", CallingConvention = CallingConvention.StdCall)]
public static extern int DecodeValueCPPSize(byte[] wszValue);

[DllImportAttribute("AZTecDecoder.dll", EntryPoint = "DecodeValueCPP", CallingConvention = CallingConvention.StdCall)]
public static extern int DecodeValueCPP(byte[] wszValue, byte[] wszOutputXml);

private void buttonDecode_Click(object sender, EventArgs e)
{
	// scanned AZTEC 2D code as an ASCII string
	string szValue = textInput.Text;

	textOutput.Text = "";

	UnicodeEncoding UNICODE = new UnicodeEncoding();

	// convert input data to UNICODE string
	byte[] wszValue = UNICODE.GetBytes(szValue);

	// get the output buffer size for the decoded data
	int dwBufferSize = DecodeValueCPPSize(wszValue);

	// if the return code is 0, input data were incorrect
	if (dwBufferSize == 0)
	{
		MessageBox.Show("Incorrect data format!");
		return;
	}

	// allocate memory for the output XML dump
	byte[] lpcDecodedData = new byte[dwBufferSize];

	// decode data
	int dwResult = DecodeValueCPP(wszValue, lpcDecodedData);

	// display XML dump of the decoded data on success
	if (dwResult == 0)
	{
		string szXml = UNICODE.GetString(lpcDecodedData);

		textOutput.Text = szXml;
	}
	else
	{
		MessageBox.Show("Cannot decode the data!");
		return;
	}
}

<?php
	include_once "AZTecDecoder.php";

	// create decoder instance
	$myAZTecDecoder = new AZTecDecoder();

	// scanned AZTEC 2D code in ASCII form
	$szValue = "gQMAANtYA...";

	// additional flag for the output JSON format
	// otherwise XML is used
	$bJson = false;

	// decode data
	$szDecoded = $myAZTecDecoder->DecodeValue($szValue, $bJson);

	// send proper header for the browser in case of JSON output option
	if ($bJson == false)
	{
		header("Content-type: text/xml; charset=utf-8");
	}

	// display decoded data
	echo $szDecoded;
?>

import AZTecDecoder

# create decoder instance
myAZTecDecoder = AZTecDecoder.AZTecDecoder()

# scanned AZTEC 2D code in ASCII form
szValue = "gQMAANtYA..."

# decode data
szDecoded = myAZTecDecoder.DecodeValue(szValue)

# display XML dump of the decoded data on success
if szDecoded:
	print szDecoded
else:
	print "Cannot decode the data!"

load 'AZTecDecoder.rb'

# create decoder instance
aztec_decoder = AZTecDecoder.new

# scanned AZTEC 2D code in ASCII form
value = "gQMAANtYA..."

# decode data
decoded = aztec_decoder.DecodeValue(value)

# display XML dump of the decoded data on success
if decoded.to_s != ''
  puts decoded
else
  puts "Cannot decode the data!"
end