public List <string> ConvertPdfJpg()
{
Guid guid = Guid.NewGuid();
string oldFileName = tbFileName.Text;
string newFileName = tmpPath + "tmp_watermake_" + guid + ".pdf";
File.Copy(oldFileName, newFileName);
string outFileName = Path.GetFileName(newFileName);
List <string> outFiles = new List <string>();
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(localGhostscriptDll);
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
/*rasterizer.CustomSwitches.Add("-r200x300");
* rasterizer.CustomSwitches.Add("-dAutoRotatePages =/ None");*/
rasterizer.Open(newFileName, gvi, false);
for (int pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
string outNameFile = tmpPath + outFileName.Replace(".pdf", "") + "_" + pageNumber.ToString() + ".jpeg";
outFiles.Add(outNameFile);
Image img = rasterizer.GetPage(300, 300, pageNumber);
img.Save(outNameFile, ImageFormat.Jpeg);
}
rasterizer.Close();
}
return(outFiles);
}
// from https://ghostscriptnet.codeplex.com/SourceControl/latest#Ghostscript.NET/Ghostscript.NET.Samples/Samples/RasterizerSample1.cs
public static void Test_PdfToImages(string file, string outputDirectory, int xDpi = 96, int yDpi = 96)
{
// GhostscriptRasterizer allows you to rasterize pdf and postscript files into the
// memory. If you want Ghostscript to store files on the disk use GhostscriptProcessor
// or one of the GhostscriptDevices (GhostscriptPngDevice, GhostscriptJpgDevice).
//string inputPdfPath = @"E:\gss_test\test.pdf";
//string outputPath = @"E:\gss_test\output\";
zdir.CreateDirectory(outputDirectory);
Trace.WriteLine($"convert pdf to images \"{file}\"");
using (var rasterizer = new GhostscriptRasterizer())
{
using (FileStream fs = zFile.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
//rasterizer.Open(file);
rasterizer.Open(fs);
for (var pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
var imageFile = zPath.Combine(outputDirectory, $"page-{pageNumber:000}.jpeg");
var img = rasterizer.GetPage(xDpi, yDpi, pageNumber);
//img.Save(imageFile, ImageFormat.Png);
img.Save(imageFile, ImageFormat.Jpeg);
Trace.WriteLine(imageFile);
}
}
}
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
var options = new Options()
{
Input = DownloadFile(GetInputFileFromUrl(req))
};
using (GhostscriptRasterizer _rasterizer = new GhostscriptRasterizer())
{
_rasterizer.Open(options.Input, options.Gvi, true);
for (int pageNr = 1; pageNr <= _rasterizer.PageCount; pageNr++)
{
string dest = Path.Combine(options.OutputPath, $"{options.DestFileNameWithoutExtension}-{pageNr}.png");
Image img = _rasterizer.GetPage(options.Desired_X_dpi, options.Desired_Y_dpi, pageNr);
img.Save(dest, ImageFormat.Png);
//upload to azure
//http://lightswitchhelpwebsite.com/Blog/tabid/61/EntryId/3303/Convert-PDF-files-to-PNG-Images-using-Azure-Functions.aspx
//file.delete
}
}
File.Delete(options.Input);
return(req.CreateResponse(HttpStatusCode.OK, "Hello"));
}
/// <summary>
/// 將Pdf檔匯出成圖檔
/// </summary>
/// <param name="outPdfImagePath"></param>
/// <param name="file"></param>
/// <param name="outImageFileName"></param>
/// <param name="outPdfTempImagePath"></param>
private static void PdfToImage(string outPdfTempImagePath, string outPdfImagePath, string file,
out string outImageFileName)
{
var tempFiles = new List <string>();
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(file, GhostScriptVersion, false);
for (var i = 1; i <= rasterizer.PageCount; i++)
{
var fileName = Path.Combine(outPdfTempImagePath, GetUniqueFileName(".png", outPdfTempImagePath));
tempFiles.Add(fileName);
var img = rasterizer.GetPage(DesiredXDpi, DesiredYDpi, i);
if (i == 1)
{
img.Save(fileName, ImageFormat.Png);
}
else
{
img.RotateFlip(RotateFlipType.Rotate90FlipNone);
img.Save(fileName, ImageFormat.Png);
}
}
rasterizer.Close();
}
outImageFileName = GetUniqueFileName(".png", outPdfImagePath);
MergeImages(tempFiles).Save(Path.Combine(outPdfImagePath, outImageFileName));
}
public static Image[] RasterizePdf(MemoryStream PdfBinary)
{
string dll32Path = AppDomain.CurrentDomain.BaseDirectory + "gsdll32.dll";
string dll64Path = AppDomain.CurrentDomain.BaseDirectory + "gsdll64.dll";
int dpi_X = int.Parse(Application.AppSettingsValue("GhostScriptRasterizeDpi_X"));
int dpi_Y = int.Parse(Application.AppSettingsValue("GhostScriptRasterizeDpi_Y"));
int requestPlatform = int.Parse(Application.AppSettingsValue("GhostScriptPlatform"));
byte[] ghLib;
if (requestPlatform == 32)
{
ghLib = File.ReadAllBytes(dll32Path);
}
else
{
ghLib = File.ReadAllBytes(dll64Path);
}
using (var _rasterizer = new GhostscriptRasterizer())
{
_rasterizer.Open(PdfBinary, ghLib);
int total = _rasterizer.PageCount;
List <Image> images = new List <Image>(total);
for (int i = 1; i <= total; i++)
{
images.Add(_rasterizer.GetPage(dpi_X, dpi_Y, i));
}
return(images.ToArray());
}
}
public void Start()
{
int desired_x_dpi = 96;
int desired_y_dpi = 96;
string inputPdfPath = @"..\..\..\test\test.pdf";
string outputPath = @"..\..\..\test\output\";
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
/* custom switches can be added before the file is opened
*
* rasterizer.CustomSwitches.Add("-dPrinted");
*
*/
byte[] buffer = File.ReadAllBytes(inputPdfPath);
MemoryStream ms = new MemoryStream(buffer);
rasterizer.Open(ms);
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);
}
}
}
//Methode FONCTIONNELLE de conversion de pdf en images
public static List <System.Drawing.Image> exportPdfToImages(string file)
{
string path = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
List <System.Drawing.Image> output = new List <System.Drawing.Image>();
System.Drawing.Image img;
GhostscriptRasterizer rasterizer = null;
GhostscriptVersionInfo vesion = new GhostscriptVersionInfo(new Version(0, 0, 0), path + @"\gsdll32.dll", string.Empty, Ghostscript.NET.GhostscriptLicense.GPL);
using (rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(file, vesion, false);
for (int i = 1; i <= rasterizer.PageCount; i++)
{
img = rasterizer.GetPage(200, 200, i);
Bitmap b = new Bitmap(img, new System.Drawing.Size(1654, 2339));
output.Add(b);
}
rasterizer.Close();
}
return(output);
}
public IEnumerable <Bitmap> Render(string path)
{
ThrowIfCantRender();
// TODO: Maybe allow this to be configured
int dpi = ScanDpi.Dpi300.ToIntDpi();
using (var doc = PdfReader.Open(path, PdfDocumentOpenMode.InformationOnly))
{
// Cap the resolution to 10k pixels in each dimension
dpi = Math.Min(dpi, (int)(10000 / doc.Pages[0].Height.Inch));
dpi = Math.Min(dpi, (int)(10000 / doc.Pages[0].Width.Inch));
}
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.SafeSetResolution(dpi, dpi);
yield return(bitmap);
}
}
}
/// <summary>
/// Convert a PDF to PNG-files, and a thumbnail for each PNG.
/// Using GhostScript.NET.
/// </summary>
/// <param name="imagePath">Desired path where files will be saved</param>
/// /// <param name="imageName">Desired name on the image files</param>
/// <param name="dpi">Desired dpi. 100-600 is normal. The higher dpi, the bigger file, and slower converting.</param>
/// <param name="heightResolution">Set desired height Resolution</param>
/// <param name="widthResolution">Set desired width Resolution</param>
/// <param name="file">pdf file send as HttpPostedFileBase</param>
public static void Pdf2Png(string imagePath, string imageName, int dpi, int heightResolution, int widthResolution, Stream pdfFile)
{
if (pdfFile != null)
{
string outputFolder = imagePath;
var xDpi = dpi;
var yDpi = dpi;
using (var rasterizer = new GhostscriptRasterizer()) //create an instance for GhostscriptRasterizer
{
rasterizer.Open(pdfFile);
var numberOfPages = rasterizer.PageCount;
for (int i = 1; i < numberOfPages + 1; i++)
{
var outputPNGPath = Path.Combine(outputFolder, string.Format("{0}.png", imageName + i.ToString("D2")));
var outputPNGThumbnailPath = Path.Combine(outputFolder, string.Format("Thumbnail_{0}.png", imageName + i.ToString("D2")));
var pdf2PNG = rasterizer.GetPage(xDpi, yDpi, i);
Bitmap bitmap = new Bitmap(pdf2PNG, new Size(widthResolution, heightResolution));
Bitmap thumbnailBitMap = new Bitmap(pdf2PNG, new Size(320, 180));
bitmap.Save(outputPNGPath, ImageFormat.Png);
thumbnailBitMap.Save(outputPNGThumbnailPath, ImageFormat.Png);
}
}
}
}
public static byte[] PdfToTiff(Stream data, int i, string datafilelocation)
{
string path64 = (SolutionPath + "\\gsdll64.dll");
string path32 = (SolutionPath + "\\gsdll32.dll");
try
{
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(path64);
using (var pdfengine = new GhostscriptRasterizer())
{
pdfengine.Open(data, gvi, true);
var image = pdfengine.GetPage(300, 300, i);
var outputPngPath = Path.Combine(string.Format(datafilelocation, i, "tiff"));
var result = new MemoryStream();
image.Save(result, System.Drawing.Imaging.ImageFormat.Tiff);
result.Position = 0;
return(result.ToArray());
}
}
catch
{
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(path32);
using (var pdfengine = new GhostscriptRasterizer())
{
pdfengine.Open(data, gvi, true);
var image = pdfengine.GetPage(300, 300, i);
var outputPngPath = Path.Combine(string.Format(datafilelocation, i, "tiff"));
var result = new MemoryStream();
image.Save(result, System.Drawing.Imaging.ImageFormat.Tiff);
result.Position = 0;
return(result.ToArray());
}
}
}
private void Export(string inputPDFFile, string outputImagesPath)
{
try
{
GhostscriptVersionInfo _lastInstalledVersion = null;
GhostscriptRasterizer _rasterizer = null;
int desired_x_dpi = 96;
int desired_y_dpi = 96;
_lastInstalledVersion =
GhostscriptVersionInfo.GetLastInstalledVersion(
GhostscriptLicense.GPL | GhostscriptLicense.AFPL,
GhostscriptLicense.GPL);
_rasterizer = new GhostscriptRasterizer();
_rasterizer.Open(inputPDFFile, _lastInstalledVersion, false);
for (int pageNumber = 1; pageNumber <= _rasterizer.PageCount; pageNumber++)
{
string pageFilePath = Path.Combine(outputImagesPath, "Page-" + pageNumber.ToString("00") + ".jpg");
Image img = _rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
img.Save(pageFilePath, ImageFormat.Jpeg);
}
_rasterizer.Dispose();
}
catch
{
}
}
private static void PdfToPng(string inputFile, string outputPath)
{
var xDpi = 300; var yDpi = 300;
if (Path.GetExtension(inputFile) != ".pdf")
{
return;
}
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputFile);
int pages = rasterizer.PageCount;
for (int pageNumber = 1; pageNumber <= pages; pageNumber++)
{
var outputPNGPath = Path.Combine(outputPath,
Path.GetFileNameWithoutExtension(inputFile) + "00" + pageNumber.ToString() + ".tif");
Console.WriteLine(outputPNGPath);
var pdf2PNG = rasterizer.GetPage(xDpi, yDpi, pageNumber);
pdf2PNG.Save(outputPNGPath, ImageFormat.Tiff);
}
}
}
private static void ConvertPdfToImage(ConvertPdfOptions options)
{
string dll = GetGhostScriptDllPath();
GhostscriptVersionInfo version = new GhostscriptVersionInfo(new System.Version(0, 0, 0), dll, string.Empty, GhostscriptLicense.GPL);
using (GhostscriptRasterizer gs = new GhostscriptRasterizer())
{
gs.Open(options.inputFile, version, false);
if (gs.PageCount > 0)
{
int dpi = options.quality * 3;
using (Image image = gs.GetPage(dpi, dpi, options.pageNumber))
{
int imageWidth = image.Width;
if (options.maxWidth > 0 && options.maxWidth < imageWidth)
{
double ratio = (double)options.maxWidth / imageWidth;
int maxHeight = Convert.ToInt32(Math.Round(ratio * image.Height));
using (Image thumb = ResizeImage(image, options.maxWidth, maxHeight))
{
SaveImage(thumb, options.outputFile);
}
}
else
{
SaveImage(image, options.outputFile);
}
}
}
gs.Close();
}
}
void PdfToJpg(string inputFile, string outputFileName)
{
string msg = "Invalid numeric value";
int dpi = ParseInt(txtDpi.Text, out bool valid);
if (!valid)
{
LogError(msg);
return;
}
var xDpi = dpi; //set the x DPI
var yDpi = dpi; //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
Console.WriteLine("In Path: " + inputFile);
Console.WriteLine("In Count: " + rasterizer.PageCount.ToString());
//set the output image(png's) complete path
var outputPNGPath = Path.Combine(outputFolder, string.Format("{0}.jpg", outputFileName));
Console.WriteLine("Out: " + Path.Combine(outputFolder, string.Format("{0}.jpg", outputFileName)));
//converts the PDF pages to png's
var pdf2TIF = rasterizer.GetPage(xDpi, yDpi, pageNumber);
//save the png's
pdf2TIF.Save(outputPNGPath, ImageFormat.Jpeg);
Console.WriteLine("Saved " + outputPNGPath);
}
}
public static IEnumerable <Image> PdfToImages(string file, int xDpi = 96, int yDpi = 96, string range = null)
{
using (var rasterizer = new GhostscriptRasterizer())
{
using (FileStream fs = zFile.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
rasterizer.Open(fs);
if (range != null)
{
foreach (int page in zstr.EnumRange(range))
{
yield return(rasterizer.GetPage(xDpi, yDpi, page));
}
}
else
{
for (int page = 1; page <= rasterizer.PageCount; page++)
{
yield return(rasterizer.GetPage(xDpi, yDpi, page));
}
}
}
}
}
public ActionResult GenerateJpeg(string signature)
{
MemoryStream pdfStream = this.CreateSignedPDF(signature);
int desired_x_dpi = 96;
int desired_y_dpi = 96;
//Reference to Ghostscript
string path = Server.MapPath("~/Libs/gsdll32.dll");
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(@path);
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(pdfStream, gvi, true);
//Only get first page
var img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, 1);
MemoryStream imageStream = new MemoryStream();
img.Save(imageStream, ImageFormat.Jpeg);
pdfStream.Dispose();
var imageContent = imageStream.ToArray();
imageStream.Dispose();
return(File(imageContent, "image/jpeg", "signed.jpeg"));
}
}
public void Start()
{
int desired_x_dpi = 96;
int desired_y_dpi = 96;
string inputPdfPath = @"E:\gss_test\test.pdf";
string outputPath = @"E:\gss_test\output\";
_lastInstalledVersion = GhostscriptVersionInfo.GetLastInstalledVersion();
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
/* MemoryStream usage sample
*
* byte[] buffer = File.ReadAllBytes(inputPdfPath);
* MemoryStream ms = new MemoryStream(buffer);
*
* _rasterizer.Open(ms);
*
*/
rasterizer.Open(inputPdfPath, _lastInstalledVersion, 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 string pdfToJpeg(string inputPdfFullFileName, string outputPath)
{
// dpi = dots per inch i.e. resolution and quality of jpeg to be created
// the higher the dpi the longer the processing time.
int desired_x_dpi = 300;
int desired_y_dpi = 300;
string fileName = Path.GetFileNameWithoutExtension(inputPdfFullFileName);
var outputFullFileName = Path.Combine(outputPath, fileName + ".jpg");
var rasterizer = new GhostscriptRasterizer();
using (rasterizer) {
// open pdf
rasterizer.Open(inputPdfFullFileName);
// rasterize first page at desired dpi
var img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, 1);
// save image
img.Save(outputFullFileName, ImageFormat.Jpeg);
}
return(outputFullFileName);
}
static List <Bitmap> toBitmap(string inputPdfPath, int desired_x_dpi, int desired_y_dpi)
{
string outputPath = @"C:\Users\Josh\Desktop\josh\";
List <Bitmap> bitmaps = new List <Bitmap>();
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputPdfPath);
for (var pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
{
var pageFilePath = Path.Combine(outputPath, string.Format("{0}.bmp", pageNumber));
var img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
Bitmap bmp = new Bitmap(img);
//bmp.RotateFlip(RotateFlipType.Rotate270FlipNone);
//Rectangle rect = new Rectangle (1904, 350, 336, 43);
//bmp = cropBitmap(bmp, rect);
bmp = toGreyScale(bmp);
bmp.Save(pageFilePath);
bitmaps.Add(bmp);
}
}
return(bitmaps);
}
/// <summary>
/// Converts PDF file to OneNote by including an image for each page in the document
/// </summary>
/// <param name="inputFile">PDF document path</param>
/// <param name="outputDir">Directory of the output OneNote Notebook</param>
/// <returns></returns>
public virtual bool ConvertPdfToOneNote(string inputFile, string outputDir)
{
//Get the name of the file
string inputFileName = Path.GetFileNameWithoutExtension(inputFile);
//Create a new OneNote Notebook
var note = new OneNoteGenerator(outputDir);
string notebookId = note.CreateNotebook(GetSupportedInputFormat());
string sectionId = note.CreateSection(inputFileName, notebookId);
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputFile);
for (var i = 1; i <= rasterizer.PageCount; i++)
{
Image img = rasterizer.GetPage(160, 160, i);
MemoryStream stream = new MemoryStream();
img.Save(stream, ImageFormat.Png);
img = Image.FromStream(stream);
string pageId = note.CreatePage(String.Format("Page{0}", i), sectionId);
note.AddImageToPage(pageId, img);
}
}
note.CreateTableOfContentPage(sectionId);
return(true);
}
public List <ImageBinary> Export(Stream streamPDF, List <int> listPage)
{
try
{
GhostscriptVersionInfo _lastInstalledVersion = null;
GhostscriptRasterizer _rasterizer = null;
int desired_x_dpi = 300;
int desired_y_dpi = 300;
_lastInstalledVersion =
GhostscriptVersionInfo.GetLastInstalledVersion(
GhostscriptLicense.GPL | GhostscriptLicense.AFPL,
GhostscriptLicense.GPL);
_rasterizer = new GhostscriptRasterizer();
_rasterizer.Open(streamPDF, _lastInstalledVersion, true);
List <ImageBinary> imgBi = new List <ImageBinary>();
foreach (int pageNumber in listPage)
{
Image img = _rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
imgBi.Add(new ImageBinary {
page_no = pageNumber, img = imageToByteArray(img)
});
}
_rasterizer.Dispose();
return(imgBi);
}
catch
{
return(new List <ImageBinary>());
}
}
public void Start()
{
int desired_x_dpi = 300;
int desired_y_dpi = 300;
string inputPdfPath = @"E:\__test_data\test2.pdf";
string outputPath = @"E:\__test_data\output\";
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
rasterizer.CustomSwitches.Add("-dUseCropBox");
rasterizer.CustomSwitches.Add("-c");
rasterizer.CustomSwitches.Add("[/CropBox [24 72 559 794] /PAGES pdfmark");
rasterizer.CustomSwitches.Add("-f");
rasterizer.Open(inputPdfPath);
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);
}
}
}
static string PDFToImage(MemoryStream inputMS, int dpi)
{
string base64String = "";
GhostscriptRasterizer rasterizer = new GhostscriptRasterizer();
GhostscriptVersionInfo version = new GhostscriptVersionInfo(
new Version(0, 0, 0), @"C:\Program Files\gs\gs9.20\bin\gsdll64.dll",
string.Empty, GhostscriptLicense.GPL
);
try
{
rasterizer.Open(inputMS, version, false);
for (int i = 1; i <= rasterizer.PageCount; i++)
{
MemoryStream ms = new MemoryStream();
Image img = rasterizer.GetPage(dpi, dpi, 1);
img.Save(ms, ImageFormat.Jpeg);
ms.Close();
base64String = Convert.ToBase64String((byte[])ms.ToArray());
}
rasterizer.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
return(base64String);
}
/// <summary>
///
/// </summary>
/// <param name="pdfFile"></param>
/// <param name="pngDir"></param>
/// <returns></returns>
/// <example>
/// @"C:\IMAGES\PORTUGAL\New folder\OA_24993.pdf".DrawToImage("C:\\TEST");
/// </example>
public static List <FileInfo> DrawToImage(this FileInfo pdfFile, int dpi)
{
// @"C:\PROJECTS\VPrint2\Others\gsdll32.dll";
lock (typeof(oLock))
{
GhostscriptVersionInfo gvi = new GhostscriptVersionInfo(sm_DLLPath);
var files = new List <FileInfo>();
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(pdfFile.FullName, gvi, false);
var pngDir = pdfFile.Directory;
for (int i = 1; i <= rasterizer.PageCount; i++)
{
var path = pngDir.CombineFileName(string.Concat(pdfFile.GetFileNameWithoutExtension(), '.', i, ".jpg"));
files.Add(path);
Global.IgnoreList.Add(path.FullName);
using (Image img = rasterizer.GetPage(dpi, dpi, i))
img.Save(path.FullName, ImageFormat.Jpeg);
}
return(files);
}
}
}
public void Sample2()
{
int desired_dpi = 96;
string inputPdfPath = @"E:\gss_test\test.pdf";
string outputPath = @"E:\gss_test\output\";
var output = new DelegateStdIOHandler(
stdOut: Console.WriteLine,
stdErr: Console.WriteLine
);
using (var rasterizer = new GhostscriptRasterizer(output))
{
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);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <returns>List Mat</returns>
public List <IImage> GetImages(string path)
{
try
{
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(path, _ghostScript, false);
List <IImage> imgs = new List <IImage>();
for (int i = 1; i <= rasterizer.PageCount; i++)
{
using (Image pdf2PNG = rasterizer.GetPage(300, 300, i))
{
string tmpFileName = _tempFiles.PrepateFileLocation();
string fullPath = _tempFiles.GetFullPath(tmpFileName);
pdf2PNG.Save(fullPath, ImageFormat.Png);
imgs.Add(new Mat(fullPath));
_tempFiles.DeleteFile(tmpFileName);
}
}
return(imgs);
}
}
catch (Ghostscript.NET.GhostscriptLibraryNotInstalledException e)
{
Debug.WriteLine(e.Message);
return(null);
}
}
/// <summary>
/// Converts given PDF file to any image format
/// </summary>
/// <param name="inputPdfPath">Initial pdf file full path</param>
/// <param name="fileName">pdf file name</param>
/// <param name="outputPath">destination path for saving converted image</param>
/// <param name="imageFormat">image format: bmp, jpg, etc.</param>
/// <returns></returns>
public List <string> Convert(string inputPdfPath, string fileName, string outputPath, ImageFormat imageFormat)
{
int desired_x_dpi = 96;
int desired_y_dpi = 96;
var convertedImages = new List <string>();
_lastInstalledVersion =
GhostscriptVersionInfo.GetLastInstalledVersion(
GhostscriptLicense.GPL | GhostscriptLicense.AFPL,
GhostscriptLicense.GPL);
_rasterizer = new GhostscriptRasterizer();
_rasterizer.Open(inputPdfPath, _lastInstalledVersion, false);
for (int pageNumber = 1; pageNumber <= _rasterizer.PageCount; pageNumber++)
{
var pageFileName = string.Format("{0}-Page-{1}.{2}", fileName, pageNumber, imageFormat); //fileName + "-Page-" + pageNumber.ToString() + "." + imageFormat;
var pageFilePath = Path.Combine(outputPath, pageFileName);
Image img = _rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber);
img.Save(pageFilePath, imageFormat);
convertedImages.Add(pageFilePath);
}
return(convertedImages);
}
public static BinaryFile ConvertPDFToImage(BinaryFile inputFile)
{
int desired_x_dpi = 96;
int desired_y_dpi = 96;
using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(inputFile.ContentStream);
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());
}
public int GetPageCount(string inputfile)
{
using (var _rasterizer = new GhostscriptRasterizer())
{
_rasterizer.Open(inputfile, GetGhostscriptVersion(), false);
return(_rasterizer.PageCount);
}
}
private static Image GetImage(byte[] pdfBytes)
{
using (var rasterizer = new GhostscriptRasterizer())
{
rasterizer.Open(new MemoryStream(pdfBytes), new GhostscriptVersionInfo("gsdll64.dll"), false);
return(rasterizer.GetPage(72, 72, 1));
}
}
