Example #1
0
        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);
                    }
                }
            }
        }
Example #5
0
        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;
            }
        }