/// <summary>
/// Match the blob
/// </summary>
/// <param name="configuration">ADR configuration</param>
/// <param name="blob">Blob to match</param>
/// <returns>Best match if exists, else null</returns>
public ADRResult Match(byte[] configuration, byte[] blob)
{
ADRResult result = null;
var tempPathId = Guid.NewGuid();
var maxIdentityValue = 0.0;
using (var gdPictureImaging = GdPictureHelper.GetImagingInstance())
{
var path = $"{temporaryDataDirectory}\\ADR\\";
var fullPath = $"{path}{tempPathId}.dat";
DirectoryHelper.CreateDirectoryIfNotExists(path);
File.WriteAllBytes(fullPath, configuration);
gdPictureImaging.ADRLoadTemplateConfig(fullPath);
int imageId = gdPictureImaging.CreateGdPictureImageFromByteArray(blob);
if (imageId != 0)
{
try
{
int closerTemplateID = gdPictureImaging.ADRGetCloserTemplateForGdPictureImage(imageId);
if (closerTemplateID != 0)
{
var tag = gdPictureImaging.ADRGetTemplateTag(closerTemplateID);
var accuracy = Math.Round(gdPictureImaging.ADRGetLastConfidence(), 2);
if (accuracy > maxIdentityValue)
{
result = new ADRResult()
{
Tag = tag,
Accuracy = accuracy
};
maxIdentityValue = accuracy;
}
}
}
finally
{
gdPictureImaging.ReleaseGdPictureImage(imageId);
}
// Remove path
if (File.Exists(fullPath))
{
File.Delete(fullPath);
}
}
}
return(result);
}
/// <summary>
/// Load image
/// </summary>
/// <param name="image">Image object</param>
/// <returns>True if loading was successfull</returns>
public bool LoadImage(byte[] image)
{
Dispose();
imaging = GdPictureHelper.GetImagingInstance();
imageId = imaging.CreateGdPictureImageFromByteArray(image);
isMultipageImage = imaging.TiffIsMultiPage(imageId);
if (isMultipageImage)
{
PageCount = imaging.TiffGetPageCount(imageId);
}
else
{
PageCount = imaging.GetPageCount(imageId);
}
ImageHeight = imaging.GetHeight(imageId);
return(imageId != 0);
}
/// <summary>
/// Create adr Configuration
/// </summary>
/// <param name="configuration">List of configuration objects</param>
/// <returns>Configuration as byte-array</returns>
public byte[] CreateConfiguration(IList <ADRConfiguration> configurations)
{
byte[] result = null;
var tempPathId = Guid.NewGuid();
var path = $"{temporaryDataDirectory}\\ADR\\";
var fullPath = $"{path}{tempPathId}.dat";
DirectoryHelper.CreateDirectoryIfNotExists(path);
using (var gdPictureImaging = GdPictureHelper.GetImagingInstance())
{
// Add images
foreach (var configuration in configurations)
{
int imageId = gdPictureImaging.CreateGdPictureImageFromByteArray(configuration.Blob);
if (imageId != 0)
{
int templateId = gdPictureImaging.ADRCreateTemplateEmpty();
gdPictureImaging.ADRSetTemplateTag(templateId, configuration.Tag);
gdPictureImaging.ADRAddGdPictureImageToTemplate(templateId, imageId);
gdPictureImaging.ReleaseGdPictureImage(imageId);
}
}
// Save file, get content and delete
if (gdPictureImaging.ADRSaveTemplateConfig(fullPath))
{
result = File.ReadAllBytes(fullPath);
File.Delete(fullPath);
}
return(result);
}
}
/// <summary>
/// Split pdf by page range
/// </summary>
/// <param name="image">Pdf to split</param>
/// <param name="ranges">List of page ranges</param>
/// <returns>List of splitted pdfs</returns>
public IList <ImageSplitResult> Split(byte[] image, IList <PageNumberRange> ranges)
{
var result = new List <ImageSplitResult>();
using (var gdPictureImage = GdPictureHelper.GetImagingInstance())
{
int imageId = gdPictureImage.CreateGdPictureImageFromByteArray(image);
int singlePageImageId = 0;
if (!gdPictureImage.TiffIsMultiPage(imageId))
{
singlePageImageId = imageId;
imageId = gdPictureImage.TiffCreateMultiPageFromGdPictureImage(imageId);
}
if (singlePageImageId != 0)
{
gdPictureImage.ReleaseGdPictureImage(singlePageImageId);
}
if (ranges == null || ranges.Count == 0)
{
return new List <ImageSplitResult> {
}
}
;
foreach (var range in ranges.Where(x => x.PageCount > 0 && x.StartPageNumber + (x.PageCount - 1) <= gdPictureImage.TiffGetPageCount(imageId)))
{
var newImageId = gdPictureImage.TiffCreateMultiPageFromGdPictureImage(imageId);
for (int i = 1; i <= gdPictureImage.TiffGetPageCount(newImageId); i++)
{
gdPictureImage.TiffDeletePage(newImageId, i);
}
for (int i = 0; i < range.PageCount; i++)
{
gdPictureImage.SelectPage(imageId, range.StartPageNumber + i);
gdPictureImage.TiffAppendPageFromGdPictureImage(newImageId, imageId);
}
using (var targetStream = new MemoryStream())
{
gdPictureImage.SaveAsStream(newImageId, targetStream, GdPicture14.DocumentFormat.DocumentFormatTIFF, 4);
targetStream.Position = 0;
result.Add(new ImageSplitResult
{
Image = targetStream.ToArray(),
PageCount = range.PageCount,
Barcode = range.Barcode,
BarcodeType = range.BarcodeType
});
gdPictureImage.ReleaseGdPictureImage(newImageId);
}
}
gdPictureImage.ReleaseGdPictureImage(imageId);
}
return(result);
}
}
public byte[] Convert(byte[] data, bool embeddOCRText = true, string language = "deu")
{
byte[] pdf = null;
using (var pdfInstance = GdPictureHelper.GetPDFInstance())
{
using (var gdPictureImaging = GdPictureHelper.GetImagingInstance())
{
int imageId = gdPictureImaging.CreateGdPictureImageFromByteArray(data);
if (gdPictureImaging.GetStat() == GdPictureStatus.OK)
{
float resolution = System.Math.Max(200, gdPictureImaging.GetVerticalResolution(imageId));
GdPictureStatus state = GdPictureStatus.OK;
if (embeddOCRText)
{
state = pdfInstance.NewPDF(PdfConformance.PDF_A_1a);
}
else
{
state = pdfInstance.NewPDF();
}
if (state == GdPictureStatus.OK)
{
for (int i = 1; i <= gdPictureImaging.GetPageCount(imageId); i++)
{
if (gdPictureImaging.SelectPage(imageId, i) == GdPictureStatus.OK)
{
var addImageResult = pdfInstance.AddImageFromGdPictureImage(imageId, false, true);
}
}
// pdfInstance.OcrPages("*", 1, language, GdPictureHelper.OCRDirectory, "", resolution, 0, true);
using (var stream = new MemoryStream())
{
pdfInstance.SaveToStream(stream);
stream.Position = 0;
pdf = stream.ToArray();
}
}
else
{
throw new Exception($"Culd not convert document. State: {state}");
}
// Release gdpicture image
gdPictureImaging.ReleaseGdPictureImage(imageId);
}
else
{
throw new Exception("Could not create gdpicture imaging instance");
}
// Close pdf document
pdfInstance?.CloseDocument();
}
}
return(pdf);
}
/// <summary>
/// Execute barcode recognition
/// </summary>
/// <param name="blob">Blob to test</param>
/// <param name="fileExtension">file extension</param>
/// <returns>List of detected barcodes</returns>
public IList <BarcodeRecognitionResult> Process(byte[] blob, string fileExtension)
{
var results = new List <BarcodeRecognitionResult>();
byte[] imgData = blob;
if (fileExtension?.ToLower()?.Replace(".", "") == "pdf")
{
imgData = pdfToTiffService.Convert(blob);
}
using (var gdPictureImage = GdPictureHelper.GetImagingInstance())
{
int imageID = 0;
try
{
imageID = gdPictureImage.CreateGdPictureImageFromByteArray(imgData);
gdPictureImage.TiffOpenMultiPageForWrite(true);
if (!gdPictureImage.TiffIsMultiPage(imageID))
{
int imagetmp = imageID;
imageID = gdPictureImage.TiffCreateMultiPageFromGdPictureImage(imagetmp);
gdPictureImage.ReleaseGdPictureImage(imagetmp);
}
int pageCount = gdPictureImage.TiffGetPageCount(imageID);
for (int pageNumber = 1; pageNumber <= pageCount; pageNumber++)
{
gdPictureImage.SelectPage(imageID, pageNumber);
if (gdPictureImage.BarcodeQRReaderDoScan(imageID, BarcodeQRReaderScanMode.BestQuality) == GdPictureStatus.OK)
{
int barcodeCount = gdPictureImage.BarcodeQRReaderGetBarcodeCount();
for (int i = 1; i <= barcodeCount; i++)
{
results.Add(new BarcodeRecognitionResult
{
Barcode = gdPictureImage.BarcodeQRReaderGetBarcodeValue(i),
BarcodeType = "QR",
Page = pageNumber
});
}
}
}
gdPictureImage.BarcodeQRReaderClear();
gdPictureImage.ReleaseGdPictureImage(imageID);
}
catch
{
if (imageID != 0)
{
gdPictureImage.BarcodeQRReaderClear();
gdPictureImage.ReleaseGdPictureImage(imageID);
}
throw;
}
}
return(results);
}
/// <summary>
/// Execute barcode recognition
/// </summary>
/// <param name="blob">Blob to test</param>
/// <param name="fileExtension">file extension</param>
/// <param name="options">Settings/options</param>
/// <returns>List of detected barcodes</returns>
public IList <BarcodeRecognitionResult> Process(byte[] blob, string fileExtension, BarcodeRecognitionOption options)
{
var result = new List <BarcodeRecognitionResult>();
var barcodeTypes = Barcode1DReaderType.Barcode1DReaderCode128 | Barcode1DReaderType.Barcode1DReaderEAN13 | Barcode1DReaderType.Barcode1DReaderCode39;
if (options.BarcodeTypes != null && options.BarcodeTypes.Any())
{
barcodeTypes = Barcode1DReaderType.Barcode1DReaderNone;
foreach (var type in options.BarcodeTypes)
{
if (string.IsNullOrWhiteSpace(type))
{
continue;
}
barcodeTypes = barcodeTypes | (Barcode1DReaderType)Enum.Parse(typeof(Barcode1DReaderType), $"Barcode1DReader{type}", true);
}
}
using (var gdPictureImage = GdPictureHelper.GetImagingInstance())
{
if (fileExtension?.Replace(".", "")?.ToLower() == "pdf")
{
using (var stream = new MemoryStream(blob))
{
using (var gdPicturePdf = GdPictureHelper.GetPDFInstance())
{
stream.Position = 0;
gdPicturePdf.LoadFromStream(stream);
var pageCount = gdPicturePdf.GetPageCount();
for (int pageNumber = 1; pageNumber <= pageCount; pageNumber++)
{
gdPicturePdf.SelectPage(pageNumber);
var imageID = gdPicturePdf.RenderPageToGdPictureImageEx(options.PdfToTiffDPI, true);
if (options.ConvertToBlackAndWhite)
{
gdPictureImage.FxBlackNWhite(imageID, BitonalReduction.Stucki);
gdPictureImage.ConvertTo1BppFast(imageID);
}
var status = gdPictureImage.Barcode1DReaderDoScan(imageID, Barcode1DReaderScanMode.BestQuality, barcodeTypes, false, 1);
if (status == GdPictureStatus.OK)
{
var barcodeAmount = gdPictureImage.Barcode1DReaderGetBarcodeCount();
for (int i = 1; i <= barcodeAmount; i++)
{
result.Add(new BarcodeRecognitionResult
{
Barcode = gdPictureImage.Barcode1DReaderGetBarcodeValue(i),
Page = pageNumber,
BarcodeType = gdPictureImage.Barcode1DReaderGetBarcodeType(i).ToString()
});
}
gdPictureImage.Barcode1DReaderClear();
}
gdPictureImage.ReleaseGdPictureImage(imageID);
}
gdPicturePdf.CloseDocument();
}
}
}
else
{
int imageID = gdPictureImage.CreateGdPictureImageFromByteArray(blob);
gdPictureImage.TiffOpenMultiPageForWrite(true);
if (!gdPictureImage.TiffIsMultiPage(imageID))
{
int imagetmp = imageID;
imageID = gdPictureImage.TiffCreateMultiPageFromGdPictureImage(imagetmp);
gdPictureImage.ReleaseGdPictureImage(imagetmp);
}
if (options.ConvertToBlackAndWhite)
{
gdPictureImage.FxBlackNWhite(imageID, BitonalReduction.Stucki);
gdPictureImage.ConvertTo1BppFast(imageID);
}
int pageCount = gdPictureImage.TiffGetPageCount(imageID);
for (int pageNumber = 1; pageNumber <= pageCount; pageNumber++)
{
gdPictureImage.TiffSelectPage(imageID, pageNumber);
var status = gdPictureImage.Barcode1DReaderDoScan(imageID, Barcode1DReaderScanMode.BestQuality, barcodeTypes, false, 1);
if (status == GdPictureStatus.OK)
{
var barcodeAmount = gdPictureImage.Barcode1DReaderGetBarcodeCount();
for (int i = 1; i <= barcodeAmount; i++)
{
result.Add(new BarcodeRecognitionResult
{
Barcode = gdPictureImage.Barcode1DReaderGetBarcodeValue(i),
Page = pageNumber,
BarcodeType = gdPictureImage.Barcode1DReaderGetBarcodeType(i).ToString()
});
}
gdPictureImage.Barcode1DReaderClear();
}
}
gdPictureImage.ReleaseGdPictureImage(imageID);
}
}
return(result);
}
