DEV Community: AsposeAG

Barcode generation and recognition in-memory with GDI+, STD and Aspose.Barcode for C++ libraries

AsposeAG — Wed, 18 Nov 2020 04:12:56 +0000

Introduction

Articles describes communication and conversion between Aspose.Barcode for C++ internal in-memory objects, GDI+ bitmaps and common C++ objects from STD library. The conversion functions could be used with other Aspose C++ libraries because they have the same Aspose System Library for C++. The library types are look like standard .Net objects and can be easily used by anyone who is common with C#.

The article describes how to write and read data from Aspose MemoryStream which copies .Net MemoryStream functions and behavior. Also, it describes how to convert Aspose Bitmap between standard in Windows GDI+ Bitmap. Conversion functions has additional layer which is conversion between Aspose Bitmap and abstract in-memory 32-bit ARGB bitmap, which can be used to connect Aspose Bitmap with other objects from different graphic libraries.

All of these helper functions allow to use Aspose System Library for C++ with well-known types and functions from STD and GDI+ libraries.

Background

Aspose.Barcode for C++ uses custom system library which is similar to .Net standard types. All of library API are documented, but have low amount of examples: how to work with all of these graphics or system objects like files, streams or strings. Some users are confused how to use these Aspose types and link them with standard C++ objects or standard Windows objects. To solve this problem, we have developed helper functions which allow to make bridge between Aspose System Library for C++ and commonly used STD library objects, GDI+ graphics objects.

In most cases, only two functions are required from the barcode library : barcode generation and recognition. Other functions are unnecessary or even excessively. Aspose.Barcode for C++ uses Aspose System Library for C++ for own purposes, but learning new methods to manipulate data objects instead of just obtaining generated barcode image or providing one for the recognition is not the best idea. Most of users have own software libraries which already have solved their problems with manipulating system or graphics objects. The problem solution is conversion between Aspose system and graphic objects and user’s libraries objects.

Developer Guide describes communication mostly by file system which is not appropriate for some projects or applications. Helper functions, developed in this project, solve the problem and allow to communicate with other system libraries as common graphic library GDI+ and C++ standard library.

Prerequisites

At first you need to read Aspose.BarCode for C++ beginners guide how to create first project with the library and obtain the library with NuGet.

The next, you need to add to you project standard Windows GDI+ library which is common for any 2D graphic usage. You need to add GDI+ library as and pragma and setup startup and shutdown GDI+ token. You need to startup GDI+ library once on process startup or dll initialization and shutdown on process exit or dll unloading. However, you can avoid GDI+ shutdown on process exit because all library variables automatically will be cleared on process exit.

//adds library to the project, can be added in linker
#pragma comment (lib,"Gdiplus.lib")

//initalize GDI+ (must be inialized in process before any call)
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR gdiplusToken;
Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

//shutdown GDI+ (can be avoided if we terminate the process)
//but we must be attentive in dll creation
Gdiplus::GdiplusShutdown(gdiplusToken);

Used types

Aspose System Library for C++ types are based on the own implementation of smart pointers and allows to use all features of heap memory management and thread automatic safe memory management. User doesn’t need to care about object destruction or memory leaks. However, to correctly exit from the process or unload Dll, you have to correctly shutdown the library with PrepareForUnload function. It is required in low number of cases but sometimes it is required.

//unload Aspose.Barcode.Cpp library variables and threads   
System::AsposeCppLibrary::PrepareForUnload();

System::IO::MemoryStream – is an Aspose memory stream class which is similar to .Net MemoryStream and used to store data into the memory.
System::Drawing::Bitmap - is an Aspose Bitmap class which is used to store pixel data for a graphics image and its attributes. It is similar to .Net Bitmap.
IStream - is an interface of streaming objects which is used in COM Automation. We use it to Save and Load GDI+ bitmaps.
Gdiplus::Bitmap – is an Microsoft GDI+ Bitmap class which is used to store pixel data of an images and their attributes.
Byte – is unsigned char C++ alias type.
ByteArray – is a vector of Byte variables. We use it to transfer data between MemoryStream, IStream and other types.
MemBmpARGB – is a memory structure in ARGB(alpha, red, green, blue: 8 bits) format, which represents color matrix and can be used to copy data into non Aspose and non GDI+ graphic libraries.

//memory structure in ARGB(alpha, red, green, blue: 8 bits) format
//which represents color matrix and can be used to copy data 
//into non Aspose and non GDI+ graphic libraries
struct MemBmpARGB
{
    //bitmap width in ARGB pixels
    int Width = 0;
    //bitmap height in ARGB pixels
    int Height = 0;
    //bitmap array in ARGB pixels
    //size is Width * Height * 4
    //format:
    //row0(width)
    //...
    //row_height-1(width)
    ByteArray Data;

    //ARGB memory bitmap constructor
    MemBmpARGB(int _width, int _height)
    {
        Width = _width;
        Height = _height;
        Data.resize(_width * _height * 4);//ARGB = 8888 4 bytes
    }
};

Streams conversions

Aspose.Barcode for C++ uses FileStream and MemoryStream to save and load image data. Because to save or load data from a file we need just provide a string with file path we do not describe working with FileStream. MemoryStream allows to save and load data into the memory which could be used for network processing or with other communication methods.

We can convert data from MemoryStream to ByteArray with this code. As we see we extract MemoryStream size, initialize vector capacity and copy the data.

//function converts memory stream to byte array
//memoryStream - is a memory steam
//returns byte array
ByteArray MemoryStreamToByteArray(System::SharedPtr<System::IO::MemoryStream> memoryStream)
{
    //initialize array capacity
    System::ByteArrayPtr lMemAdr = memoryStream->GetBuffer();
    ByteArray arr(lMemAdr->Count());

    //copy data
    memcpy(arr.data(), lMemAdr->data_ptr(), lMemAdr->Count());

    return arr;
}

The same thing we can convert ByteArray to MemoryStream. We initialize memory stream length, receive addresses of our buffers and copy data from vector to memory stream.

//function converts byte array to memory stream
//arr - is byte array
//returns memory stream
System::SharedPtr<System::IO::MemoryStream> ByteArrayToMemoryStream(ByteArray &arr)
{
    //intialize memory stream capacity
    System::SharedPtr<System::IO::MemoryStream> memoryStream = System::MakeObject<System::IO::MemoryStream>();
    memoryStream->SetLength(arr.size());
    System::ByteArrayPtr lMemAdr = memoryStream->GetBuffer();

    //copy data and set position to 0
    memcpy(lMemAdr->data_ptr(), arr.data(), arr.size());
    memoryStream->set_Position(0);

    return memoryStream;
}

The library also have code to copy data from/to std::string and creation MemoryStream from memory pointer with size.

System::SharedPtr<System::IO::MemoryStream> MemoryStreamFromBuffer(void* buffer, int size);
std::string MemoryStreamToString(System::SharedPtr<System::IO::MemoryStream> memoryStream);
System::SharedPtr<System::IO::MemoryStream> StringToToMemoryStream(std::string &str);

GDI+ uses IStream to load and saves bitmaps into non file stream, as example memory stream, in various formats.

We can create in-memory IStream from ByteArray with the function SHCreateMemStream

SHCreateMemStream(arr.data(), (UINT)arr.size());

Read data from IStream into ByteArray is slightly more complicated and provided with this function

//function coverts COM IStream implementation to byte array
//https://docs.microsoft.com/en-us/windows/win32/api/objidl/nn-objidl-istream
//istr - is COM IStream implementation
//returns byte array
ByteArray IStreamToByteArray(IStream *istr)
{
    //set position to zero
    LARGE_INTEGER SeekPos;
    SeekPos.QuadPart = 0;
    ULARGE_INTEGER actualPos;
    ULARGE_INTEGER zeroPos;
    //remember position
    istr->Seek(SeekPos, STREAM_SEEK_CUR, &actualPos);
    //set to zero
    istr->Seek(SeekPos, STREAM_SEEK_SET, &zeroPos);

    //get size
    tagSTATSTG istat;
    istr->Stat(&istat, STATFLAG_NONAME);

    //read to buffer
    int size = istat.cbSize.LowPart;
    ULONG actualBytes = 0;
    ByteArray arr(size);
    istr->Read(arr.data(), size, &actualBytes);

    //return position
    SeekPos.QuadPart = actualPos.QuadPart;
    istr->Seek(SeekPos, STREAM_SEEK_CUR, &actualPos);

    return arr;
}

It is simple to convert directly IStream from/to MemoryStream with usage of previous code.

IStream* MemoryStreamToIStream(System::SharedPtr<System::IO::MemoryStream> memoryStream);
System::SharedPtr<System::IO::MemoryStream> IStreamToMemoryStream(IStream *istr);

Bitmaps conversions

Aspose.Barcode for C++ can write and read data not only from the file and streams but also from Aspose Bitmap which is similar to .Net Bitmap. In this way, understanding how to manipulate with Bitmap data helps to use it for reports, screen drawing or printing.

We implemented structure MemBmpARGB which represents pixels array, representing ARGB(alpha, red, green, blue: 8 bits) most common format. This helps to convert data from other graphic libraries.

We can convert Aspose Bitmap to MemBmpARGB with this code. In this code we extract raw pixels in 32-bit ARGB format from Aspose Bitmap and copy to our in-memory structure.

//function converts Aspose Bitmap to ARGB memory bitmap
//bitmap - is Aspose Bitmap
//returns ARGB memory bitmap
MemBmpARGB AsposeBitmapToMemBitmap(System::SharedPtr<System::Drawing::Bitmap> bitmap)
{
    MemBmpARGB memBitmap(bitmap->get_Width(), bitmap->get_Height());

    //lock and extract bitmap data
    System::Drawing::Rectangle rect(0, 0, bitmap->get_Width(), bitmap->get_Height());
    System::SharedPtr<System::Drawing::Imaging::BitmapData> lBmpData =
        bitmap->LockBits(rect, System::Drawing::Imaging::ImageLockMode::ReadOnly, System::Drawing::Imaging::PixelFormat::Format32bppArgb);
    int lBuffSize = std::min(lBmpData->get_Stride() * lBmpData->get_Height(), (int)memBitmap.Data.size());

    //copy data
    memcpy(memBitmap.Data.data(), (void*)lBmpData->get_Scan0(), lBuffSize);
    bitmap->UnlockBits(lBmpData);

    return memBitmap;
}

The same way we can copy data from MemBmpARGB structure to Aspose Bitmap. We receive buffer information from Aspose Bitmap and copy pixels array data directly to the buffer.

//function converts ARGB memory bitmap to Aspose Bitmap
//memBitmap - is ARGB memory bitmap
//returns Aspose Bitmap
System::SharedPtr<System::Drawing::Bitmap> MemBitmapToAsposeBitmap(MemBmpARGB &memBitmap)
{
    System::SharedPtr<System::Drawing::Bitmap> bitmap = 
        System::MakeObject<System::Drawing::Bitmap>(memBitmap.Width, memBitmap.Height, System::Drawing::Imaging::PixelFormat::Format32bppArgb);

    //lock and extract bitmap data
    System::Drawing::Rectangle rect(0, 0, memBitmap.Width, memBitmap.Height);
    System::SharedPtr<System::Drawing::Imaging::BitmapData> lBmpData =
        bitmap->LockBits(rect, System::Drawing::Imaging::ImageLockMode::WriteOnly, System::Drawing::Imaging::PixelFormat::Format32bppArgb);

    int lBuffSize = std::min(lBmpData->get_Stride() * lBmpData->get_Height(), (int)memBitmap.Data.size());

    //copy data
    memcpy((void*)lBmpData->get_Scan0(), memBitmap.Data.data(), lBuffSize);
    bitmap->UnlockBits(lBmpData);

    return bitmap;
}

On the Windows, in most cases, we use GDI+ graphic library because it fast and has enough functions for any 2D graphic requirements. Converting from Aspose Bitmap to GDI+ Bitmap we can use following code. As we see we just need to unlock data buffers both from Aspose Bitmap and GDI+ Bitmap and copy pixels array one from other.

//function converts Aspose Bitmap to GDI+ Bitmap
//abitmap - is Aspose Bitmap
//returns GDI+ Bitmap
std::shared_ptr<Gdiplus::Bitmap> AsposeBitmapToGdiPlusBitmap(System::SharedPtr<System::Drawing::Bitmap> abitmap)
{
    std::shared_ptr<Gdiplus::Bitmap> gbitmap = std::make_shared<Gdiplus::Bitmap>(abitmap->get_Width(), abitmap->get_Height(), PixelFormat32bppARGB);

    //lock gbitmap
    Gdiplus::BitmapData gbitmapData;
    Gdiplus::Rect grect(0, 0, abitmap->get_Width(), abitmap->get_Height());
    gbitmap->LockBits(&grect, Gdiplus::ImageLockModeWrite, PixelFormat32bppARGB, &gbitmapData);

    //lock abitmap
    System::Drawing::Rectangle arect(0, 0, abitmap->get_Width(), abitmap->get_Height());
    System::SharedPtr<System::Drawing::Imaging::BitmapData> abitmapData =
        abitmap->LockBits(arect, System::Drawing::Imaging::ImageLockMode::ReadOnly, System::Drawing::Imaging::PixelFormat::Format32bppArgb);

    //copy
    int lBuffSize = std::min((int)(gbitmapData.Stride * gbitmapData.Height), abitmapData->get_Stride() * abitmapData->get_Height());
    memcpy(gbitmapData.Scan0, (void*)abitmapData->get_Scan0(), lBuffSize);

    //unlock
    abitmap->UnlockBits(abitmapData);
    gbitmap->UnlockBits(&gbitmapData);

    return gbitmap;
}

The same way is conversion between GDI+ Bitmap and Aspose Bitmap, we extract data buffers in 32-bit ARGB formats and copy pixels from GDI+ buffer to Aspose buffer.

//function converts GDI+ Bitmap to Aspose Bitmap
//gbitmap - is GDI+ Bitmap
//returns Aspose Bitmap
System::SharedPtr<System::Drawing::Bitmap> GdiPlusBitmapToAsposeBitmap(Gdiplus::Bitmap &gbitmap)
{
    System::SharedPtr<System::Drawing::Bitmap> abitmap =
        System::MakeObject<System::Drawing::Bitmap>(gbitmap.GetWidth(), gbitmap.GetHeight(), System::Drawing::Imaging::PixelFormat::Format32bppArgb);

    //lock abitmap
    System::Drawing::Rectangle arect(0, 0, abitmap->get_Width(), abitmap->get_Height());
    System::SharedPtr<System::Drawing::Imaging::BitmapData> abitmapData =
        abitmap->LockBits(arect, System::Drawing::Imaging::ImageLockMode::WriteOnly, System::Drawing::Imaging::PixelFormat::Format32bppArgb);

    //lock gbitmap
    Gdiplus::BitmapData gbitmapData;
    Gdiplus::Rect grect(0, 0, abitmap->get_Width(), abitmap->get_Height());
    gbitmap.LockBits(&grect, Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, &gbitmapData);

    //copy
    int lBuffSize = std::min((int)(gbitmapData.Stride * gbitmapData.Height), abitmapData->get_Stride() * abitmapData->get_Height());
    memcpy((void*)abitmapData->get_Scan0(), gbitmapData.Scan0, lBuffSize);

    //unlock
    abitmap->UnlockBits(abitmapData);
    gbitmap.UnlockBits(&gbitmapData);

    return abitmap;
}

Sometimes we need to store or load data GDI+ Bitmap to or from file or stream. GDI+ Bitmap can use IStream for this. IStream of system memory stream can be created with function SHCreateMemStream. How to convert IStream from and to MemoryStream** we have reviewed in previous section. But GDI+ need not only image format identifier to save image in special format it needs encoder GUID. To find encoder GUID we can use the following code.

//function searches image encoders/decoder for GDI+
//imageFormat - is image format (bmp, png, jpg...)
//isEncoder - is is we are searching Encoders(true) or decoders(false)
//returns encoder/decoders ID
CLSID FindCodecByFormat(const GUID &imageFormat, bool isEncoder)
{
    //get buffer size
    UINT  num, size;
    Gdiplus::Status stat = Gdiplus::Status::Ok;
    if (isEncoder)
        stat = Gdiplus::GetImageEncodersSize(&num, &size);
    else
        stat = Gdiplus::GetImageDecodersSize(&num, &size);

    if ((Gdiplus::Status::Ok!= stat) || (0 == size))
        return CLSID_NULL;

    //get encoders/decoders
    Gdiplus::ImageCodecInfo* pArray = (Gdiplus::ImageCodecInfo*)(malloc(size));
    if (isEncoder)
        Gdiplus::GetImageEncoders(num, size, pArray);
    else
        Gdiplus::GetImageDecoders(num, size, pArray);

    CLSID codec = CLSID_NULL;
    for (UINT j = 0; j < num; ++j)
        if (imageFormat == pArray[j].FormatID)
        {
            codec = pArray[j].Clsid;
            break;
        }

    free(pArray);
    return codec;
}

How to save GDI+ Bitmap to file or memory stream is shown in these functions.

//function load GDI+ Bitmap from memory stream
//memoryStream - is memory stream
//returns GDI+ Bitmap
std::shared_ptr<Gdiplus::Bitmap> GdiPlusBitmapFromMemoryStream(System::SharedPtr<System::IO::MemoryStream> memoryStream);
//function saves GDI+ Bitmap to memory stream
//gbitmap - is GDI+ Bitmap
//imageFormat - is image format (bmp, png, jpg...)
//returns memory stream
System::SharedPtr<System::IO::MemoryStream> GdiPlusBitmapToMemoryStream(Gdiplus::Bitmap &gbitmap, const GUID &imageFormat = Gdiplus::ImageFormatPNG);

//function saves GDI+ Bitmap to file
//gbitmap - is GDI+ Bitmap
//fileName - is file name
//imageFormat - is image format (bmp, png, jpg...)
void SaveGdiPlusBitmapToFile(Gdiplus::Bitmap &gbitmap, const wchar_t* fileName, const GUID &imageFormat = Gdiplus::ImageFormatPNG);
//function loads GDI+ Bitmap from file
//fileName - is file name
//returns GDI+ Bitmap
std::shared_ptr<Gdiplus::Bitmap> LoadGdiPlusBitmapFromFile(const wchar_t* fileName);

Examples

Project contains a lot of examples which demonstrate usage of described upper functions. Al of these examples are provided in example.cpp. There are not only Streams and Bitmap conversions, but barcode generation and recognition examples from GDI+ or system in-memory objects and examples in generation barcodes with drawing them on device surfaces.

These two functions demonstrate how to convert MemoryStream, IStream, ByteArray, memory buffer or std::string each in other.

//test examples
//functions demonstrates how to extract data from and to memory stream
void HowToConvertAndSaveMemoryStream(const wchar_t* pathName);
//functions demonstrates how to extract data from and to memory stream
//with special data types like memory buffer or std::string
void HowToConvertAndSaveMemoryStreamExt(const wchar_t* pathName);

In this section usage of different conversion between bitmaps are shown.

//functions demonstrates how to extract from and to ARGB memory bitmap
void HowToWorkWithMemBmpARGB(const wchar_t* pathName);
//functions demonstrates how to convert data between GDI+ and Aspose bitmap objects
void HowToWorkWithGdiPlusAndAsposeBitmapConversion(const wchar_t* pathName);
//functions demonstrates how to load and save GDI+ bitmaps to memory stream
void HowToWorkWithGdiPlusAndMemoryStream(const wchar_t* pathName);

This section shows how to draw barcodes with GDI+ graphic library function on GDI+ Bitmap, HBITMAP. The same way the barcode can be drawn or captured from any DC context.

//functions demonstrates how to draw barcodes on GDI+ bitmap
void HowToDrawBarcodeOnBitmap(const wchar_t* pathName);
//functions demonstrates how to draw barcodes on HBITMAP object
void HowToDrawBarcodeOnHBITMAP(const wchar_t* pathName);

And this section describes how we can recognize barcodes not only from file on the disk but from GDI+ image acquired from different contexts.

//functions demonstrates how to recognize barcode from  GDI+ Bitmap
void HowToRecognize(const wchar_t* pathName);

Conclusion

In this article and project, we provide helper library which allows Aspose.Barcode for C++ easily communicating with standard system graphics library GDI+ or standard system objects. This can help to use Aspose barcode library in different C++ projects without storing or loading data directly from disk subsystem.

Aspose.BarCode for C++ beginners guide

AsposeAG — Fri, 13 Nov 2020 03:16:18 +0000

Download example source

Introduction

Aspose.BarCode for C++ is a C++ library providing the barcode generation and recognition features to your project and supports more than 60 barcode types and 7 image formats. The library is a part of Aspose.Barcode is multi-platform family of libraries are written on C++, .Net and Java.

In this article we describe simple example how to write and read barcodes on C++ for Windows platform. However, the library supports Windows, Linux and MacOS platforms. On Windows it can be used only in x64 project types and last 19.9.0 version of the library requires VS2017(v141) platform toolset. The projects can be developed in VS2017 and VS2019.

Background

Barcodes is a technology which allows to add machine reading tags or machine reading additional data to any object of real world with less than one cent cost. Before, it requires specialized devices to print or recognize barcode but currently they can be recognized with any camera equipped device and specialized software library - barcode library.

Barcode libraries in main cases have two functions: reading and writing barcodes. Some of the libraries support only one function, some support both functions.

Aspose.BarCode for C++ supports two functions with the following components: BarcodeGenerator (writing), BarCodeReader (reading).

BarcodeGenerator allows generating more than 60 barcode types, both 1D barcode types and 2D barcode types. The component has wide options to specifying appearance-related properties, customize barcode encoding modes and parameters. Appearance-related properties include customization of image borders, style, margin, width, background / foreground colors, fonts, location (hide, above, below) and alignment. Barcode image, depends on requirements, can be rotated on any angle and be produced in high quality with anti-aliasing. Depends on type of appearance of screen or printing mode, image resolution or auto size mode also can be customized.

BarCodeReader allows to recognize more than 60 barcode types, both 1D barcode types and 2D barcode types, on scanned image in the most popular file formats like: JPEG, TIFF, PNG, BMP, GIF and EXIF. The recognition process is highly configurable and allows selection of preferred barcode types and image regions for recognition, also customization of internal engine variables to choose better balance between recognition performance and recognition quality.

Obtaining license

Aspose.BarCode for C++ is proprietary library and requires license to support all of the features. Without license recognition and generation function could be watermarked.

To obtain temporary 30 day license with mostly unlimited prolongation you could go to Temporary License page select purchase wizard and obtain Aspose.Total or Aspose.Barcode license.

The other way is obtaining free Publicity License

Create project and install the library

In this section we describe how to create console project which can support Aspose.BarCode for C++ and install the library by the NuGet.

1.Run VS2019 and create console project.

2. Set platform to x64 version

3. Setup platform toolset to VS2017(v141) and SDK to 8.1+ to Debug and Release configirations.

4. Press right click on project References and select “Manage NuGet Packages”

5. Find Aspose.BarCode.Cpp on “Browse” folder and push “Install”.

Using the code

At first add these headers to the example file, they are required for implementation of BarcodeGenerator and BarCodeReader basic functions.

#include <windows.h>
#include <Licensing\License.h>
#include <Generation/EncodeTypes/SymbologyEncodeType.h>
#include <Generation/EncodeTypes/EncodeTypes.h>
#include <BarCode.Generation/BarcodeGenerator.h>
#include <BarCode.Generation/GenerationParameters/BaseGenerationParameters.h>
#include <BarCode.Generation/GenerationParameters/BarcodeParameters.h>
#include <BarCode.Generation/GenerationParameters/CodetextParameters.h>
#include <BarCode.Generation/Helpers/Unit.h>
#include <Generation/BarCodeImageFormat.h>

//BarCodeReader
#include <BarCodeRecognition/Recognition/RecognitionSession/BarCodeReader.h>
#include <BarCodeRecognition/Recognition/RecognitionSession/DecodeTypes/DecodeType.h>
#include <BarCodeRecognition/Recognition/RecognitionSession/DecodeTypes/MultyDecodeType.h>
#include <BarCodeRecognition/Recognition/RecognitionSession/DecodeTypes/SingleDecodeType.h>

Adding license

Then we add to “main” function the code, which applies license to the project. License file could be obtained on previous steps and without license generated images and recognized barcode text could be watermarked.

//set license
System::SharedPtr<Aspose::BarCode::License> license = System::MakeObject<Aspose::BarCode::License>();
license->SetLicense(System::String::FromWCS(lExampleFolder + L"LicenseName.lic"));

BarcodeGenerator

In the function GenerateBarcode we generate Code128 barcode with codetext. Any other barcode type with any other codetext can be generated. Also, we can setup barcode special parameters.

void GenerateBarcode(std::wstring &folder)
{
    //initialize out codetext
    const System::String codeText = u"ABCTZCS1234567890T4444T5678901234XYZ";

    //create barcode generator with Code128 symbology
    System::SharedPtr<Aspose::BarCode::Generation::BarcodeGenerator> barcodeGenerator = System::MakeObject<Aspose::BarCode::Generation::BarcodeGenerator>(Aspose::BarCode::Generation::EncodeTypes::Code128, codeText);
    //set barcode parameters as no codetext
    barcodeGenerator->get_Parameters()->get_Barcode()->get_CodeTextParameters()->set_Location(Aspose::BarCode::Generation::CodeLocation::None);
    //and bar unit size 5 pixels
    barcodeGenerator->get_Parameters()->get_Barcode()->get_XDimension()->set_Pixels(5);

    //save our barcode in png format
    barcodeGenerator->Save(System::String::FromWCS(folder + L"code128.png"), Aspose::BarCode::BarCodeImageFormat::Png);
    std::wcout << L"Barcode generated!\n";
}

The library uses System::String type which is similar to std::wstring and can be converted with FromWCS and ToWCS functions.

BarCodeReader

In the function RecognizeBarcodeToConsole we recognize previously generated barcode and write recognition result to the console. It is advised to run this function in Release mode because recognition time in Release and Debug modes can be different in 20-60 times. Or you can replace debug libraries to release libraries in “Aspose.BarCode.Cpp.targets” file.

void RecognizeBarcodeToConsole(std::wstring& folder)
{
    //PLEASE USE RELEASE MODE IT IS FASTER IN 20-60 TIMES THEN DEBUG MODE
    //create barcode reader with Code128 symbology
    System::SharedPtr<Aspose::BarCode::BarCodeRecognition::BarCodeReader> reader =
        System::MakeObject<Aspose::BarCode::BarCodeRecognition::BarCodeReader>(System::String::FromWCS(folder + L"code128.png"),
            Aspose::BarCode::BarCodeRecognition::DecodeType::Code128);

    //read recognized values and write to the console
    while (reader->Read())
    {
        std::wstring result = L"Type:" + reader->GetCodeTypeName().ToWCS() + L" Codetext:" + reader->GetCodeText().ToWCS() + L"\n";
        std::wcout << result.data();
    }
    std::wcout << L"Barcode recognized!\n";
}

Documentation

Extended documentation about the library classes and functions is provided on the product page.

Conclusion

Aspose.BarCode for C++ can easily add any barcode feature to your projects on C++ and Windows platform. The library contains features which allows to use library in heavy industrial applications or use for your own business needs. The main library advantage is simplicity with rich abilities.