public ATAPY.Common.IO.Files CreatePageFiles(ATAPY.Common.IO.File PdfFile)
{
Trace.Assert(PdfFile != null);
ATAPY.Common.IO.Files Ret = new ATAPY.Common.IO.Files();
try {
using (GdPicturePDF SourcePDF = new GdPicturePDF()) {
if (SourcePDF.LoadFromFile(PdfFile.FullPath, true) != GdPictureStatus.OK)
{
throw new Warning("Cannot open source file.\r\nSource file -" + PdfFile.FullPath);
}
if (SourcePDF.IsEncrypted())
{
throw new Warning("Source PDF file is encrypted.");
}
int PagesCount = SourcePDF.GetPageCount();
using (GdPictureImaging Imaging = new GdPictureImaging()) {
for (int i = 1; i <= PagesCount; i++)
{
SourcePDF.SelectPage(i);
int RenderedPageId = SourcePDF.RenderPageToGdPictureImageEx((float)DEFAULT_RENDER_DPI, true, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
ATAPY.Common.IO.File RetFile = new ATAPY.Common.IO.File(PageImagesFolder, PdfFile.NameWithoutExtension + "_" + i.ToString("D3") + ".png");
Imaging.SaveAsPNG(RenderedPageId, RetFile.FullPath);
Imaging.ReleaseGdPictureImage(RenderedPageId);
Ret.Add(RetFile);
}
}
SourcePDF.CloseDocument();
}
} catch (Exception ex) {
GlobalObjects.Log.WriteError(ex);
throw;
}
return(Ret);
}
private static void CustomActionDispatcher(object sender, CustomActionEventArgs e)
{
GdPicturePDF oPDF = new GdPicturePDF();
AnnotationManager oAnnotationsManager = new AnnotationManager();
Annotation oAnnotation;
switch (e.actionName)
{
case "tooltip":
e.docuVieware.GetNativePDF(out oPDF);
oAnnotationsManager.InitFromGdPicturePDF(oPDF);
for (int y = 1; y <= oPDF.GetPageCount(); y++)
{
oAnnotationsManager.SelectPage(y);
oPDF.SetOrigin(PdfOrigin.PdfOriginTopLeft);
oPDF.SetMeasurementUnit(PdfMeasurementUnit.PdfMeasurementUnitInch);
int AnnotationCount = oAnnotationsManager.GetAnnotationCount();
if (AnnotationCount > 0)
{
for (int c = 0; c < AnnotationCount; c++)
{
oAnnotation = oAnnotationsManager.GetAnnotationFromIdx(c);
if (oAnnotation.Guid == e.args.ToString())
{
e.result = oAnnotation;
}
}
}
}
break;
}
}
/// <summary>
/// Loads a PDF file into the file viewer
/// </summary>
/// <param name="pdfPath">Path of the PDF file</param>
public override async Task LoadPdf(string pdfPath)
{
this.pdfPath = pdfPath;
gdPdf = new GdPicturePDF();
var gdStatus = gdPdf.LoadFromFile(pdfPath, false);
if (gdStatus == GdPictureStatus.OK)
{
gdViewer1.DisplayFromGdPicturePDF(gdPdf);
thumbnailEx1.LoadFromGdViewer(gdViewer1);
}
}
/// <summary>
/// Gets total pages number in file
/// </summary>
/// <param name="filePath">The file path.</param>
/// <returns></returns>
public int GetTotalPages(string filePath)
{
int totalPages = 0;
using (GdPicturePDF pdf = new GdPicturePDF())
{
pdf.LoadFromFile(filePath, false);
totalPages = pdf.GetPageCount();
}
return(totalPages);
}
/// <summary>
/// Save page to jpeg file
/// </summary>
/// <param name="sourceFilePath">The source file path.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="pageNumber">Page number</param>
/// <param name="dpi">Dpi of the generated file</param>
public void SavePageToJpeg(string sourceFilePath, string outputPath, int pageNumber, int dpi)
{
using (GdPicturePDF pdf = new GdPicturePDF())
{
pdf.LoadFromFile(sourceFilePath, false);
pdf.SelectPage(pageNumber);
int imageId = pdf.RenderPageToGdPictureImage(200, true);
using (GdPictureImaging image = new GdPictureImaging())
{
image.SaveAsJPEG(imageId, outputPath);
image.ReleaseGdPictureImage(imageId);
}
}
}
private void FillPageText(string PageText, GdPicturePDF SourcePDF, Page Page)
{
GdPictureImaging GdPictureImaging = new GdPictureImaging();
var Words = PageText.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
SourcePDF.SetOrigin(PdfOrigin.PdfOriginTopLeft);
SourcePDF.SetMeasurementUnit(PdfMeasurementUnit.PdfMeasurementUnitPoint);
for (int i = 0; i < Words.Length; i++)
{
string WordSet = Words[i];
try {
var Coords = WordSet.Split(SEPARATOR[0]);
var Word = CorrectWord(Coords[8]);
if (!string.IsNullOrEmpty(Word) && !string.IsNullOrWhiteSpace(Word))
{
E_TextOrientation Orientation;
System.Windows.Rect Rect = GetRect(Coords, out Orientation);
if (Rect.IsEmpty)
{
continue;
}
//var asdf = SourcePDF.GetPageTextArea(0, 0, 500, 500);
//var AltText = SourcePDF.GetPageTextArea((float)(Rect.Left / Scale / 72.0), (float)(Rect.Top / Scale / 72.0), (float)(Rect.Width / Scale / 72.0), (float)(Rect.Height / Scale / 72.0));
TextArea Area = new TextArea(Rect, Word, Page);
Area.Orientation = Orientation;
//SetPDFFontSize(SourcePDF, Area, Fonts);
if (Orientation == E_TextOrientation.LeftRight)
{
Page.TextAreas.Add(Area);
FillCharParams(Area);
}
}
} catch (Exception ex) {
throw ex;
}
}
int ID = GdPictureImaging.CreateNewGdPictureImage((int)Page.Width, (int)Page.Height, 24, System.Drawing.Color.White);
foreach (var item in Page.TextAreas)
{
//calc sizes
var FontSize = GetFontSize(GdPictureImaging, ID, item, "Arial");
/*if (item.Text == "-") {
* var a = item.FontSize;
* }*/
}
GdPictureImaging.ReleaseGdPictureImage(ID);
}
private void frmDokuExtractorTable_Load(object sender, EventArgs e)
{
var pdfPath = Path.Combine(Application.StartupPath, "TableFiles", "TableFileMultiPage1.pdf");
var gdPdf = new GdPicturePDF();
var gdStatus = gdPdf.LoadFromFile(pdfPath, false);
if (gdStatus == GdPictureStatus.OK)
{
ucDokuViewerGdPicture1.LoadGdPdf(gdPdf);
}
this.WindowState = FormWindowState.Maximized;
UpdateInstructionLabel(false);
}
public static File GetTiff(File file)
{
var filename = GetFileName();
var compression = TiffCompression.TiffCompressionNONE;
int dpi = 300;
int tiffId = 0;
var status = GdPictureStatus.OK;
using (var pdf = new GdPicturePDF())
{
using (var imaging = new GdPictureImaging())
{
if (pdf.LoadFromFile(file.FullPath, false) == GdPictureStatus.OK)
{
var pagesCount = pdf.GetPageCount();
for (int i = 1; i <= pagesCount; i++)
{
if (status == GdPictureStatus.OK)
{
pdf.SelectPage(i);
var pageId = pdf.RenderPageToGdPictureImageEx(dpi, true);
if (pageId == 0)
{
throw new Exception($"Cannot converp page {i}");
}
if (i == 1)
{
tiffId = pageId;
status = imaging.TiffSaveAsMultiPageFile(tiffId, filename, compression);
}
else
{
status = imaging.TiffAddToMultiPageFile(tiffId, pageId);
imaging.ReleaseGdPictureImage(pageId);
}
}
}
if (imaging.TiffCloseMultiPageFile(tiffId) != GdPictureStatus.OK)
{
throw new Exception($"Cannot save file {filename}");
}
imaging.ReleaseGdPictureImage(tiffId);
}
}
}
return(new File(filename));
}
private bool IsDigitalDocument(File file)
{
using (var pdf = new GdPicturePDF())
{
var status = pdf.LoadFromFile(file.FullPath, false);
if (status != GdPictureStatus.OK)
{
throw new ArgumentException(status.ToString());
}
status = pdf.SelectPage(1);
if (status != GdPictureStatus.OK)
{
throw new ArgumentException(status.ToString());
}
return(pdf.PageHasText());
}
}
private static void ProcessMovedFileWithGdPicture(string filePath, string ocrDirectory, string completedDirectory)
{
var fileName = Path.GetFileName(filePath);
//We assume that GdPicture has been correctly installed and unlocked.
GdPicturePDF oGdPicturePDF = new GdPicturePDF();
//Loading an input document.
GdPictureStatus status = oGdPicturePDF.LoadFromFile(filePath, false);
//Checking if loading has been successful.
if (status == GdPictureStatus.OK)
{
int pageCount = oGdPicturePDF.GetPageCount();
//Loop through pages.
for (int i = 1; i <= pageCount; i++)
{
//Selecting a page.
oGdPicturePDF.SelectPage(i);
if (oGdPicturePDF.OcrPage("eng", ocrDirectory, "", 200.0F) != GdPictureStatus.OK)
{
//Console.WriteLine("OCR Pages Example - Error occurred on the page " + i.ToString() + ". Error: " + oGdPicturePDF.GetStat().ToString());
}
}
//Saving to a different file.
var completedFilePath = Path.Combine(
completedDirectory,
fileName
);
status = oGdPicturePDF.SaveToFile(completedFilePath, true);
if (status == GdPictureStatus.OK)
{
Console.WriteLine("OCR Pages Example - Done! " + fileName);
}
else
{
Console.WriteLine("OCR Pages Example - " + "The document can't be saved." + status.ToString() + " " + fileName);
}
//Closing and releasing resources.
oGdPicturePDF.CloseDocument();
}
else
{
Console.WriteLine("OCR Pages Example - " + "The document can't be opened." + status.ToString() + " " + fileName);
}
oGdPicturePDF.Dispose();
}
private void CleanPage(GdPicturePDF SourcePDF)
{
int ImagesCount = SourcePDF.GetPageImageCount();
List <string> ResNames = new List <string>();
for (int i = 0; i < ImagesCount; i++)
{
string Name = SourcePDF.GetPageImageResName(i);
if (!ResNames.Contains(Name))
{
ResNames.Add(Name);
}
}
foreach (var item in ResNames)
{
SourcePDF.DeleteImage(item);
}
}
/// <summary>
/// Deletes current page of Image and/or PDF file formats
/// </summary>
/// <param name="e"></param>
public static void HandleRemovePage(CustomActionEventArgs e)
{
RotateActionParameters rotateParams = JsonConvert.DeserializeObject <RotateActionParameters>(e.args.ToString());
int currPage = rotateParams.CurrentPage;
rotateParams = null;
// For PDF FILES
if (e.docuVieware.GetDocumentType() == DocumentType.DocumentTypePDF)
{
GdPicturePDF gdPdf = null;
if (e.docuVieware.GetNativePDF(out gdPdf) == GdPictureStatus.OK)
{
gdPdf.DeletePage(currPage);
e.message = GetMessage("Page Deleted Successfully ", DocuViewareMessageIcon.Information);
}
}
// For Image Files, Scanned docs
int imgId;
if (e.docuVieware.GetNativeImage(out imgId) == GdPictureStatus.OK)
{
GdPictureImaging gdImg = new GdPictureImaging();
if (gdImg.SelectPage(imgId, currPage) == GdPictureStatus.OK)
{
if (gdImg.TiffDeletePage(imgId, currPage) == GdPictureStatus.OK)
//gdImg.ReleaseGdPictureImage(imgId) == GdPictureStatus.OK)
{
e.message = GetMessage("Document was rejected successfully.", DocuViewareMessageIcon.Information);
}
}
}
else
{
e.message = GetMessage("Remove Page : File Type not supported ! ", DocuViewareMessageIcon.Warning);
}
return;
}
private static void CustomActionDispatcher(object sender, CustomActionEventArgs e)
{
switch (e.actionName)
{
case "delete":
if (e.docuVieware.GetDocumentType() == DocumentType.DocumentTypePDF)
{
GdPicturePDF oGdPicturePDF = new GdPicturePDF();
//prepare array of selected pages
List <int> selectedPages = JsonConvert.DeserializeObject <List <int> >(e.args.ToString());
selectedPages = selectedPages.OrderByDescending(t => t).ToList();
//delete pages from the native PDF
if (e.docuVieware.GetNativePDF(out oGdPicturePDF) == GdPictureStatus.OK)
{
foreach (int page in selectedPages)
{
if (oGdPicturePDF.DeletePage(page) != GdPictureStatus.OK)
{
e.result = oGdPicturePDF.GetStat().ToString();
break;
}
}
}
e.docuVieware.RedrawPage();
}
else
{
e.message = new DocuViewareMessage("Wrong document format");
}
break;
}
}
/// <summary>
/// ConvertToPdf the provided TIFF to a PDF.
/// </summary>
/// <param name="stream">The stream where to write the Pdf.</param>
/// <param name="errorMessage">Used to retrieve an error message.</param>
/// <param name="gdPictureImaging">The GdPictureImaging.</param>
/// <param name="imageId">The image identifier.</param>
/// <param name="pageCount">The number of pages.</param>
/// <returns>true if the conversion succeded otherwise returns false.</returns>
private static bool ConvertToPdf(Stream stream, ref string errorMessage, GdPictureImaging gdPictureImaging,
int imageId,
int pageCount)
{
using (GdPicturePDF gdPicturePdf = new GdPicturePDF())
{
gdPicturePdf.NewPDF(false);
PdfAdvancedImageCompression advancedCompression = default(PdfAdvancedImageCompression);
gdPicturePdf.SetCompressionForBitonalImage(PdfCompression.PdfCompressionJBIG2);
gdPicturePdf.SetCompressionForColorImage(PdfCompression.PdfCompressionJPEG);
for (int pageIndex = 0; pageIndex < pageCount; pageIndex++)
{
// Page selection is 1 based index
gdPictureImaging.SelectPage(imageId, pageIndex + 1);
gdPicturePdf.AddImageFromGdPictureImage(imageId, advancedCompression);
if (gdPicturePdf.GetStat() != GdPictureStatus.OK)
{
errorMessage = "Error adding bitmap to the PDF. Status: " + gdPicturePdf.GetStat().ToString();
gdPicturePdf.CloseDocument();
return(false);
}
}
gdPicturePdf.SaveToStream(stream);
if (gdPicturePdf.GetStat() != GdPictureStatus.OK)
{
errorMessage = "Error saving PDF. Status: " + gdPicturePdf.GetStat().ToString();
gdPicturePdf.CloseDocument();
return(false);
}
return(true);
}
}
public Document GetDocument(File SourceFile, string language)
{
Trace.Assert(SourceFile != null);
try
{
if (!SourceFile.Exists)
{
throw new Warning("Source file does not exist.\r\nSource file - " + SourceFile.FullPath);
}
Document Doc = new Document();
Doc.SourceFormat = E_SourceFormat.PDF;
Doc.SourceFile = SourceFile.Clone();
using (GdPicturePDF SourcePDF = new GdPicturePDF())
{
//var PassRes = SourcePDF.SetPassword("test");
var Result = SourcePDF.LoadFromFile(SourceFile.FullPath, false);
if (Result != GdPictureStatus.OK)
{
throw new Warning("Cannot open source file.\r\nSource file -" + SourceFile.FullPath);
}
if (SourcePDF.IsEncrypted())
{
throw new Warning("Source PDF file is encrypted.");
}
int PagesCount = SourcePDF.GetPageCount();
//var PdfVersion = SourcePDF.GetVersion();
for (int i = 1; i <= PagesCount; i++)
{
SourcePDF.SelectPage(i);
//string aaa = SourcePDF.GetPageMetadata();
//string PageText = SourcePDF.GetPageText();
//System.IO.File.WriteAllText(ResFile.FullPath + i.ToString() + ".txt", PageText);
string PageTextWCoords = SourcePDF.GetPageTextWithCoords(SEPARATOR);
Page Page = new Page();
int Width = (int)(SourcePDF.GetPageWidth() * Scale);
int Height = (int)(SourcePDF.GetPageHeight() * Scale);
/*double WidthInCm = SourcePDF.GetPageWidth() / 72;
* double HeughtInCm = SourcePDF.GetPageHeight() / 72;
* int ImagesCount = SourcePDF.GetPageImageCount();
* for (int j = 0; j < ImagesCount; j++) {
* float HDPI = 0;
* float VDPI = 0;
* var Stat = SourcePDF.GetPageImageResolution(j, ref HDPI, ref VDPI);
* }*/
Page.Bound = new Rect(0, 0, Width, Height);
Doc.Pages.Add(Page);
FillPageText(PageTextWCoords, SourcePDF, Page);
if (FixWordsAreas || ExtraTextCheck)
{
using (GdPictureImaging Imaging = new GdPictureImaging())
{
CleanPage(SourcePDF);
int RenderedPageId = SourcePDF.RenderPageToGdPictureImageEx((float)DEFAULT_RENDER_DPI, true, System.Drawing.Imaging.PixelFormat.Format1bppIndexed);
if (FixWordsAreas)
{
CorrectTextCoordinates(Page, RenderedPageId);
}
if (ExtraTextCheck)
{
CheckTextWithRecognition(Page, RenderedPageId);
}
Imaging.ReleaseGdPictureImage(RenderedPageId);
}
}
Page.TextAreas.RemoveClones();
Page.AnalyzeData();
/*File PNGFile = new File(OutputFolder, SourceFile.NameWithoutExtension + "_Page_" + i.ToString() + ".png");
* File CSVFile = new File(OutputFolder, SourceFile.NameWithoutExtension + "_Page_" + i.ToString() + ".csv");
* TablesFound += DrawPageText(PageText, Width, Height, PNGFile.FullPath, WriteText, "Helvetica");
* PageText.SaveTablesToCSV(CSVFile);*/
}
//var res = SourcePDF.SaveToFile(SourceFile.FullPath);
SourcePDF.CloseDocument();
}
return(Doc);
}
catch (Exception ex)
{
GlobalObjects.Log.WriteError(ex);
throw;
}
}
public static string castTopdf(string file, GdPictureImaging oGdPictureImaging, GdPicturePDF oGdPicturePDF, bool pdfa = true, string idioma = "por", string white = null, string titulo = null, string autor = null, string assunto = null, string palavrasChaves = null, string criador = null, int dpi = 250)
{
try
{
var exFile = Path.GetExtension(file).ToUpper();
switch (exFile)
{
case ".PDF":
#region PDF
String folderpdf = Guid.NewGuid().ToString();
string strpdf = "";
GdPictureStatus status = oGdPicturePDF.LoadFromFile(file, false);
if (status == GdPictureStatus.OK)
{
int ident = 1;
int num1 = oGdPicturePDF.GetPageCount();
int num4 = 1;
string[] mergeArray = new string[num1];
Directory.CreateDirectory(folderpdf);
if (num1 > 0)
{
bool flagpdf = true;
while (num4 <= num1)
{
oGdPicturePDF.SelectPage(num4);
int numpdf1 = oGdPicturePDF.RenderPageToGdPictureImage(300, true);
var docuemntoId = Guid.NewGuid();
string sstr = string.Concat(Ocr.GetCurrentDirectory(), "\\GdPicture\\Idiomas");
oGdPicturePDF.SaveToFile(folderpdf + @"\" + ident + "_" + docuemntoId + ".pdf");
var id = oGdPictureImaging.PdfOCRStart(folderpdf + @"\" + ident + "_" + docuemntoId + ".pdf", true, "", "", "", "", "");
oGdPictureImaging.PdfAddGdPictureImageToPdfOCR(id, numpdf1, "por", sstr, "");
oGdPictureImaging.PdfOCRStop(id);
mergeArray[num4 - 1] = folderpdf + @"\" + ident + "_" + docuemntoId + ".pdf";
if (oGdPicturePDF.GetStat() == 0)
{
num4++;
ident++;
}
else
{
flagpdf = false;
break;
}
oGdPictureImaging.ReleaseGdPictureImage(numpdf1);
}
oGdPicturePDF.CloseDocument();
if (flagpdf)
{
var strPdf1 = file.Replace(Path.GetExtension(file), ".pdf");
oGdPicturePDF.MergeDocuments(mergeArray, strPdf1);
strpdf = strPdf1;
oGdPicturePDF.CloseDocument();
}
oGdPictureImaging.ClearGdPicture();
string str1pdf = ConfigurationManager.AppSettings["PastaDestinoTemp"].ToString();
if (File.Exists(str1pdf + @"\" + Path.GetFileName(strpdf)))
{
File.Replace(strpdf, str1pdf + @"\" + Path.GetFileName(strpdf), null);
}
else
{
File.Move(strpdf, str1pdf + @"\" + Path.GetFileName(strpdf));
}
var filefinal = str1pdf + @"\" + Path.GetFileName(strpdf);
foreach (var item in Directory.GetFiles(folderpdf))
{
File.Delete(item);
}
Directory.Delete(folderpdf);
file = filefinal;
}
else
{
oGdPicturePDF.SelectPage(num4);
int numpdf = oGdPicturePDF.RenderPageToGdPictureImage(300, true);
var docuemntoId = Guid.NewGuid();
string sstr = string.Concat(Ocr.GetCurrentDirectory(), "\\GdPicture\\Idiomas");
oGdPictureImaging.SaveAsPDFOCR(numpdf, folderpdf + @"\" + docuemntoId + ".pdf", idioma, sstr, white, pdfa, titulo, autor, assunto, palavrasChaves, criador);
var strPdf = file.Replace(Path.GetExtension(file), ".pdf");
oGdPictureImaging.ReleaseGdPictureImage(numpdf);
oGdPicturePDF.MergeDocuments(System.IO.Directory.GetFiles(folderpdf), strPdf);
strpdf = strPdf;
oGdPictureImaging.ClearGdPicture();
string str1tif = ConfigurationManager.AppSettings["PastaDestinoTemp"].ToString();
if (File.Exists(str1tif + @"\" + Path.GetFileName(strpdf)))
{
File.Replace(strpdf, str1tif + @"\" + Path.GetFileName(strpdf), null);
}
else
{
File.Move(strpdf, str1tif + @"\" + Path.GetFileName(strpdf));
}
var filefinal = str1tif + @"\" + Path.GetFileName(strpdf);
foreach (var item in Directory.GetFiles(folderpdf))
{
File.Delete(item);
}
Directory.Delete(folderpdf);
file = filefinal;
}
}
#endregion
break;
case (".TIF"):
String folder = Guid.NewGuid().ToString();
string str = "";
oGdPictureImaging.TiffOpenMultiPageForWrite(false);
int num = oGdPictureImaging.CreateGdPictureImageFromFile(file);
if (num != 0)
{
int ident = 1;
Directory.CreateDirectory(folder);
if (oGdPictureImaging.TiffIsMultiPage(num))
{
int num1 = oGdPictureImaging.TiffGetPageCount(num);
bool flag = true;
int num4 = 1;
string[] mergeArray = new string[num1];
while (num4 <= num1)
{
oGdPictureImaging.TiffSelectPage(num, num4);
// oGdPicturePDF.AddImageFromGdPictureImage(num, false, true);
oGdPicturePDF.NewPDF();
var docuemntoId = Guid.NewGuid();
oGdPicturePDF.SaveToFile(folder + @"\" + ident + "_" + docuemntoId + ".pdf");
var id = oGdPictureImaging.PdfOCRStart(folder + @"\" + ident + "_" + docuemntoId + ".pdf", true, "", "", "", "", "");
string sstr = string.Concat(Ocr.GetCurrentDirectory(), "\\GdPicture\\Idiomas");
oGdPictureImaging.PdfAddGdPictureImageToPdfOCR(id, num, "por", sstr, "");
oGdPictureImaging.PdfOCRStop(id);
// oGdPictureImaging.SaveAsPDFOCR(num4, @"C:\Processamento" + @"\" + docuemntoId + ".pdf", idioma, sstr, "", true, titulo, autor, assunto, palavrasChaves, criador);
oGdPicturePDF.CloseDocument();
mergeArray[num4 - 1] = folder + @"\" + ident + "_" + docuemntoId + ".pdf";
if (oGdPicturePDF.GetStat() == 0)
{
num4++;
ident++;
}
else
{
flag = false;
break;
}
// oGdPictureImaging.ReleaseGdPictureImage(num);
}
if (flag)
{
var strPdf = file.Replace(Path.GetExtension(file), ".pdf");
oGdPicturePDF.MergeDocuments(mergeArray, strPdf);
str = strPdf;
}
oGdPictureImaging.ReleaseGdPictureImage(num);
oGdPictureImaging.ClearGdPicture();
string str1tif = ConfigurationManager.AppSettings["PastaDestinoTemp"].ToString();
if (File.Exists(str1tif + @"\" + Path.GetFileName(str)))
{
File.Replace(str, str1tif + @"\" + Path.GetFileName(str), null);
File.Delete(file);
}
else
{
File.Move(str, str1tif + @"\" + Path.GetFileName(str));
File.Delete(file);
}
var filefinal = str1tif + @"\" + Path.GetFileName(str);
foreach (var item in Directory.GetFiles(folder))
{
File.Delete(item);
}
Directory.Delete(folder);
file = filefinal;
}
else
{
var docuemntoId = Guid.NewGuid();
string sstr = string.Concat(Ocr.GetCurrentDirectory(), "\\GdPicture\\Idiomas");
oGdPicturePDF.NewPDF();
oGdPicturePDF.SaveToFile(folder + @"\" + ident + "_" + docuemntoId + ".pdf");
var id = oGdPictureImaging.PdfOCRStart(folder + @"\" + ident + "_" + docuemntoId + ".pdf", true, "", "", "", "", "");
oGdPictureImaging.PdfAddGdPictureImageToPdfOCR(id, num, "por", sstr, "");
oGdPictureImaging.PdfOCRStop(id);
oGdPicturePDF.CloseDocument();
//oGdPictureImaging.SaveAsPDFOCR(num, folder + @"\" + docuemntoId + ".pdf", idioma, sstr, white, pdfa, titulo, autor, assunto, palavrasChaves, criador);
var strPdf = file.Replace(Path.GetExtension(file), ".pdf");
oGdPicturePDF.MergeDocuments(System.IO.Directory.GetFiles(folder), strPdf);
str = strPdf;
oGdPictureImaging.ReleaseGdPictureImage(num);
oGdPicturePDF.CloseDocument();
oGdPictureImaging.ClearGdPicture();
string str1tif = ConfigurationManager.AppSettings["PastaDestinoTemp"].ToString();
if (File.Exists(str1tif + @"\" + Path.GetFileName(str)))
{
File.Replace(str, str1tif + @"\" + Path.GetFileName(str), null);
File.Delete(file);
}
else
{
File.Move(str, str1tif + @"\" + Path.GetFileName(str));
File.Delete(file);
}
var filefinal = str1tif + @"\" + Path.GetFileName(str);
foreach (var item in Directory.GetFiles(folder))
{
File.Delete(item);
}
Directory.Delete(folder);
file = filefinal;
}
}
break;
case ".TIFF":
String folder2 = Guid.NewGuid().ToString();
string str2 = "";
oGdPictureImaging.TiffOpenMultiPageForWrite(false);
int num2 = oGdPictureImaging.CreateGdPictureImageFromFile(file);
if (num2 != 0)
{
int ident = 1;
Directory.CreateDirectory(folder2);
if (oGdPictureImaging.TiffIsMultiPage(num2))
{
int num1 = oGdPictureImaging.TiffGetPageCount(num2);
bool flag = true;
int num3 = 1;
string[] mergeArray = new string[num1];
while (num3 <= num1)
{
oGdPictureImaging.TiffSelectPage(num2, num3);
oGdPicturePDF.NewPDF();
oGdPicturePDF.AddImageFromGdPictureImage(num2, false, true);
var docuemntoId = Guid.NewGuid();
// oGdPicturePDF.SaveToFile(folder + @"\" + docuemntoId + ".pdf");
oGdPicturePDF.SaveToFile(folder2 + @"\" + ident + "_" + docuemntoId + ".pdf");
// var id = oGdPictureImaging.PdfOCRStart(folder + @"\" + docuemntoId + ".pdf", true, "", "", "", "", "");
//oGdPictureImaging.PdfAddGdPictureImageToPdfOCR(id, num, "por", str, "");
string sstr = string.Concat(Ocr.GetCurrentDirectory(), "\\GdPicture\\Idiomas");
var id = oGdPictureImaging.PdfOCRStart(folder2 + @"\" + ident + "_" + docuemntoId + ".pdf", true, "", "", "", "", "");
oGdPictureImaging.PdfAddGdPictureImageToPdfOCR(id, num2, "por", sstr, "");
oGdPictureImaging.PdfOCRStop(id);
oGdPicturePDF.CloseDocument();
//oGdPictureImaging.SaveAsPDFOCR(num3, folder2 + @"\" + docuemntoId + ".pdf", idioma, sstr, white, pdfa, titulo, autor, assunto, palavrasChaves, criador);
mergeArray[num3 - 1] = folder2 + @"\" + ident + "_" + docuemntoId + ".pdf";
if (oGdPicturePDF.GetStat() == 0)
{
num3++;
ident++;
}
else
{
flag = false;
break;
}
//oGdPictureImaging.ReleaseGdPictureImage(num2);
}
if (flag)
{
var strPdf = file.Replace(Path.GetExtension(file), ".pdf");
oGdPicturePDF.MergeDocuments(mergeArray, strPdf);
str2 = strPdf;
}
oGdPictureImaging.ReleaseGdPictureImage(num2);
oGdPictureImaging.ClearGdPicture();
string str1tiff = ConfigurationManager.AppSettings["PastaDestinoTemp"].ToString();
if (File.Exists(str1tiff + @"\" + Path.GetFileName(str2)))
{
File.Replace(str2, str1tiff + @"\" + Path.GetFileName(str2), null);
File.Delete(file);
}
else
{
File.Move(str2, str1tiff + @"\" + Path.GetFileName(str2));
File.Delete(file);
}
var filefinal2 = str1tiff + @"\" + Path.GetFileName(str2);
foreach (var item in Directory.GetFiles(folder2))
{
File.Delete(item);
}
Directory.Delete(folder2);
file = filefinal2;
}
else
{
var docuemntoId = Guid.NewGuid();
string sstr = string.Concat(Ocr.GetCurrentDirectory(), "\\GdPicture\\Idiomas");
oGdPicturePDF.NewPDF();
var id = oGdPictureImaging.PdfOCRStart(folder2 + @"\" + ident + "_" + docuemntoId + ".pdf", true, "", "", "", "", "");
oGdPicturePDF.SaveToFile(folder2 + @"\" + ident + "_" + docuemntoId + ".pdf");
oGdPictureImaging.PdfAddGdPictureImageToPdfOCR(id, num2, "por", sstr, "");
oGdPictureImaging.PdfOCRStop(id);
oGdPicturePDF.CloseDocument();
var strPdf = file.Replace(Path.GetExtension(file), ".pdf");
oGdPicturePDF.MergeDocuments(System.IO.Directory.GetFiles(folder2), strPdf);
str2 = strPdf;
oGdPictureImaging.ReleaseGdPictureImage(num2);
oGdPicturePDF.CloseDocument();
oGdPictureImaging.ClearGdPicture();
string str1tiff = ConfigurationManager.AppSettings["PastaDestinoTemp"].ToString();
if (File.Exists(str1tiff + @"\" + Path.GetFileName(str2)))
{
File.Replace(str2, str1tiff + @"\" + Path.GetFileName(str2), null);
File.Delete(file);
}
else
{
File.Move(str2, str1tiff + @"\" + Path.GetFileName(str2));
File.Delete(file);
}
var filefinal2 = str1tiff + @"\" + Path.GetFileName(str2);
foreach (var item in Directory.GetFiles(folder2))
{
File.Delete(item);
}
Directory.Delete(folder2);
file = filefinal2;
}
}
break;
}
}
catch (Exception ex)
{
var logpath = ConfigurationManager.AppSettings["PastaDestinoLog"].ToString();
File.AppendAllText(logpath + @"\" + "log.txt", ex.ToString());
// Console.WriteLine(ex.Message);
}
return(file);
}
/// <summary>
/// Loads a GdPicturePdf
/// </summary>
/// <param name="gdPdf">GdPicturePdf</param>
public void LoadGdPdf(GdPicturePDF gdPdf)
{
this.gdPdf = gdPdf;
gdViewer1.DisplayFromGdPicturePDF(this.gdPdf);
thumbnailEx1.LoadFromGdViewer(gdViewer1);
}
public static string GerarDocumentoPesquisavelPdf(GdPictureImaging _gdPictureImaging, GdPicturePDF _gdPicturePDF, string documento, bool pdfa = true, string idioma = "por", string titulo = null, string autor = null, string assunto = null, string palavrasChaves = null, string criador = null, int dpi = 250)
{
if (Path.GetExtension(documento) != ".pdf")
{
documento = Ocr.castTopdf(documento, _gdPictureImaging, _gdPicturePDF);
}
int num = 0;
var pasta = Guid.NewGuid().ToString();
_gdPicturePDF.LoadFromFile(documento, true);
string str = string.Concat(Ocr.GetCurrentDirectory(), "\\GdPicture\\Idiomas");
using (FileStream fs = File.Create("c:\\lodg.txt"))
{
Byte[] info = new UTF8Encoding(true).GetBytes(str);
// Add some information to the file.
fs.Write(info, 0, info.Length);
}
// Console.WriteLine(ex.Message);
string str1 = ConfigurationManager.AppSettings["PastaDestinoTemp"].ToString();
string str2 = string.Concat(str1, "\\", Path.GetFileName(documento));
string folder = Guid.NewGuid().ToString();
int pageCount = _gdPicturePDF.GetPageCount();
for (int i = 1; i <= pageCount; i++)
{
Directory.CreateDirectory(str1 + "\\" + pasta);
_gdPicturePDF.SelectPage(i);
int gdPictureImageEx = _gdPicturePDF.RenderPageToGdPictureImageEx((float)dpi, true);
if (gdPictureImageEx != 0)
{
num = _gdPictureImaging.PdfOCRStart(str1 + "\\" + pasta + "\\" + i.ToString() + ".pdf", pdfa, titulo, autor, assunto, palavrasChaves, criador);
_gdPictureImaging.PdfAddGdPictureImageToPdfOCR(num, gdPictureImageEx, idioma, str, "");
_gdPictureImaging.ReleaseGdPictureImage(gdPictureImageEx);
_gdPictureImaging.PdfOCRStop(num);
}
}
_gdPicturePDF.CloseDocument();
File.Delete(documento);
GdPictureStatus status = _gdPicturePDF.MergeDocuments(Directory.GetFiles(str1 + "\\" + pasta), str2);
DirectoryInfo dir = new DirectoryInfo(str1 + "\\" + pasta);
foreach (FileInfo fi in dir.GetFiles())
{
fi.Delete();
}
Directory.Delete(str1 + "\\" + pasta);
return(str2);
}
public static string castTopdf(string file, GdPictureImaging oGdPictureImaging, GdPicturePDF oGdPicturePDF)
{
string str = "";
oGdPictureImaging.TiffOpenMultiPageForWrite(false);
int num = oGdPictureImaging.CreateGdPictureImageFromFile(file);
if (num != 0)
{
oGdPicturePDF.NewPDF();
if (oGdPictureImaging.TiffIsMultiPage(num))
{
int num1 = oGdPictureImaging.TiffGetPageCount(num);
bool flag = true;
int num2 = 1;
while (num2 <= num1)
{
oGdPictureImaging.TiffSelectPage(num, num2);
oGdPicturePDF.AddImageFromGdPictureImage(num, false, true);
if (oGdPicturePDF.GetStat() == 0)
{
num2++;
}
else
{
flag = false;
break;
}
}
if (flag)
{
str = file.Replace(Path.GetExtension(file), ".pdf");
oGdPicturePDF.SaveToFile(file.Replace(Path.GetExtension(file), ".pdf"));
if (oGdPicturePDF.GetStat() != 0)
{
}
}
oGdPicturePDF.CloseDocument();
oGdPictureImaging.ReleaseGdPictureImage(num);
}
else
{
oGdPicturePDF.AddImageFromGdPictureImage(num, false, true);
if (oGdPicturePDF.GetStat() == 0)
{
str = file.Replace(Path.GetExtension(file), ".pdf");
if (oGdPicturePDF.SaveToFile(file.Replace(Path.GetExtension(file), ".pdf")) != 0)
{
}
}
oGdPicturePDF.CloseDocument();
oGdPictureImaging.ReleaseGdPictureImage(num);
}
}
File.Delete(file);
return(str);
}
private static void Dispatcher(object sender, CustomActionEventArgs e)
{
GdPicturePDF oPdf = new GdPicturePDF();
switch (e.actionName)
{
//loading document and setting annotations access control
//the workflow is designed for PDF files, you can apply similar workflow on the other formats using GdPictureImaging class
case "load":
load oLoad = JsonConvert.DeserializeObject <load>(e.args.ToString());
GdPictureStatus status = oPdf.LoadFromFile(HttpRuntime.AppDomainAppPath + "\\Files\\" + oLoad.Path, true);
AnnotationManager oAnnotationmanager = new AnnotationManager();
oAnnotationmanager.InitFromGdPicturePDF(oPdf);
for (int i = 1; i < oAnnotationmanager.PageCount; i++)
{
oAnnotationmanager.SelectPage(i);
for (int y = 0; y < oAnnotationmanager.GetAnnotationCount(); y++)
{
Annotation annot = oAnnotationmanager.GetAnnotationFromIdx(y);
if (oLoad.UserType == "user") //case for external user member
{
if (annot.Tag != oLoad.UserType) //annotation is not vissible if not added by external group memebr
{
annot.Visible = false;
}
}
else if (oLoad.UserType == "staff") //case for staff member
{
annot.Visible = true; //all annot are visible
}
}
oAnnotationmanager.SaveAnnotationsToPage();
}
e.docuVieware.LoadFromGdPicturePdf(oPdf);
e.docuVieware.DisplayPage(1);
break;
//setting annotation tag that represents access group and saving annotation to PDF
//the workflow is designed for PDF files, you can apply similar workflow on the other formats using GdPictureImaging class
case "setAnnotationTag":
e.docuVieware.GetNativePDF(out oPdf);
AnnotationManager manager = new AnnotationManager();
manager.InitFromGdPicturePDF(oPdf);
details oDetails = JsonConvert.DeserializeObject <details>(e.args.ToString());
manager.SelectPage(oDetails.annot.pageNo);
int pages = manager.GetAnnotationCount();
for (int i = 0; i < pages; i++)
{
Annotation oAnnotation = manager.GetAnnotationFromIdx(i);
if (oAnnotation.Guid == oDetails.annot.id)
{
oAnnotation.Tag = oDetails.type;
}
}
manager.SaveAnnotationsToPage();
status = oPdf.SaveToFile(HttpRuntime.AppDomainAppPath + "\\Files\\DocuViewareFlyer.pdf", true);
break;
}
}
/*
* /// <summary>
* ///
* /// </summary>
* /// <param name="e"></param>
* public static void HandleSaveFile(CustomActionEventArgs customActionEventArgs)
* {
*
* DocumentType docType = customActionEventArgs.docuVieware.GetDocumentType();
* if (docType == DocumentType.DocumentTypeTXT)
* {
* MemoryStream memStream = null;
* GdPictureStatus status;
*
* status = customActionEventArgs.docuVieware.GetDocumentData(out memStream);
*
* if (status == GdPictureStatus.OK)
* {
* string nm = customActionEventArgs.docuVieware.GetDocumentName();
* int indexOf = nm.IndexOf('.');
* if (indexOf > 0)
* nm = nm.Substring(0, indexOf);
*
* nm = nm + ".tiff";
* string fileName = HttpRuntime.AppDomainAppPath + "\\" + nm;
* FileStream fs = new FileStream(fileName, FileMode.CreateNew, FileAccess.ReadWrite);
* fs.Write(memStream.GetBuffer(), 0, (int)memStream.Length);
* customActionEventArgs.docuVieware.SaveAsTIFF(memStream);
*
* fs = null;
* } else
* {
* customActionEventArgs.message = GetMessage("Save : Fail to get Stream data.", DocuViewareMessageIcon.Error);
* }
*
* memStream = null;
* }
* }
*/
/// <summary>
/// Triggers when user clicks on Rotate -90 or Rotate +90. Rotates the image file as per the request.
/// </summary>
/// <remarks>
/// Only image file formats can be Rotated. Shows error message if File is not Supported, File is not of proper format,
/// Cannot select Page, Failed to Rotate the file contents.
/// </remarks>
/// <param name="e">The CustomActionEventArgs received from the Global.asax.cs custom actions handler</param>
public static void HandleRotationAction(CustomActionEventArgs e)
{
GdPictureStatus status = GdPictureStatus.Aborted;
// For Images
if (e.docuVieware.GetDocumentType() == DocumentType.DocumentTypeBitmap)
{
int imageId;
status = e.docuVieware.GetNativeImage(out imageId);
if (status == GdPictureStatus.OK)
{
GdPictureImaging gdPictureImaging = new GdPictureImaging();
RotateActionParameters rotateParams = JsonConvert.DeserializeObject <RotateActionParameters>(e.args.ToString());
int currPage = rotateParams.CurrentPage;
status = gdPictureImaging.SelectPage(imageId, currPage); // rotateParams.CurrentPage);
if (status == GdPictureStatus.OK)
{
switch (e.actionName)
{
case "rotateM90":
status = gdPictureImaging.Rotate(imageId, RotateFlipType.Rotate270FlipNone);
break;
case "rotateP90":
status = gdPictureImaging.Rotate(imageId, RotateFlipType.Rotate90FlipNone);
break;
}
if (status != GdPictureStatus.OK)
{
e.message = new DocuViewareMessage("Error during rotating: " + status + ".", icon: DocuViewareMessageIcon.Error);
}
else
{
status = e.docuVieware.RedrawPage();
e.message = status == GdPictureStatus.OK ? new DocuViewareMessage("Rotation successfuly applied.", icon: DocuViewareMessageIcon.Ok) : new DocuViewareMessage("Error during redraw pages : " + status + ".", icon: DocuViewareMessageIcon.Error);
}
}
else
{
e.message = new DocuViewareMessage("Error during page selection: " + status + ".", icon: DocuViewareMessageIcon.Error);
}
rotateParams = null;
gdPictureImaging = null;
}
else
{
e.message = new DocuViewareMessage("Error during get native image : " + status + ".", icon: DocuViewareMessageIcon.Error);
}
}
else if (e.docuVieware.GetDocumentType() == DocumentType.DocumentTypePDF)
{
GdPicturePDF gdPdf = null;
if (e.docuVieware.GetNativePDF(out gdPdf) == GdPictureStatus.OK)
{
RotateActionParameters rotateParams = JsonConvert.DeserializeObject <RotateActionParameters>(e.args.ToString());
int currPage = rotateParams.CurrentPage;
gdPdf.SelectPage(currPage);
switch (e.actionName)
{
case "rotateM90":
status = gdPdf.RotatePage(-90);
break;
case "rotateP90":
status = gdPdf.RotatePage(90);
break;
}
if (status != GdPictureStatus.OK)
{
e.message = GetMessage("Error during rotating: " + status + ".", DocuViewareMessageIcon.Error);
}
else
{
status = e.docuVieware.RedrawPage();
e.message = status == GdPictureStatus.OK ? GetMessage("Rotation successfuly applied.", DocuViewareMessageIcon.Ok) : GetMessage("Error during redraw pages : " + status + ".", DocuViewareMessageIcon.Error);
}
rotateParams = null;
gdPdf = null;
}
else
{
e.message = GetMessage("Error during get native image : " + status + ".", DocuViewareMessageIcon.Error);
}
}
else
{
e.message = GetMessage("Only Images & PDF formats Rotation supported", DocuViewareMessageIcon.Error);
}
return;
}
/// <summary>
/// Initialize service
/// </summary>
public PdfContentExtractionService()
{
pdfInstance = GdPictureHelper.GetPDFInstance();
}
public string GetImages(Params par)
{
string path = System.Web.HttpContext.Current.Server.MapPath(par.path);
List <AnnotationJSON> res = new List <AnnotationJSON>();
GdPicturePDF pdf = new GdPicturePDF();
AnnotationManager an = new AnnotationManager();
GdPictureImaging im = new GdPictureImaging();
int width = 0;
int height = 0;
int left = 0;
int top = 0;
pdf.SetOrigin(PdfOrigin.PdfOriginTopLeft);
pdf.SetMeasurementUnit(PdfMeasurementUnit.PdfMeasurementUnitInch);
//this API is only works for PDF files , if you need to process image based files you could implement similar logic using GdPictureImaging
//instead of GdPicturePDF
pdf.LoadFromFile(path, false);
an.InitFromGdPicturePDF(pdf);
for (int i = 1; i <= pdf.GetPageCount(); i++)
{
an.SelectPage(i);
int count = an.GetAnnotationCount();
if (count > 0)
{
List <Annotation> ans = new List <Annotation>();
for (int m = 0; m < count; m++)
{
Annotation annot = an.GetAnnotationFromIdx(m);
annot.Rotation = 0;
ans.Add(annot);
}
an.BurnAnnotationsToPage(false);
//we render PDF page to an image to crop
int imageNr = pdf.RenderPageToGdPictureImage(300, false);
for (int y = 0; y < count; y++)
{
//we copy the same image so we can crop it and send back
int imageCrop = im.CreateClonedGdPictureImage(imageNr);
Annotation annot = ans[y];
//conversion from inches to pixels
left = (int)Math.Ceiling(annot.Left * 300 + 0.5);
top = (int)Math.Ceiling(annot.Top * 300 + 0.5);
width = (int)Math.Ceiling(annot.Width * 300 + 0.5);
height = (int)Math.Ceiling(annot.Height * 300 + 0.5);
//cropping the immage to get snapshot of the annotation
im.Crop(imageCrop, left - width / 2, top - height / 2, width, height);
//rescale the image to 20%
im.Scale(imageCrop, 20, System.Drawing.Drawing2D.InterpolationMode.High);
//prepare image and send it as base64
byte[] arr = { };
int length = 0;
im.SaveAsByteArray(imageCrop, ref arr, ref length, GdPicture14.DocumentFormat.DocumentFormatJPEG, 100);
string bs = System.Convert.ToBase64String(arr);
AnnotationJSON json = new AnnotationJSON();
json.Image = bs;
res.Add(json);
//releasing the resources
im.ReleaseGdPictureImage(imageCrop);
}
im.ReleaseGdPictureImage(imageNr);
}
}
pdf.Dispose();
return(JsonConvert.SerializeObject(res));
}
