public IEnumerable <Bitmap> Render(string path)
{
ThrowIfCantRender();
// TODO: Maybe allow this to be configured
int dpi = ScanDpi.Dpi300.ToIntDpi();
using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var rasterizer = new GhostscriptRasterizer();
rasterizer.Open(stream, gsLibBytes.Value);
for (int pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
var bitmap = (Bitmap)rasterizer.GetPage(dpi, dpi, pageNumber);
bitmap.SetResolution(dpi, dpi);
yield return(bitmap);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
int desired_x_dpi = 300;
int desired_y_dpi = 300;
string inputPdfPath = @"C:\3page.pdf";
string outputPath = @"C:\OUTPUT";
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputPdfPath);
for (var pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
var pageFilePath = Path.Combine(outputPath, string.Format("Page-{0}.png", pageNumber));
var img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
img.Save(pageFilePath);
}
}
}
/// HasColor
#region HasColor
/// <summary>
/// Determines if the specified file has color
/// </summary>
/// <param name="fileName">file to be inspected</param>
/// <returns>true if has color; otherwise false</returns>
public static bool HasColor(string fileName, int desired_x_dpi = 96, int desired_y_dpi = 96)
{
LogHelper.LogDebug(fileName);
try
{
GhostscriptVersionInfo gsVersion = new GhostscriptVersionInfo(GetLib());
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(fileName, gsVersion, false);
for (int pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
try
{
using (Image img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber))
{
if (img.HasColor())
{
LogHelper.LogDebug("Has Color");
return(true);
}
}
}
catch (Exception ex)
{
LogHelper.LogDebug(ex);
}
}
rasterizer.Close();
}
}
catch (Exception ex)
{
WPFNotifier.DebugError(ex);
}
LogHelper.LogDebug("No Color");
return(false);
}
private static void PdfToPng(string inputFile, string outputFileName)
{
var xDpi = 100; //set the x DPI
var yDpi = 100; //set the y DPI
var pageNumber = 1; // the pages in a PDF document
using (var rasterizer = new GhostscriptRasterizer()) //create an instance for GhostscriptRasterizer
{
rasterizer.Open(inputFile); //opens the PDF file for rasterizing
//set the output image(png's) complete path
var outputPNGPath = System.IO.Path.Combine(outputFolder, string.Format("{0}.png", outputFileName));
//converts the PDF pages to png's
var pdf2PNG = rasterizer.GetPage(xDpi, yDpi, pageNumber);
//save the png's
pdf2PNG.Save(outputPNGPath, ImageFormat.Png);
Console.WriteLine("Saved " + outputPNGPath);
}
}
public override Stream CreateThumbnail(Stream stream, Size size, int pageNumber)
{
const string ghostDllPath = @"C:\Development\DRS\src\Web\bin\gsdll64.dll"; //todo: banish the hardcode
var version = new Ghostscript.NET.GhostscriptVersionInfo(new Version(0, 0, 0), ghostDllPath, string.Empty, Ghostscript.NET.GhostscriptLicense.GPL);
using (var rasterizer = new GhostscriptRasterizer())
{
var path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid() + ".pdf");
try
{
using (var fs = File.Create(path))
{
//todo: why is ghostscript requiring i save the pdf to file first??
stream.CopyTo(fs);
stream.Dispose();
}
rasterizer.Open(path, version, true);
using (var thumbnail = rasterizer.GetPage(200, 200, pageNumber))
{
using (var thumbnailStream = new MemoryStream())
{
thumbnail.Save(thumbnailStream, ImageFormat.Png);
thumbnail.Dispose();
thumbnailStream.Position = 0;
return(ResizeAndCrop(thumbnailStream, size.Width, size.Height));
}
}
}
finally
{
File.Delete(path);
}
}
}
public void Sample1()
{
int desired_dpi = 96;
string inputPdfPath = @"E:\gss_test\test\a.pdf";
string outputPath = @"E:\gss_test\output\";
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputPdfPath);
for (var pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
var pageFilePath = Path.Combine(outputPath, string.Format("Page-{0}.png", pageNumber));
var img = rasterizer.GetPage(desired_dpi, pageNumber);
img.Save(pageFilePath, ImageFormat.Png);
Console.WriteLine(pageFilePath);
}
}
}
public static void PdfToPng(string inputFilePath, ref List <string> retFilePaths)
{
string outputDirectory = Path.GetDirectoryName(inputFilePath);
string inputFileName = Path.GetFileNameWithoutExtension(inputFilePath);
var xDpi = 300;
var yDpi = 300;
PdfReader pdf = new PdfReader(inputFilePath);
int nPages = pdf.NumberOfPages;
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputFilePath);
for (int index = 1; index <= nPages; index++)
{
string currentPageFileName = inputFileName + "-" + System.Convert.ToString(index);
var outputPNGPath = Path.Combine(outputDirectory, string.Format("{0}.png", currentPageFileName));
var pdf2PNG = rasterizer.GetPage(xDpi, yDpi, index);
pdf2PNG.Save(outputPNGPath, ImageFormat.Png);
retFilePaths.Add(outputPNGPath);
}
}
}
private void ConvertPdfToPng(string inputPdfPath, string outputPath)
{
int desired_x_dpi = 96;
int desired_y_dpi = 96;
GhostscriptVersionInfo gv = GhostscriptVersionInfo.GetLastInstalledVersion();
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputPdfPath, gv, false);
for (int pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
string pageFilePath = Path.Combine(outputPath, "Page-" + pageNumber.ToString() + ".png");
Image img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
img.Save(pageFilePath, ImageFormat.Png);
Console.WriteLine(pageFilePath);
}
}
}
public static int GetPdfPageCount(Stream data)
{
string path64 = (SolutionPath + "\\gsdll64.dll");
string path32 = (SolutionPath + "\\gsdll32.dll");
{
try
{
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(path64);
GhostscriptRasterizer pdfengine = new GhostscriptRasterizer();
pdfengine.Open(data, gvi, true);
return(pdfengine.PageCount);
}
catch
{
GhostscriptVersionInfo gviCatch = new GhostscriptVersionInfo(path32);
GhostscriptRasterizer pdfenginecatch = new GhostscriptRasterizer();
pdfenginecatch.Open(data, gviCatch, true);
return(pdfenginecatch.PageCount);
}
}
}
public void CreateImageFromPdf(string BatchName)
{
this.OutputFolder = ConfigurationManager.AppSettings["OutputFiles"].ToString();
string PdfSourceFolder = Path.Combine(OutputFolder, BatchName, "pdfs");
string ImageDestinationFolder = Path.Combine(OutputFolder, BatchName, "Images");
// check if the images already there
var ImagesDir = new DirectoryInfo(ImageDestinationFolder);
FileInfo[] Images = ImagesDir.GetFiles();
if (Images.Count() > 0)
{
return;
}
ManageUnclassifiedDocs(BatchName);
GhostscriptVersionInfo _lastInstalledVersion = null;
GhostscriptRasterizer _rasterizer = null;
_lastInstalledVersion = GhostscriptVersionInfo.GetLastInstalledVersion(GhostscriptLicense.GPL | GhostscriptLicense.AFPL, GhostscriptLicense.GPL);
_rasterizer = new GhostscriptRasterizer();
int desired_x_dpi = 96;
int desired_y_dpi = 96;
var dir = new DirectoryInfo(PdfSourceFolder);
FileInfo[] files = dir.GetFiles();
foreach (var file in files)
{
_rasterizer.Open(file.FullName, _lastInstalledVersion, true);
string pageFilePath = Path.Combine(ImageDestinationFolder, Path.GetFileNameWithoutExtension(file.Name) + ".png");
System.Drawing.Image img = _rasterizer.GetPage(desired_x_dpi, desired_y_dpi, 1);
img.Save(pageFilePath, ImageFormat.Png);
}
}
public void Start()
{
// For users who distribute their gsdll32.dll or gsdll64.dll with their application: Ghostscript.NET by default
// peeks into the registry to collect all installed Ghostscript locations. If you want to use ghostscript dll from
// a custom location, it's recommended to do something like this:
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(@"e:\dummyfolder\myapplication\gsdll32.dll");
// and then pass that GhostscriptVersionInfo to the required constructor or method
// sample #1
GhostscriptProcessor proc = new GhostscriptProcessor(gvi);
// sample #2
GhostscriptRasterizer rast = new GhostscriptRasterizer();
rast.Open("test.pdf", gvi, true);
// sample #3
GhostscriptViewer view = new GhostscriptViewer();
view.Open("test.pdf", gvi, true);
}
/// <summary>
/// Turn each pdf page into it's own png file to be processed.
/// </summary>
/// <param name="psFilename">File path to the pdf.</param>
/// <param name="outputPath">Path to dump the output into.</param>
/// <param name="dpi"></param>
/// <returns>Array where each object in the array is a file path to a png file.</returns>
private static string[] GetPngImage(string psFilename, string outputPath, int dpi = 300)
{
using (var rasterizer = new GhostscriptRasterizer()) //create an instance for GhostscriptRasterizer
{
rasterizer.Open(psFilename); //opens the PDF file for rasterizing
PdfReader reader = new PdfReader(psFilename);
var results = new string[reader.NumberOfPages];
for (int pageNum = 0; pageNum < reader.NumberOfPages; pageNum++)
{
//set the output image(png's) complete path
var outputPNGPath = Path.Combine(outputPath, $"{Path.GetFileNameWithoutExtension(psFilename).Trim()}_page{pageNum + 1}.png");
results[pageNum] = outputPNGPath;
//converts the PDF pages to png's
var pdf2PNG = rasterizer.GetPage(dpi, pageNum + 1);
//save the png's
pdf2PNG.Save(outputPNGPath, System.Drawing.Imaging.ImageFormat.Png);
}
return(results);
}
}
public string[] Generate(string pdfFile, int dpi = 100, bool multi = false)
{
string binPath = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
string gsDllPath = Path.Combine(binPath, "gsdll32.dll");
dll = new Ghostscript.NET.GhostscriptVersionInfo(new Version(9, 2, 2), gsDllPath, string.Empty,
Ghostscript.NET.GhostscriptLicense.GPL);
using (FileStream stream = new FileStream(pdfFile, FileMode.Open, FileAccess.Read))
{
_rasterizer = new GhostscriptRasterizer();
_rasterizer.Open(stream, dll, false);
if (multi)
{
pageCount = _rasterizer.PageCount;
}
else
{
pageCount = 1;
}
string[] tmpPathArr = new string[pageCount];
for (int pageNumber = 1; pageNumber <= pageCount; pageNumber++)
{
string tmpPath = Path.GetTempFileName();
Image img = _rasterizer.GetPage(dpi, dpi, pageNumber);
img.Save(tmpPath, ImageFormat.Png);
tmpPathArr[pageNumber - 1] = tmpPath;
}
_rasterizer.Close();
return(tmpPathArr);
}
}
public void Sample1()
{
int desired_dpi = 96;
string inputPdfPath = @"E:\gss_test\test.pdf";
string outputPath = @"E:\gss_test\output\";
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(@"C:\Program Files\gs\gs9.53.3\bin\gsdll64.dll");
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputPdfPath, gvi, false);
for (var pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
var pageFilePath = Path.Combine(outputPath, string.Format("Page-{0}.png", pageNumber));
var img = rasterizer.GetPage(desired_dpi, pageNumber);
img.Save(pageFilePath, ImageFormat.Png);
Console.WriteLine(pageFilePath);
}
}
}
// This function will get triggered/executed when a new message is written
// on an Azure Queue called queue.
public static void ProcessPdfFiles(
[QueueTrigger("workitems")] string pdfFilename,
[Blob("pdf-files/{queueTrigger}.pdf", FileAccess.Read)] Stream pdfBlob,
IBinder binder,
ILogger logger)
{
logger.LogInformation($"Start Processing: {pdfFilename}");
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(@"gsdll32.dll");
using (GhostscriptRasterizer _rasterizer = new GhostscriptRasterizer())
{
logger.LogInformation($"Open: {pdfFilename}");
_rasterizer.Open(pdfBlob, gvi, true);
for (int pageNumber = 1; pageNumber <= _rasterizer.PageCount; pageNumber++)
{
string pngFilename = $"{pdfFilename}-page-{pageNumber.ToString()}.png".ToLower();
logger.LogInformation($"pageFilePath: {pngFilename}");
BlobAttribute blobAttribute = new BlobAttribute($"png-files/{pngFilename}");
CloudBlockBlob pngBlob = binder.Bind <CloudBlockBlob>(blobAttribute);
logger.LogInformation($"GetPage: {pageNumber}");
Image img = _rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
logger.LogInformation($"Save: {pngFilename}");
MemoryStream ms = new MemoryStream();
img.Save(ms, ImageFormat.Png);
ms.Flush();
ms.Position = 0;
pngBlob.UploadFromStream(ms);
}
}
logger.LogInformation($"Finish Processing: {pdfFilename}");
}
private void PdfToPng(string inputFile, string outputFileName, string doctypename)
{
var xDpi = 100; //set the x DPI
var yDpi = 100; //set the y DPI
var pageNumber = 1; // the pages in a PDF document
string ExtractionSampleImages1 = ExtractionSampleImages + doctypename;
if (!System.IO.Directory.Exists(ExtractionSampleImages1))
{
CreateDirectoryRecursively(ExtractionSampleImages1);
}
using (var rasterizer = new GhostscriptRasterizer()) //create an instance for GhostscriptRasterizer
{
rasterizer.Open(inputFile); //opens the PDF file for rasterizing
int pagecount = rasterizer.PageCount;
for (int i = 1; i < pagecount + 1; i++)
{
pageNumber = i;
//set the output image(png's) complete path
var outputPNGPath = Path.Combine(ExtractionSampleImages1, string.Format("{0}.jpeg", outputFileName + "_" + pageNumber));
//converts the PDF pages to png's
var pdf2PNG = rasterizer.GetPage(xDpi, yDpi, pageNumber);
//save the png's
pdf2PNG.Save(outputPNGPath, ImageFormat.Jpeg);
}
//Console.WriteLine("Saved " + outputPNGPath);
}
}
public static BinaryFile ConvertPDFToImage(BinaryFile inputFile)
{
int desired_x_dpi = 96;
int desired_y_dpi = 96;
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
using (MemoryStream ms = new MemoryStream(inputFile.DatabaseData.Content))
{
rasterizer.Open(ms);
if (rasterizer.PageCount > 0)
{
string filename = "ImageConvertedPDF.png";
Image img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, 1);
using (MemoryStream m = new MemoryStream())
{
img.Save(m, ImageFormat.Png);
var data = m.ToArray();
var databaseData = new BinaryFileData()
{
Content = data
};
var outputFile = new BinaryFile()
{
FileName = filename,
MimeType = "image/png",
DatabaseData = databaseData,
};
return(outputFile);
}
}
}
}
return(new BinaryFile());
}
private bool PdfToImage(string pdfName, string fileCurrentName)
{
int desired_x_dpi = 300;
int desired_y_dpi = 300;
int pageCount = 1;
string ServerPath = Server.MapPath(".\\");
string pdfPath = Server.MapPath("~/Pdf/" + fileCurrentName + ".pdf");
PdfSharp.Pdf.PdfDocument inputDocument = PdfReader.Open(pdfPath, PdfDocumentOpenMode.ReadOnly);
int widthPage = 0;
widthPage = (int)inputDocument.Pages[0].Width;
if (widthPage > 800)
{
paper_type = "L";
}
else
{
paper_type = "P";
}
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(pdfPath);
pageCount = rasterizer.PageCount;
for (var pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
if (rasterizer.PageCount > 1)
{
var pageFilePath = Path.Combine(Server.MapPath("~/PdfToImage/"), fileCurrentName + "_" + (pageNumber) + ".PNG");
var img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
img.Save(pageFilePath);
}
else
{
var pageFilePath = Path.Combine(Server.MapPath("~/PdfToImage/"), fileCurrentName + ".PNG");
var img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
img.Save(pageFilePath);
}
}
}
Model.Criteria.Document doc = new Model.Criteria.Document();
doc.doc_id = fileCurrentName;
doc.upload_date = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
doc.page_count = pageCount;
doc.paper_type = paper_type;
BLL.Upload _BLL = new BLL.Upload();
_BLL.Update_upload_date(doc);
// Write LOG
Model.Log L = new Model.Log();
Helper.Utility Log = new Helper.Utility();
L.content = "Convert PDF to Image success.";
L.create_by = Session["EMAIL"].ToString();
Log.WriteLog(L);
return(true);
}
private void _convert(string inputPdfPath)
{
_outputToInfo(inputPdfPath);
// make a sub path in the same folder as this
// put file(s) in there
// single file has NAME.png
// multiples are NAME_000.png
// overwrite just uses folder always
// otherwise, append output folder if it exists and is NOT empty
try
{
outputFolder = _createOutputFolder(inputPdfPath, _overwrite);
if (outputFolder == null)
{
_outputToInfo("Error");
return;
}
string historyFile = Path.Combine(outputFolder, "history.txt");
_outputToInfo("Output to: " + outputFolder);
_outputToInfo(" ");
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputPdfPath, _lastInstalledVersion, false);
if (_multiFiles)
{
string outputPath = Path.Combine(outputFolder, Path.GetFileNameWithoutExtension(inputPdfPath));
int nFiles = 0;
for (int pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
if (cancel)
{
break;
}
if (_isPageNumberRequired(pageNumber))
{
string pageFilePath = outputPath + "_" + pageNumber.ToString("000") + _imageExt;
Image img = rasterizer.GetPage(_dpi, _dpi, pageNumber);
img.Save(pageFilePath, _imageFmt);
_outputToInfo(img);
_outputToInfo(" " + Path.GetFileName(pageFilePath));
_outputToInfo(" Dimensions:" + img.Width + " x " + img.Height);
_outputToInfo();
_history(historyFile, inputPdfPath, pageFilePath);
nFiles++;
}
}
_outputToInfo(" complete, " + nFiles + " files in:");
_outputToInfo(" " + outputFolder);
_outputToInfo();
}
else
{
// work in PNG here
string outputPath = Path.GetTempPath();
string prefix = Guid.NewGuid().ToString().Substring(0, 7);
List <string> pathList = new List <string>();
int w = 0, h = 0;
for (int pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
if (cancel)
{
break;
}
if (_isPageNumberRequired(pageNumber))
{
string pageFilePath = Path.Combine(outputPath, prefix + "_" + pageNumber.ToString() + ".png");
Image img = rasterizer.GetPage(_dpi, _dpi, pageNumber);
img.Save(pageFilePath, ImageFormat.Png);
_outputToInfo(img);
pathList.Add(pageFilePath);
_outputToInfo(" building page: " + pageNumber + " of " + rasterizer.PageCount);
_outputToInfo();
h += img.Height;
w = Math.Max(w, img.Width);
}
}
// combine!!
if (cancel == false && pathList.Count > 0)
{
string bigImagePath = Path.Combine(outputPath, prefix + "_BIG" + ".png");
PngReader pngr = FileHelper.CreatePngReader(pathList[0]); // or you can use the constructor
ImageInfo ii = new ImageInfo(w, h, pngr.ImgInfo.BitDepth, pngr.ImgInfo.Alpha, false, false);
PngWriter pngw = FileHelper.CreatePngWriter(bigImagePath, ii, true);
int chunkBehav = ChunkCopyBehaviour.COPY_ALL_SAFE; // tell to copy all 'safe' chunks
pngw.CopyChunksFirst(pngr, chunkBehav); // copy some metadata from reader
pngr.End();
int destRow = 0;
int ic = 1;
foreach (string path in pathList)
{
pngr = FileHelper.CreatePngReader(path);
ImageLines iLines = pngr.ReadRowsInt(0, pngr.ImgInfo.Rows, 1);
int nrr = iLines.Nrows;
for (int i = 0; i < nrr; i++)
{
pngw.WriteRow(iLines.GetImageLineAtMatrixRow(i), destRow++);
}
_outputToInfo(" combining page:" + ic + " of " + pathList.Count);
ic++;
pngr.End();
File.Delete(path); // remove them as we go
}
pngw.CopyChunksLast(pngr, chunkBehav); // metadata after the image pixels? can happen
pngw.End(); // dont forget this
_autoCrop(bigImagePath);
// convert to required type if not PNG
string outputSingleFile = Path.Combine(outputFolder, Path.GetFileNameWithoutExtension(inputPdfPath) + _imageExt);
Bitmap bm;
if (_imageExt != ".png")
{
bm = new Bitmap(bigImagePath);
bm.Save(outputSingleFile, _imageFmt);
}
else
{
bm = new Bitmap(bigImagePath);
_moveFile(bigImagePath, outputSingleFile);
}
_outputToInfo(bm);
_outputToInfo(" Dimensions:" + bm.Width + " x " + bm.Height);
_outputToInfo(" Complete: ");
_outputToInfo(" " + outputSingleFile);
_history(historyFile, inputPdfPath, outputSingleFile);
}
else
{
_outputToInfo(" NO PAGES set! Try again.");
}
}
}
}
catch (Exception ex)
{
_outputToInfo("Error");
_outputToInfo(ex.ToString());
throw;
}
}
public void Open(Stream stream)
{
_ghostscriptRasterizer.Open(stream, _ghostscriptNativeDll.Value);
}
protected void Unnamed_Click(object sender, EventArgs e)
{
if (!checkBoxOCR.Checked)
{
if (fileUpload.HasFile)
{
if (Path.GetExtension(fileUpload.FileName) == ".pdf")
{
XmlDocument doc = new XmlDocument();
doc.Load(Server.MapPath("~/xml.xml"));
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(fileUpload.FileContent, gvi, true);
for (int i = 1; i <= 5; i++)
{
var ocr = new TesseractEngine(Server.MapPath("./tessdata"), "eng");
var pdf2jpg = (System.Drawing.Image)rasterizer.GetPage(200, 200, i).Clone();
Tesseract.Page page = ocr.Process((Bitmap)pdf2jpg);
List <Field> fields = new List <Field>();
switch (i)
{
case 1:
fields = Constants.fields1;
break;
case 2:
fields = Constants.fields2;
break;
case 3:
fields = Constants.fields3;
break;
case 4:
fields = Constants.fields4;
break;
case 5:
fields = Constants.fields5;
break;
}
foreach (Field field in fields)
{
string txtRetrieved = "";
if (field.isCross)
{
if (field.specialTreatment)
{
txtRetrieved = !Methods.IsBlank(Methods.CropImage(new Bitmap(pdf2jpg), field.rect.X1, field.rect.Y1, field.rect.Width, field.rect.Height)) ? field.value : "";
}
else
{
txtRetrieved = !Methods.IsBlank(Methods.CropImage(new Bitmap(pdf2jpg), field.rect.X1, field.rect.Y1, field.rect.Width, field.rect.Height)) ? "Y" : field.CrossNo ? "N" : "";
}
}
else
{
page.RegionOfInterest = field.rect;
txtRetrieved = page.GetText();
}
doc.SelectSingleNode(field.xmlField).InnerText = txtRetrieved;
}
}
Response.Clear();
Response.AddHeader("Content-Disposition", "attachment;filename=MyXmlDocument.xml");
Response.AddHeader("Content-Length", doc.OuterXml.Length.ToString());
Response.ContentType = "application/octet-stream";
Response.Write(doc.OuterXml);
Response.End();
}
}
}
}
else
{
if (page1Upload.HasFile && page2Upload.HasFile && page3Upload.HasFile && page4Upload.HasFile && page5Upload.HasFile)
{
XmlDocument doc = new XmlDocument();
List <System.Drawing.Image> pages = new List <System.Drawing.Image>()
{
ResizeImage(System.Drawing.Image.FromStream(new MemoryStream(page1Upload.FileBytes)), 1700, 2200),
ResizeImage(System.Drawing.Image.FromStream(new MemoryStream(page2Upload.FileBytes)), 1700, 2200),
ResizeImage(System.Drawing.Image.FromStream(new MemoryStream(page3Upload.FileBytes)), 1700, 2200),
ResizeImage(System.Drawing.Image.FromStream(new MemoryStream(page4Upload.FileBytes)), 1700, 2200),
ResizeImage(System.Drawing.Image.FromStream(new MemoryStream(page5Upload.FileBytes)), 1700, 2200)
};
using (var rasterizer = new GhostscriptRasterizer())
{
doc.Load(Server.MapPath("~/xml.xml"));
List <Field> fields = new List <Field>();
for (int i = 0; i <= 4; i++)
{
using (var page = pages[i])
{
var ocr = new TesseractEngine(Server.MapPath("./tessdata"), "eng");
Tesseract.Page pageOCR = ocr.Process((Bitmap)page);
switch (i)
{
case 0:
fields = Constants.fields1;
break;
case 1:
fields = Constants.fields2;
break;
case 2:
fields = Constants.fields3;
break;
case 3:
fields = Constants.fields4;
break;
case 4:
fields = Constants.fields5;
break;
}
foreach (Field field in fields)
{
string text = "";
if (field.isCross)
{
if (field.specialTreatment)
{
text = !Methods.IsBlank(Methods.CropImage(new Bitmap(page), field.rect.X1, field.rect.Y1, field.rect.Width, field.rect.Height)) ? field.value : "";
}
else
{
text = !Methods.IsBlank(Methods.CropImage(new Bitmap(page), field.rect.X1, field.rect.Y1, field.rect.Width, field.rect.Height)) ? "Y" : field.CrossNo ? "N" : "";
}
}
else
{
pageOCR.RegionOfInterest = field.rect;
text = pageOCR.GetText();
}
doc.SelectSingleNode(field.xmlField).InnerText = text;
}
}
}
MemoryStream stream = new MemoryStream();
doc.Save(stream);
StreamReader reader = new StreamReader(stream);
Response.Clear();
Response.AddHeader("Content-Disposition", "attachment;filename=MyXmlDocument.xml");
Response.AddHeader("Content-Length", doc.OuterXml.Length.ToString());
Response.ContentType = "application/octet-stream";
Response.Write(reader.ReadToEnd());
Response.End();
}
}
}
}
private bool PdfToImage(string pdfName, string fileCurrentName)
{
int desired_x_dpi = 300;
int desired_y_dpi = 300;
string ServerPath = Server.MapPath(".\\");
string pdfPath = Server.MapPath(".\\") + "PO_PdfRequest/" + fileCurrentName + ".pdf";
string pageCount;
BLL.PO _BLL = new BLL.PO();
pageCount = _BLL.Get_PageCount(Session["DOC_ID"].ToString());
//for (int i = 0; i < int.Parse(pageCount); i++)
//{
// if (int.Parse(pageCount) > 1)
// {
// zoomImg.Save(@ServerPath + "/PdfToImageApprove/" + fileCurrentName + "_" + (i + 1) + ".PNG");
// }
// else
// {
// zoomImg.Save(@ServerPath + "/PdfToImageApprove/" + fileCurrentName + ".PNG");
// }
//}
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(pdfPath);
for (var pageNumber = 1; pageNumber <= int.Parse(pageCount); pageNumber++)
{
if (int.Parse(pageCount) > 1)
{
var pageFilePath = Path.Combine(Server.MapPath("~/PO_PdfToImageRequest/"), fileCurrentName + "_" + (pageNumber) + ".PNG");
var img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
img.Save(pageFilePath);
}
else
{
var pageFilePath = Path.Combine(Server.MapPath("~/PO_PdfToImageRequest/"), fileCurrentName + ".PNG");
var img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
img.Save(pageFilePath);
}
}
}
//Model.Criteria.Document doc = new Model.Criteria.Document();
//doc.doc_id = fileCurrentName;
//doc.upload_date = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
//BLL.Upload _BLL = new BLL.Upload();
//int ret;
//ret = _BLL.Update_upload_date(doc);
// Write LOG
Model.Log L = new Model.Log();
Helper.Utility Log = new Helper.Utility();
L.content = "Convert PO PDF to Image success.";
L.create_by = Session["EMAIL"].ToString();
Log.WriteLog(L);
return(true);
}
public string convertFileToImage(byte[] buffer, string Url, string UrlFileOld = null)
{
System.Drawing.Image imgRe = null;
BlobManager blob = new BlobManager();
Rectangle rec = new Rectangle();
string urlImage = "";
try
{
int desired_x_dpi = 96;
int desired_y_dpi = 96;
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
MemoryStream ms = new MemoryStream(buffer);
string gsdll = HttpContext.Current.Request.MapPath("~/Dlls/gsdll32.dll");
GhostscriptVersionInfo gvi =
new GhostscriptVersionInfo(gsdll);
rasterizer.Open(ms, gvi, true);
//for (int pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
//{
System.Drawing.Image img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, 1);
//Rectangle rec = new Rectangle(20, 200, 790, 400);
if (getNamePage(Url) == 1)
{
rec = new Rectangle(20, 145, 790, 620);
}
else if (getNamePage(Url) == 2)
{
rec = new Rectangle(20, 89, 790, 750);
}
System.Drawing.Image imgCrop = cropimage(img, rec);
if (UrlFileOld != null)
{
if (blob.DeleteByResourceId(UrlFileOld))
{
urlImage = saveImageBlob(imgCrop);
}
}
else
{
urlImage = saveImageBlob(imgCrop);
}
}
return(urlImage);
}
catch (Exception ex)
{
throw;
}
}
public async Task <IActionResult> Upload(IList <IFormFile> files)
{
try
{
if (files.Any(f => !Path.GetExtension(f.FileName).Equals(".pdf")))
{
return(Redirect("~/Home"));
}
if (files.Any(f => f.Length > 31457280))
{
return(Redirect("~/Home"));
}
FileDownloadModel fdm = new FileDownloadModel();
fdm.Files = new List <FileModel>();
long size = files.Sum(f => f.Length);
long totalReadBytes = 0;
string firstFolderId = Guid.NewGuid().ToString();
string directoryPath = $"{this.HostingEnvironment.WebRootPath}/download/{firstFolderId}";
var filePath = Path.GetTempFileName();
filePath = filePath.Replace(".tmp", ".pdf");
foreach (var formFile in files)
{
var type = Path.GetExtension(formFile.FileName);
if (formFile.Length > 0)
{
byte[] buffer = new byte[16 * 1024];
using (var stream = new FileStream(filePath, FileMode.Create))
{
using (Stream input = formFile.OpenReadStream())
{
int readBytes;
while ((readBytes = input.Read(buffer, 0, buffer.Length)) > 0)
{
await stream.WriteAsync(buffer, 0, readBytes);
}
}
await formFile.CopyToAsync(stream);
}
directoryPath = string.Concat(directoryPath, "/" + formFile.FileName);
Directory.CreateDirectory(directoryPath);
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(filePath);
for (int i = 1; i <= rasterizer.PageCount; i++)
{
var page = rasterizer.GetPage(120, 120, i);
var savePath = $"{directoryPath}/{formFile.FileName}_{i}.jpg";
page.Save(savePath);
}
rasterizer.Close();
}
string zipPath = $"{this.HostingEnvironment.WebRootPath}/download/{firstFolderId}/{formFile.FileName}.zip";
ZipFile.CreateFromDirectory(directoryPath, zipPath);
FileModel fileModel = new FileModel
{
FileName = formFile.FileName,
FilePath = zipPath
};
fdm.Files.Add(fileModel);
}
directoryPath = $"{this.HostingEnvironment.WebRootPath}/download/{firstFolderId}";
}
fdm.DownloadAllId = firstFolderId;
if (files.Count > 1)
{
string allZipPath = $"{this.HostingEnvironment.WebRootPath}/download/{firstFolderId}/pdftojpg.zip";
var allToZip = Directory.GetFiles(directoryPath);
using (ZipArchive newFile = ZipFile.Open(allZipPath, ZipArchiveMode.Create))
{
foreach (string file in allToZip)
{
newFile.CreateEntryFromFile(file, System.IO.Path.GetFileName(file));
}
}
}
return(View(fdm));
}
catch (Exception ex)
{
log.Error(ex.Message, ex);
return(Redirect("~/Home"));
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
GC.Collect();
if (sourcefolder == "" || destfolder == "")
{
MessageBox.Show("Ustal folder źródłowy i docelowy.\nSet source and destination folder");
}
else
{
this.IsEnabled = false;
this.Height += 20;
string[] files = Directory.GetFiles(this.sourcefolder, "*.pdf");
int couter = 0;
foreach (string file in files)
{
progress.Value = couter * 100 / files.Length;
Application.Current.Dispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { }));
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo("gsdll32.dll");
using (GhostscriptProcessor proc = new GhostscriptProcessor(gvi))
{
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
using (FileStream stream = File.Open(file, FileMode.Open))
{
rasterizer.Open(stream, gvi, true);
if (rasterizer.PageCount == 1)
{
Image img = rasterizer.GetPage((int)this.cbDPI.SelectedItem, (int)this.cbDPI.SelectedItem, 1);
img.Save(string.Concat(this.destfolder, Path.DirectorySeparatorChar, Path.GetFileNameWithoutExtension(file), ".", this.cbFormat.Text.ToLower()),
(ImageFormat)this.cbFormat.SelectedItem);
img.Dispose();
}
else
{
for (var pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
Image img = rasterizer.GetPage((int)this.cbDPI.SelectedItem, (int)this.cbDPI.SelectedItem, pageNumber);
img.Save(string.Concat(this.destfolder, Path.DirectorySeparatorChar, Path.GetFileNameWithoutExtension(file), "_", pageNumber, ".", this.cbFormat.Text.ToLower()),
(ImageFormat)this.cbFormat.SelectedItem);
img.Dispose();
}
}
}
}
GC.Collect();
}
couter++;
}
this.Height -= 20;
this.IsEnabled = true;
MessageBox.Show("Konwersja zakończona.\nConversion completed");
}
}
static int Main(string[] args)
{
//Анализ командной строки
int countArgs = args.Count();
int ret = 0;
bool pP = false;
bool pS = false;
string dir;
if (countArgs == 0)
{
Console.WriteLine("Ошибка в синтаксисе команды. Наберите PDFCounter /? для получения справки.");
Console.WriteLine("Укажите каталог содержащий *.PDF файлы. ");
PrintHelp();
return(-1);
}
dir = args[0].ToString();
if (!Directory.Exists(dir))
{
Console.WriteLine("Укажите каталог содержащий *.PDF файлы. ");
PrintHelp();
return(-1);
}
for (int i = 1; i < countArgs; i++)
{
if (args[i] == "/?")
{
PrintHelp(); return(0);
}
if (args[i] == "/P" || args[i] == "/p")
{
pP = true;
}
if (args[i] == "/S" || args[i] == "/s")
{
pS = true;
}
}
var localGhostscriptDll = Path.Combine(Environment.CurrentDirectory, "gsdll32.dll");
var localDllInfo = new GhostscriptVersionInfo(localGhostscriptDll);
GhostscriptRasterizer rasterizer = new GhostscriptRasterizer();
int pagecount = 0;
//Получение списка файлов PDF в каталоге
string[] files = Directory.GetFiles(dir, "*.pdf");
//Получение информации о PDF файле (размер, количество страниц)
foreach (string filename in files)
{
Trace.WriteLine("Обработка файла: " + filename);
//Сохранение информации в результирующем файле
Console.Write(filename + "\t");
if (pP)
{
rasterizer.Open(filename, localDllInfo, false);
pagecount = rasterizer.PageCount;
Console.Write(pagecount + "\t");
}
if (pS)
{
FileInfo f = new FileInfo(filename);
Console.Write(f.Length);
}
ret++;
Console.WriteLine();
}
Console.WriteLine("Обработано файлов " + ret);
return(ret);
}
public ActionResult CortarImagenPdf()
{
string folderPath = @"D:/PdfToImages/" + (DateTime.Now.ToString()).Replace(":", "-");
Directory.CreateDirectory(folderPath);
string zipPath = folderPath + "/" + "PdfToImages.zip";
try
{
var file = Request.Files[0];
if (file.ContentType == "application/pdf")
{
var constructorInfo = typeof(HttpPostedFile).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0];
var obj = (HttpPostedFile)constructorInfo
.Invoke(new object[] { file.FileName, file.ContentType, file.InputStream });
HttpPostedFile filePosted = obj;
string filePath = "";
if (filePosted != null && filePosted.ContentLength > 0)
{
string fileNameApplication = System.IO.Path.GetFileName(filePosted.FileName);
string fileExtensionApplication = System.IO.Path.GetExtension(fileNameApplication);
// generating a random guid for a new file at server for the uploaded file
string newFile = fileNameApplication;
// getting a valid server path to save
filePath = System.IO.Path.Combine(folderPath, newFile);
if (fileNameApplication != String.Empty)
{
filePosted.SaveAs(filePath);
}
}
var xDpi = 192; //set the x DPI
var yDpi = 192; //set the y DPI
using (var rasterizer = new GhostscriptRasterizer()) //create an instance for GhostscriptRasterizer
{
rasterizer.Open(filePath); //opens the PDF file for rasterizing
int frameNum = rasterizer.PageCount;
//set the output image(png's) complete path
var outputPNGPath = Path.Combine(filePath, string.Format("{0}.png", folderPath));
//converts the PDF pages to png's
for (int i = 1; i < frameNum + 1; i++)
{
var pdf2PNG = rasterizer.GetPage(xDpi, yDpi, i);
//save the png's
pdf2PNG.Save(folderPath + "\\" + Convert.ToString(i) + ".jpg", ImageFormat.Jpeg);
//pdf2PNG.Save("C:/PdfToImages", ImageFormat.Png);
}
rasterizer.Close();
using (ZipFile zip = new ZipFile())
{
zip.AddDirectory(folderPath);
zip.Save(zipPath);
}
Byte[] bytes = System.IO.File.ReadAllBytes(zipPath);
Directory.Delete(folderPath, true);
//return RedirectToAction("Index");
return(File(bytes, System.Net.Mime.MediaTypeNames.Application.Octet, file.FileName + ".zip"));
}
}
else
{
Directory.Delete(folderPath, true);
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
Directory.Delete(folderPath, true);
return(RedirectToAction("Index"));
}
}