Beispiel #1
0
        public override IEnumerable <LocalRenderingExtensionInfo> ListRenderingExtensions()
        {
            if (m_renderingExtensions == null)
            {
                List <LocalRenderingExtensionInfo> list = new List <LocalRenderingExtensionInfo>();
                RPLRenderer rPLRenderer = new RPLRenderer();
                list.Add(new LocalRenderingExtensionInfo("RPL", rPLRenderer.LocalizedName, isVisible: false, typeof(RPLRenderer), isExposedExternally: false));
                ExcelRenderer excelRenderer = new ExcelRenderer();
                list.Add(new LocalRenderingExtensionInfo("Excel", excelRenderer.LocalizedName, isVisible: false, typeof(ExcelRenderer), isExposedExternally: true));
                ExcelOpenXmlRenderer excelOpenXmlRenderer = new ExcelOpenXmlRenderer();
                list.Add(new LocalRenderingExtensionInfo("EXCELOPENXML", excelOpenXmlRenderer.LocalizedName, isVisible: true, typeof(ExcelOpenXmlRenderer), isExposedExternally: true));
                ImageRenderer imageRenderer = new ImageRenderer();
                list.Add(new LocalRenderingExtensionInfo("IMAGE", imageRenderer.LocalizedName, isVisible: false, typeof(ImageRenderer), isExposedExternally: true));
                PDFRenderer pDFRenderer = new PDFRenderer();
                list.Add(new LocalRenderingExtensionInfo("PDF", pDFRenderer.LocalizedName, isVisible: true, typeof(PDFRenderer), isExposedExternally: true));
                WordDocumentRenderer wordDocumentRenderer = new WordDocumentRenderer();
                list.Add(new LocalRenderingExtensionInfo("WORD", wordDocumentRenderer.LocalizedName, isVisible: false, typeof(WordDocumentRenderer), isExposedExternally: true));
                WordOpenXmlDocumentRenderer wordOpenXmlDocumentRenderer = new WordOpenXmlDocumentRenderer();
                list.Add(new LocalRenderingExtensionInfo("WORDOPENXML", wordOpenXmlDocumentRenderer.LocalizedName, isVisible: true, typeof(WordOpenXmlDocumentRenderer), isExposedExternally: true));

                list.Add(new LocalRenderingExtensionInfo("MHTML", new ReportingServices.Rendering.HtmlRenderer.MHtmlRenderingExtension().LocalizedName, isVisible: true, typeof(ReportingServices.Rendering.HtmlRenderer.MHtmlRenderingExtension), isExposedExternally: true));
                list.Add(new LocalRenderingExtensionInfo("HTML4.0", new ReportingServices.Rendering.HtmlRenderer.Html40RenderingExtension().LocalizedName, isVisible: true, typeof(ReportingServices.Rendering.HtmlRenderer.Html40RenderingExtension), isExposedExternally: true));
                list.Add(new LocalRenderingExtensionInfo("HTML5", new ReportingServices.Rendering.HtmlRenderer.Html5RenderingExtension().LocalizedName, isVisible: true, typeof(ReportingServices.Rendering.HtmlRenderer.Html5RenderingExtension), isExposedExternally: true));

                m_renderingExtensions = list;
            }
            return(m_renderingExtensions);
        }
Beispiel #2
0
        public static void TestTextExtraction()
        {
            PDFRenderer renderer = new PDFRenderer(TEST_PDF_FILENAME, null, null);

            renderer.OnPageTextAvailable += PageTextReady;

            while (true)
            {
                renderer.FlushCachedTexts();

                for (int i = 0; i < 8; ++i)
                {
                    try
                    {
                        string filename = renderer.PDFRendererFileLayer.MakeFilename_TextSingle(i);
                        if (File.Exists(filename))
                        {
                            File.Delete(filename);
                        }
                    }
                    catch (Exception)
                    {
                    }

                    WordList text = renderer.GetOCRText(i);
                }

                Thread.Sleep(100);
            }
        }
Beispiel #3
0
        public bool ConvertToImage(string outputFile, int pageNumber)
        {
            try
            {
                try
                {
                    ImageType bINARY = null;
                    switch (this.OutputImageColor)
                    {
                    case PDF2Image.PDF2ImageColor.BINARY:
                    {
                        bINARY = ImageType.BINARY;
                        break;
                    }

                    case PDF2Image.PDF2ImageColor.GRAY:
                    {
                        bINARY = ImageType.GRAY;
                        break;
                    }

                    case PDF2Image.PDF2ImageColor.RGB:
                    {
                        bINARY = ImageType.RGB;
                        break;
                    }

                    case PDF2Image.PDF2ImageColor.ARGB:
                    {
                        bINARY = ImageType.ARGB;
                        break;
                    }
                    }
                    PDFHelper.CheckOutputFolder(PDF2Image.TempPath);
                    bool flag = true;
                    this.startPage = Math.Max(this.startPage, 1);
                    if (this.endPage < 0)
                    {
                        this.endPage = this.pdfDocument.getNumberOfPages();
                    }
                    this.endPage = Math.Min(this.endPage, this.pdfDocument.getNumberOfPages());
                    PDFRenderer   pDFRenderer   = new PDFRenderer(this.pdfDocument);
                    BufferedImage bufferedImage = null;
                    bufferedImage = (bINARY != null ? pDFRenderer.renderImageWithDPI(pageNumber - 1, (float)this.dpi, bINARY) : pDFRenderer.renderImageWithDPI(pageNumber - 1, (float)this.dpi));
                    flag          = flag & ImageIOUtil.writeImage(bufferedImage, outputFile, this.dpi);
                }
                catch (Exception exception1)
                {
                    Exception exception = exception1;
                    throw new PDFToolkitException(exception.Message, exception);
                }
            }
            finally
            {
                PDFHelper.EmptyDirectory(PDF2Image.TempPath);
            }
            return(true);
        }
        public PDFPrinterDocumentPaginator(PDFDocument pdf_document, PDFRenderer pdf_renderer, int page_from, int page_to, Size page_size)
        {
            this.pdf_document = pdf_document;
            this.pdf_renderer = pdf_renderer;
            this.page_from    = page_from;
            this.page_to      = page_to;
            this.page_size    = page_size;

            StatusManager.Instance.ClearCancelled("PDFPrinter");
        }
Beispiel #5
0
        private void SetPage(int page)
        {
            PDFRenderer renderer = new PDFRenderer();

            int width  = _document.GetPageWidth(_currentPage);
            int height = _document.GetPageHeight(_currentPage);

            _rawImage.texture = renderer.RenderPageToTexture(_document.GetPage(_currentPage), width, height);

            _aspectRatioFitter.aspectRatio = ((float)width / (float)height);
        }
        /// <summary>
        /// Starts a thread that periodically polls the <see cref="Context"/> to determine how much memory it is using in the asset cache store.
        /// </summary>
        private void UIUpdater()
        {
            Grid        cacheFillGrid   = this.FindControl <Grid>("CacheFillGrid");
            Canvas      cacheFillCanvas = this.FindControl <Canvas>("CacheFillCanvas");
            PDFRenderer renderer        = this.FindControl <PDFRenderer>("MuPDFRenderer");

            Thread thr = new Thread(async() =>
            {
                //Keep running until the window is closed.
                while (!ClosedHandle.WaitOne(0))
                {
                    if (Context != null)
                    {
                        long currentSize = Context.StoreSize;
                        long maxSize     = Context.StoreMaxSize;

                        double perc = (double)currentSize / (double)maxSize;

                        await Dispatcher.UIThread.InvokeAsync(() =>
                        {
                            cacheFillGrid.ColumnDefinitions[0] = new ColumnDefinition(perc, GridUnitType.Star);
                            cacheFillGrid.ColumnDefinitions[1] = new ColumnDefinition(1 - perc, GridUnitType.Star);

                            ToolTip.SetTip(cacheFillGrid, perc.ToString("0%") + " (" + Math.Round(currentSize / 1024.0 / 1024.0).ToString("0") + "/" + Math.Round(maxSize / 1024.0 / 1024.0).ToString("0") + "MiB)");

                            if (perc <= 0.5)
                            {
                                cacheFillCanvas.Background = new SolidColorBrush(Color.FromRgb(187, 204, 51));
                            }
                            else if (perc <= 0.75)
                            {
                                cacheFillCanvas.Background = new SolidColorBrush(Color.FromRgb(238, 221, 136));
                            }
                            else
                            {
                                cacheFillCanvas.Background = new SolidColorBrush(Color.FromRgb(238, 136, 102));
                            }

                            //The update does not need to have a high priority.
                        }, DispatcherPriority.MinValue);
                    }
                    else
                    {
                        cacheFillGrid.ColumnDefinitions[0] = new ColumnDefinition(0, GridUnitType.Star);
                        cacheFillGrid.ColumnDefinitions[1] = new ColumnDefinition(1, GridUnitType.Star);
                    }

                    //We don't need to keep polling too often.
                    Thread.Sleep(2000);
                }
            });

            thr.Start();
        }
        public static IEnumerator UpdatePageWithExistingTexture(PDFDocument document, int pageIndex, Texture2D existingTexture, PDFPageTextureHolder[] pageTextureHolderList)
        {
            PDFJS_Promise <PDFPage> pagePromise = document.GetPageAsync(pageIndex);

            while (!pagePromise.HasFinished)
            {
                yield return(null);
            }

            if (pagePromise.HasSucceeded)
            {
                PDFJS_Promise <Texture2D> renderPromise = PDFRenderer.RenderPageToExistingTextureAsync(pagePromise.Result, existingTexture);

                pageTextureHolderList[pageIndex].m_RenderingPromise = renderPromise;

                while (!renderPromise.HasFinished)
                {
                    yield return(null);
                }

                pageTextureHolderList[pageIndex].m_RenderingPromise = null;
                pageTextureHolderList[pageIndex].m_RenderingStarted = false;

                if (renderPromise.HasSucceeded)
                {
                    if (pageTextureHolderList[pageIndex].Texture != null &&
                        pageTextureHolderList[pageIndex].Texture != renderPromise.Result)
                    {
                        UnityEngine.Object.DestroyImmediate(pageTextureHolderList[pageIndex].Texture);
                        Resources.UnloadAsset(pageTextureHolderList[pageIndex].Texture);
                        pageTextureHolderList[pageIndex].Texture = null;
                    }

                    if (pageTextureHolderList[pageIndex].m_Visible)
                    {
                        pageTextureHolderList[pageIndex].Texture = renderPromise.Result;
                    }
                    else
                    {
                        UnityEngine.Object.DestroyImmediate(renderPromise.Result);
                        Resources.UnloadAsset(renderPromise.Result);
                        renderPromise.Result = null;
                    }
                }
            }
            else
            {
                pageTextureHolderList[pageIndex].m_RenderingPromise = null;
                pageTextureHolderList[pageIndex].m_RenderingStarted = false;
            }
        }
Beispiel #8
0
        public void TestOCREngGrayText()
        {
            using (Tesseract ocr = GetTesseract())
                using (Image <Gray, Byte> img = new Image <Gray, byte>(480, 200))
                {
                    ocr.SetVariable("tessedit_char_whitelist", "ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz,");
                    IntPtr oclDevice = new IntPtr();
                    int    deviceId  = ocr.GetOpenCLDevice(ref oclDevice);

                    String message = "Hello, World";
                    CvInvoke.PutText(img, message, new Point(50, 100), CvEnum.FontFace.HersheySimplex, 1.0, new MCvScalar(255));

                    //
                    //ocr.Recognize(img);
                    using (Image <Gray, Byte> rotatedImg = img.Rotate(10, new Gray(), false))
                    {
                        ocr.PageSegMode = PageSegMode.AutoOsd;
                        ocr.SetImage(rotatedImg);
                        ocr.Recognize();
                        using (PageIterator pi = ocr.AnalyseLayout())
                        {
                            Orientation   or       = pi.Orientation;
                            LineSegment2D?baseLine = pi.GetBaseLine(PageIteratorLevel.Textline);
                            if (baseLine.HasValue)
                            {
                                CvInvoke.Line(rotatedImg, baseLine.Value.P1, baseLine.Value.P2, new MCvScalar(255));
                                //Emgu.CV.UI.ImageViewer.Show(rotatedImg);
                            }
                        }


                        String messageOcr = ocr.GetUTF8Text().TrimEnd('\n', '\r'); // remove end of line from ocr-ed text
                        //EmguAssert.AreEqual(message, messageOcr,
                        //   String.Format("'{0}' is not equal to '{1}'", message, messageOcr));

                        Tesseract.Character[] results = ocr.GetCharacters();

                        String s1 = ocr.GetBoxText();
                        //String s2 = ocr.GetOsdText();
                        String s3 = ocr.GetTSVText();
                        String s4 = ocr.GetUNLVText();

                        using (PDFRenderer pdfRenderer = new PDFRenderer("abc.pdf", "./", false))
                            using (Pix imgPix = new Pix(img.Mat))
                            {
                                //bool success = ocr.ProcessPage(imgPix, 1, "img", null, 100000, pdfRenderer);
                                //EmguAssert.IsTrue(success, "failed to export pdf");
                            }
                    }
                }
        }
        /// <summary>
        /// Invoked when the mouse is moved around after the left button has been pressed on the NavigatorCanvas. Moves the DisplayArea around.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void NavigatorPointerMoved(object sender, PointerEventArgs e)
        {
            if (IsMouseDown)
            {
                PDFRenderer renderer = this.FindControl <PDFRenderer>("MuPDFRenderer");
                Avalonia.Controls.Shapes.Rectangle displayRect = this.FindControl <Avalonia.Controls.Shapes.Rectangle>("DisplayAreaRectangle");

                Point point = e.GetPosition(this.FindControl <Canvas>("NavigatorCanvas"));

                double deltaX = -(-point.X + MouseDownPoint.X) / displayRect.Width * MouseDownDisplayArea.Width;
                double deltaY = -(-point.Y + MouseDownPoint.Y) / displayRect.Height * MouseDownDisplayArea.Height;

                renderer.SetDisplayAreaNow(new Rect(new Point(this.MouseDownDisplayArea.X + deltaX, this.MouseDownDisplayArea.Y + deltaY), new Point(this.MouseDownDisplayArea.Right + deltaX, this.MouseDownDisplayArea.Bottom + deltaY)));
            }
        }
Beispiel #10
0
 public static void TestCoherentTextExtractor()
 {
     {
         PDFRenderer pdf_renderer = new PDFRenderer(TEST_PDF_FILENAME_LOCAL2, null, null);
         PDFCoherentTextExtractor.ExtractText(pdf_renderer);
     }
     {
         PDFRenderer pdf_renderer = new PDFRenderer(TEST_PDF_FILENAME_LOCAL5, null, null);
         PDFCoherentTextExtractor.ExtractText(pdf_renderer);
     }
     {
         PDFRenderer pdf_renderer = new PDFRenderer(TEST_PDF_FILENAME_LOCAL8, null, null);
         PDFCoherentTextExtractor.ExtractText(pdf_renderer);
     }
 }
Beispiel #11
0
        public static void TestPDFRenderer()
        {
            PDFRenderer renderer = new PDFRenderer(TEST_PDF_FILENAME, null, null);

            while (true)
            {
                for (int i = 1; i < 10; ++i)
                {
                    Logging.Info("Asking for page {0}", i);
                    Image image = Image.FromStream(new MemoryStream(renderer.GetPageByDPIAsImage(i, 72)));
                    Logging.Info("Image is {0}", image);

                    Thread.Sleep(100);
                }
            }
        }
        public static void TestPDFRendererControl()
        {
            Library            library       = Library.GuestInstance;
            List <PDFDocument> pdf_documents = library.PDFDocuments;

            if (0 < pdf_documents.Count)
            {
                PDFDocument       pdf_document        = pdf_documents[0];
                PDFRenderer       pdf_renderer        = new PDFRenderer(pdf_document.DocumentPath, null, null);
                PDFAnnotationList pdf_annotation_list = pdf_document.Annotations;

                PDFRendererControl   control = new PDFRendererControl(pdf_document, true);
                ControlHostingWindow window  = new ControlHostingWindow("PDFRenderer", control);
                window.Show();
            }
        }
    void Start()
    {
        PDFDocument pdfDocument = new PDFDocument(PDFBytesSupplierExample.PDF_SAMPLE, "");

        if (pdfDocument.IsValid)
        {
            int pageCount = pdfDocument.GetPageCount();

            PDFRenderer renderer = new PDFRenderer();
            Texture2D   tex      = renderer.RenderPageToTexture(pdfDocument.GetPage(m_Page % pageCount), 1024, 1024);

            tex.filterMode = FilterMode.Bilinear;
            tex.anisoLevel = 8;

            GetComponent <MeshRenderer>().material.mainTexture = tex;
        }
    }
Beispiel #14
0
    protected override void Render(HtmlTextWriter writer)
    {
        if (OverrideRender)
        {
            StringBuilder sbOut = new StringBuilder();

            using (StringWriter swOut = new StringWriter(sbOut, CultureInfo.InvariantCulture))
            {
                UTF8Encoding enc = new UTF8Encoding(true);
                swOut.Write(Encoding.UTF8.GetString(enc.GetPreamble()));
                using (HtmlTextWriter htwOut = new HtmlTextWriter(swOut))
                {
                    base.Render(htwOut);
                }
            }

            PDFRenderer.RenderFile(sbOut.ToString(),
                                   PageOptions,
                                   () => // onError
            {
                util.NotifyAdminEvent("Error saving PDF", String.Format(CultureInfo.CurrentCulture, "User: {0}\r\nOptions:\r\n{1}\r\n\r\nQuery:{2}\r\n",
                                                                        CurrentUser.UserName,
                                                                        JsonConvert.SerializeObject(PageOptions),
                                                                        JsonConvert.SerializeObject(PrintOptions1.Options)), ProfileRoles.maskSiteAdminOnly);

                Response.Redirect(Request.Url.PathAndQuery + (Request.Url.PathAndQuery.Contains("?") ? "&" : "?") + "pdfErr=1");
            },
                                   (szOutputPDF) => // onSuccess
            {
                Page.Response.Clear();
                Page.Response.ContentType = "application/pdf";
                Response.AddHeader("content-disposition", String.Format(CultureInfo.CurrentCulture, @"attachment;filename=""{0}.pdf""", CurrentUser.UserFullName));
                Response.WriteFile(szOutputPDF);
                Page.Response.Flush();

                // See http://stackoverflow.com/questions/20988445/how-to-avoid-response-end-thread-was-being-aborted-exception-during-the-exce for the reason for the next two lines.
                Page.Response.SuppressContent = true;                      // Gets or sets a value indicating whether to send HTTP content to the client.
                HttpContext.Current.ApplicationInstance.CompleteRequest(); // Causes ASP.NET to bypass all events and filtering in the HTTP pipeline chain of execution and directly execute the EndRequest event.
            });
        }
        else
        {
            base.Render(writer);
        }
    }
        protected override void Render(HtmlTextWriter writer)
        {
            if (OverrideRender)
            {
                PDFRenderer.RenderFile(
                    PrintOptions.PDFSettings,
                    (htwOut) => { base.Render(htwOut); },
                    (szErr) => // onError
                {
                    util.NotifyAdminEvent("Error saving PDF", String.Format(CultureInfo.CurrentCulture, "{0}\r\nUser: {1}\r\nOptions:\r\n{2}\r\n",
                                                                            szErr,
                                                                            CurrentUser.UserName,
                                                                            JsonConvert.SerializeObject(PrintOptions)
                                                                            ), ProfileRoles.maskSiteAdminOnly);

                    // put the error into the session
                    PDFError = szErr;
                    Response.Redirect(Request.Url.PathAndQuery);
                },
                    (szOutputPDF) => // onSuccess
                {
                    try
                    {
                        Page.Response.Clear();
                        Page.Response.ContentType = "application/pdf";
                        Response.AddHeader("content-disposition", String.Format(CultureInfo.CurrentCulture, @"attachment;filename=""{0}.pdf""", CurrentUser.UserFullName));
                        Response.WriteFile(szOutputPDF);
                        Page.Response.Flush();

                        // See http://stackoverflow.com/questions/20988445/how-to-avoid-response-end-thread-was-being-aborted-exception-during-the-exce for the reason for the next two lines.
                        Page.Response.SuppressContent = true;                      // Gets or sets a value indicating whether to send HTTP content to the client.
                        HttpContext.Current.ApplicationInstance.CompleteRequest(); // Causes ASP.NET to bypass all events and filtering in the HTTP pipeline chain of execution and directly execute the EndRequest event.
                    }
                    catch (HttpUnhandledException) { }                             // sometimes the remote host has closed the connection - allow cleanup to proceed.
                    catch (HttpException) { }
                });
            }
            else
            {
                base.Render(writer);
            }
        }
        public static void Print(PDFDocument pdf_document, PDFRenderer pdf_renderer, string description)
        {
            FeatureTrackingManager.Instance.UseFeature(Features.Document_Print);

            PrintDialog print_dialog = new PrintDialog();

            print_dialog.UserPageRangeEnabled = true;
            print_dialog.MinPage = 1;
            print_dialog.MaxPage = (uint)pdf_renderer.PageCount;
            if (print_dialog.ShowDialog() == true)
            {
                if (print_dialog.PageRangeSelection == PageRangeSelection.AllPages)
                {
                    PrintThreadEntry(print_dialog, pdf_document, pdf_renderer, description, (int)print_dialog.MinPage, (int)print_dialog.MaxPage);
                }
                else
                {
                    PrintThreadEntry(print_dialog, pdf_document, pdf_renderer, description, print_dialog.PageRange.PageFrom, print_dialog.PageRange.PageTo);
                }
            }
        }
Beispiel #17
0
        /// <summary>
        /// Invoked when a property of the <see cref="PDFRenderer"/> changes; used to update the NavigatorCanvas when the DisplayArea changes.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void RendererPropertyChanged(object sender, AvaloniaPropertyChangedEventArgs e)
        {
            if (e.Property == PDFRenderer.DisplayAreaProperty)
            {
                PDFRenderer renderer = this.FindControl <PDFRenderer>("MuPDFRenderer");

                Rect displayArea = renderer.DisplayArea;
                Rect pageSize    = renderer.PageSize;

                double minX = Math.Min(displayArea.Left, pageSize.Left);
                double minY = Math.Min(displayArea.Top, pageSize.Top);
                double maxX = Math.Max(displayArea.Right, pageSize.Right);
                double maxY = Math.Max(displayArea.Bottom, pageSize.Bottom);

                double width  = maxX - minX;
                double height = maxY - minY;

                double size = Math.Max(width, height);

                minX -= (size - width) * 0.5;
                maxX += (size - width) * 0.5;
                minY -= (size - height) * 0.5;
                maxY += (size - height) * 0.5;

                Image  pageRect   = this.FindControl <Image>("PageAreaImage");
                Canvas pageCanavs = this.FindControl <Canvas>("PageAreaCanvas");
                Avalonia.Controls.Shapes.Rectangle displayRect = this.FindControl <Avalonia.Controls.Shapes.Rectangle>("DisplayAreaRectangle");

                pageRect.Width  = pageSize.Width / (maxX - minX) * 200;
                pageRect.Height = pageSize.Height / (maxY - minY) * 200;

                pageCanavs.Width           = pageSize.Width / (maxX - minX) * 200;
                pageCanavs.Height          = pageSize.Height / (maxY - minY) * 200;
                pageCanavs.RenderTransform = new TranslateTransform((pageSize.Left - minX) / (maxX - minX) * 200, (pageSize.Top - minY) / (maxY - minY) * 200);

                displayRect.Width           = displayArea.Width / (maxX - minX) * 200;
                displayRect.Height          = displayArea.Height / (maxY - minY) * 200;
                displayRect.RenderTransform = new TranslateTransform((displayArea.Left - minX) / (maxX - minX) * 200, (displayArea.Top - minY) / (maxY - minY) * 200);
            }
        }
Beispiel #18
0
 static ControlService()
 {
     if (m_renderingExtensions == null)
     {
         List <LocalRenderingExtensionInfo> list = new List <LocalRenderingExtensionInfo>();
         //Html.HTMLRenderer htmlRenderer = new Html.HTMLRenderer();
         //list.Add(new LocalRenderingExtensionInfo("HTML", htmlRenderer.LocalizedName, false, typeof(Html.HTMLRenderer), true));
         RPLRenderer rPLRenderer = new RPLRenderer();
         list.Add(new LocalRenderingExtensionInfo("RPL", rPLRenderer.LocalizedName, false, typeof(RPLRenderer), false));
         ExcelRenderer excelRenderer = new ExcelRenderer();
         list.Add(new LocalRenderingExtensionInfo("Excel", excelRenderer.LocalizedName, false, typeof(ExcelRenderer), true));
         ExcelOpenXmlRenderer excelOpenXmlRenderer = new ExcelOpenXmlRenderer();
         list.Add(new LocalRenderingExtensionInfo("EXCELOPENXML", excelOpenXmlRenderer.LocalizedName, true, typeof(ExcelOpenXmlRenderer), true));
         ImageRenderer imageRenderer = new ImageRenderer();
         list.Add(new LocalRenderingExtensionInfo("IMAGE", imageRenderer.LocalizedName, false, typeof(ImageRenderer), true));
         PDFRenderer pDFRenderer = new PDFRenderer();
         list.Add(new LocalRenderingExtensionInfo("PDF", pDFRenderer.LocalizedName, true, typeof(PDFRenderer), true));
         WordDocumentRenderer wordDocumentRenderer = new WordDocumentRenderer();
         list.Add(new LocalRenderingExtensionInfo("WORD", wordDocumentRenderer.LocalizedName, false, typeof(WordDocumentRenderer), true));
         WordOpenXmlDocumentRenderer wordOpenXmlDocumentRenderer = new WordOpenXmlDocumentRenderer();
         list.Add(new LocalRenderingExtensionInfo("WORDOPENXML", wordOpenXmlDocumentRenderer.LocalizedName, true, typeof(WordOpenXmlDocumentRenderer), true));
         m_renderingExtensions = list;
     }
 }
Beispiel #19
0
        /// <summary>
        /// Sets the form in the state FormState.Finished.
        /// </summary>
        internal virtual void Finish()
        {
#if GDI
            if (_formState == FormState.NotATemplate || _formState == FormState.Finished)
            {
                return;
            }

            if (Gfx.Metafile != null)
            {
                _gdiImage = Gfx.Metafile;
            }

            Debug.Assert(_formState == FormState.Created || _formState == FormState.UnderConstruction);
            _formState = FormState.Finished;
            Gfx.Dispose();
            Gfx = null;

            if (PDFRenderer != null)
            {
                //pdfForm.CreateStream(PDFEncoders.RawEncoding.GetBytes(PDFRenderer.GetContent()));
                PDFRenderer.Close();
                Debug.Assert(PDFRenderer == null);

                if (_document.Options.CompressContentStreams)
                {
                    _pdfForm.Stream.Value        = Filtering.FlateDecode.Encode(_pdfForm.Stream.Value, _document.Options.FlateEncodeMode);
                    _pdfForm.Elements["/Filter"] = new PDFName("/FlateDecode");
                }
                int length = _pdfForm.Stream.Length;
                _pdfForm.Elements.SetInteger("/Length", length);
            }
#endif
#if WPF
#endif
        }
Beispiel #20
0
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();

        int page = (int)FindObjectOfType <Slider>().value;

        if (GUILayout.Button("Add to page"))
        {
            foreach (var t in targets)
            {
                var myScript = (TextItem)t;
                if (!myScript.otherPages.Contains(page))
                {
                    myScript.otherPages.Add(page);
                    FindObjectOfType <TextManager>().SliderChanged();
                }
            }
        }

        if (GUILayout.Button("CreateJSON"))
        {
            PDFRenderer.GeneratePDF();
        }
    }
        public static ExtractionResult ExtractText(PDFRenderer pdf_renderer)
        {
            Logging.Info("Doing text extraction for {0}", pdf_renderer.ToString());

            try
            {
                int          page_count   = pdf_renderer.PageCount;
                PageDetail[] page_details = new PageDetail[page_count];

                for (int i = 0; i < page_count; ++i)
                {
                    page_details[i] = new PageDetail(i + 1);
                }

                bool all_pages_already_with_ocr = true;
                foreach (PageDetail page_detail in page_details)
                {
                    WordList word_list = pdf_renderer.GetOCRText(page_detail.page);

                    if (null != word_list)
                    {
                        Logging.Debug特("Page {0} has OCR available ({1})", page_detail.page, pdf_renderer.DocumentFingerprint);
                    }
                    else
                    {
                        Logging.Debug特("Page {0} has not had OCR done ({1})", page_detail.page, pdf_renderer.DocumentFingerprint);
                        all_pages_already_with_ocr = false;
                    }
                }

                if (!all_pages_already_with_ocr)
                {
                    Logging.Info("Not all pages are ready with OCR");
                    return(new ExtractionResult(ExtractionResult.ResultType.OCR_NOT_COMPLETE));
                }

                // All pages OCR are complete, so load the words lists
                foreach (PageDetail page_detail in page_details)
                {
                    page_detail.word_list = pdf_renderer.GetOCRText(page_detail.page);
                }

                // Order the words on each page in a manner that makes sense of multiple columns
                List <Word> words_ordered = new List <Word>();
                foreach (PageDetail page_detail in page_details)
                {
                    WordList words_ordered_for_page = ColumnWordOrderer.ReorderWords(page_detail.word_list);
                    words_ordered.AddRange(words_ordered_for_page);
                }

                // Concatenate the words
                List <string> words = new List <string>();
                foreach (Word word in words_ordered)
                {
                    words.Add(word.Text);
                }

                // Kill some of the line-wrapping hyphenation
                for (int i = words.Count - 2; i >= 0; --i)
                {
                    if (words[i].EndsWith("-"))
                    {
                        words[i] = words[i].Substring(0, words[i].Length - 1) + words[i + 1];
                        words.RemoveAt(i + 1);
                    }
                }

                // Return the words
                Logging.Info("Successfully extracted {0} words: {1}", words.Count, ArrayFormatter.listElements(words));
                return(new ExtractionResult(ExtractionResult.ResultType.SUCCESS, words));
            }
            catch (Exception ex)
            {
                Logging.Warn(ex, "There was an exception while extracting coherent text");
                return(new ExtractionResult(ExtractionResult.ResultType.EXCEPTION, ex));
            }
        }
        private static void PrintThreadEntry(PrintDialog print_dialog, PDFDocument pdf_document, PDFRenderer pdf_renderer, string description, int page_from, int page_to)
        {
            PDFPrinterDocumentPaginator paginator = new PDFPrinterDocumentPaginator(pdf_document, pdf_renderer, page_from, page_to, new Size(print_dialog.PrintableAreaWidth, print_dialog.PrintableAreaHeight));

            print_dialog.PrintDocument(paginator, description);
            StatusManager.Instance.UpdateStatus("PDFPrinter", String.Format("Finished printing {0} pages", paginator.TotalPagesPrinted));
        }
Beispiel #23
0
    IEnumerator Start()
    {
        Debug.Log("WebGLTest: ");

        PDFJS_Promise <PDFDocument> documentPromise = PDFDocument.LoadDocumentFromUrlAsync("https://crossorigin.me/http://www.pdf995.com/samples/pdf.pdf");

        while (!documentPromise.HasFinished)
        {
            yield return(null);
        }

        if (!documentPromise.HasSucceeded)
        {
            Debug.Log("Fail: documentPromise");
            yield break;
        }
        else
        {
            Debug.Log("Success: documentPromise");
        }

        PDFDocument document = documentPromise.Result;

        PDFJS_Promise <PDFPage> pagePromise = document.GetPageAsync(0);

        while (!pagePromise.HasFinished)
        {
            yield return(null);
        }

        if (!pagePromise.HasSucceeded)
        {
            Debug.Log("Fail: pagePromise");
            yield break;
        }
        else
        {
            Debug.Log("Success: pagePromise");
        }

        PDFPage page = pagePromise.Result;

        PDFJS_Promise <Texture2D> renderPromise = PDFRenderer.RenderPageToTextureAsync(page, (int)page.GetPageSize().x, (int)page.GetPageSize().y);

        while (!renderPromise.HasFinished)
        {
            yield return(null);
        }

        if (!renderPromise.HasSucceeded)
        {
            Debug.Log("Fail: pagePromise");
            yield break;
        }

        Texture2D renderedPageTexture = renderPromise.Result;

        (m_RawImage.transform as RectTransform).sizeDelta = new Vector2(renderedPageTexture.width, renderedPageTexture.height);
        m_RawImage.texture = renderedPageTexture;

        yield return(new WaitForSeconds(2.5f));
    }
Beispiel #24
0
        public bool ConvertToMultipageTiffImage(string outputFile)
        {
            try
            {
                try
                {
                    if (!Directory.Exists(PDF2Image.TempPath))
                    {
                        Directory.CreateDirectory(PDF2Image.TempPath);
                    }
                    ImageType bINARY = null;
                    switch (this.OutputImageColor)
                    {
                    case PDF2Image.PDF2ImageColor.BINARY:
                    {
                        bINARY = ImageType.BINARY;
                        break;
                    }

                    case PDF2Image.PDF2ImageColor.GRAY:
                    {
                        bINARY = ImageType.GRAY;
                        break;
                    }

                    case PDF2Image.PDF2ImageColor.RGB:
                    {
                        bINARY = ImageType.RGB;
                        break;
                    }

                    case PDF2Image.PDF2ImageColor.ARGB:
                    {
                        bINARY = ImageType.ARGB;
                        break;
                    }

                    default:
                    {
                        bINARY = null;
                        break;
                    }
                    }
                    string str  = ".bmp";
                    bool   flag = true;
                    this.startPage = Math.Max(this.startPage, 1);
                    if (this.endPage < 0)
                    {
                        this.endPage = this.pdfDocument.getNumberOfPages();
                    }
                    this.endPage = Math.Min(this.endPage, this.pdfDocument.getNumberOfPages());
                    PDFRenderer   pDFRenderer = new PDFRenderer(this.pdfDocument);
                    List <string> strs        = new List <string>();
                    for (int i = this.startPage - 1; i < this.endPage; i++)
                    {
                        BufferedImage bufferedImage = null;
                        bufferedImage = (bINARY != null ? pDFRenderer.renderImageWithDPI(i, (float)this.dpi, bINARY) : pDFRenderer.renderImageWithDPI(i, (float)this.dpi));
                        string str1 = string.Concat(new object[] { PDF2Image.TempPath, "\\", i + 1, str });
                        flag = flag & ImageIOUtil.writeImage(bufferedImage, str1, this.dpi);
                        strs.Add(str1);
                    }
                    this.ConvertJPGToTiff(strs, outputFile);
                }
                catch (Exception exception1)
                {
                    Exception exception = exception1;
                    throw new PDFToolkitException(exception.Message, exception);
                }
            }
            finally
            {
                PDFHelper.EmptyDirectory(PDF2Image.TempPath);
            }
            return(true);
        }