static void Main(string[] args)
{
Console.WriteLine("GetSeparatedImages Sample:");
String sInput = "../../Resources/Sample_Input/ducky.pdf";
String sOutput = "../GetSeparatedImages-out.tiff";
if (args.Length > 0)
{
sInput = args[0];
}
if (args.Length > 1)
{
sOutput = args[1];
}
Console.WriteLine("Input file: " + sInput + ", will write to " + sOutput);
using (Library lib = new Library())
{
Document doc = new Document(sInput);
Page pg = doc.GetPage(0);
// Get all inks that are present on the page
List <Ink> inks = (List <Ink>)pg.ListInks();
List <SeparationColorSpace> colorants = new List <SeparationColorSpace>();
// Here we decide, which inks should be drawn
foreach (Ink theInk in inks)
{
// note: if the Ink can't be found in page's resources,
// default tintTransform and alternate will be used
colorants.Add(new SeparationColorSpace(pg, theInk));
}
PageImageParams pip = new PageImageParams();
pip.HorizontalResolution = 300;
pip.VerticalResolution = 300;
ImageCollection images = pg.GetImageSeparations(pg.CropBox, pip, colorants);
// Save images as multi-paged tiff - each page is a separated color from the page bitmap.
images.Save(sOutput, ImageType.TIFF);
}
}
private string UploadFile(HttpContext context, string filename)
{
string msg = "";
HttpPostedFile file = context.Request.Files[0];
byte[] fileBytes = new byte[file.ContentLength];
file.InputStream.Read(fileBytes, 0, file.ContentLength);
using (FileStream outStream = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite))
{
using (MemoryStream ms = new MemoryStream())
{
ms.Write(fileBytes, 0, fileBytes.Length);
ms.Position = 0;
try
{
ImageDecoder decoder = RegisteredDecoders.GetDecoder(ms);
if (decoder is TiffDecoder)
{
outStream.Write(fileBytes, 0, fileBytes.Length);
outStream.Position = 0;
}
else
{
ImageCollection ic = new ImageCollection(ms, null);
TiffEncoder tiffEncoder = new TiffEncoder();
ic.Save(outStream, tiffEncoder, null);
}
}
catch (Exception ex)
{
msg = ex.Message;
}
ms.Position = 0;
}
}
return(msg);
}
public void export_doc_images_type(Document doc, ImageType imtype)
{
exporttype = imtype;
int pgno;
for (pgno = 0; pgno < doc.NumPages; pgno++)
{
Page pg = doc.GetPage(pgno);
Content content = pg.Content;
Export_Element_Images(content);
}
if (ic.Count != 0)
{
try
{
ic.Save("ImageExport-page" + pgno + "-out.tif", ImageType.TIFF);
}
catch (Exception ex)
{
Console.WriteLine("Cannot write file: " + ex.Message);
}
}
}
static void Main(string[] args)
{
string docpath;
Console.WriteLine("PDF Document to Images Sample:");
if (args.Length < 2)
{
Usage();
Environment.Exit(1);
}
DocToImagesOptions options = new DocToImagesOptions();
if (args[args.Length - 1].StartsWith("-") || args[args.Length - 1].Contains("="))
{
Console.WriteLine("The last option must be the path to a PDF file.");
Usage();
Environment.Exit(1);
}
for (int i = 0; i < args.Length - 1; i++)
{
String arg = args[i];
if (arg.StartsWith("-") && arg.Contains("="))
{
String opt = arg.Substring(arg.IndexOf("=") + 1);
if (arg.StartsWith("-format="))
{
// Process output format option
if (opt.Equals("jpg"))
{
options.setoutputformat(ImageType.JPEG);
}
else if (opt.Equals("tif"))
{
options.setoutputformat(ImageType.TIFF);
}
else if (opt.Equals("bmp"))
{
options.setoutputformat(ImageType.BMP);
}
else if (opt.Equals("png"))
{
options.setoutputformat(ImageType.PNG);
}
else if (opt.Equals("gif"))
{
options.setoutputformat(ImageType.GIF);
}
else
{
Console.WriteLine("Invalid value for the format option. Valid values are jpg, tif, bmp, png, gif");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-color="))
{
// Process output color option
if (opt.Equals("gray"))
{
options.setcolor(ColorSpace.DeviceGray);
}
else if (opt.Equals("rgb"))
{
options.setcolor(ColorSpace.DeviceRGB);
}
else if (opt.Equals("cmyk"))
{
options.setcolor(ColorSpace.DeviceCMYK);
}
else
{
Console.WriteLine("Invalid value for the color option. Valid values are gray, rgb, cmyk");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-grayhalftone="))
{
// Process grayscale half tone
if (opt.Equals("y"))
{
options.setgrayhalftone(true);
}
else if (opt.Equals("n"))
{
options.setgrayhalftone(false);
}
else
{
Console.WriteLine("Invalid value for the grayhalftone option. Valid values are n or y");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-first="))
{
// Process first page only option
if (opt.Equals("y"))
{
options.setfirst(true);
}
else if (opt.Equals("n"))
{
options.setfirst(false);
}
else
{
Console.WriteLine("Invalid value for the first option. Valid values are 'y' and 'n'.");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-quality="))
{
// Process jpeg quality option
int quality = int.Parse(opt);
if (quality < 1 || 1 > 100)
{
Console.WriteLine("Invalid value for the quality option. Valid values are 1 through 100.");
Environment.Exit(1);
}
options.setquality(quality);
continue;
}
if (arg.Contains("resolution="))
{
// Process horizontal and/or vertical resolution option
if (opt.Contains("x"))
{
string hopt = opt.Substring(0, opt.IndexOf("x"));
String vopt = opt.Substring(opt.IndexOf("x") + 1);
options.sethres(double.Parse(hopt));
options.setvres(double.Parse(vopt));
}
else
{
double res = double.Parse(opt);
options.sethres(res);
options.setvres(res);
}
continue;
}
if (arg.StartsWith("-fontlist="))
{
// process font search directory list option
options.setfontdirs(opt);
continue;
}
if (arg.StartsWith("-pixels="))
{
// process size in pixels option
if (opt.Contains("x"))
{
string hopt = opt.Substring(0, opt.IndexOf("x"));
String vopt = opt.Substring(opt.IndexOf("x") + 1);
options.sethpixels(int.Parse(hopt));
options.setvpixels(int.Parse(vopt));
}
else
{
int pixels = int.Parse(opt);
options.sethpixels(pixels);
options.setvpixels(pixels);
}
continue;
}
if (arg.StartsWith("-compression="))
{
// process TIFF compression option
if (opt.Equals("no"))
{
options.setcompress(CompressionCode.NONE);
}
else if (opt.Equals("lzw"))
{
options.setcompress(CompressionCode.LZW);
}
else if (opt.Equals("g3"))
{
options.setcompress(CompressionCode.G3);
}
else if (opt.Equals("g4"))
{
options.setcompress(CompressionCode.G4);
}
else if (opt.Equals("flate"))
{
options.setcompress(CompressionCode.FLATE);
}
else if (opt.Equals("dct"))
{
options.setcompress(CompressionCode.DCT);
}
else if (opt.Equals("default"))
{
options.setcompress(CompressionCode.Default);
}
else if (opt.Equals("none"))
{
options.setcompress(CompressionCode.NONE);
}
else
{
Console.WriteLine("Invalid value for the compression option. Valid values are: no|lzw|g3|g4|jpg");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-region="))
{
// process page output region option
if (!(opt.Equals("crop") || opt.Equals("media") || opt.Equals("art") ||
opt.Equals("trim") || opt.Equals("bleed") || opt.Equals("bounding")))
{
Console.WriteLine("Invalid value for the region option. Value values are: crop|media|art|trim|bleed|bounding");
Environment.Exit(1);
}
options.setpageregion(opt);
continue;
}
if (arg.Contains("pages="))
{
// process pages to be rasterized list option
if (opt.Equals("even"))
{
options.setevenpages();
}
else if (opt.Equals("odd"))
{
options.setoddpages();
}
else
{
/*
* Get the comma separated page groups and check each
* for page ranges. If page ranges exist then create the
* range using the page numbers on either side of the '-' as
* the lower and upper bound.
*/
string[] pagegroups = opt.Split(',');
for (int ix = 0; ix < pagegroups.Length; ix++)
{
string pagegroup = pagegroups[ix];
if (pagegroup.Contains("-"))
{
string[] pagerange = pagegroup.Split('-');
if (pagerange.Length != 2 || pagerange[0].Equals("") || pagerange[1].Equals(""))
{
Console.WriteLine("Misformatted page range: " + pagegroup);
Environment.Exit(1);
}
else
{
for (int z = int.Parse(pagerange[0]); z <= int.Parse(pagerange[1]); z++)
{
options.appendpagelist(z);
}
}
}
else
{
int printpage = int.Parse(pagegroup);
options.appendpagelist(printpage);
}
}
}
continue;
}
if (arg.StartsWith("-output="))
{
// process output filename option
options.setoutputfile(opt);
continue;
}
if (arg.StartsWith("-smoothing="))
{
// process smoothing option none|text|all
if (opt.Equals("none"))
{
options.setsmooth(SmoothFlags.None);
}
else if (opt.Equals("text"))
{
options.setsmooth(SmoothFlags.Text);
}
else if (opt.Equals("all"))
{
options.setsmooth(SmoothFlags.Image | SmoothFlags.LineArt | SmoothFlags.Text);
}
else
{
Console.WriteLine("Invalid value for the smoothing option. Valid values are none|text|all");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-reverse="))
{
// process gray reverse option
if (opt.Equals("y"))
{
options.setreversegray(true);
}
else if (opt.Equals("n"))
{
options.setreversegray(false);
}
else
{
Console.WriteLine("Invalid value for the reverse option. Valid values are 'y' and 'n'.");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-blackisone="))
{
// Photometrically reverse Tiff option
if (opt.Equals("y"))
{
options.setblackisone(true);
}
else if (opt.Equals("n"))
{
options.setblackisone(false);
}
else
{
Console.WriteLine("Invalid value for the blackisone option. Valid values are 'y' and 'n'.");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-multi="))
{
// process multipage tif option
if (opt.Equals("y"))
{
options.setmultipage(true);
}
else if (opt.Equals("n"))
{
options.setmultipage(false);
}
else
{
Console.WriteLine("Invalid value for the multi option. Valid values are 'y' and 'n'.");
Environment.Exit(1);
}
continue;
}
if (arg.StartsWith("-digits="))
{
// process fixed digit suffix length option
int numdigits = int.Parse(opt);
if (numdigits < 0 || numdigits > 9)
{
Console.WriteLine("Invalid value for the digits option. Valid values are 0-9.");
}
options.setZeroSuffix(numdigits);
continue;
}
if (arg.StartsWith("-asprinted="))
{
// process render only printable annotations option
if (opt.Equals("y"))
{
options.setasprinted(true);
}
else if (opt.Equals("n"))
{
options.setasprinted(false);
}
else
{
Console.WriteLine("Invalid value for the asprinted option. Valid values are 'y' and 'n'.");
Environment.Exit(1);
}
continue;
}
Console.WriteLine("Invalid option: " + arg);
Usage();
Environment.Exit(1);
}
else
{
Console.WriteLine("Invalid option: " + arg);
Usage();
Environment.Exit(1);
}
}
docpath = args[args.Length - 1];
// Now crosscheck and verify the combinations of the options we have entered.
int errorcount = 0;
if (options.checkformattype() == false)
{
Console.WriteLine("format must be set to tif, jpg, bmp, png, or gif");
errorcount++;
}
if (options.checkcolorspacegrayhalftone() == false)
{
Console.WriteLine("grayhalftone can only be set to 1 for a value of 'gray' for color");
errorcount++;
}
if (options.checkformatcompressiontiff() == false)
{
Console.WriteLine("Compression can only be this value for a format value of 'tif'");
errorcount++;
}
if (options.checkformatcompressionpng() == false)
{
Console.WriteLine("Compression can only be this value for a format value of 'png'");
errorcount++;
}
if (options.checkformatcompressionjpg() == false)
{
Console.WriteLine("Compression can only be this value for a format value of 'jpg'");
errorcount++;
}
if (options.checkcompressionnone() == false)
{
Console.WriteLine("Compression can only be this value for a format value of 'bmp' or 'png' or 'tif'");
errorcount++;
}
if (options.checkreversegray() == false)
{
Console.WriteLine("reverse can only be set to 'y' for a value of 'gray' for color");
errorcount++;
}
if (options.checkblackisoneformat() == false)
{
Console.WriteLine("blackisone can only be set to 'y' for a format value of 'tif'");
errorcount++;
}
if (options.checktiffcompressgrayhalftone() == false)
{
Console.WriteLine("compression can only be set to 'g3' or 'g4' if grayhalftone is set to 'y' and color is set to 'gray'");
errorcount++;
}
if (options.checkgrayhalftoneformat() == false)
{
Console.WriteLine("grayhalftone can only be set to 'y' for format set to tif");
errorcount++;
}
if (options.checkqualityimagetype() == false)
{
Console.WriteLine("quality can only be set to a value other than 0 for a format value of 'jpg'");
errorcount++;
}
if (options.checkfirstonlypagerange() == false)
{
Console.WriteLine("The pages option cannot be specified if firstonly is set to 'y'");
errorcount++;
}
if (options.checkfirstonlyevenodd() == false)
{
Console.WriteLine("The pages option cannot be set to 'even' or 'odd' if firstonly is set to 'y'");
errorcount++;
}
if (options.checkmultiformat() == false)
{
Console.WriteLine("The multi option can only be set to 'y' if format is set to 'tif'");
errorcount++;
}
if (options.checkfontdirs() != true)
{
errorcount++;
}
if (errorcount > 0)
{
Console.WriteLine("Because of command line option errors, no image processing will be performed.");
Environment.Exit(1);
}
using (Library lib = new Library(options.getfontdirs()))
{
Document pdfdocument = null;
int numpages = 0;
List <int> pagelist = new List <int>(0);
try
{
pdfdocument = new Document(docpath);
numpages = pdfdocument.NumPages;
}
catch (Exception ex)
{
Console.WriteLine("Error opening PDF document " + docpath + ":" + ex.Message);
Environment.Exit(1);
}
/*
* Now that we know we can open the PDF file, use the filename to create what will be the basis
* of the output filename and directory name.
*/
string outputfilename;
if (options.getoutputfile() == "")
{
outputfilename = docpath;
}
else
{
outputfilename = options.getoutputfile();
}
options.setoutputdir(System.IO.Path.GetDirectoryName(outputfilename));
string[] basefilename = System.IO.Path.GetFileName(outputfilename).Split('.'); // split off the .pdf suffix.
options.setoutputfile(basefilename[0]);
if (options.checkpagelist(numpages) == false)
{
Console.WriteLine("The list of pages given in the 'pages' option is outside the number of pages in this PDF document: " + pdfdocument.NumPages);
Environment.Exit(1);
}
/*
* If the list of pages were not populated from the command line options, or if the options have specified
* all odd or all even, then populate the list here and then reget the list.
*/
pagelist = options.getpagelist();
if (pagelist.Count == 0)
{
if (options.getfirst() == true) // First page only.
{
numpages = 1; // Will modify the operation of the loop below.
}
for (int i = 0; i < numpages; i++)
{
// Remember in the Doc object page #'s start with 0, but physically they start with 1.
if ((options.onlyodd() == false && options.onlyeven() == false) || // all pages
(options.onlyodd() == true && (((i + 1) % 2) == 1)) || // this is an odd page
(options.onlyeven() == true && (((i + 1) % 2) == 0))) // this is an even page
{
options.appendpagelist(i);
}
}
pagelist = options.getpagelist();
}
PageImageParams pip = new PageImageParams(options.getcolor(), options.getsmooth(), options.gethpixels(),
options.getvpixels(), options.gethres(), options.getvres(),
(DrawFlags.UseAnnotFaces | DrawFlags.DoLazyErase));
if (options.getasprinted() == true)
{
pip.PageDrawFlags |= DrawFlags.IsPrinting;
}
ImageCollection Pageimagecollection = new ImageCollection();
if (options.getoutputformat() == ImageType.TIFF && options.getcompress() == CompressionCode.NONE)
{
options.setcompress(CompressionCode.LZW); // Default for TIF
}
ImageSaveParams isp = new ImageSaveParams();
isp.HalftoneGrayImages = options.getgrayhalftone();
isp.Compression = options.getcompress();
if (options.getoutputformat() == ImageType.JPEG)
{
isp.JPEGQuality = options.getquality();
}
isp.ReverseGray = options.getreversegray();
isp.TIFFBlackIsOne = options.getblackisone();
for (int i = 0; i < pagelist.Count; i++) // Get the images of the PDF pages to create an image collection.
{
Page docpage = pdfdocument.GetPage(pagelist[i]);
Rect PageRect = null;
if (options.getpageregion().Equals("crop"))
{
PageRect = docpage.CropBox;
}
else if (options.getpageregion().Equals("media"))
{
PageRect = docpage.MediaBox;
}
else if (options.getpageregion().Equals("art"))
{
PageRect = docpage.ArtBox;
}
else if (options.getpageregion().Equals("bounding"))
{
PageRect = docpage.BBox;
}
else if (options.getpageregion().Equals("bleed"))
{
PageRect = docpage.BleedBox;
}
else if (options.getpageregion().Equals("trim"))
{
PageRect = docpage.TrimBox;
}
else
{
Console.WriteLine("Unknown page region option.");
Environment.Exit(1);
}
try
{
Image pageimage = docpage.GetImage(PageRect, pip);
if (options.getmultipage() == true)
{
Pageimagecollection.Append(pageimage);
}
else
{
int x = i + 1;
saveTheImage(pageimage, x, options, isp);
}
}
catch (Exception ex)
{
Console.WriteLine("Cannot rasterize page to an image: " + ex.Message);
Environment.Exit(1);
}
}
/*
* Pageimagecollection now Contains, as the name states,
* a collection of images created from the PDF pages according
* to the user's options. Now to post process them to the image.
* type according to the user's options.
*/
if (options.getmultipage() == true)
{
string outputfilepath;
if (options.getoutputdir() != "")
{
outputfilepath = options.getoutputdir() + "/" + options.getoutputfile();
}
else
{
outputfilepath = options.getoutputfile();
}
outputfilepath = CreateFileSuffix(outputfilepath, options.getoutputformat());
try
{
Pageimagecollection.Save(outputfilepath, options.getoutputformat(), isp);
}
catch (Exception ex)
{
Console.WriteLine("Cannot save images to a multi-page TIF file: " + ex.Message);
}
}
}
}
private void AttachDocument()
{
Person person = null;
using (personSearchForm = new PersonSearchForm())
{
personSearchForm.ShowDialog();
person = personSearchForm.SelectedPerson;
personSearchForm.Dispose();
}
if (person != null)
{
this.Cursor = Cursors.WaitCursor;
string userName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
myDocType docType = (myDocType)getCheckedMenuItem(miDocumentType).Tag;
PersonAttribute pa = new PersonAttribute(person.PersonID, docType.AttributeId);
if (pa.IntValue == -1 ||
MessageBox.Show(
string.Format("{0} already has a {1} document associated with their record. Do you want to overwrite the existing document?", person.NickName, docType.TypeName),
"Document Already Exists", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == System.Windows.Forms.DialogResult.Yes)
{
Arena.Utility.ArenaDataBlob blob = new Arena.Utility.ArenaDataBlob(pa.IntValue);
Atalasoft.Imaging.Codec.Pdf.PdfEncoder pdf = new Atalasoft.Imaging.Codec.Pdf.PdfEncoder();
pdf.Metadata = new Atalasoft.Imaging.Codec.Pdf.PdfMetadata(
person.FullName, "", docType.DocType.TypeName,
"", organization.Name, "", DateTime.Now, DateTime.Now);
string fileName = string.Format("{0}_{1}.pdf",
person.FullName.Replace(" ", ""),
docType.TypeName.Replace(" ", ""));
blob.SetFileInfo(fileName);
using (MemoryStream ms = new MemoryStream())
{
ScannedImages.Save(ms, pdf, null);
blob.ByteArray = ms.ToArray();
ms.Close();
}
blob.Cache = false;
blob.DocumentTypeID = docType.DocType.DocumentTypeId;
blob.Title = docType.DocType.TypeName;
pa.IntValue = blob.Save(userName);
pa.PersonID = person.PersonID;
pa.AttributeId = docType.AttributeId;
pa.Save(organizationID, userName);
PersonDocument pDoc = new PersonDocument(person.PersonID, pa.IntValue);
pDoc.PersonID = person.PersonID;
pDoc.DocumentID = pa.IntValue;
pDoc.SaveRelationship(userName);
ScannedImages.Clear();
tViewer.Items.Clear();
RefreshView();
}
this.Cursor = Cursors.Default;
}
}