示例#1
0
        /// <summary>
        /// Get skew angle
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="exludeBorders">Excluding borders from reaserch</param>
        /// <param name="percentageOfExcludableBorders">Percent of excluded borders</param>
        /// <returns></returns>
        public static float GetSkewAngle(Bitmap bitmap, bool exludeBorders = false, int percentageOfExcludableBorders = 0)
        {
            GdPictureImaging image = new GdPictureImaging();
            float            angle = 0;

            try
            {
                int imageId = image.CreateGdPictureImageFromBitmap(bitmap);
                if (imageId > 0)
                {
                    if (exludeBorders)
                    {
                        int width  = image.GetWidth(imageId);
                        int height = image.GetHeight(imageId);
                        int left   = width / 100 * percentageOfExcludableBorders;
                        int top    = width / 100 * percentageOfExcludableBorders;
                        image.Crop(imageId, left, top, width - 2 * left, height - 2 * top);
                    }
                    angle = image.GetSkewAngle(imageId, MaxAngleOfDeskewResearch, AngleResearchStep, true);
                    image.ReleaseGdPictureImage(imageId);
                }
            }
            catch (Exception e)
            {
            }

            return(angle);
        }
示例#2
0
        /// <summary>
        /// Rotates image
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="angle">Angle of rotation</param>
        /// <param name="fillColor">Fill color</param>
        /// <returns></returns>
        public static Bitmap Rotate(Bitmap bitmap, float angle, Color fillColor)
        {
            Bitmap resultImage = bitmap;

            if (angle != 0)
            {
                GdPictureImaging image = new GdPictureImaging();

                int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

                try
                {
                    if (imageId > 0)
                    {
                        image.RotateAngleBackColor(imageId, angle, fillColor);
                        resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                    }
                }
                finally
                {
                    image.ReleaseGdPictureImage(imageId);
                }
            }

            return(resultImage);
        }
 public ATAPY.Common.IO.Files CreatePageFiles(ATAPY.Common.IO.File PdfFile)
 {
     Trace.Assert(PdfFile != null);
     ATAPY.Common.IO.Files Ret = new ATAPY.Common.IO.Files();
     try {
         using (GdPicturePDF SourcePDF = new GdPicturePDF()) {
             if (SourcePDF.LoadFromFile(PdfFile.FullPath, true) != GdPictureStatus.OK)
             {
                 throw new Warning("Cannot open source file.\r\nSource file -" + PdfFile.FullPath);
             }
             if (SourcePDF.IsEncrypted())
             {
                 throw new Warning("Source PDF file is encrypted.");
             }
             int PagesCount = SourcePDF.GetPageCount();
             using (GdPictureImaging Imaging = new GdPictureImaging()) {
                 for (int i = 1; i <= PagesCount; i++)
                 {
                     SourcePDF.SelectPage(i);
                     int RenderedPageId           = SourcePDF.RenderPageToGdPictureImageEx((float)DEFAULT_RENDER_DPI, true, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                     ATAPY.Common.IO.File RetFile = new ATAPY.Common.IO.File(PageImagesFolder, PdfFile.NameWithoutExtension + "_" + i.ToString("D3") + ".png");
                     Imaging.SaveAsPNG(RenderedPageId, RetFile.FullPath);
                     Imaging.ReleaseGdPictureImage(RenderedPageId);
                     Ret.Add(RetFile);
                 }
             }
             SourcePDF.CloseDocument();
         }
     } catch (Exception ex) {
         GlobalObjects.Log.WriteError(ex);
         throw;
     }
     return(Ret);
 }
        /// <summary>
        /// ReadPageInfo reads the page information required for the conversion of the annotations.
        /// </summary>
        /// <param name="gdPictureImaging">The GdPictureImaging.</param>
        /// <param name="imageId">The image identifier.</param>
        /// <param name="pageCount">The number of pages.</param>
        /// <returns>An array with the information.</returns>
        private static PageInfo[] ReadPageInfo(GdPictureImaging gdPictureImaging, int imageId, int pageCount)
        {
            PageInfo[] pageInfo = new PageInfo[pageCount];

            for (int pageIndex = 0; pageIndex < pageCount; pageIndex++)
            {
                // Page selection is 1 based index
                gdPictureImaging.SelectPage(imageId, pageIndex + 1);
                pageInfo[pageIndex].WidthPixels  = gdPictureImaging.GetWidth(imageId);
                pageInfo[pageIndex].HeightPixels = gdPictureImaging.GetHeight(imageId);
                pageInfo[pageIndex].WidthInches  = gdPictureImaging.GetWidthInches(imageId);
                pageInfo[pageIndex].HeightInches = gdPictureImaging.GetHeightInches(imageId);
                pageInfo[pageIndex].WangTagData  = null;
                int tagCount = gdPictureImaging.TagCount(imageId);
                for (int tagIndex = 1; tagIndex <= tagCount; tagIndex++)
                {
                    Tags tag = gdPictureImaging.TagGetID(imageId, tagIndex);
                    if (tag == Tags.TagWangAnnotations)
                    {
                        int length = gdPictureImaging.TagGetLength(imageId, tagIndex);
                        pageInfo[pageIndex].WangTagData = new byte[length];
                        gdPictureImaging.TagGetValueBytes(imageId, tagIndex, ref pageInfo[pageIndex].WangTagData);
                    }
                }
            }

            return(pageInfo);
        }
 private bool[] GetAreaLines(int AreaId, GdPictureImaging Imaging, int Width, int Height, out bool[] VerticalLines)
 {
     int[] Data = new int[Width * Height];
     Imaging.GetPixelArrayInteger(AreaId, ref Data, 0, 0, Width, Height);
     bool[] Ret = new bool[Height];
     VerticalLines = new bool[Width];
     for (int i = 0; i < Height; i++)
     {
         Ret[i] = true;
         for (int j = 0; j < Width; j++)
         {
             if (Data[i * Width + j] != -1)
             {
                 Ret[i] = false;
                 break;
             }
         }
     }
     for (int i = 0; i < Width; i++)
     {
         VerticalLines[i] = true;
         for (int j = 0; j < Height; j++)
         {
             if (Data[i + j * Width] != -1)
             {
                 VerticalLines[i] = false;
                 break;
             }
         }
     }
     return(Ret);
 }
示例#6
0
        /// <summary>
        /// Removes blobs from image
        /// </summary>
        /// <param name="bitmap">Bitmap.</param>
        /// <param name="blobsDimensions">Blobs dimensions</param>
        /// <returns></returns>
        public static Bitmap RemoveBlobs(Bitmap bitmap, BlobsDimensions blobsDimensions)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            try
            {
                if (imageId > 0)
                {
                    if (image.GetBitDepth(imageId) != 1)
                    {
                        image.ConvertTo1BppAT(imageId);
                    }

                    image.RemoveBlob(imageId, blobsDimensions.MinBlobWidth, blobsDimensions.MinBlobHeight, blobsDimensions.MaxBlobWidth, blobsDimensions.MaxBlobHeight, BlobRemoveMode.FavorQuality);
                    resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                }
            }
            finally
            {
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }
示例#7
0
        /// <summary>
        /// Removes staple marks
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <returns></returns>
        public static Bitmap RemoveStapleMarks(Bitmap bitmap)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            try
            {
                if (imageId > 0)
                {
                    if (image.GetBitDepth(imageId) != 1)
                    {
                        image.ConvertTo1BppAT(imageId);
                    }

                    image.RemoveStapleMark(imageId);
                    resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                }
            }
            catch
            {
            }
            finally
            {
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }
示例#8
0
        /// <summary>
        /// Converts to jpeg.
        /// </summary>
        /// <param name="outputPath">The output path.</param>
        public void ConvertToJpeg(string outputPath)
        {
            GdPictureImaging image = new GdPictureImaging();
            int imageId            = image.CreateGdPictureImageFromFile(ImagePath);

            image.SaveAsJPEG(imageId, outputPath);
            image.ReleaseGdPictureImage(imageId);
            GC.Collect();
        }
示例#9
0
        public static string castTopdf(string file, GdPictureImaging oGdPictureImaging, GdPicturePDF oGdPicturePDF)
        {
            string str = "";

            oGdPictureImaging.TiffOpenMultiPageForWrite(false);
            int num = oGdPictureImaging.CreateGdPictureImageFromFile(file);

            if (num != 0)
            {
                oGdPicturePDF.NewPDF();
                if (oGdPictureImaging.TiffIsMultiPage(num))
                {
                    int  num1 = oGdPictureImaging.TiffGetPageCount(num);
                    bool flag = true;
                    int  num2 = 1;
                    while (num2 <= num1)
                    {
                        oGdPictureImaging.TiffSelectPage(num, num2);
                        oGdPicturePDF.AddImageFromGdPictureImage(num, false, true);
                        if (oGdPicturePDF.GetStat() == 0)
                        {
                            num2++;
                        }
                        else
                        {
                            flag = false;
                            break;
                        }
                    }
                    if (flag)
                    {
                        str = file.Replace(Path.GetExtension(file), ".pdf");
                        oGdPicturePDF.SaveToFile(file.Replace(Path.GetExtension(file), ".pdf"));
                        if (oGdPicturePDF.GetStat() != 0)
                        {
                        }
                    }
                    oGdPicturePDF.CloseDocument();
                    oGdPictureImaging.ReleaseGdPictureImage(num);
                }
                else
                {
                    oGdPicturePDF.AddImageFromGdPictureImage(num, false, true);
                    if (oGdPicturePDF.GetStat() == 0)
                    {
                        str = file.Replace(Path.GetExtension(file), ".pdf");
                        if (oGdPicturePDF.SaveToFile(file.Replace(Path.GetExtension(file), ".pdf")) != 0)
                        {
                        }
                    }
                    oGdPicturePDF.CloseDocument();
                    oGdPictureImaging.ReleaseGdPictureImage(num);
                }
            }
            File.Delete(file);
            return(str);
        }
        private void CheckTextWithRecognition(Page Page, int PageImageID)
        {
            using (GdPictureImaging Imaging = new GdPictureImaging()) {
                Imaging.OCRTesseractSetOCRContext(OCRContext.OCRContextSingleBlock);
                Imaging.OCRTesseractSetPassCount(2);
                for (int i = 0; i < Page.TextAreas.Count; i++)
                {
                    var Area = Page.TextAreas[i];
                    if (!IsEven(Area.Text.Length))
                    {
                        continue;
                    }
                    var Left  = Area.Text.Substring(0, Area.Text.Length / 2);
                    var Right = Area.Text.Substring(Area.Text.Length / 2);
                    if (Left != Right)
                    {
                        continue;
                    }

                    int Width  = (int)Area.Width + 2;
                    int Height = (int)Area.Height + 2;
                    int TempId = Imaging.CreateNewGdPictureImage(Width, Height, 1, System.Drawing.Color.Transparent);
                    Imaging.DrawGdPictureImageRect(PageImageID, TempId, 1, 1, Width, Height, (int)Area.Bound.Left, (int)Area.Bound.Top,
                                                   Width, Height, System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor);

                    //Imaging.SetROI((int)Area.Bound.Left - 10, (int)Area.Bound.Top - 1, (int)Area.Width + 2, (int)Area.Height + 20);
                    string RecognizedValue = Imaging.OCRTesseractDoOCR(TempId, "nld", ATAPY.Common.Application.Path, string.Empty);
                    Imaging.OCRTesseractClear();

                    //Imaging.SaveAsPNG(TempId, @"d:\Temp\P2P\" + string.Format("Page_{0}_Word_{1}_Cropped.png", Page.Index, i.ToString("D3")));
                    Imaging.ReleaseGdPictureImage(TempId);
                    //check for words duplication
                    if (RecognizedValue.Length * 2 == Area.Text.Length)
                    {
                        if (Area.Text == RecognizedValue + RecognizedValue)
                        {
                            Area.Text = RecognizedValue;
                            FillCharParams(Area);
                        }
                    }
                    else if (ATAPY.Common.String.MatchRegularExpression(Left, @"^EUR|€|$\d+\s?[.,]?\s?\d*\s?[.,]?\s?\d{2}$"))
                    {
                        Area.Text = Left;
                        FillCharParams(Area);
                    }

                    /*else if (IsEven(Area.Text.Length)) {
                     *  var Left = Area.Text.Substring(0, Area.Text.Length / 2);
                     *  var Right = Area.Text.Substring(Area.Text.Length / 2);
                     *  if (Left == Right && ATAPY.Common.String.MatchRegularExpression(Left, @"^EUR|€|$\d+\s?[.,]?\s?\d*\s?[.,]?\s?\d{2}$")) {
                     *      Area.Text = Left;
                     *      FillCharParams(Area);
                     *  }
                     * }*/
                }
            }
        }
示例#11
0
        public static string GerarDocumentoPesquisavelPdf(GdPictureImaging _gdPictureImaging, GdPicturePDF _gdPicturePDF, string documento, bool pdfa = true, string idioma = "por", string titulo = null, string autor = null, string assunto = null, string palavrasChaves = null, string criador = null, int dpi = 250)
        {
            if (Path.GetExtension(documento) != ".pdf")
            {
                documento = Ocr.castTopdf(documento, _gdPictureImaging, _gdPicturePDF);
            }
            int num   = 0;
            var pasta = Guid.NewGuid().ToString();

            _gdPicturePDF.LoadFromFile(documento, true);
            string str = string.Concat(Ocr.GetCurrentDirectory(), "\\GdPicture\\Idiomas");


            using (FileStream fs = File.Create("c:\\lodg.txt"))
            {
                Byte[] info = new UTF8Encoding(true).GetBytes(str);
                // Add some information to the file.
                fs.Write(info, 0, info.Length);
            }
            //  Console.WriteLine(ex.Message);

            string str1      = ConfigurationManager.AppSettings["PastaDestinoTemp"].ToString();
            string str2      = string.Concat(str1, "\\", Path.GetFileName(documento));
            string folder    = Guid.NewGuid().ToString();
            int    pageCount = _gdPicturePDF.GetPageCount();

            for (int i = 1; i <= pageCount; i++)
            {
                Directory.CreateDirectory(str1 + "\\" + pasta);
                _gdPicturePDF.SelectPage(i);
                int gdPictureImageEx = _gdPicturePDF.RenderPageToGdPictureImageEx((float)dpi, true);
                if (gdPictureImageEx != 0)
                {
                    num = _gdPictureImaging.PdfOCRStart(str1 + "\\" + pasta + "\\" + i.ToString() + ".pdf", pdfa, titulo, autor, assunto, palavrasChaves, criador);
                    _gdPictureImaging.PdfAddGdPictureImageToPdfOCR(num, gdPictureImageEx, idioma, str, "");
                    _gdPictureImaging.ReleaseGdPictureImage(gdPictureImageEx);
                    _gdPictureImaging.PdfOCRStop(num);
                }
            }

            _gdPicturePDF.CloseDocument();
            File.Delete(documento);

            GdPictureStatus status = _gdPicturePDF.MergeDocuments(Directory.GetFiles(str1 + "\\" + pasta), str2);


            DirectoryInfo dir = new DirectoryInfo(str1 + "\\" + pasta);

            foreach (FileInfo fi in dir.GetFiles())
            {
                fi.Delete();
            }

            Directory.Delete(str1 + "\\" + pasta);
            return(str2);
        }
示例#12
0
        /// <summary>
        /// Save page to jpeg file
        /// </summary>
        /// <param name="sourceFilePath">The source file path.</param>
        /// <param name="outputPath">The output path.</param>
        /// <param name="pageNumber">Page number</param>
        public void SavePageToJpeg(string sourceFilePath, string outputPath, int pageNumber)
        {
            using (GdPictureImaging image = new GdPictureImaging())
            {
                int imageId = image.CreateGdPictureImageFromFile(sourceFilePath);
                image.SelectPage(imageId, pageNumber);
                image.SaveAsJPEG(imageId, outputPath);
                image.ReleaseGdPictureImage(imageId);
            }

            GC.Collect();
        }
        private float GetFontSize(GdPictureImaging GdPictureImaging, int ID, TextArea Text, string FontName)
        {
            var Height = GdPictureImaging.GetTextHeight(ID, Text.Text, FontName, 50, GdPicture9.FontStyle.FontStyleRegular);
            var Width  = GdPictureImaging.GetTextWidth(ID, Text.Text, FontName, 50, GdPicture9.FontStyle.FontStyleRegular);

            var Ratio1 = Height / Text.Height;

            Text.FontSize = 50 / Ratio1;
            var Ratio2 = Width / Text.Width;

            return((float)(50 / Math.Max(Ratio1, Ratio2)));
        }
示例#14
0
        /// <summary>
        /// Gets total pages number in file
        /// </summary>
        /// <param name="filePath">The file path.</param>
        /// <returns></returns>
        public int GetTotalPages(string filePath)
        {
            int totalPages = 0;

            using (GdPictureImaging image = new GdPictureImaging())
            {
                int imageId = image.CreateGdPictureImageFromFile(filePath);
                totalPages = image.TiffGetPageCount(imageId);
                totalPages = totalPages > 0 ? totalPages : 1;
            }

            return(totalPages);
        }
示例#15
0
 /// <summary>
 /// Save page to jpeg file
 /// </summary>
 /// <param name="sourceFilePath">The source file path.</param>
 /// <param name="outputPath">The output path.</param>
 /// <param name="pageNumber">Page number</param>
 /// <param name="dpi">Dpi of the generated file</param>
 public void SavePageToJpeg(string sourceFilePath, string outputPath, int pageNumber, int dpi)
 {
     using (GdPicturePDF pdf = new GdPicturePDF())
     {
         pdf.LoadFromFile(sourceFilePath, false);
         pdf.SelectPage(pageNumber);
         int imageId = pdf.RenderPageToGdPictureImage(200, true);
         using (GdPictureImaging image = new GdPictureImaging())
         {
             image.SaveAsJPEG(imageId, outputPath);
             image.ReleaseGdPictureImage(imageId);
         }
     }
 }
示例#16
0
        /// <summary>
        /// Creates the thumbnail.
        /// </summary>
        /// <param name="outputPath">The output path.</param>
        /// <param name="width">Width.</param>
        /// <param name="height">Height.</param>
        public void CreateThumbnail(string outputPath, int width, int height)
        {
            GdPictureImaging image = new GdPictureImaging();
            int imageId            = image.CreateGdPictureImageFromFile(ImagePath);

            if (imageId > 0)
            {
                int thumbnailId = image.CreateThumbnailHQ(imageId, width, height, Color.Black);
                image.SaveAsJPEG(thumbnailId, outputPath);
                image.ReleaseGdPictureImage(imageId);
            }

            GarbageCollector.Collect();
        }
        private void FillPageText(string PageText, GdPicturePDF SourcePDF, Page Page)
        {
            GdPictureImaging GdPictureImaging = new GdPictureImaging();
            var Words = PageText.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);

            SourcePDF.SetOrigin(PdfOrigin.PdfOriginTopLeft);
            SourcePDF.SetMeasurementUnit(PdfMeasurementUnit.PdfMeasurementUnitPoint);
            for (int i = 0; i < Words.Length; i++)
            {
                string WordSet = Words[i];
                try {
                    var Coords = WordSet.Split(SEPARATOR[0]);
                    var Word   = CorrectWord(Coords[8]);
                    if (!string.IsNullOrEmpty(Word) && !string.IsNullOrWhiteSpace(Word))
                    {
                        E_TextOrientation   Orientation;
                        System.Windows.Rect Rect = GetRect(Coords, out Orientation);
                        if (Rect.IsEmpty)
                        {
                            continue;
                        }
                        //var asdf = SourcePDF.GetPageTextArea(0, 0, 500, 500);
                        //var AltText = SourcePDF.GetPageTextArea((float)(Rect.Left / Scale / 72.0), (float)(Rect.Top / Scale / 72.0), (float)(Rect.Width / Scale / 72.0), (float)(Rect.Height / Scale / 72.0));
                        TextArea Area = new TextArea(Rect, Word, Page);
                        Area.Orientation = Orientation;
                        //SetPDFFontSize(SourcePDF, Area, Fonts);
                        if (Orientation == E_TextOrientation.LeftRight)
                        {
                            Page.TextAreas.Add(Area);
                            FillCharParams(Area);
                        }
                    }
                } catch (Exception ex) {
                    throw ex;
                }
            }
            int ID = GdPictureImaging.CreateNewGdPictureImage((int)Page.Width, (int)Page.Height, 24, System.Drawing.Color.White);

            foreach (var item in Page.TextAreas)
            {
                //calc sizes
                var FontSize = GetFontSize(GdPictureImaging, ID, item, "Arial");

                /*if (item.Text == "-") {
                 *  var a = item.FontSize;
                 * }*/
            }
            GdPictureImaging.ReleaseGdPictureImage(ID);
        }
        public TesseractProcessor()
        {
            GdImg = new GdPictureImaging();

            GdOcr = new GdPictureOCR
            {
                EnablePreprocessing = false,
                OCRMode             = OCRMode.FavorAccuracy,
                Context             = OCRContext.OCRContextSingleWord,
                CharacterSet        = "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
                ResourceFolder      = @"C:\GdPicture.NET 14\Redist\OCR"
            };

            blobFactory = new SpecialFactory();
        }
示例#19
0
        static ColorMap[] GetBoxTable(GdPictureImaging GdPic, int id, IBox box)
        {
            var converter = new ColorConverter();

            Color cIn  = (Color)converter.ConvertFromString("#613e32");
            Color cOut = (Color)converter.ConvertFromString("#6c4b3d");
            Color cBkg = (Color)converter.ConvertFromString("#fff6d2");

            int wi = GdPic.GetWidth(id);
            int hi = GdPic.GetHeight(id);

            var result = new List <ColorMap>();

            for (int w = 0; w < wi; w++)
            {
                for (int h = 0; h < hi; h++)
                {
                    Color c = GdPic.PixelGetColor(id, w, h);

                    ColorMap map = new ColorMap();

                    if (box.IsBkg(c))
                    {
                        map.OldColor = c;
                        map.NewColor = cBkg;
                    }
                    else if (box.IsIn(c))
                    {
                        map.OldColor = c;
                        map.NewColor = cIn;
                    }
                    else
                    {
                        map.OldColor = c;
                        map.NewColor = cOut;
                    }

                    if (result.Contains(map))
                    {
                        continue;
                    }

                    result.Add(map);
                }
            }

            return(result.ToArray());
        }
示例#20
0
        /// <summary>
        /// Set gamma for specified bitmap
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="gamma">Gamma (values from -100 to 100)</param>
        /// <returns></returns>
        public static Bitmap SetGammaCorrection(Bitmap bitmap, int gamma)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            if (imageId > 0)
            {
                image.SetGammaCorrection(imageId, gamma);
                resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }
示例#21
0
        /// <summary>
        /// Set contrast for specified bitmap
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="contrast">Contrast (values from -100 to 100)</param>
        /// <returns></returns>
        public static Bitmap SetContrast(Bitmap bitmap, int contrast)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            if (imageId > 0)
            {
                image.SetContrast(imageId, contrast);
                resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }
示例#22
0
        /// <summary>
        /// Binarizes the specified bitmap
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="threshold">Threshold</param>
        /// <returns></returns>
        public static Bitmap Binarize(Bitmap bitmap, byte threshold)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            if (imageId > 0)
            {
                image.ConvertTo1Bpp(imageId, threshold);
                resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }
示例#23
0
        /// <summary>
        /// Crops the specified bitmap
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="rectangle">Rectangle</param>
        /// <returns></returns>
        public static Bitmap Crop(Bitmap bitmap, Rectangle rectangle)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            if (imageId > 0)
            {
                image.Crop(imageId, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
                resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }
示例#24
0
        /// <summary>
        /// Removes lines
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="orientation">Lines orientation</param>
        /// <returns></returns>
        public static Bitmap RemoveLines(Bitmap bitmap, Enums.LineRemoveOrientation orientation)
        {
            Bitmap resultImage = bitmap;

            LineRemoveOrientation lineRemoveOrientation;

            switch (orientation)
            {
            case Enums.LineRemoveOrientation.Horizontal:
                lineRemoveOrientation = LineRemoveOrientation.Horizontal;
                break;

            case Enums.LineRemoveOrientation.Vertical:
                lineRemoveOrientation = LineRemoveOrientation.Vertical;
                break;

            default:
                return(resultImage);
            }

            if (orientation != Enums.LineRemoveOrientation.None)
            {
                GdPictureImaging image = new GdPictureImaging();

                int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

                try
                {
                    if (imageId > 0)
                    {
                        if (image.GetBitDepth(imageId) != 1)
                        {
                            image.ConvertTo1BppAT(imageId);
                        }

                        image.RemoveLines(imageId, lineRemoveOrientation);
                        resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                    }
                }
                finally
                {
                    image.ReleaseGdPictureImage(imageId);
                }
            }

            return(resultImage);
        }
示例#25
0
        public static File GetTiff(File file)
        {
            var filename    = GetFileName();
            var compression = TiffCompression.TiffCompressionNONE;
            int dpi         = 300;
            int tiffId      = 0;
            var status      = GdPictureStatus.OK;

            using (var pdf = new GdPicturePDF())
            {
                using (var imaging = new GdPictureImaging())
                {
                    if (pdf.LoadFromFile(file.FullPath, false) == GdPictureStatus.OK)
                    {
                        var pagesCount = pdf.GetPageCount();
                        for (int i = 1; i <= pagesCount; i++)
                        {
                            if (status == GdPictureStatus.OK)
                            {
                                pdf.SelectPage(i);
                                var pageId = pdf.RenderPageToGdPictureImageEx(dpi, true);
                                if (pageId == 0)
                                {
                                    throw new Exception($"Cannot converp page {i}");
                                }
                                if (i == 1)
                                {
                                    tiffId = pageId;
                                    status = imaging.TiffSaveAsMultiPageFile(tiffId, filename, compression);
                                }
                                else
                                {
                                    status = imaging.TiffAddToMultiPageFile(tiffId, pageId);
                                    imaging.ReleaseGdPictureImage(pageId);
                                }
                            }
                        }
                        if (imaging.TiffCloseMultiPageFile(tiffId) != GdPictureStatus.OK)
                        {
                            throw new Exception($"Cannot save file {filename}");
                        }
                        imaging.ReleaseGdPictureImage(tiffId);
                    }
                }
            }
            return(new File(filename));
        }
示例#26
0
        /// <summary>
        /// Removes the holes from holemaker
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="punchHolesPosition">Holes position</param>
        /// <returns></returns>
        public static Bitmap RemovePunchHoles(Bitmap bitmap, PunchHolesPositions punchHolesPosition)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            try
            {
                if (imageId > 0)
                {
                    if (image.GetBitDepth(imageId) != 1)
                    {
                        image.ConvertTo1BppAT(imageId);
                    }

                    if (punchHolesPosition.LeftSide)
                    {
                        image.RemoveHolePunch(imageId, HolePunchMargins.MarginLeft);
                    }
                    if (punchHolesPosition.TopSide)
                    {
                        image.RemoveHolePunch(imageId, HolePunchMargins.MarginTop);
                    }
                    if (punchHolesPosition.RightSide)
                    {
                        image.RemoveHolePunch(imageId, HolePunchMargins.MarginRight);
                    }
                    if (punchHolesPosition.BottomSide)
                    {
                        image.RemoveHolePunch(imageId, HolePunchMargins.MarginBottom);
                    }

                    resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                }
            }
            catch (Exception e)
            {
            }
            finally
            {
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }
示例#27
0
        /// <summary>
        /// Binarizes the specified bitmap
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <returns></returns>
        public static Bitmap Binarize(Bitmap bitmap)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            if (imageId > 0)
            {
                image.FxBlackNWhite(imageId, BitonalReduction.Stucki);
                image.ConvertTo1BppFast(imageId);
                resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }
示例#28
0
        /// <summary>
        /// Releases file from the Memory & Closes the file
        /// </summary>
        /// <param name="e"></param>
        public static void HandleCloseDocument(CustomActionEventArgs e)
        {
            // Release from memory
            int imgId;

            if (e.docuVieware.GetNativeImage(out imgId) == GdPictureStatus.OK)
            {
                GdPictureImaging gdImg = new GdPictureImaging();
                gdImg.ReleaseGdPictureImage(imgId);
            }

            // Close the document
            e.docuVieware.Close();


            return;
        }
示例#29
0
        /// <summary>
        /// Convert the provided TIFF to a PDF, including conversion of the annotations.
        /// </summary>
        /// <param name="strOutputFilePath">The path to the Pdf.</param>
        /// <param name="errorMessage">Used to retrieve an error message.</param>
        /// <param name="strInputFilePath">The path to the tiff.</param>
        /// <param name="textExtension">The extension for the text file.</param>
        /// <returns>true if the conversion succeded otherwise returns false.</returns>
        public static bool Convert(string strOutputFilePath, ref string errorMessage, string strInputFilePath,
                                   string textExtension = "")
        {
            using (GdPictureImaging gdPictureImaging = new GdPictureImaging())
            {
                // Load the image

                int imageId = gdPictureImaging.CreateGdPictureImageFromFile(strInputFilePath);
                if (imageId == 0)
                {
                    errorMessage = System.Convert.ToString(gdPictureImaging.GetStat().ToString());
                    gdPictureImaging.ReleaseGdPictureImage(imageId);
                    return(false);
                }

                int pageCount = gdPictureImaging.GetPageCount(imageId);

                // Collect the information required for the conversion of the annotations

                PageInfo[] pageInfo = ReadPageInfo(gdPictureImaging, imageId, pageCount);

                using (MemoryStream stream = new MemoryStream())
                {
                    // Convert to Pdf in a stream

                    if (!ConvertToPdf(stream, ref errorMessage, gdPictureImaging, imageId, pageCount))
                    {
                        gdPictureImaging.ReleaseGdPictureImage(imageId);
                        return(false);
                    }

                    gdPictureImaging.ReleaseGdPictureImage(imageId);

                    // Writes the annotations to the pdf

                    if (
                        !WriteAnnotations(strOutputFilePath, ref errorMessage, stream, pageCount, pageInfo,
                                          textExtension))
                    {
                        return(false);
                    }
                }
                return(true);
            }
        }
示例#30
0
        /// <summary>
        /// Set sharpness for specified bitmap
        /// </summary>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="sharpness">Sharpness</param>
        /// <returns></returns>
        public static Bitmap SetSharpness(Bitmap bitmap, int sharpness)
        {
            Bitmap           resultImage = bitmap;
            GdPictureImaging image       = new GdPictureImaging();

            int imageId = image.CreateGdPictureImageFromBitmap(bitmap);

            if (imageId > 0)
            {
                for (int i = 0; i < sharpness; i++)
                {
                    image.FxSharpen(imageId);
                }
                resultImage = image.GetBitmapFromGdPictureImage(imageId).CloneSmart(image.GetPixelFormat(imageId));
                image.ReleaseGdPictureImage(imageId);
            }

            return(resultImage);
        }